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

Author: actions-user

src/compiler.ts

@@ -1450,7 +1450,7 @@ export class Compiler extends DiagnosticEmitter {
   // === Memory ===================================================================================
 
   /** Adds a static memory segment with the specified data. */
-  addMemorySegment(buffer: Uint8Array, alignment: i32 = 8): MemorySegment {
+  addMemorySegment(buffer: Uint8Array, alignment: i32 = 16): MemorySegment {
     var memoryOffset = i64_align(this.memoryOffset, alignment);
     var segment = MemorySegment.create(buffer, memoryOffset);
     this.memorySegments.push(segment);
@@ -7455,17 +7455,33 @@ export class Compiler extends DiagnosticEmitter {
     switch (expression.literalKind) {
       case LiteralKind.ARRAY: {
         assert(!implicitlyNegate);
-        let classType = contextualType.classReference;
-        if (classType) {
-          if (classType.prototype == this.program.arrayPrototype) {
-            return this.compileArrayLiteral(
-              assert(classType.typeArguments)[0],
-              (<ArrayLiteralExpression>expression).elementExpressions,
-              constraints,
-              expression
-            );
+        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"
@@ -7544,17 +7560,42 @@ export class Compiler extends DiagnosticEmitter {
     var module = this.module;
     var program = this.program;
     var arrayPrototype = assert(program.arrayPrototype);
-    var arrayInstance = assert(this.resolver.resolveClass(arrayPrototype, [ elementType ]));
     var arrayBufferInstance = assert(program.arrayBufferInstance);
-    var arrayType = arrayInstance.type;
     var flow = this.currentFlow;
 
     // block those here so compiling expressions doesn't conflict
-    var tempThis = flow.getTempLocal(arrayType);
+    var tempThis = flow.getTempLocal(this.options.usizeType);
     var tempDataStart = flow.getTempLocal(arrayBufferInstance.type);
 
-    // compile value expressions and find out whether all are constant
+    // 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;
+
+    // compile value expressions and find out whether all are constant
     var values = new Array<ExpressionRef>(length);
     var isStatic = true;
     var nativeElementType = elementType.toNativeType();

std/assembly/index.d.ts

@@ -1290,6 +1290,8 @@ declare abstract class TypedArray<T> implements ArrayBufferView {
   reverse(): this;
   /** The join() method joins all elements of an array into a string. This method has the same algorithm as Array.prototype.join(). */
   join(separator?: string): string;
+  /** The set() method stores multiple values in the typed array, reading input values from a specified array. */
+  set<U extends ArrayBufferView>(source: U, offset?: i32): void
   /** The toString() method returns a string representing the specified array and its elements. This method has the same algorithm as Array.prototype.toString() */
   toString(): string;
 }

std/assembly/rt/stub.ts

@@ -31,7 +31,7 @@ export function __alloc(size: usize, id: u32): usize {
   maybeGrowMemory(ptr + actualSize);
   var block = changetype<BLOCK>(ptr - BLOCK_OVERHEAD);
   block.mmInfo = actualSize;
-  if (DEBUG) block.gcInfo = -1;
+  if (DEBUG) block.gcInfo = 1;
   block.rtId = id;
   block.rtSize = size;
   return ptr;
@@ -43,7 +43,7 @@ export function __realloc(ptr: usize, size: usize): usize {
   assert(ptr != 0 && !(ptr & AL_MASK)); // must exist and be aligned
   var block = changetype<BLOCK>(ptr - BLOCK_OVERHEAD);
   var actualSize = block.mmInfo;
-  if (DEBUG) assert(block.gcInfo == -1);
+  if (DEBUG) assert(block.gcInfo == 1);
   var isLast = ptr + actualSize == offset;
   var alignedSize = (size + AL_MASK) & ~AL_MASK;
   if (size > actualSize) {
@@ -69,7 +69,7 @@ export function __realloc(ptr: usize, size: usize): usize {
 export function __free(ptr: usize): void {
   assert(ptr != 0 && !(ptr & AL_MASK)); // must exist and be aligned
   var block = changetype<BLOCK>(ptr - BLOCK_OVERHEAD);
-  if (DEBUG) assert(block.gcInfo == -1);
+  if (DEBUG) assert(block.gcInfo == 1);
   if (ptr + block.mmInfo == offset) { // last block: discard
     offset = changetype<usize>(block);
   }

std/assembly/rt/tlsf.ts

@@ -459,22 +459,26 @@ function prepareSize(size: usize): usize {
 }
 
 /** Initilizes the root structure. */
-export function initializeRoot(): void {
-  var rootOffset = (__heap_base + AL_MASK) & ~AL_MASK;
-  var pagesBefore = memory.size();
-  var pagesNeeded = <i32>((((rootOffset + ROOT_SIZE) + 0xffff) & ~0xffff) >>> 16);
-  if (pagesNeeded > pagesBefore && memory.grow(pagesNeeded - pagesBefore) < 0) unreachable();
-  var root = changetype<Root>(rootOffset);
-  root.flMap = 0;
-  SETTAIL(root, changetype<Block>(0));
-  for (let fl: usize = 0; fl < FL_BITS; ++fl) {
-    SETSL(root, fl, 0);
-    for (let sl: u32 = 0; sl < SL_SIZE; ++sl) {
-      SETHEAD(root, fl, sl, null);
+export function maybeInitialize(): Root {
+  var root = ROOT;
+  if (!root) {
+    const rootOffset = (__heap_base + AL_MASK) & ~AL_MASK;
+    let pagesBefore = memory.size();
+    let pagesNeeded = <i32>((((rootOffset + ROOT_SIZE) + 0xffff) & ~0xffff) >>> 16);
+    if (pagesNeeded > pagesBefore && memory.grow(pagesNeeded - pagesBefore) < 0) unreachable();
+    root = changetype<Root>(rootOffset);
+    root.flMap = 0;
+    SETTAIL(root, changetype<Block>(0));
+    for (let fl: usize = 0; fl < FL_BITS; ++fl) {
+      SETSL(root, fl, 0);
+      for (let sl: u32 = 0; sl < SL_SIZE; ++sl) {
+        SETHEAD(root, fl, sl, null);
+      }
     }
+    addMemory(root, (rootOffset + ROOT_SIZE + AL_MASK) & ~AL_MASK, memory.size() << 16);
+    ROOT = root;
   }
-  addMemory(root, (rootOffset + ROOT_SIZE + AL_MASK) & ~AL_MASK, memory.size() << 16);
-  ROOT = root;
+  return root;
 }
 
 // @ts-ignore: decorator
@@ -551,9 +555,11 @@ export function reallocateBlock(root: Root, block: Block, size: usize): Block {
   var newBlock = allocateBlock(root, size);
   newBlock.rtId = block.rtId;
   memory.copy(changetype<usize>(newBlock) + BLOCK_OVERHEAD, changetype<usize>(block) + BLOCK_OVERHEAD, size);
-  block.mmInfo = blockInfo | FREE;
-  insertBlock(root, block);
-  if (isDefined(ASC_RTRACE)) onfree(block);
+  if (changetype<usize>(block) >= __heap_base) {
+    block.mmInfo = blockInfo | FREE;
+    insertBlock(root, block);
+    if (isDefined(ASC_RTRACE)) onfree(block);
+  }
   return newBlock;
 }
 
@@ -569,28 +575,21 @@ export function freeBlock(root: Root, block: Block): void {
 // @ts-ignore: decorator
 @global @unsafe
 export function __alloc(size: usize, id: u32): usize {
-  var root = ROOT;
-  if (!root) {
-    initializeRoot();
-    root = ROOT;
-  }
-  var block = allocateBlock(root, size);
+  var block = allocateBlock(maybeInitialize(), size);
   block.rtId = id;
   return changetype<usize>(block) + BLOCK_OVERHEAD;
 }
 
 // @ts-ignore: decorator
 @global @unsafe
 export function __realloc(ref: usize, size: usize): usize {
-  if (DEBUG) assert(ROOT); // must be initialized
   assert(ref != 0 && !(ref & AL_MASK)); // must exist and be aligned
-  return changetype<usize>(reallocateBlock(ROOT, changetype<Block>(ref - BLOCK_OVERHEAD), size)) + BLOCK_OVERHEAD;
+  return changetype<usize>(reallocateBlock(maybeInitialize(), changetype<Block>(ref - BLOCK_OVERHEAD), size)) + BLOCK_OVERHEAD;
 }
 
 // @ts-ignore: decorator
 @global @unsafe
 export function __free(ref: usize): void {
-  if (DEBUG) assert(ROOT); // must be initialized
   assert(ref != 0 && !(ref & AL_MASK)); // must exist and be aligned
-  freeBlock(ROOT, changetype<Block>(ref - BLOCK_OVERHEAD));
+  freeBlock(maybeInitialize(), changetype<Block>(ref - BLOCK_OVERHEAD));
 }