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

Author: actions-user

NOTICE

@@ -17,6 +17,7 @@ under the licensing terms detailed in LICENSE:
 * Bowen Wang <bowen@nearprotocol.com>
 * Emil Laine <laine.emil@gmail.com>
 * Stephen Paul Weber <stephen.weber@shopify.com>
+* Jay Phelps <hello@jayphelps.com>
 
 Portions of this software are derived from third-party works licensed under
 the following terms:

bin/asinit

@@ -218,13 +218,10 @@ exports.main = function main(argv, options, callback) {
   if (args.transform) {
     let transformArgs = args.transform;
     for (let i = 0, k = transformArgs.length; i < k; ++i) {
-      let filename = transformArgs[i];
-      filename = path.isAbsolute(filename = filename.trim())
-        ? filename
-        : path.join(process.cwd(), filename);
+      let filename = transformArgs[i].trim();
       if (/\.ts$/.test(filename)) require("ts-node").register({ transpileOnly: true, skipProject: true });
       try {
-        const classOrModule = require(filename);
+        const classOrModule = require(require.resolve(filename, { paths: [baseDir, process.cwd()] }));
         if (typeof classOrModule === "function") {
           Object.assign(classOrModule.prototype, {
             baseDir,

cli/asc.js

@@ -324,6 +324,7 @@ export class Flow {
       case NativeType.F32: { temps = parentFunction.tempF32s; break; }
       case NativeType.F64: { temps = parentFunction.tempF64s; break; }
       case NativeType.V128: { temps = parentFunction.tempV128s; break; }
+      case NativeType.Anyref: { temps = parentFunction.tempAnyrefs; break; }
       default: throw new Error("concrete type expected");
     }
     var local: Local;
@@ -395,6 +396,10 @@ export class Flow {
         temps = parentFunction.tempV128s || (parentFunction.tempV128s = []);
         break;
       }
+      case NativeType.Anyref: {
+        temps = parentFunction.tempAnyrefs || (parentFunction.tempAnyrefs = []);
+        break;
+      }
       default: throw new Error("concrete type expected");
     }
     assert(local.index >= 0);

src/flow.ts

@@ -1423,6 +1423,10 @@ export class Module {
             // TODO
             return 0;
           }
+          // Not possible to clone an anyref as it is opaque
+          case NativeType.Anyref: {
+            return 0;
+          }
           default: {
             throw new Error("concrete type expected");
           }

src/module.ts

@@ -2900,6 +2900,7 @@ export class Function extends TypedElement {
   tempF32s: Local[] | null = null;
   tempF64s: Local[] | null = null;
   tempV128s: Local[] | null = null;
+  tempAnyrefs: Local[] | null = null;
 
   // used by flows to keep track of break labels
   nextBreakId: i32 = 0;

src/program.ts

@@ -105,9 +105,12 @@ export class Array<T> extends ArrayBufferView {
   }
 
   @operator("[]=") private __set(index: i32, value: T): void {
-    ensureSize(changetype<usize>(this), index + 1, alignof<T>());
+    if (<u32>index >= <u32>this.length_) {
+      if (index < 0) throw new RangeError(E_INDEXOUTOFRANGE);
+      ensureSize(changetype<usize>(this), index + 1, alignof<T>());
+      this.length_ = index + 1;
+    }
     this.__unchecked_set(index, value);
-    if (index >= this.length_) this.length_ = index + 1;
   }
 
   @unsafe @operator("{}=") private __unchecked_set(index: i32, value: T): void {

std/assembly/array.ts

@@ -1248,8 +1248,6 @@ declare abstract class TypedArray<T> implements ArrayBufferView {
   [key: number]: T;
   /** Number of bytes per element. */
   static readonly BYTES_PER_ELEMENT: usize;
-  /** Wrap an ArrayBuffer */
-  static wrap(buffer: ArrayBuffer, byteOffset?: i32, length?: i32): ArrayBufferView;
   /** Constructs a new typed array. */
   constructor(length: i32);
   /** The {@link ArrayBuffer} referenced by this view. */
@@ -1301,27 +1299,60 @@ declare abstract class TypedArray<T> implements ArrayBufferView {
 }
 
 /** An array of twos-complement 8-bit signed integers. */
-declare class Int8Array extends TypedArray<i8> {}
+declare class Int8Array extends TypedArray<i8> {
+  /** Wrap an ArrayBuffer */
+  static wrap(buffer: ArrayBuffer, byteOffset?: i32, length?: i32): Int8Array;
+}
 /** An array of 8-bit unsigned integers. */
-declare class Uint8Array extends TypedArray<u8> {}
+declare class Uint8Array extends TypedArray<u8> {
+  /** Wrap an ArrayBuffer */
+  static wrap(buffer: ArrayBuffer, byteOffset?: i32, length?: i32): Uint8Array;
+}
 /** A clamped array of 8-bit unsigned integers. */
-declare class Uint8ClampedArray extends TypedArray<u8> {}
+declare class Uint8ClampedArray extends TypedArray<u8> {
+  /** Wrap an ArrayBuffer */
+  static wrap(buffer: ArrayBuffer, byteOffset?: i32, length?: i32): Uint8ClampedArray;
+}
 /** An array of twos-complement 16-bit signed integers. */
-declare class Int16Array extends TypedArray<i16> {}
+declare class Int16Array extends TypedArray<i16> {
+  /** Wrap an ArrayBuffer */
+  static wrap(buffer: ArrayBuffer, byteOffset?: i32, length?: i32): Int16Array;
+}
 /** An array of 16-bit unsigned integers. */
-declare class Uint16Array extends TypedArray<u16> {}
+declare class Uint16Array extends TypedArray<u16> {
+  /** Wrap an ArrayBuffer */
+  static wrap(buffer: ArrayBuffer, byteOffset?: i32, length?: i32): Uint16Array;
+}
 /** An array of twos-complement 32-bit signed integers. */
-declare class Int32Array extends TypedArray<i32> {}
+declare class Int32Array extends TypedArray<i32> {
+  /** Wrap an ArrayBuffer */
+  static wrap(buffer: ArrayBuffer, byteOffset?: i32, length?: i32): Int32Array;
+}
 /** An array of 32-bit unsigned integers. */
-declare class Uint32Array extends TypedArray<u32> {}
+declare class Uint32Array extends TypedArray<u32> {
+  /** Wrap an ArrayBuffer */
+  static wrap(buffer: ArrayBuffer, byteOffset?: i32, length?: i32): Uint32Array;
+}
 /** An array of twos-complement 64-bit signed integers. */
-declare class Int64Array extends TypedArray<i64> {}
+declare class Int64Array extends TypedArray<i64> {
+  /** Wrap an ArrayBuffer */
+  static wrap(buffer: ArrayBuffer, byteOffset?: i32, length?: i32): Int64Array;
+}
 /** An array of 64-bit unsigned integers. */
-declare class Uint64Array extends TypedArray<u64> {}
+declare class Uint64Array extends TypedArray<u64> {
+  /** Wrap an ArrayBuffer */
+  static wrap(buffer: ArrayBuffer, byteOffset?: i32, length?: i32): Uint64Array;
+}
 /** An array of 32-bit floating point numbers. */
-declare class Float32Array extends TypedArray<f32> {}
+declare class Float32Array extends TypedArray<f32> {
+  /** Wrap an ArrayBuffer */
+  static wrap(buffer: ArrayBuffer, byteOffset?: i32, length?: i32): Float32Array;
+}
 /** An array of 64-bit floating point numbers. */
-declare class Float64Array extends TypedArray<f64> {}
+declare class Float64Array extends TypedArray<f64> {
+  /** Wrap an ArrayBuffer */
+  static wrap(buffer: ArrayBuffer, byteOffset?: i32, length?: i32): Float64Array;
+}
 
 /** Class representing a sequence of values of type `T`. */
 declare class Array<T> {

std/assembly/index.d.ts

@@ -260,8 +260,7 @@
     return
    end
    local.get $2
-   i64.const 0
-   i64.eq
+   i64.eqz
    if (result i64)
     local.get $1
     i64.const 0

tests/compiler/binary.optimized.wat

@@ -3,7 +3,10 @@
 export declare function external(a: anyref): anyref;
 
 export function internal(a: anyref): anyref {
-  return a;
+  const b = external(a);
+  let c = external(b);
+  var d = external(c);
+  return d;
 }
 
 // can use reflection to work with anyref values