Fix special 'null' cases when inferring array literals (#1088)

Author: dcodeIO

src/compiler.ts

@@ -7442,6 +7442,10 @@ export class Compiler extends DiagnosticEmitter {
           return module.ref_null();
         }
         this.currentType = options.usizeType;
+        this.warning(
+          DiagnosticCode.Expression_resolves_to_unusual_type_0,
+          expression.range, this.currentType.toString()
+        );
         return options.isWasm64
           ? module.i64(0)
           : module.i32(0);
@@ -7778,38 +7782,10 @@ export class Compiler extends DiagnosticEmitter {
     switch (expression.literalKind) {
       case LiteralKind.ARRAY: {
         assert(!implicitlyNegate);
-        let elementExpressions = (<ArrayLiteralExpression>expression).elementExpressions;
-
-        // Infer from first element in auto contexts
-        if (contextualType == Type.auto) {
-          return this.compileArrayLiteral(
-            Type.auto,
-            elementExpressions,
-            constraints,
-            expression
-          );
-        }
-
-        // Use contextual type if an array
-        if (contextualType.is(TypeFlags.REFERENCE)) {
-          let classType = contextualType.classReference;
-          if (classType) {
-            if (classType.prototype == this.program.arrayPrototype) {
-              return this.compileArrayLiteral(
-                assert(classType.typeArguments)[0],
-                elementExpressions,
-                constraints,
-                expression
-              );
-            }
-          }
-        }
-
-        this.error(
-          DiagnosticCode.The_type_argument_for_type_parameter_0_cannot_be_inferred_from_the_usage_Consider_specifying_the_type_arguments_explicitly,
-          expression.range, "T"
+        return this.compileArrayLiteral(
+          <ArrayLiteralExpression>expression,
+          constraints
         );
-        return module.unreachable();
       }
       case LiteralKind.FLOAT: {
         let floatValue = (<FloatLiteralExpression>expression).value;
@@ -7875,50 +7851,29 @@ export class Compiler extends DiagnosticEmitter {
   }
 
   private compileArrayLiteral(
-    elementType: Type,
-    expressions: (Expression | null)[],
-    constraints: Constraints,
-    reportNode: Node
+    expression: ArrayLiteralExpression,
+    constraints: Constraints
   ): ExpressionRef {
     var module = this.module;
+    var flow = this.currentFlow;
+
+    var arrayInstance = this.resolver.lookupExpression(expression, flow, this.currentType);
+    if (!arrayInstance) return module.unreachable();
+
     var program = this.program;
-    var arrayPrototype = assert(program.arrayPrototype);
     var arrayBufferInstance = assert(program.arrayBufferInstance);
-    var flow = this.currentFlow;
 
     // block those here so compiling expressions doesn't conflict
     var tempThis = flow.getTempLocal(this.options.usizeType);
     var tempDataStart = flow.getTempLocal(arrayBufferInstance.type);
 
-    // infer common element type in auto contexts
-    var length = expressions.length;
-    if (elementType == Type.auto) {
-      for (let i = 0; i < length; ++i) {
-        let expression = expressions[i];
-        if (expression) {
-          let currentType = this.resolver.resolveExpression(expression, this.currentFlow, elementType);
-          if (!currentType) return module.unreachable();
-          if (elementType == Type.auto) elementType = currentType;
-          else if (currentType != elementType) {
-            let commonType = Type.commonDenominator(elementType, currentType, false);
-            if (commonType) elementType = commonType;
-            // otherwise triggers error further down
-          }
-        }
-      }
-      if (elementType /* still */ == Type.auto) {
-        this.error(
-          DiagnosticCode.The_type_argument_for_type_parameter_0_cannot_be_inferred_from_the_usage_Consider_specifying_the_type_arguments_explicitly,
-          reportNode.range, "T"
-        );
-        return module.unreachable();
-      }
-    }
-
-    var arrayInstance = assert(this.resolver.resolveClass(arrayPrototype, [ elementType ]));
-    var arrayType = arrayInstance.type;
+    assert(arrayInstance.kind == ElementKind.CLASS);
+    var arrayType = (<Class>arrayInstance).type;
+    var elementType = assert((<Class>arrayInstance).getTypeArgumentsTo(this.program.arrayPrototype))[0];
+    var expressions = expression.elementExpressions;
 
     // compile value expressions and find out whether all are constant
+    var length = expressions.length;
     var values = new Array<ExpressionRef>(length);
     var isStatic = true;
     var nativeElementType = elementType.toNativeType();
@@ -7966,11 +7921,11 @@ export class Compiler extends DiagnosticEmitter {
           program.options.isWasm64
             ? module.i64(elementType.alignLog2)
             : module.i32(elementType.alignLog2),
-          module.i32(arrayInstance.id),
+          module.i32((<Class>arrayInstance).id),
           program.options.isWasm64
             ? module.i64(i64_low(bufferAddress), i64_high(bufferAddress))
             : module.i32(i64_low(bufferAddress))
-        ], reportNode);
+        ], expression);
         this.currentType = arrayType;
         expr = this.makeRetain(expr);
         if (arrayType.isManaged) {
@@ -7985,13 +7940,13 @@ export class Compiler extends DiagnosticEmitter {
     }
 
     // otherwise compile an explicit instantiation with indexed sets
-    var setter = arrayInstance.lookupOverload(OperatorKind.INDEXED_SET, true);
+    var setter = (<Class>arrayInstance).lookupOverload(OperatorKind.INDEXED_SET, true);
     if (!setter) {
       flow.freeTempLocal(tempThis);
       flow.freeTempLocal(tempDataStart);
       this.error(
         DiagnosticCode.Index_signature_in_type_0_only_permits_reading,
-        reportNode.range, arrayInstance.internalName
+        expression.range, arrayInstance.internalName
       );
       this.currentType = arrayType;
       return module.unreachable();
@@ -8008,11 +7963,11 @@ export class Compiler extends DiagnosticEmitter {
             program.options.isWasm64
               ? module.i64(elementType.alignLog2)
               : module.i32(elementType.alignLog2),
-            module.i32(arrayInstance.id),
+            module.i32((<Class>arrayInstance).id),
             program.options.isWasm64
               ? module.i64(0)
               : module.i32(0)
-          ], reportNode)
+          ], expression)
         )
       )
     );

