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

Author: actions-user

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,4 @@
+<!--
+ Thanks for submitting an issue to AssemblyScript! Please take a moment to
+ read the contributing guidelines linked below to get off to a good start 🙂
+-->

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,10 @@
+<!--
+ Thanks for submitting a pull request to AssemblyScript! Please take a moment to
+ review the contributing guidelines linked below, and confirm with an [x] 🙂
+-->
+
+⯈
+⯈
+⯈
+
+- [ ] I've read the contributing guidelines

CONTRIBUTING.md

@@ -35,15 +35,20 @@ Submitting Pull Requests
 
 Instructions are similar to those for bug reports. Please provide the following information:
 
+* If this is not a trivial fix, consider **creating an issue to discuss first** and **later link to it from the PR**.
 * Use a **clear and descriptive title** for the pull request.
-* Provide a **description of the suggested changes** in as many details as necessary.
+* Provide a **description of the changes** in as many details as necessary.
 * **Document your new code** where necessary.
 * Please **refrain from refactoring (unrelated code)** as it makes your pull request easier to review.
 * **Create tests for your new code** where necessary. For creating or updating tests, please see the [Test Instructions](./tests).
 
-Before submitting your pull request, please make sure that the following conditions are met:
+Before submitting your pull request, also make sure that the following conditions are met:
 
 * Your new code **adheres to the code style** through running `npm run check`.
 * Your new code **passes all existing and new tests** through running `npm run test`.
 * Your PR **excludes distribution files** in `dist/**`.
 * You appended yourself to the **list of contributors** in the [NOTICE](./NOTICE) file.
+
+Please note that if a pull request is rather complicated, i.e. touches lots of internals, or became stale, it is not uncommon that a core contributor performs the final integration to get it done in good conscience while naming you as a co-author.
+
+Thank you!

NOTICE

@@ -21,6 +21,7 @@ under the licensing terms detailed in LICENSE:
 * Vladimir Tikhonov <[email protected]>
 * Duncan Uszkay <[email protected]>
 * Surma <[email protected]>
+* Julien Letellier <[email protected]>
 
 Portions of this software are derived from third-party works licensed under
 the following terms:

cli/asc.js

