Merge remote-tracking branch 'origin/master' into release

Author: actions-user

README.md

@@ -1,7 +1,7 @@
 ![](https://avatars1.githubusercontent.com/u/28916798?s=64) AssemblyScript
 =================
 
-[![Actions Status](https://github.com/AssemblyScript/assemblyscript/workflows/CI/badge.svg)](https://github.com/AssemblyScript/assemblyscript/actions) [![npm](https://img.shields.io/npm/v/assemblyscript.svg?color=0074C1)](https://www.npmjs.com/package/assemblyscript) [![npm@nightly](https://img.shields.io/npm/v/assemblyscript/nightly.svg?color=0074C1)](https://www.npmjs.com/package/assemblyscript)
+[![Actions Status](https://github.com/AssemblyScript/assemblyscript/workflows/CI/badge.svg?branch=master&event=push)](https://github.com/AssemblyScript/assemblyscript/actions) [![npm](https://img.shields.io/npm/v/assemblyscript.svg?color=0074C1)](https://www.npmjs.com/package/assemblyscript) [![npm@nightly](https://img.shields.io/npm/v/assemblyscript/nightly.svg?color=0074C1)](https://www.npmjs.com/package/assemblyscript)
 
 **AssemblyScript** compiles a strict subset of [TypeScript](http://www.typescriptlang.org) (basically JavaScript with types) to [WebAssembly](http://webassembly.org) using [Binaryen](https://github.com/WebAssembly/binaryen). It generates lean and mean WebAssembly modules while being just an `npm install` away.
 
@@ -35,7 +35,7 @@ The core team members and most contributors do this open source work in their fr
 Motivation
 ----------
 
-> You are now able to write WebAssembly, without learning a new language, and harness all these benefits WebAssembly might offer you. I think that is kind of powerful. [...] It [AssemblyScript] is absolutely usable, and very enjoyable! - Surma, [WebAssembly for Web Developers (Google I/O ’19)](https://youtu.be/njt-Qzw0mVY) (May 8th, 2019) 
+> You are now able to write WebAssembly, without learning a new language, and harness all these benefits WebAssembly might offer you. I think that is kind of powerful. [...] It [AssemblyScript] is absolutely usable, and very enjoyable! - Surma, [WebAssembly for Web Developers (Google I/O ’19)](https://youtu.be/njt-Qzw0mVY) (May 8th, 2019)
 
 > AssemblyScript was frictionless. Not only does it allow you to use TypeScript to write WebAssembly, [...] it also produces glue-free WebAssembly modules that are very small with decent performance. – Surma, [Replacing a hot path in your app's JavaScript with WebAssembly](https://developers.google.com/web/updates/2019/02/hotpath-with-wasm) (Feb 16, 2019)
 

package-lock.json

@@ -21,7 +21,7 @@
     "url": "https://github.com/AssemblyScript/assemblyscript/issues"
   },
   "dependencies": {
-    "binaryen": "90.0.0-nightly.20200128",
+    "binaryen": "90.0.0-nightly.20200208",
     "long": "^4.0.0",
     "source-map-support": "^0.5.16",
     "ts-node": "^6.2.0"

package.json

@@ -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/compiler.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,
@@ -65,6 +66,7 @@ export enum DiagnosticCode {
   An_accessor_cannot_have_type_parameters = 1094,
   A_set_accessor_cannot_have_a_return_type_annotation = 1095,
   Type_parameter_list_cannot_be_empty = 1098,
+  Type_argument_list_cannot_be_empty = 1099,
   A_continue_statement_can_only_be_used_within_an_enclosing_iteration_statement = 1104,
   A_break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement = 1105,
   A_return_statement_can_only_be_used_within_a_function_body = 1108,
@@ -186,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.";
@@ -214,6 +217,7 @@ export function diagnosticCodeToString(code: DiagnosticCode): string {
     case 1094: return "An accessor cannot have type parameters.";
     case 1095: return "A 'set' accessor cannot have a return type annotation.";
     case 1098: return "Type parameter list cannot be empty.";
+    case 1099: return "Type argument list cannot be empty.";
     case 1104: return "A 'continue' statement can only be used within an enclosing iteration statement.";
     case 1105: return "A 'break' statement can only be used within an enclosing iteration or switch statement.";
     case 1108: return "A 'return' statement can only be used within a function body.";

src/diagnosticMessages.generated.ts

@@ -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,
@@ -60,6 +61,7 @@
   "An accessor cannot have type parameters.": 1094,
   "A 'set' accessor cannot have a return type annotation.": 1095,
   "Type parameter list cannot be empty.": 1098,
+  "Type argument list cannot be empty.": 1099,
   "A 'continue' statement can only be used within an enclosing iteration statement.": 1104,
   "A 'break' statement can only be used within an enclosing iteration or switch statement.": 1105,
   "A 'return' statement can only be used within a function body.": 1108,

src/diagnosticMessages.json

@@ -5,7 +5,8 @@
  *//***/
 
 import {
-  Range
+  Range,
+  Source
 } from "./ast";
 
 import {
@@ -241,7 +242,7 @@ export abstract class DiagnosticEmitter {
   /** Diagnostic messages emitted so far. */
   diagnostics: DiagnosticMessage[];
   /** Diagnostic messages already seen, by range. */
-  private seen: Map<Range,Set<DiagnosticCode>> = new Map();
+  private seen: Map<Source,Map<i32,i32[]>> = new Map();
 
   /** Initializes this diagnostic emitter. */
   protected constructor(diagnostics: DiagnosticMessage[] | null = null) {
@@ -260,17 +261,23 @@ export abstract class DiagnosticEmitter {
   ): void {
     // It is possible that the same diagnostic is emitted twice, for example
     // when compiling generics with different types or when recompiling a loop
-    // because our initial assumptions didn't hold. Deduplicate these.
+    // because our initial assumptions didn't hold. It is even possible to get
+    // multiple instances of the same range during parsing. Deduplicate these.
     if (range) {
       let seen = this.seen;
-      if (seen.has(range)) {
-        let codes = seen.get(range)!;
-        if (codes.has(code)) return;
-        codes.add(code);
+      if (seen.has(range.source)) {
+        let seenInSource = seen.get(range.source)!;
+        if (seenInSource.has(range.start)) {
+          let seenCodesAtPos = seenInSource.get(range.start)!;
+          if (seenCodesAtPos.includes(code)) return;
+          seenCodesAtPos.push(code);
+        } else {
+          seenInSource.set(range.start, [ code ]);
+        }
       } else {
-        let codes = new Set<DiagnosticCode>();
-        codes.add(code);
-        seen.set(range, codes);
+        let seenInSource = new Map();
+        seenInSource.set(range.start, [ code ]);
+        seen.set(range.source, seenInSource);
       }
     }
     var message = DiagnosticMessage.create(code, category, arg0, arg1, arg2);

src/diagnostics.ts

@@ -781,7 +781,7 @@ export declare function _BinaryenSideEffectImplicitTrap(): BinaryenSideEffects;
 export declare function _BinaryenSideEffectIsAtomic(): BinaryenSideEffects;
 export declare function _BinaryenSideEffectAny(): BinaryenSideEffects;
 
-export declare function _BinaryenExpressionGetSideEffects(expr: BinaryenExpressionRef): BinaryenSideEffects;
+export declare function _BinaryenExpressionGetSideEffects(expr: BinaryenExpressionRef, features: BinaryenFeatureFlags): BinaryenSideEffects;
 
 type BinaryenRelooperRef = usize;
 type BinaryenRelooperBlockRef = usize;
@@ -799,5 +799,10 @@ export declare function _BinaryenGetShrinkLevel(): i32;
 export declare function _BinaryenSetShrinkLevel(level: i32): void;
 export declare function _BinaryenGetDebugInfo(): bool;
 export declare function _BinaryenSetDebugInfo(on: bool): void;
+export declare function _BinaryenGetLowMemoryUnused(): bool;
+export declare function _BinaryenSetLowMemoryUnused(on: bool): void;
+export declare function _BinaryenGetPassArgument(key: usize): usize;
+export declare function _BinaryenSetPassArgument(key: usize, value: usize): void;
+export declare function _BinaryenClearPassArguments(): void;
 
 export declare function _BinaryenSetAPITracing(on: bool): void;