Maybe not a bug. Safety: Cannot cast nullable value to not nullable type with Std.instance

[restorer]

class SomeClass {
    public function new() {}
}

class MaybeBug12 {
    public function bug() : Void {
        var a = new SomeClass();

        // Safety: Cannot cast nullable value to not nullable type.
        // Probably this is not a bug in Safety, and this issue related to Std.instance() signature
        var b : Null<SomeClass> = Std.instance(a, SomeClass);
    }
}

See https://github.com/restorer/haxe-safety-bugs/blob/master/safetybugs/Main.hx#L163 for working example.

[restorer]

This is for Haxe 4.0.0-preview.5 and Safety from master.

[RealyUniqueName]

This is an intended behavior for a typed cast:

Safety/test/cases/TestCompileTime.hx

Lines 505 to 509 in 9dc8579

	static function cast_nullableExprToNotNullableType_shouldFail() {
	var s:Null<String> = 'hello';
	shouldFail((s:String));
	shouldFail(cast(s, String));
	}

However, Std.instance() uses an untyped cast, which should ignore null safety checks:

Safety/test/cases/TestCompileTime.hx

Lines 511 to 514 in 9dc8579

	static function untypedCast_shouldPass() {
	var n:Null<String> = 'hello';
	var s:String = cast n;
	}

Maybe Haxe typer makes them indistinguishable for the Safety plugin in case of Std.instance()

[restorer]

I think problem is in Std.instance signature, which is

public static function instance<T:{},S:T>( value : T, c : Class<S> ) : S;

However, documentation says:

This method checks if a downcast is possible. That is, if the runtime type of value is assignable to the class specified by c, value is returned. Otherwise null is returned.

Proper signature should be

public static function instance<T:{},S:T>( value : T, c : Class<S> ) : Null<S>;

I "fix" this by

@:safety(unsafe)
public static function instanceExt<T : {}, S : T>(value : T, c : Class<S>) : Null<S> {
    return Std.instance(value, c);
}

I understand that this is something not on Safety side, but maybe you can propose this change for Haxe.