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

Author: actions-user

src/program.ts

@@ -787,6 +787,7 @@ export class Program extends DiagnosticEmitter {
     // queued imports should be resolvable now through traversing exports and queued exports
     for (let i = 0, k = queuedImports.length; i < k; ++i) {
       let queuedImport = queuedImports[i];
+      let localIdentifier = queuedImport.localIdentifier;
       let foreignIdentifier = queuedImport.foreignIdentifier;
       if (foreignIdentifier) { // i.e. import { foo [as bar] } from "./baz"
         let element = this.lookupForeign(
@@ -797,9 +798,9 @@ export class Program extends DiagnosticEmitter {
         );
         if (element) {
           queuedImport.localFile.add(
-            queuedImport.localIdentifier.text,
+            localIdentifier.text,
             element,
-            true // isImport
+            localIdentifier // isImport
           );
         } else {
           // FIXME: file not found is not reported if this happens?
@@ -812,14 +813,15 @@ export class Program extends DiagnosticEmitter {
         let foreignFile = this.lookupForeignFile(queuedImport.foreignPath, queuedImport.foreignPathAlt);
         if (foreignFile) {
           let localFile = queuedImport.localFile;
-          let localName = queuedImport.localIdentifier.text;
+          let localName = localIdentifier.text;
           localFile.add(
             localName,
             foreignFile.asImportedNamespace(
               localName,
-              localFile
+              localFile,
+              localIdentifier
             ),
-            true // isImport
+            localIdentifier // isImport
           );
         } else {
           assert(false); // already reported by the parser not finding the file
@@ -1775,7 +1777,7 @@ export class Program extends DiagnosticEmitter {
     // resolve right away if the element exists
     var element = this.lookupForeign(declaration.foreignName.text, foreignPath, foreignPathAlt, queuedExports);
     if (element) {
-      parent.add(declaration.name.text, element, true);
+      parent.add(declaration.name.text, element, declaration.name /* isImport */);
       return;
     }
 
@@ -2161,7 +2163,7 @@ export abstract class Element {
   abstract lookup(name: string): Element | null;
 
   /** Adds an element as a member of this one. Reports and returns `false` if a duplicate. */
-  add(name: string, element: DeclaredElement): bool {
+  add(name: string, element: DeclaredElement, localIdentifierIfImport: IdentifierExpression | null = null): bool {
     var originalDeclaration = element.declaration;
     var members = this.members;
     if (!members) this.members = members = new Map();
@@ -2174,17 +2176,18 @@ export abstract class Element {
         if (merged) {
           element = merged; // use merged element
         } else {
+          let reportedIdentifier = localIdentifierIfImport || element.identifierNode;
           if (isDeclaredElement(existing.kind)) {
             this.program.errorRelated(
               DiagnosticCode.Duplicate_identifier_0,
-              element.identifierNode.range,
-              (<DeclaredElement>existing).declaration.name.range,
-              element.identifierNode.text
+              reportedIdentifier.range,
+              (<DeclaredElement>existing).identifierNode.range,
+              reportedIdentifier.text
             );
           } else {
             this.program.error(
               DiagnosticCode.Duplicate_identifier_0,
-              element.identifierNode.range, element.identifierNode.text
+              reportedIdentifier.range, reportedIdentifier.text
             );
           }
           return false;
@@ -2338,13 +2341,13 @@ export class File extends Element {
   }
 
   /* @override */
-  add(name: string, element: DeclaredElement, isImport: bool = false): bool {
+  add(name: string, element: DeclaredElement, localIdentifierIfImport: IdentifierExpression | null = null): bool {
     if (element.hasDecorator(DecoratorFlags.GLOBAL)) {
       element = this.program.ensureGlobal(name, element); // possibly merged globally
     }
-    if (!super.add(name, element)) return false;
+    if (!super.add(name, element, localIdentifierIfImport)) return false;
     element = assert(this.lookupInSelf(name)); // possibly merged locally
-    if (element.is(CommonFlags.EXPORT) && !isImport) {
+    if (element.is(CommonFlags.EXPORT) && !localIdentifierIfImport) {
       this.ensureExport(
         element.name,
         element
@@ -2404,12 +2407,10 @@ export class File extends Element {
   }
 
   /** Creates an imported namespace from this file. */
-  asImportedNamespace(name: string, parent: Element): Namespace {
-    var ns = new Namespace(
-      name,
-      parent,
-      this.program.makeNativeNamespaceDeclaration(name)
-    );
+  asImportedNamespace(name: string, parent: Element, localIdentifier: IdentifierExpression): Namespace {
+    var declaration = this.program.makeNativeNamespaceDeclaration(name);
+    declaration.name = localIdentifier;
+    var ns = new Namespace(name, parent, declaration);
     var exports = this.exports;
     if (exports) {
       for (let [memberName, member] of exports) {
@@ -3719,7 +3720,7 @@ function tryMerge(older: Element, newer: Element): DeclaredElement | null {
   // NOTE: some of the following cases are not supported by TS, not sure why exactly.
   // suggesting to just merge what seems to be possible for now and revisit later.
   assert(older.program === newer.program);
-  assert(!newer.members);
+  if (newer.members) return null;
   var merged: DeclaredElement | null = null;
   switch (older.kind) {
     case ElementKind.FUNCTION_PROTOTYPE: {

std/assembly/string.ts

@@ -1,10 +1,9 @@
 /// <reference path="./rt/index.d.ts" />
 
 import { BLOCK, BLOCK_OVERHEAD, BLOCK_MAXSIZE } from "./rt/common";
-import { compareImpl, strtol, strtod, isSpace, isAscii, toLower8, toUpper8 } from "./util/string";
+import { compareImpl, strtol, strtod, isSpace, isAscii, isFinalSigma, toLower8, toUpper8 } from "./util/string";
 import { SPECIALS_UPPER, casemap, bsearch } from "./util/casemap";
 import { E_INVALIDLENGTH } from "./util/error";
-import { idof } from "./builtins";
 
 @sealed export abstract class String {
 
@@ -54,7 +53,7 @@ import { idof } from "./builtins";
     if (<u32>pos >= <u32>len) return -1; // (undefined)
     var first = <i32>load<u16>(changetype<usize>(this) + (<usize>pos << 1));
     if ((first & 0xFC00) != 0xD800 || pos + 1 == len) return first;
-    var second = <i32>load<u16>(changetype<usize>(this) + ((<usize>pos + 1) << 1));
+    var second = <i32>load<u16>(changetype<usize>(this) + (<usize>pos << 1), 2);
     if ((second & 0xFC00) != 0xDC00) return first;
     return (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;
   }
@@ -526,6 +525,13 @@ import { idof } from "./builtins";
           // 0x0130 -> [0x0069, 0x0307]
           store<u32>(codes + (j << 1), (0x0307 << 16) | 0x0069);
           ++j;
+        } else if (c == 0x03A3) { // 'Σ'
+          // Σ maps to σ but except at the end of a word where it maps to ς
+          let sigma = 0x03C3; // σ
+          if (len > 1 && isFinalSigma(changetype<usize>(this), i, len)) {
+            sigma = 0x03C2; // ς
+          }
+          store<u16>(codes + (j << 1), sigma);
         } else if (c - 0x24B6 <= 0x24CF - 0x24B6) {
           // Range 0x24B6 <= c <= 0x24CF not covered by casemap and require special early handling
           store<u16>(codes + (j << 1), c + 26);
@@ -552,7 +558,8 @@ import { idof } from "./builtins";
     var len = <usize>this.length;
     if (!len) return this;
     var codes = __alloc(len * 3 * 2, idof<String>());
-    var specialsUpperLen = SPECIALS_UPPER.length;
+    var specialsPtr = changetype<usize>(SPECIALS_UPPER);
+    var specialsLen = SPECIALS_UPPER.length;
     var j: usize = 0;
     for (let i: usize = 0; i < len; ++i, ++j) {
       let c = <u32>load<u16>(changetype<usize>(this) + (i << 1));
@@ -578,15 +585,15 @@ import { idof } from "./builtins";
           // monkey patch
           store<u16>(codes + (j << 1), c - 26);
         } else {
-          let index = -1;
+          let index = -1 as usize;
           // Fast range check. See first and last rows in specialsUpper table
           if (c - 0x00DF <= 0xFB17 - 0x00DF) {
-            index = <usize>bsearch(c, changetype<usize>(SPECIALS_UPPER), specialsUpperLen);
+            index = <usize>bsearch(c, specialsPtr, specialsLen);
           }
           if (~index) {
             // load next 3 code points from row with `index` offset for specialsUpper table
-            let ab = load<u32>(changetype<usize>(SPECIALS_UPPER) + (index << 1), 2);
-            let cc = load<u16>(changetype<usize>(SPECIALS_UPPER) + (index << 1), 6);
+            let ab = load<u32>(specialsPtr + (index << 1), 2);
+            let cc = load<u16>(specialsPtr + (index << 1), 6);
             store<u32>(codes + (j << 1), ab, 0);
             store<u16>(codes + (j << 1), cc, 4);
             j += 1 + usize(cc != 0);