Require exact type in instanceof basicType, fixes AssemblyScript#493

Author: dcodeIO

src/compiler.ts

@@ -6138,24 +6138,32 @@ export class Compiler extends DiagnosticEmitter {
  // time of implementation, this seemed more useful because dynamic rhs expressions are not
  // possible in AS anyway.
  var expr = this.compileExpressionRetainType(expression.expression, this.options.usizeType, WrapMode.NONE);
- var type = this.currentType;
- var isType = this.resolver.resolveType(
+ var actualType = this.currentType;
+ var expectedType = this.resolver.resolveType(
  expression.isType,
  this.currentFlow.actualFunction
  );
  this.currentType = Type.bool;
- if (!isType) return module.createUnreachable();
- return type.is(TypeFlags.NULLABLE) && !isType.is(TypeFlags.NULLABLE)
- ? type.nonNullableType.isAssignableTo(isType)
- ? module.createBinary( // not precomputeable
- type.is(TypeFlags.LONG)
- ? BinaryOp.NeI64
- : BinaryOp.NeI32,
- expr,
- type.toNativeZero(module)
- )
- : module.createI32(0)
- : module.createI32(type.isAssignableTo(isType, true) ? 1 : 0);
+ if (!expectedType) return module.createUnreachable();
+
+ // instanceof <basicType> must be exact
+ if (!expectedType.is(TypeFlags.REFERENCE)) {
+ return module.createI32(actualType == expectedType ? 1 : 0);
+ }
+ // <nullable> instanceof <nonNullable> must be != 0
+ if (
+ actualType.is(TypeFlags.NULLABLE) && !expectedType.is(TypeFlags.NULLABLE) &&
+ actualType.nonNullableType.isAssignableTo(expectedType)
+ ) {
+ return module.createBinary(
+ actualType.is(TypeFlags.LONG)
+ ? BinaryOp.NeI64
+ : BinaryOp.NeI32,
+ expr,
+ actualType.toNativeZero(module)
+ );
+ }
+ return module.createI32(actualType.isAssignableTo(expectedType) ? 1 : 0);
  }
 
  compileLiteralExpression(

tests/compiler/instanceof.optimized.wat

@@ -15,7 +15,7 @@
  if
  i32.const 0
  i32.const 8
- i32.const 43
+ i32.const 68
  i32.const 0
  call $~lib/env/abort
  unreachable
@@ -27,7 +27,7 @@
  if
  i32.const 0
  i32.const 8
- i32.const 46
+ i32.const 71
  i32.const 0
  call $~lib/env/abort
  unreachable

tests/compiler/instanceof.ts

@@ -4,27 +4,51 @@ class B extends A {}
 var a: A;
 var b: B;
 var i: i32;
+var I: i64;
 var f: f32;
+var F: f64;
 
 assert( a instanceof A );
 assert( b instanceof A );
 assert(!(i instanceof A));
+assert(!(I instanceof A));
 assert(!(f instanceof A));
+assert(!(F instanceof A));
 
 assert(!(a instanceof B));
 assert( b instanceof B );
 assert(!(i instanceof B));
+assert(!(I instanceof B));
 assert(!(f instanceof B));
+assert(!(F instanceof B));
 
 assert(!(a instanceof i32));
 assert(!(b instanceof i32));
 assert( i instanceof i32 );
+assert(!(I instanceof i32));
 assert(!(f instanceof i32));
+assert(!(F instanceof i32));
+
+assert(!(a instanceof i64));
+assert(!(b instanceof i64));
+assert(!(i instanceof i64));
+assert( I instanceof i64 );
+assert(!(f instanceof i64));
+assert(!(F instanceof i64));
 
 assert(!(a instanceof f32));
 assert(!(b instanceof f32));
 assert(!(i instanceof f32));
+assert(!(I instanceof f32));
 assert( f instanceof f32 );
+assert(!(F instanceof f32));
+
+assert(!(a instanceof f64));
+assert(!(b instanceof f64));
+assert(!(i instanceof f64));
+assert(!(I instanceof f64));
+assert(!(f instanceof f64));
+assert( F instanceof f64 );
 
 function isI32<T>(v: T): bool {
  // should eliminate non-applicable branches (see fixture)
@@ -38,13 +62,14 @@ function isI32<T>(v: T): bool {
 assert( isI32(0));
 assert(!isI32(0.0));
 assert(!isI32(<u32>0)); // signedness is relevant
+assert(!isI32(<u16>0)); // byte size is relevant
 
 var an: A | null = null;
-assert(!(an instanceof A)); // TS: null is not an instance of A
-assert( an instanceof A | null); // AS: null is an instance of A | null
+assert(!(an instanceof A)); // TS: ==null is not an instance of A
+assert( an instanceof A | null); // AS: ==null is an instance of A | null
 an = changetype<A | null>(1);
-assert( an instanceof A); // TS: non-null is an instance of A
-assert( an instanceof A | null); // AS: non-null is an instance of A | null
+assert( an instanceof A); // TS: !=null is an instance of A
+assert( an instanceof A | null); // AS: !=null is an instance of A | null
 
 // TODO: keep track of nullability during flows, so this becomes precomputable:
 // assert(an !== null && an instanceof A);