@@ -207,20 +207,20 @@ exports.main = function main(argv, options, callback) {
   // Check for unknown arguments
   if (opts.unknown.length) {
     opts.unknown.forEach(arg => {
-      stderr.write(colorsUtil.stderr.yellow("WARN: ") + "Unknown option '" + arg + "'" + EOL);
+      stderr.write(colorsUtil.stderr.yellow("WARNING ") + "Unknown option '" + arg + "'" + EOL);
     });
   }
 
   // Check for trailing arguments
   if (opts.trailing.length) {
-    stderr.write(colorsUtil.stderr.yellow("WARN: ") + "Unsupported trailing arguments: " + opts.trailing.join(" ") + EOL);
+    stderr.write(colorsUtil.stderr.yellow("WARNING ") + "Unsupported trailing arguments: " + opts.trailing.join(" ") + EOL);
   }
 
   // Use default callback if none is provided
   if (!callback) callback = function defaultCallback(err) {
     var code = 0;
     if (err) {
-      stderr.write(colorsUtil.stderr.red("ERROR: ") + err.stack.replace(/^ERROR: /i, "") + EOL);
+      stderr.write(colorsUtil.stderr.red("FAILURE ") + err.stack.replace(/^ERROR: /i, "") + EOL);
       code = 1;
     }
     return code;
@@ -534,15 +534,20 @@ exports.main = function main(argv, options, callback) {
     var internalPath;
     while ((internalPath = assemblyscript.nextFile(program)) != null) {
       let file = getFile(internalPath, assemblyscript.getDependee(program, internalPath));
-      if (!file) return callback(Error("Import '" + internalPath + "' not found."));
-      stats.parseCount++;
-      stats.parseTime += measure(() => {
-        assemblyscript.parse(program, file.sourceText, file.sourcePath, false);
-      });
+      if (file) {
+        stats.parseCount++;
+        stats.parseTime += measure(() => {
+          assemblyscript.parse(program, file.sourceText, file.sourcePath, false);
+        });
+      } else {
+        assemblyscript.parse(program, null, internalPath + extension.ext, false);
+      }
     }
     var numErrors = checkDiagnostics(program, stderr);
     if (numErrors) {
-      return callback(Error(numErrors + " parse error(s)"));
+      const err = Error(numErrors + " parse error(s)");
+      err.stack = err.message; // omit stack
+      return callback(err);
     }
   }
 
@@ -577,8 +582,8 @@ exports.main = function main(argv, options, callback) {
     let sourceText = readFile(sourcePath + extension.ext, baseDir);
     if (sourceText == null) {
       sourceText = readFile(sourcePath + "/index" + extension.ext, baseDir);
-      if (sourceText == null) return callback(Error("Entry file '" + sourcePath + extension.ext + "' not found."));
-      sourcePath += "/index" + extension.ext;
+      if (sourceText != null) sourcePath += "/index" + extension.ext;
+      else sourcePath += extension.ext;
     } else {
       sourcePath += extension.ext;
     }
@@ -634,7 +639,9 @@ exports.main = function main(argv, options, callback) {
   var numErrors = checkDiagnostics(program, stderr);
   if (numErrors) {
     if (module) module.dispose();
-    return callback(Error(numErrors + " compile error(s)"));
+    const err = Error(numErrors + " compile error(s)");
+    err.stack = err.message; // omit stack
+    return callback(err);
   }
 
   // Call afterCompile transform hook

src/index.ts

@@ -214,8 +214,8 @@ export function isError(message: DiagnosticMessage): bool {
 export function parse(
   /** Program reference. */
   program: Program,
-  /** Source text of the file. */
-  text: string,
+  /** Source text of the file, or `null` to indicate not found. */
+  text: string | null,
   /** Normalized path of the file. */
   path: string,
   /** Whether this is an entry file. */

src/parser.ts

@@ -89,6 +89,14 @@ import {
   mangleInternalPath
 } from "./ast";
 
+/** Represents a dependee. */
+class Dependee {
+  constructor(
+    public source: Source,
+    public reportNode: Node
+  ) {}
+}
+
 /** Parser interface. */
 export class Parser extends DiagnosticEmitter {
 
@@ -102,8 +110,8 @@ export class Parser extends DiagnosticEmitter {
   onComment: CommentHandler | null = null;
   /** Current file being parsed. */
   currentSource: Source | null = null;
-  /** Dependency map **/
-  dependees: Map<string, Source> = new Map();
+  /** Map of dependees being depended upon by a source, by path. */
+  dependees: Map<string, Dependee> = new Map();
   /** An array of parsed sources. */
   sources: Source[];
 
@@ -118,21 +126,37 @@ export class Parser extends DiagnosticEmitter {
 
   /** Parses a file and adds its definitions to the program. */
   parseFile(
-    /** Source text of the file. */
-    text: string,
+    /** Source text of the file, or `null` to indicate not found. */
+    text: string | null,
     /** Normalized path of the file. */
     path: string,
     /** Whether this is an entry file. */
     isEntry: bool
   ): void {
     // the frontend gives us paths with file extensions
     var normalizedPath = normalizePath(path);
-    var internalPath = mangleInternalPath(normalizedPath);
+    var internalPath = mangleInternalPath(path);
+
     // check if already processed
     if (this.donelog.has(internalPath)) return;
     this.donelog.add(internalPath); // do not parse again
     this.seenlog.add(internalPath); // do not request again
 
+    // check if this is an error
+    if (text === null) {
+      let dependees = this.dependees;
+      let dependee: Dependee | null = null;
+      if (dependees.has(internalPath)) dependee = assert(dependees.get(internalPath));
+      this.error(
+        DiagnosticCode.File_0_not_found,
+        dependee
+          ? dependee.reportNode.range
+          : null,
+        path
+      );
+      return;
+    }
+
     // create the source element
     var source = new Source(
       isEntry
@@ -402,10 +426,13 @@ export class Parser extends DiagnosticEmitter {
     return backlog.length ? assert(backlog.shift()) : null;
   }
 
-  /** Obtains the dependee of the given imported file. */
+  /** Obtains the path of the dependee of the given imported file. */
   getDependee(dependent: string): string | null {
-    var source = this.dependees.get(dependent);
-    if (source) return source.internalPath;
+    var dependees = this.dependees;
+    if (dependees.has(dependent)) {
+      let dependee = assert(dependees.get(dependent));
+      return dependee.source.internalPath;
+    }
     return null;
   }
 
@@ -2447,11 +2474,13 @@ export class Parser extends DiagnosticEmitter {
         }
       }
       let ret = Node.createExportStatement(members, path, isDeclare, tn.range(startPos, tn.pos));
-      let internalPath = ret.internalPath;
-      if (internalPath !== null && !this.seenlog.has(internalPath)) {
-        this.dependees.set(internalPath, currentSource);
-        this.backlog.push(internalPath);
-        this.seenlog.add(internalPath);
+      if (path !== null) {
+        let internalPath = assert(ret.internalPath);
+        if (!this.seenlog.has(internalPath)) {
+          this.dependees.set(internalPath, new Dependee(currentSource, path));
+          this.backlog.push(internalPath);
+          this.seenlog.add(internalPath);
+        }
       }
       tn.skip(Token.SEMICOLON);
       return ret;
@@ -2466,7 +2495,7 @@ export class Parser extends DiagnosticEmitter {
           if (!exportPaths) source.exportPaths = [ internalPath ];
           else if (!exportPaths.includes(internalPath)) exportPaths.push(internalPath);
           if (!this.seenlog.has(internalPath)) {
-            this.dependees.set(internalPath, currentSource);
+            this.dependees.set(internalPath, new Dependee(currentSource, path));
             this.backlog.push(internalPath);
           }
           tn.skip(Token.SEMICOLON);
@@ -2638,7 +2667,7 @@ export class Parser extends DiagnosticEmitter {
         }
         let internalPath = ret.internalPath;
         if (!this.seenlog.has(internalPath)) {
-          this.dependees.set(internalPath, assert(this.currentSource));
+          this.dependees.set(internalPath, new Dependee(assert(this.currentSource), path));
           this.backlog.push(internalPath);
         }
         tn.skip(Token.SEMICOLON);

std/portable/index.d.ts

@@ -303,3 +303,48 @@ declare function unmanaged(constructor: Function): void;
 
 /** Environmental tracing function. */
 declare function trace(msg: string, n?: i32, a0?: f64, a1?: f64, a2?: f64, a3?: f64, a4?: f64): void;
+
+declare interface Int8ArrayConstructor {
+  /** Equivalent to calling `new Int8Array` with multiple arguments. */
+  wrap(buffer: ArrayBuffer, byteOffset?: i32, length?: i32): Int8Array;
+}
+
+declare interface Uint8ArrayConstructor {
+  /** Equivalent to calling `new Uint8Array` with multiple arguments. */
+  wrap(buffer: ArrayBuffer, byteOffset?: i32, length?: i32): Uint8Array;
+}
+
+declare interface Uint8ClampedArrayConstructor {
+  /** Equivalent to calling `new Uint8ClampedArray` with multiple arguments. */
+  wrap(buffer: ArrayBuffer, byteOffset?: i32, length?: i32): Uint8ClampedArray;
+}
+
+declare interface Int16ArrayConstructor {
+  /** Equivalent to calling `new Int16Array` with multiple arguments. */
+  wrap(buffer: ArrayBuffer, byteOffset?: i32, length?: i32): Int16Array;
+}
+
+declare interface Uint16ArrayConstructor {
+  /** Equivalent to calling `new Uint16Array` with multiple arguments. */
+  wrap(buffer: ArrayBuffer, byteOffset?: i32, length?: i32): Uint16Array;
+}
+
+declare interface Int32ArrayConstructor {
+  /** Equivalent to calling `new Int32Array` with multiple arguments. */
+  wrap(buffer: ArrayBuffer, byteOffset?: i32, length?: i32): Int32Array;
+}
+
+declare interface Uint32ArrayConstructor {
+  /** Equivalent to calling `new Uint32Array` with multiple arguments. */
+  wrap(buffer: ArrayBuffer, byteOffset?: i32, length?: i32): Uint32Array;
+}
+
+declare interface Float32ArrayConstructor {
+  /** Equivalent to calling `new Float32Array` with multiple arguments. */
+  wrap(buffer: ArrayBuffer, byteOffset?: i32, length?: i32): Float32Array;
+}
+
+declare interface Float64ArrayConstructor {
+  /** Equivalent to calling `new Float64Array` with multiple arguments. */
+  wrap(buffer: ArrayBuffer, byteOffset?: i32, length?: i32): Float64Array;
+}

std/portable/index.js

@@ -313,3 +313,57 @@ globalScope["trace"] = function(message, n) {
   if (n) message += Array.prototype.slice.call(arguments, 2, 2 + n);
   console.error("trace: " + message);
 };
+
+Object.defineProperty(Int8Array, "wrap", {
+  value: function wrap(buffer, byteOffset, length) {
+    return new Int8Array(buffer, byteOffset, length);
+  }
+});
+
+Object.defineProperty(Uint8Array, "wrap", {
+  value: function wrap(buffer, byteOffset, length) {
+    return new Uint8Array(buffer, byteOffset, length);
+  }
+});
+
+Object.defineProperty(Uint8ClampedArray, "wrap", {
+  value: function wrap(buffer, byteOffset, length) {
+    return new Uint8ClampedArray(buffer, byteOffset, length);
+  }
+});
+
+Object.defineProperty(Int16Array, "wrap", {
+  value: function wrap(buffer, byteOffset, length) {
+    return new Int16Array(buffer, byteOffset, length);
+  }
+});
+
+Object.defineProperty(Uint16Array, "wrap", {
+  value: function wrap(buffer, byteOffset, length) {
+    return new Uint16Array(buffer, byteOffset, length);
+  }
+});
+
+Object.defineProperty(Int32Array, "wrap", {
+  value: function wrap(buffer, byteOffset, length) {
+    return new Int32Array(buffer, byteOffset, length);
+  }
+});
+
+Object.defineProperty(Uint32Array, "wrap", {
+  value: function wrap(buffer, byteOffset, length) {
+    return new Uint32Array(buffer, byteOffset, length);
+  }
+});
+
+Object.defineProperty(Float32Array, "wrap", {
+  value: function wrap(buffer, byteOffset, length) {
+    return new Float32Array(buffer, byteOffset, length);
+  }
+});
+
+Object.defineProperty(Float64Array, "wrap", {
+  value: function wrap(buffer, byteOffset, length) {
+    return new Float64Array(buffer, byteOffset, length);
+  }
+});

tests/packages/packages/g/test.js

@@ -1,17 +1,16 @@
 #!/usr/bin/env node
-let asc = require("../../../../cli/asc");
+const asc = require("../../../../cli/asc");
 
-let argv = [
+const stderr = asc.createMemoryStream();
+asc.main([
   "assembly/index.ts",
   "--noEmit",
   "--runtime", "stub",
   "--traceResolution"
-];
-
-asc.main(argv, error => {
-  if (/Import .*lib\/a.* not found/g.test(error.message)) {
+], { stderr }, err => {
+  if (stderr.toString().includes("File '~lib/a.ts' not found.")) {
     process.exit(0);
   }
-  console.error("Failed!\n" + error);
+  console.error("Failed!\n" + err);
   process.exit(1);
 });