src/diagnosticMessages.generated.ts

@@ -37,6 +37,7 @@ export enum DiagnosticCode {
   _0_must_be_a_power_of_two = 223,
   _0_is_not_a_valid_operator = 224,
   Expression_cannot_be_represented_by_a_type = 225,
+  Expression_resolves_to_unusual_type_0 = 226,
   Type_0_is_cyclic_Module_will_include_deferred_garbage_collection = 900,
   Importing_the_table_disables_some_indirect_call_optimizations = 901,
   Exporting_the_table_disables_some_indirect_call_optimizations = 902,
@@ -187,6 +188,7 @@ export function diagnosticCodeToString(code: DiagnosticCode): string {
     case 223: return "'{0}' must be a power of two.";
     case 224: return "'{0}' is not a valid operator.";
     case 225: return "Expression cannot be represented by a type.";
+    case 226: return "Expression resolves to unusual type '{0}'.";
     case 900: return "Type '{0}' is cyclic. Module will include deferred garbage collection.";
     case 901: return "Importing the table disables some indirect call optimizations.";
     case 902: return "Exporting the table disables some indirect call optimizations.";

src/diagnosticMessages.json

@@ -30,6 +30,7 @@
   "'{0}' must be a power of two.": 223,
   "'{0}' is not a valid operator.": 224,
   "Expression cannot be represented by a type.": 225,
+  "Expression resolves to unusual type '{0}'.": 226,
 
   "Type '{0}' is cyclic. Module will include deferred garbage collection.": 900,
   "Importing the table disables some indirect call optimizations.": 901,

src/resolver.ts

@@ -65,7 +65,8 @@ import {
   TernaryExpression,
   isTypeOmitted,
   FunctionExpression,
-  NewExpression
+  NewExpression,
+  ArrayLiteralExpression
 } from "./ast";
 
 import {
@@ -2160,10 +2161,10 @@ export class Resolver extends DiagnosticEmitter {
     /** How to proceed with eventual diagnostics. */
     reportMode: ReportMode = ReportMode.REPORT
   ): Element | null {
+    this.currentThisExpression = node;
+    this.currentElementExpression = null;
     switch (node.literalKind) {
       case LiteralKind.INTEGER: {
-        this.currentThisExpression = node;
-        this.currentElementExpression = null;
         let intType = this.determineIntegerLiteralType(
           (<IntegerLiteralExpression>node).value,
           ctxType
@@ -2173,20 +2174,61 @@ export class Resolver extends DiagnosticEmitter {
         return wrapperClasses.get(intType)!;
       }
       case LiteralKind.FLOAT: {
-        this.currentThisExpression = node;
-        this.currentElementExpression = null;
         let fltType = ctxType == Type.f32 ? Type.f32 : Type.f64;
         let wrapperClasses = this.program.wrapperClasses;
         assert(wrapperClasses.has(fltType));
         return wrapperClasses.get(fltType)!;
       }
       case LiteralKind.STRING: {
-        this.currentThisExpression = node;
-        this.currentElementExpression = null;
         return this.program.stringInstance;
       }
-      // TODO
-      // case LiteralKind.ARRAY:
+      case LiteralKind.ARRAY: {
+        let classReference = ctxType.classReference;
+        if (ctxType.is(TypeFlags.REFERENCE) && classReference !== null && classReference.prototype == this.program.arrayPrototype) {
+          return this.getElementOfType(ctxType);
+        }
+        // otherwise infer, ignoring ctxType
+        let expressions = (<ArrayLiteralExpression>node).elementExpressions;
+        let length = expressions.length;
+        let elementType = Type.auto;
+        let numNullLiterals = 0;
+        for (let i = 0, k = length; i < k; ++i) {
+          let expression = expressions[i];
+          if (expression) {
+            if (expression.kind == NodeKind.NULL && length > 1) {
+              ++numNullLiterals;
+            } else {
+              let currentType = this.resolveExpression(expression, ctxFlow, elementType);
+              if (!currentType) return null;
+              if (elementType == Type.auto) elementType = currentType;
+              else if (currentType != elementType) {
+                let commonType = Type.commonDenominator(elementType, currentType, false);
+                if (commonType) elementType = commonType;
+                // otherwise triggers error on compilation
+              }
+            }
+          }
+        }
+        if (elementType /* still */ == Type.auto) {
+          if (numNullLiterals == length) { // all nulls infers as usize
+            elementType = this.program.options.usizeType;
+          } else {
+            this.error(
+              DiagnosticCode.The_type_argument_for_type_parameter_0_cannot_be_inferred_from_the_usage_Consider_specifying_the_type_arguments_explicitly,
+              node.range, "T"
+            );
+            return null;
+          }
+        }
+        if (
+          numNullLiterals > 0 &&
+          elementType.is(TypeFlags.REFERENCE) &&
+          !elementType.is(TypeFlags.HOST) // TODO: anyref isn't nullable as-is
+        ) {
+          elementType = elementType.asNullable();
+        }
+        return assert(this.resolveClass(this.program.arrayPrototype, [ elementType ]));
+      }
     }
     if (reportMode == ReportMode.REPORT) {
       this.error(

std/assembly/array.ts

@@ -38,7 +38,7 @@ export class Array<T> extends ArrayBufferView {
   private length_: i32;
 
   static isArray<U>(value: U): bool {
-    return builtin_isArray(value) && value !== null;
+    return isReference<U>() ? builtin_isArray(value) && value !== null : false;
   }
 
   static create<T>(capacity: i32 = 0): Array<T> {
@@ -355,10 +355,7 @@ export class Array<T> extends ArrayBufferView {
       base + sizeof<T>(),
       <usize>lastIndex << alignof<T>()
     );
-    store<T>(base + (<usize>lastIndex << alignof<T>()),
-      // @ts-ignore: cast
-      <T>null
-    );
+    store<T>(base + (<usize>lastIndex << alignof<T>()), isReference<T>() ? null : 0);
     this.length_ = lastIndex;
     return element; // no need to retain -> is moved
   }

tests/compiler/builtins.ts

@@ -24,20 +24,20 @@ assert(isInteger(<i32>1));
 assert(!isInteger(<f32>1));
 assert(isFloat(<f32>1));
 assert(!isFloat(<i32>1));
-assert(isReference(changetype<string>(null)));
-assert(!isReference(changetype<usize>(null)));
+assert(isReference(changetype<string>(0)));
+assert(!isReference(changetype<usize>(0)));
 assert(isString(""));
 assert(isString("abc"));
 assert(!isString(1));
-assert(isArray(changetype<i32[]>(null)));
-assert(isArrayLike(changetype<i32[]>(null)));
-assert(isArrayLike(changetype<string>(null)));
-assert(isArrayLike(changetype<Uint8Array>(null)));
-assert(!isArray(changetype<usize>(null)));
-assert(isFunction(changetype<() => void>(null)));
-assert(!isFunction(changetype<u32>(null)));
-assert(isNullable(changetype<C | null>(null)));
-assert(!isNullable(changetype<C>(null)));
+assert(isArray(changetype<i32[]>(0)));
+assert(isArrayLike(changetype<i32[]>(0)));
+assert(isArrayLike(changetype<string>(0)));
+assert(isArrayLike(changetype<Uint8Array>(0)));
+assert(!isArray(changetype<usize>(0)));
+assert(isFunction(changetype<() => void>(0)));
+assert(!isFunction(changetype<u32>(0)));
+assert(isNullable(changetype<C | null>(0)));
+assert(!isNullable(changetype<C>(0)));
 
 // evaluation