Merge branch 'master' into tscJsFiles

Jakefile.js

@@ -780,17 +780,36 @@ task("update-sublime", ["local", serverFile], function() {
     jake.cpR(serverFile + ".map", "../TypeScript-Sublime-Plugin/tsserver/");
 });
 
+var tslintRuleDir = "scripts/tslint";
+var tslintRules = ([
+    "nextLineRule",
+    "noInferrableTypesRule",
+    "noNullRule",
+    "booleanTriviaRule"
+]);
+var tslintRulesFiles = tslintRules.map(function(p) {
+    return path.join(tslintRuleDir, p + ".ts");
+});
+var tslintRulesOutFiles = tslintRules.map(function(p) {
+    return path.join(builtLocalDirectory, "tslint", p + ".js");
+});
+desc("Compiles tslint rules to js");
+task("build-rules", tslintRulesOutFiles);
+tslintRulesFiles.forEach(function(ruleFile, i) {
+    compileFile(tslintRulesOutFiles[i], [ruleFile], [ruleFile], [], /*useBuiltCompiler*/ true, /*noOutFile*/ true, /*generateDeclarations*/ false, path.join(builtLocalDirectory, "tslint")); 
+});
+
 // if the codebase were free of linter errors we could make jake runtests
 // run this task automatically
 desc("Runs tslint on the compiler sources");
-task("lint", [], function() {
+task("lint", ["build-rules"], function() {
     function success(f) { return function() { console.log('SUCCESS: No linter errors in ' + f + '\n'); }};
     function failure(f) { return function() { console.log('FAILURE: Please fix linting errors in ' + f + '\n') }};
 
     var lintTargets = compilerSources.concat(harnessCoreSources);
     for (var i in lintTargets) {
         var f = lintTargets[i];
-        var cmd = 'tslint -c tslint.json ' + f;
+        var cmd = 'tslint --rules-dir built/local/tslint -c tslint.json ' + f;
         exec(cmd, success(f), failure(f));
     }
 }, { async: true });

scripts/tslint/booleanTriviaRule.ts

@@ -0,0 +1,50 @@
+/// <reference path="../../node_modules/tslint/typings/typescriptServices.d.ts" />
+/// <reference path="../../node_modules/tslint/lib/tslint.d.ts" />
+
+
+export class Rule extends Lint.Rules.AbstractRule {
+    public static FAILURE_STRING_FACTORY = (name: string, currently: string) => `Tag boolean argument as '${name}' (currently '${currently}')`;
+
+    public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
+        const program = ts.createProgram([sourceFile.fileName], Lint.createCompilerOptions());
+        const checker = program.getTypeChecker();
+        return this.applyWithWalker(new BooleanTriviaWalker(checker, program.getSourceFile(sourceFile.fileName), this.getOptions()));
+    }
+}
+
+class BooleanTriviaWalker extends Lint.RuleWalker {
+    constructor(private checker: ts.TypeChecker, file: ts.SourceFile, opts: Lint.IOptions) {
+        super(file, opts);
+    }
+
+    visitCallExpression(node: ts.CallExpression) {
+        super.visitCallExpression(node);
+		if (node.arguments) {
+            const targetCallSignature = this.checker.getResolvedSignature(node);
+            if (!!targetCallSignature) {
+                const targetParameters = targetCallSignature.getParameters();
+                const source = this.getSourceFile();
+                for (let index = 0; index < targetParameters.length; index++) {
+                    const param = targetParameters[index];
+                    const arg = node.arguments[index];
+                    if (!(arg && param)) continue;
+
+                    const argType = this.checker.getContextualType(arg);
+                    if (argType && (argType.getFlags() & ts.TypeFlags.Boolean)) {
+                        if (arg.kind !== ts.SyntaxKind.TrueKeyword && arg.kind !== ts.SyntaxKind.FalseKeyword) {
+                            continue;
+                        }
+                        let triviaContent: string;
+                        const ranges = ts.getLeadingCommentRanges(arg.getFullText(), 0);
+                        if (ranges && ranges.length === 1 && ranges[0].kind === ts.SyntaxKind.MultiLineCommentTrivia) {
+                            triviaContent = arg.getFullText().slice(ranges[0].pos + 2, ranges[0].end - 2); //+/-2 to remove /**/
+                        }
+                        if (triviaContent !== param.getName()) {
+                            this.addFailure(this.createFailure(arg.getStart(source), arg.getWidth(source), Rule.FAILURE_STRING_FACTORY(param.getName(), triviaContent)));
+                        }
+                    }
+                }
+            }
+		}			
+    }
+}

scripts/tslint/nextLineRule.ts

@@ -0,0 +1,61 @@
+/// <reference path="../../node_modules/tslint/typings/typescriptServices.d.ts" />
+/// <reference path="../../node_modules/tslint/lib/tslint.d.ts" />
+
+const OPTION_CATCH = "check-catch";
+const OPTION_ELSE = "check-else";
+
+export class Rule extends Lint.Rules.AbstractRule {
+    public static CATCH_FAILURE_STRING = "'catch' should be on the line following the previous block's ending curly brace";
+    public static ELSE_FAILURE_STRING = "'else' should be on the line following the previous block's ending curly brace";
+
+    public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
+        return this.applyWithWalker(new NextLineWalker(sourceFile, this.getOptions()));
+    }
+}
+
+class NextLineWalker extends Lint.RuleWalker {
+    public visitIfStatement(node: ts.IfStatement) {
+        const sourceFile = node.getSourceFile();
+        const thenStatement = node.thenStatement;
+
+        const elseStatement = node.elseStatement;
+        if (!!elseStatement) {
+            // find the else keyword
+            const elseKeyword = getFirstChildOfKind(node, ts.SyntaxKind.ElseKeyword);
+            if (this.hasOption(OPTION_ELSE) && !!elseKeyword) {
+                const thenStatementEndLoc = sourceFile.getLineAndCharacterOfPosition(thenStatement.getEnd());
+                const elseKeywordLoc = sourceFile.getLineAndCharacterOfPosition(elseKeyword.getStart(sourceFile));
+                if (thenStatementEndLoc.line !== (elseKeywordLoc.line - 1)) {
+                    const failure = this.createFailure(elseKeyword.getStart(sourceFile), elseKeyword.getWidth(sourceFile), Rule.ELSE_FAILURE_STRING);
+                    this.addFailure(failure);
+                }
+            }
+        }
+
+        super.visitIfStatement(node);
+    }
+
+    public visitTryStatement(node: ts.TryStatement) {
+        const sourceFile = node.getSourceFile();
+        const catchClause = node.catchClause;
+
+        // "visit" try block
+        const tryBlock = node.tryBlock;
+
+        if (this.hasOption(OPTION_CATCH) && !!catchClause) {
+            const tryClosingBrace = tryBlock.getLastToken(sourceFile);
+            const catchKeyword = catchClause.getFirstToken(sourceFile);
+            const tryClosingBraceLoc = sourceFile.getLineAndCharacterOfPosition(tryClosingBrace.getEnd());
+            const catchKeywordLoc = sourceFile.getLineAndCharacterOfPosition(catchKeyword.getStart(sourceFile));
+            if (tryClosingBraceLoc.line !== (catchKeywordLoc.line - 1)) {
+                const failure = this.createFailure(catchKeyword.getStart(sourceFile), catchKeyword.getWidth(sourceFile), Rule.CATCH_FAILURE_STRING);
+                this.addFailure(failure);
+            }
+        }
+        super.visitTryStatement(node);
+    }
+}
+
+function getFirstChildOfKind(node: ts.Node, kind: ts.SyntaxKind) {
+    return node.getChildren().filter((child) => child.kind === kind)[0];
+}

scripts/tslint/noInferrableTypesRule.ts

@@ -0,0 +1,49 @@
+/// <reference path="../../node_modules/tslint/typings/typescriptServices.d.ts" />
+/// <reference path="../../node_modules/tslint/lib/tslint.d.ts" />
+
+
+export class Rule extends Lint.Rules.AbstractRule {
+    public static FAILURE_STRING_FACTORY = (type: string) => `LHS type (${type}) inferred by RHS expression, remove type annotation`;
+
+    public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
+        return this.applyWithWalker(new InferrableTypeWalker(sourceFile, this.getOptions()));
+    }
+}
+
+class InferrableTypeWalker extends Lint.RuleWalker {
+    visitVariableStatement(node: ts.VariableStatement) {
+        node.declarationList.declarations.forEach(e => {
+            if ((!!e.type) && (!!e.initializer)) {
+                let failure: string;
+                switch (e.type.kind) {
+                    case ts.SyntaxKind.BooleanKeyword:
+                        if (e.initializer.kind === ts.SyntaxKind.TrueKeyword || e.initializer.kind === ts.SyntaxKind.FalseKeyword) {
+                            failure = 'boolean';
+                        }
+                    break;
+                    case ts.SyntaxKind.NumberKeyword:
+                        if (e.initializer.kind === ts.SyntaxKind.NumericLiteral) {
+                            failure = 'number';
+                        }
+                    break;
+                    case ts.SyntaxKind.StringKeyword:
+                        switch (e.initializer.kind) {
+                            case ts.SyntaxKind.StringLiteral:
+                            case ts.SyntaxKind.NoSubstitutionTemplateLiteral:
+                            case ts.SyntaxKind.TemplateExpression:
+                                failure = 'string';
+                                break;
+                            default:
+                                break;
+                        }
+                    break;
+                }
+                if (failure) {
+                    this.addFailure(this.createFailure(e.type.getStart(), e.type.getWidth(), Rule.FAILURE_STRING_FACTORY(failure)));
+                }
+            }
+        });
+
+        super.visitVariableStatement(node);
+    }
+}

scripts/tslint/noNullRule.ts

@@ -0,0 +1,20 @@
+/// <reference path="../../node_modules/tslint/typings/typescriptServices.d.ts" />
+/// <reference path="../../node_modules/tslint/lib/tslint.d.ts" />
+
+
+export class Rule extends Lint.Rules.AbstractRule {
+    public static FAILURE_STRING = "Don't use the 'null' keyword - use 'undefined' for missing values instead";
+
+    public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
+        return this.applyWithWalker(new NullWalker(sourceFile, this.getOptions()));
+    }
+}
+
+class NullWalker extends Lint.RuleWalker {
+    visitNode(node: ts.Node) {
+        super.visitNode(node);
+        if (node.kind === ts.SyntaxKind.NullKeyword) {
+            this.addFailure(this.createFailure(node.getStart(), node.getWidth(), Rule.FAILURE_STRING));
+        }
+    }
+}

scripts/tslint/tsconfig.json

@@ -0,0 +1,7 @@
+{
+	"compilerOptions": {
+		"noImplicitAny": true,
+		"module": "commonjs",
+		"outDir": "../../built/local/tslint"
+	}
+}

src/compiler/emitter.ts

@@ -1517,8 +1517,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                         else if (declaration.kind === SyntaxKind.ImportSpecifier) {
                             // Identifier references named import
                             write(getGeneratedNameForNode(<ImportDeclaration>declaration.parent.parent.parent));
-                            write(".");
-                            writeTextOfNode(currentSourceFile, (<ImportSpecifier>declaration).propertyName || (<ImportSpecifier>declaration).name);
+                            var name =  (<ImportSpecifier>declaration).propertyName || (<ImportSpecifier>declaration).name;
+                            var identifier = getSourceTextOfNodeFromSourceFile(currentSourceFile, name);
+                            if (languageVersion === ScriptTarget.ES3 && identifier === "default") {
+                                write(`["default"]`);
+                            }
+                            else {
+                                write(".");
+                                write(identifier);
+                            }
                             return;
                         }
                     }

src/lib/es6.d.ts

@@ -125,7 +125,34 @@ interface ObjectConstructor {
       * Copy the values of all of the enumerable own properties from one or more source objects to a 
       * target object. Returns the target object.
       * @param target The target object to copy to.
-      * @param sources One or more source objects to copy properties from.
+      * @param source The source object from which to copy properties.
+      */
+    assign<T, U>(target: T, source: U): T & U;
+
+    /**
+      * Copy the values of all of the enumerable own properties from one or more source objects to a 
+      * target object. Returns the target object.
+      * @param target The target object to copy to.
+      * @param source1 The first source object from which to copy properties.
+      * @param source2 The second source object from which to copy properties.
+      */
+    assign<T, U, V>(target: T, source1: U, source2: V): T & U & V;
+
+    /**
+      * Copy the values of all of the enumerable own properties from one or more source objects to a 
+      * target object. Returns the target object.
+      * @param target The target object to copy to.
+      * @param source1 The first source object from which to copy properties.
+      * @param source2 The second source object from which to copy properties.
+      * @param source3 The third source object from which to copy properties.
+      */
+    assign<T, U, V, W>(target: T, source1: U, source2: V, source3: W): T & U & V & W;
+
+    /**
+      * Copy the values of all of the enumerable own properties from one or more source objects to a 
+      * target object. Returns the target object.
+      * @param target The target object to copy to.
+      * @param sources One or more source objects from which to copy properties
       */
     assign(target: any, ...sources: any[]): any;
 

tests/baselines/reference/arrayLiterals2ES6.symbols

@@ -72,14 +72,14 @@ var temp2: [number[], string[]] = [[1, 2, 3], ["hello", "string"]];
 
 interface myArray extends Array<Number> { }
 >myArray : Symbol(myArray, Decl(arrayLiterals2ES6.ts, 40, 67))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4091, 1))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4118, 1))
 >Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
 
 interface myArray2 extends Array<Number|String> { }
 >myArray2 : Symbol(myArray2, Decl(arrayLiterals2ES6.ts, 42, 43))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4091, 1))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4118, 1))
 >Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4209, 1))
+>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4236, 1))
 
 var d0 = [1, true, ...temp, ];  // has type (string|number|boolean)[]
 >d0 : Symbol(d0, Decl(arrayLiterals2ES6.ts, 44, 3))

tests/baselines/reference/asyncArrowFunction1_es6.symbols

@@ -2,6 +2,6 @@
 
 var foo = async (): Promise<void> => {
 >foo : Symbol(foo, Decl(asyncArrowFunction1_es6.ts, 1, 3))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 
 };

tests/baselines/reference/asyncAwait_es6.symbols

@@ -2,16 +2,16 @@
 type MyPromise<T> = Promise<T>;
 >MyPromise : Symbol(MyPromise, Decl(asyncAwait_es6.ts, 0, 0), Decl(asyncAwait_es6.ts, 1, 11))
 >T : Symbol(T, Decl(asyncAwait_es6.ts, 0, 15))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 >T : Symbol(T, Decl(asyncAwait_es6.ts, 0, 15))
 
 declare var MyPromise: typeof Promise;
 >MyPromise : Symbol(MyPromise, Decl(asyncAwait_es6.ts, 0, 0), Decl(asyncAwait_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 
 declare var p: Promise<number>;
 >p : Symbol(p, Decl(asyncAwait_es6.ts, 2, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 
 declare var mp: MyPromise<number>;
 >mp : Symbol(mp, Decl(asyncAwait_es6.ts, 3, 11))
@@ -22,7 +22,7 @@ async function f0() { }
 
 async function f1(): Promise<void> { }
 >f1 : Symbol(f1, Decl(asyncAwait_es6.ts, 5, 23))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 
 async function f3(): MyPromise<void> { }
 >f3 : Symbol(f3, Decl(asyncAwait_es6.ts, 6, 38))
@@ -33,7 +33,7 @@ let f4 = async function() { }
 
 let f5 = async function(): Promise<void> { }
 >f5 : Symbol(f5, Decl(asyncAwait_es6.ts, 10, 3))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 
 let f6 = async function(): MyPromise<void> { }
 >f6 : Symbol(f6, Decl(asyncAwait_es6.ts, 11, 3))
@@ -44,7 +44,7 @@ let f7 = async () => { };
 
 let f8 = async (): Promise<void> => { };
 >f8 : Symbol(f8, Decl(asyncAwait_es6.ts, 14, 3))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 
 let f9 = async (): MyPromise<void> => { }; 
 >f9 : Symbol(f9, Decl(asyncAwait_es6.ts, 15, 3))
@@ -60,7 +60,7 @@ let f11 = async () => mp;
 
 let f12 = async (): Promise<number> => mp;
 >f12 : Symbol(f12, Decl(asyncAwait_es6.ts, 18, 3))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 >mp : Symbol(mp, Decl(asyncAwait_es6.ts, 3, 11))
 
 let f13 = async (): MyPromise<number> => p;
@@ -76,7 +76,7 @@ let o = {
 
 	async m2(): Promise<void> { },
 >m2 : Symbol(m2, Decl(asyncAwait_es6.ts, 22, 16))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 
 	async m3(): MyPromise<void> { }
 >m3 : Symbol(m3, Decl(asyncAwait_es6.ts, 23, 31))
@@ -92,7 +92,7 @@ class C {
 
 	async m2(): Promise<void> { }
 >m2 : Symbol(m2, Decl(asyncAwait_es6.ts, 28, 15))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 
 	async m3(): MyPromise<void> { }
 >m3 : Symbol(m3, Decl(asyncAwait_es6.ts, 29, 30))
@@ -103,7 +103,7 @@ class C {
 
 	static async m5(): Promise<void> { }
 >m5 : Symbol(C.m5, Decl(asyncAwait_es6.ts, 31, 22))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 
 	static async m6(): MyPromise<void> { }
 >m6 : Symbol(C.m6, Decl(asyncAwait_es6.ts, 32, 37))

tests/baselines/reference/asyncFunctionDeclaration11_es6.symbols

@@ -1,5 +1,5 @@
 === tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration11_es6.ts ===
 async function await(): Promise<void> {
 >await : Symbol(await, Decl(asyncFunctionDeclaration11_es6.ts, 0, 0))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 }

tests/baselines/reference/asyncFunctionDeclaration14_es6.symbols

@@ -1,7 +1,7 @@
 === tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration14_es6.ts ===
 async function foo(): Promise<void> {
 >foo : Symbol(foo, Decl(asyncFunctionDeclaration14_es6.ts, 0, 0))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 
   return;
 }

tests/baselines/reference/asyncFunctionDeclaration1_es6.symbols

@@ -1,5 +1,5 @@
 === tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration1_es6.ts ===
 async function foo(): Promise<void> {
 >foo : Symbol(foo, Decl(asyncFunctionDeclaration1_es6.ts, 0, 0))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 }

tests/baselines/reference/awaitBinaryExpression1_es6.symbols

@@ -4,11 +4,11 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitBinaryExpression1_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitBinaryExpression1_es6.ts, 1, 32))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 
     "before";
     var b = await p || a;

tests/baselines/reference/awaitBinaryExpression2_es6.symbols

@@ -4,11 +4,11 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitBinaryExpression2_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitBinaryExpression2_es6.ts, 1, 32))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 
     "before";
     var b = await p && a;

tests/baselines/reference/awaitBinaryExpression3_es6.symbols

@@ -4,11 +4,11 @@ declare var a: number;
 
 declare var p: Promise<number>;
 >p : Symbol(p, Decl(awaitBinaryExpression3_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitBinaryExpression3_es6.ts, 1, 31))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 
     "before";
     var b = await p + a;

tests/baselines/reference/awaitBinaryExpression4_es6.symbols

@@ -4,11 +4,11 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitBinaryExpression4_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitBinaryExpression4_es6.ts, 1, 32))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 
     "before";
     var b = await p, a;

tests/baselines/reference/awaitBinaryExpression5_es6.symbols

@@ -4,11 +4,11 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitBinaryExpression5_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitBinaryExpression5_es6.ts, 1, 32))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 
     "before";
     var o: { a: boolean; };

tests/baselines/reference/awaitCallExpression1_es6.symbols

@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression1_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression1_es6.ts, 1, 32))
@@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
 
 declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >pfn : Symbol(pfn, Decl(awaitCallExpression1_es6.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression1_es6.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression1_es6.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression1_es6.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression1_es6.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 >fn : Symbol(fn, Decl(awaitCallExpression1_es6.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression1_es6.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression1_es6.ts, 5, 43))
@@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression1_es6.ts, 5, 84))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 
     "before";
     var b = fn(a, a, a);

tests/baselines/reference/awaitCallExpression2_es6.symbols

@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression2_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression2_es6.ts, 1, 32))
@@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
 
 declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >pfn : Symbol(pfn, Decl(awaitCallExpression2_es6.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression2_es6.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression2_es6.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression2_es6.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression2_es6.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 >fn : Symbol(fn, Decl(awaitCallExpression2_es6.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression2_es6.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression2_es6.ts, 5, 43))
@@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression2_es6.ts, 5, 84))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 
     "before";
     var b = fn(await p, a, a);

tests/baselines/reference/awaitCallExpression3_es6.symbols

@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression3_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression3_es6.ts, 1, 32))
@@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
 
 declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >pfn : Symbol(pfn, Decl(awaitCallExpression3_es6.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression3_es6.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression3_es6.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression3_es6.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression3_es6.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 >fn : Symbol(fn, Decl(awaitCallExpression3_es6.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression3_es6.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression3_es6.ts, 5, 43))
@@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression3_es6.ts, 5, 84))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 
     "before";
     var b = fn(a, await p, a);

tests/baselines/reference/awaitCallExpression4_es6.symbols

@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression4_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression4_es6.ts, 1, 32))
@@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
 
 declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >pfn : Symbol(pfn, Decl(awaitCallExpression4_es6.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression4_es6.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression4_es6.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression4_es6.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression4_es6.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 >fn : Symbol(fn, Decl(awaitCallExpression4_es6.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression4_es6.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression4_es6.ts, 5, 43))
@@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression4_es6.ts, 5, 84))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 
     "before";
     var b = (await pfn)(a, a, a);

tests/baselines/reference/awaitCallExpression5_es6.symbols

@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression5_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression5_es6.ts, 1, 32))
@@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
 
 declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >pfn : Symbol(pfn, Decl(awaitCallExpression5_es6.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression5_es6.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression5_es6.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression5_es6.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression5_es6.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 >fn : Symbol(fn, Decl(awaitCallExpression5_es6.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression5_es6.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression5_es6.ts, 5, 43))
@@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression5_es6.ts, 5, 84))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 
     "before";
     var b = o.fn(a, a, a);

tests/baselines/reference/awaitCallExpression6_es6.symbols

@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression6_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression6_es6.ts, 1, 32))
@@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
 
 declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >pfn : Symbol(pfn, Decl(awaitCallExpression6_es6.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression6_es6.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression6_es6.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression6_es6.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression6_es6.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 >fn : Symbol(fn, Decl(awaitCallExpression6_es6.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression6_es6.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression6_es6.ts, 5, 43))
@@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression6_es6.ts, 5, 84))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 
     "before";
     var b = o.fn(await p, a, a);

tests/baselines/reference/awaitCallExpression7_es6.symbols

@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression7_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression7_es6.ts, 1, 32))
@@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
 
 declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >pfn : Symbol(pfn, Decl(awaitCallExpression7_es6.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression7_es6.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression7_es6.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression7_es6.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression7_es6.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 >fn : Symbol(fn, Decl(awaitCallExpression7_es6.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression7_es6.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression7_es6.ts, 5, 43))
@@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression7_es6.ts, 5, 84))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 
     "before";
     var b = o.fn(a, await p, a);

tests/baselines/reference/awaitCallExpression8_es6.symbols

@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression8_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression8_es6.ts, 1, 32))
@@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
 
 declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >pfn : Symbol(pfn, Decl(awaitCallExpression8_es6.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression8_es6.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression8_es6.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression8_es6.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression8_es6.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 >fn : Symbol(fn, Decl(awaitCallExpression8_es6.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression8_es6.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression8_es6.ts, 5, 43))
@@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression8_es6.ts, 5, 84))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 
     "before";
     var b = (await po).fn(a, a, a);

tests/baselines/reference/callWithSpreadES6.symbols

@@ -94,7 +94,7 @@ xa[1].foo(1, 2, ...a, "abc");
 >a : Symbol(a, Decl(callWithSpreadES6.ts, 8, 3))
 
 (<Function>xa[1].foo)(...[1, 2, "abc"]);
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11), Decl(lib.d.ts, 4009, 1))
+>Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11), Decl(lib.d.ts, 4036, 1))
 >xa[1].foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13))
 >xa : Symbol(xa, Decl(callWithSpreadES6.ts, 11, 3))
 >foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13))

tests/baselines/reference/destructuringParameterDeclaration3ES5.symbols

@@ -8,18 +8,18 @@
 
 type arrayString = Array<String>
 >arrayString : Symbol(arrayString, Decl(destructuringParameterDeclaration3ES5.ts, 0, 0))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4091, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4209, 1))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4118, 1))
+>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4236, 1))
 
 type someArray = Array<String> | number[];
 >someArray : Symbol(someArray, Decl(destructuringParameterDeclaration3ES5.ts, 7, 32))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4091, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4209, 1))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4118, 1))
+>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4236, 1))
 
 type stringOrNumArray = Array<String|Number>;
 >stringOrNumArray : Symbol(stringOrNumArray, Decl(destructuringParameterDeclaration3ES5.ts, 8, 42))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4091, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4209, 1))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4118, 1))
+>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4236, 1))
 >Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
 
 function a1(...x: (number|string)[]) { }
@@ -33,8 +33,8 @@ function a2(...a) { }
 function a3(...a: Array<String>) { }
 >a3 : Symbol(a3, Decl(destructuringParameterDeclaration3ES5.ts, 12, 21))
 >a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 13, 12))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4091, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4209, 1))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4118, 1))
+>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4236, 1))
 
 function a4(...a: arrayString) { }
 >a4 : Symbol(a4, Decl(destructuringParameterDeclaration3ES5.ts, 13, 36))

tests/baselines/reference/destructuringParameterDeclaration3ES6.symbols

@@ -8,18 +8,18 @@
 
 type arrayString = Array<String>
 >arrayString : Symbol(arrayString, Decl(destructuringParameterDeclaration3ES6.ts, 0, 0))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4091, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4209, 1))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4118, 1))
+>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4236, 1))
 
 type someArray = Array<String> | number[];
 >someArray : Symbol(someArray, Decl(destructuringParameterDeclaration3ES6.ts, 7, 32))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4091, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4209, 1))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4118, 1))
+>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4236, 1))
 
 type stringOrNumArray = Array<String|Number>;
 >stringOrNumArray : Symbol(stringOrNumArray, Decl(destructuringParameterDeclaration3ES6.ts, 8, 42))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4091, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4209, 1))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4118, 1))
+>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4236, 1))
 >Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
 
 function a1(...x: (number|string)[]) { }
@@ -33,8 +33,8 @@ function a2(...a) { }
 function a3(...a: Array<String>) { }
 >a3 : Symbol(a3, Decl(destructuringParameterDeclaration3ES6.ts, 12, 21))
 >a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 13, 12))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4091, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4209, 1))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4118, 1))
+>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4236, 1))
 
 function a4(...a: arrayString) { }
 >a4 : Symbol(a4, Decl(destructuringParameterDeclaration3ES6.ts, 13, 36))

tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols

@@ -5,7 +5,7 @@ function f() {
 
     if (Math.random()) {
 >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 4392, 60))
+>Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 4419, 60))
 >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
 
         let arguments = 100;

tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols

@@ -8,7 +8,7 @@ function f() {
 
     if (Math.random()) {
 >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 4392, 60))
+>Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 4419, 60))
 >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
 
         const arguments = 100;

tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols

@@ -8,7 +8,7 @@ function f() {
 
     if (Math.random()) {
 >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 4392, 60))
+>Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 4419, 60))
 >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
 
         return () => arguments[0];

tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols

@@ -9,7 +9,7 @@ function f() {
 
     if (Math.random()) {
 >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 4392, 60))
+>Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 4419, 60))
 >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
 
         return () => arguments[0];

tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols

@@ -10,7 +10,7 @@ function f() {
 
     if (Math.random()) {
 >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 4392, 60))
+>Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 4419, 60))
 >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
 
         return () => arguments;

tests/baselines/reference/es3defaultAliasIsQuoted.js

@@ -0,0 +1,33 @@
+//// [tests/cases/compiler/es3defaultAliasIsQuoted.ts] ////
+
+//// [es3defaultAliasQuoted_file0.ts]
+
+export class Foo {
+    static CONSTANT = "Foo";
+}
+
+export default function assert(value: boolean) {
+    if (!value) throw new Error("Assertion failed!");
+}
+
+//// [es3defaultAliasQuoted_file1.ts]
+import {Foo, default as assert} from "./es3defaultAliasQuoted_file0";
+assert(Foo.CONSTANT === "Foo");
+
+//// [es3defaultAliasQuoted_file0.js]
+var Foo = (function () {
+    function Foo() {
+    }
+    Foo.CONSTANT = "Foo";
+    return Foo;
+})();
+exports.Foo = Foo;
+function assert(value) {
+    if (!value)
+        throw new Error("Assertion failed!");
+}
+exports.__esModule = true;
+exports["default"] = assert;
+//// [es3defaultAliasQuoted_file1.js]
+var es3defaultAliasQuoted_file0_1 = require("./es3defaultAliasQuoted_file0");
+es3defaultAliasQuoted_file0_1["default"](es3defaultAliasQuoted_file0_1.Foo.CONSTANT === "Foo");

tests/baselines/reference/es3defaultAliasIsQuoted.symbols

@@ -0,0 +1,30 @@
+=== tests/cases/compiler/es3defaultAliasQuoted_file0.ts ===
+
+export class Foo {
+>Foo : Symbol(Foo, Decl(es3defaultAliasQuoted_file0.ts, 0, 0))
+
+    static CONSTANT = "Foo";
+>CONSTANT : Symbol(Foo.CONSTANT, Decl(es3defaultAliasQuoted_file0.ts, 1, 18))
+}
+
+export default function assert(value: boolean) {
+>assert : Symbol(assert, Decl(es3defaultAliasQuoted_file0.ts, 3, 1))
+>value : Symbol(value, Decl(es3defaultAliasQuoted_file0.ts, 5, 31))
+
+    if (!value) throw new Error("Assertion failed!");
+>value : Symbol(value, Decl(es3defaultAliasQuoted_file0.ts, 5, 31))
+>Error : Symbol(Error, Decl(lib.d.ts, 876, 38), Decl(lib.d.ts, 889, 11))
+}
+
+=== tests/cases/compiler/es3defaultAliasQuoted_file1.ts ===
+import {Foo, default as assert} from "./es3defaultAliasQuoted_file0";
+>Foo : Symbol(Foo, Decl(es3defaultAliasQuoted_file1.ts, 0, 8))
+>default : Symbol(assert, Decl(es3defaultAliasQuoted_file1.ts, 0, 12))
+>assert : Symbol(assert, Decl(es3defaultAliasQuoted_file1.ts, 0, 12))
+
+assert(Foo.CONSTANT === "Foo");
+>assert : Symbol(assert, Decl(es3defaultAliasQuoted_file1.ts, 0, 12))
+>Foo.CONSTANT : Symbol(Foo.CONSTANT, Decl(es3defaultAliasQuoted_file0.ts, 1, 18))
+>Foo : Symbol(Foo, Decl(es3defaultAliasQuoted_file1.ts, 0, 8))
+>CONSTANT : Symbol(Foo.CONSTANT, Decl(es3defaultAliasQuoted_file0.ts, 1, 18))
+

tests/baselines/reference/es3defaultAliasIsQuoted.types

@@ -0,0 +1,37 @@
+=== tests/cases/compiler/es3defaultAliasQuoted_file0.ts ===
+
+export class Foo {
+>Foo : Foo
+
+    static CONSTANT = "Foo";
+>CONSTANT : string
+>"Foo" : string
+}
+
+export default function assert(value: boolean) {
+>assert : (value: boolean) => void
+>value : boolean
+
+    if (!value) throw new Error("Assertion failed!");
+>!value : boolean
+>value : boolean
+>new Error("Assertion failed!") : Error
+>Error : ErrorConstructor
+>"Assertion failed!" : string
+}
+
+=== tests/cases/compiler/es3defaultAliasQuoted_file1.ts ===
+import {Foo, default as assert} from "./es3defaultAliasQuoted_file0";
+>Foo : typeof Foo
+>default : (value: boolean) => void
+>assert : (value: boolean) => void
+
+assert(Foo.CONSTANT === "Foo");
+>assert(Foo.CONSTANT === "Foo") : void
+>assert : (value: boolean) => void
+>Foo.CONSTANT === "Foo" : boolean
+>Foo.CONSTANT : string
+>Foo : typeof Foo
+>CONSTANT : string
+>"Foo" : string
+

tests/baselines/reference/for-of13.symbols

@@ -4,6 +4,6 @@ var v: string;
 
 for (v of [""].values()) { }
 >v : Symbol(v, Decl(for-of13.ts, 0, 3))
->[""].values : Symbol(Array.values, Decl(lib.d.ts, 4119, 37))
->values : Symbol(Array.values, Decl(lib.d.ts, 4119, 37))
+>[""].values : Symbol(Array.values, Decl(lib.d.ts, 4146, 37))
+>values : Symbol(Array.values, Decl(lib.d.ts, 4146, 37))
 

tests/baselines/reference/for-of37.symbols

@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/for-ofStatements/for-of37.ts ===
 var map = new Map([["", true]]);
 >map : Symbol(map, Decl(for-of37.ts, 0, 3))
->Map : Symbol(Map, Decl(lib.d.ts, 4608, 1), Decl(lib.d.ts, 4631, 11))
+>Map : Symbol(Map, Decl(lib.d.ts, 4635, 1), Decl(lib.d.ts, 4658, 11))
 
 for (var v of map) {
 >v : Symbol(v, Decl(for-of37.ts, 1, 8))

tests/baselines/reference/for-of38.symbols

@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/for-ofStatements/for-of38.ts ===
 var map = new Map([["", true]]);
 >map : Symbol(map, Decl(for-of38.ts, 0, 3))
->Map : Symbol(Map, Decl(lib.d.ts, 4608, 1), Decl(lib.d.ts, 4631, 11))
+>Map : Symbol(Map, Decl(lib.d.ts, 4635, 1), Decl(lib.d.ts, 4658, 11))
 
 for (var [k, v] of map) {
 >k : Symbol(k, Decl(for-of38.ts, 1, 10))

tests/baselines/reference/for-of40.symbols

@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/for-ofStatements/for-of40.ts ===
 var map = new Map([["", true]]);
 >map : Symbol(map, Decl(for-of40.ts, 0, 3))
->Map : Symbol(Map, Decl(lib.d.ts, 4608, 1), Decl(lib.d.ts, 4631, 11))
+>Map : Symbol(Map, Decl(lib.d.ts, 4635, 1), Decl(lib.d.ts, 4658, 11))
 
 for (var [k = "", v = false] of map) {
 >k : Symbol(k, Decl(for-of40.ts, 1, 10))

tests/baselines/reference/for-of45.symbols

@@ -5,7 +5,7 @@ var k: string, v: boolean;
 
 var map = new Map([["", true]]);
 >map : Symbol(map, Decl(for-of45.ts, 1, 3))
->Map : Symbol(Map, Decl(lib.d.ts, 4608, 1), Decl(lib.d.ts, 4631, 11))
+>Map : Symbol(Map, Decl(lib.d.ts, 4635, 1), Decl(lib.d.ts, 4658, 11))
 
 for ([k = "", v = false] of map) {
 >k : Symbol(k, Decl(for-of45.ts, 0, 3))

tests/baselines/reference/for-of50.symbols

@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/for-ofStatements/for-of50.ts ===
 var map = new Map([["", true]]);
 >map : Symbol(map, Decl(for-of50.ts, 0, 3))
->Map : Symbol(Map, Decl(lib.d.ts, 4608, 1), Decl(lib.d.ts, 4631, 11))
+>Map : Symbol(Map, Decl(lib.d.ts, 4635, 1), Decl(lib.d.ts, 4658, 11))
 
 for (const [k, v] of map) {
 >k : Symbol(k, Decl(for-of50.ts, 1, 12))

tests/baselines/reference/for-of57.symbols

@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/for-ofStatements/for-of57.ts ===
 var iter: Iterable<number>;
 >iter : Symbol(iter, Decl(for-of57.ts, 0, 3))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4369, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1))
 
 for (let num of iter) { }
 >num : Symbol(num, Decl(for-of57.ts, 1, 8))

tests/baselines/reference/generatorOverloads4.symbols

@@ -5,15 +5,15 @@ class C {
     f(s: string): Iterable<any>;
 >f : Symbol(f, Decl(generatorOverloads4.ts, 0, 9), Decl(generatorOverloads4.ts, 1, 32), Decl(generatorOverloads4.ts, 2, 32))
 >s : Symbol(s, Decl(generatorOverloads4.ts, 1, 6))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4369, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1))
 
     f(s: number): Iterable<any>;
 >f : Symbol(f, Decl(generatorOverloads4.ts, 0, 9), Decl(generatorOverloads4.ts, 1, 32), Decl(generatorOverloads4.ts, 2, 32))
 >s : Symbol(s, Decl(generatorOverloads4.ts, 2, 6))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4369, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1))
 
     *f(s: any): Iterable<any> { }
 >f : Symbol(f, Decl(generatorOverloads4.ts, 0, 9), Decl(generatorOverloads4.ts, 1, 32), Decl(generatorOverloads4.ts, 2, 32))
 >s : Symbol(s, Decl(generatorOverloads4.ts, 3, 7))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4369, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1))
 }

tests/baselines/reference/generatorOverloads5.symbols

@@ -5,15 +5,15 @@ module M {
     function f(s: string): Iterable<any>;
 >f : Symbol(f, Decl(generatorOverloads5.ts, 0, 10), Decl(generatorOverloads5.ts, 1, 41), Decl(generatorOverloads5.ts, 2, 41))
 >s : Symbol(s, Decl(generatorOverloads5.ts, 1, 15))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4369, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1))
 
     function f(s: number): Iterable<any>;
 >f : Symbol(f, Decl(generatorOverloads5.ts, 0, 10), Decl(generatorOverloads5.ts, 1, 41), Decl(generatorOverloads5.ts, 2, 41))
 >s : Symbol(s, Decl(generatorOverloads5.ts, 2, 15))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4369, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1))
 
     function* f(s: any): Iterable<any> { }
 >f : Symbol(f, Decl(generatorOverloads5.ts, 0, 10), Decl(generatorOverloads5.ts, 1, 41), Decl(generatorOverloads5.ts, 2, 41))
 >s : Symbol(s, Decl(generatorOverloads5.ts, 3, 16))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4369, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1))
 }

tests/baselines/reference/generatorTypeCheck1.symbols

@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck1.ts ===
 function* g1(): Iterator<string> { }
 >g1 : Symbol(g1, Decl(generatorTypeCheck1.ts, 0, 0))
->Iterator : Symbol(Iterator, Decl(lib.d.ts, 4363, 1))
+>Iterator : Symbol(Iterator, Decl(lib.d.ts, 4390, 1))
 

tests/baselines/reference/generatorTypeCheck10.symbols

@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck10.ts ===
 function* g(): IterableIterator<any> {
 >g : Symbol(g, Decl(generatorTypeCheck10.ts, 0, 0))
->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4373, 1))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4400, 1))
 
     return;
 }

tests/baselines/reference/generatorTypeCheck11.symbols

@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck11.ts ===
 function* g(): IterableIterator<number> {
 >g : Symbol(g, Decl(generatorTypeCheck11.ts, 0, 0))
->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4373, 1))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4400, 1))
 
     return 0;
 }

tests/baselines/reference/generatorTypeCheck12.symbols

@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck12.ts ===
 function* g(): IterableIterator<number> {
 >g : Symbol(g, Decl(generatorTypeCheck12.ts, 0, 0))
->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4373, 1))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4400, 1))
 
     return "";
 }

tests/baselines/reference/generatorTypeCheck13.symbols

@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck13.ts ===
 function* g(): IterableIterator<number> {
 >g : Symbol(g, Decl(generatorTypeCheck13.ts, 0, 0))
->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4373, 1))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4400, 1))
 
     yield 0;
     return "";

tests/baselines/reference/generatorTypeCheck17.symbols

@@ -10,7 +10,7 @@ class Bar extends Foo { y: string }
 
 function* g(): IterableIterator<Foo> {
 >g : Symbol(g, Decl(generatorTypeCheck17.ts, 1, 35))
->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4373, 1))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4400, 1))
 >Foo : Symbol(Foo, Decl(generatorTypeCheck17.ts, 0, 0))
 
     yield;

tests/baselines/reference/generatorTypeCheck19.symbols

@@ -10,7 +10,7 @@ class Bar extends Foo { y: string }
 
 function* g(): IterableIterator<Foo> {
 >g : Symbol(g, Decl(generatorTypeCheck19.ts, 1, 35))
->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4373, 1))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4400, 1))
 >Foo : Symbol(Foo, Decl(generatorTypeCheck19.ts, 0, 0))
 
     yield;

tests/baselines/reference/generatorTypeCheck2.symbols

@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck2.ts ===
 function* g1(): Iterable<string> { }
 >g1 : Symbol(g1, Decl(generatorTypeCheck2.ts, 0, 0))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4369, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1))
 

tests/baselines/reference/generatorTypeCheck26.symbols

@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck26.ts ===
 function* g(): IterableIterator<(x: string) => number> {
 >g : Symbol(g, Decl(generatorTypeCheck26.ts, 0, 0))
->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4373, 1))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4400, 1))
 >x : Symbol(x, Decl(generatorTypeCheck26.ts, 0, 33))
 
     yield x => x.length;

tests/baselines/reference/generatorTypeCheck27.symbols

@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck27.ts ===
 function* g(): IterableIterator<(x: string) => number> {
 >g : Symbol(g, Decl(generatorTypeCheck27.ts, 0, 0))
->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4373, 1))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4400, 1))
 >x : Symbol(x, Decl(generatorTypeCheck27.ts, 0, 33))
 
     yield * function* () {

tests/baselines/reference/generatorTypeCheck28.symbols

@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck28.ts ===
 function* g(): IterableIterator<(x: string) => number> {
 >g : Symbol(g, Decl(generatorTypeCheck28.ts, 0, 0))
->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4373, 1))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4400, 1))
 >x : Symbol(x, Decl(generatorTypeCheck28.ts, 0, 33))
 
     yield * {

tests/baselines/reference/generatorTypeCheck29.symbols

@@ -1,8 +1,8 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck29.ts ===
 function* g2(): Iterator<Iterable<(x: string) => number>> {
 >g2 : Symbol(g2, Decl(generatorTypeCheck29.ts, 0, 0))
->Iterator : Symbol(Iterator, Decl(lib.d.ts, 4363, 1))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4369, 1))
+>Iterator : Symbol(Iterator, Decl(lib.d.ts, 4390, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1))
 >x : Symbol(x, Decl(generatorTypeCheck29.ts, 0, 35))
 
     yield function* () {

tests/baselines/reference/generatorTypeCheck3.symbols

@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck3.ts ===
 function* g1(): IterableIterator<string> { }
 >g1 : Symbol(g1, Decl(generatorTypeCheck3.ts, 0, 0))
->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4373, 1))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4400, 1))
 

tests/baselines/reference/generatorTypeCheck30.symbols

@@ -1,8 +1,8 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck30.ts ===
 function* g2(): Iterator<Iterable<(x: string) => number>> {
 >g2 : Symbol(g2, Decl(generatorTypeCheck30.ts, 0, 0))
->Iterator : Symbol(Iterator, Decl(lib.d.ts, 4363, 1))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4369, 1))
+>Iterator : Symbol(Iterator, Decl(lib.d.ts, 4390, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1))
 >x : Symbol(x, Decl(generatorTypeCheck30.ts, 0, 35))
 
     yield function* () {

tests/baselines/reference/generatorTypeCheck45.symbols

@@ -6,7 +6,7 @@ declare function foo<T, U>(x: T, fun: () => Iterator<(x: T) => U>, fun2: (y: U)
 >x : Symbol(x, Decl(generatorTypeCheck45.ts, 0, 27))
 >T : Symbol(T, Decl(generatorTypeCheck45.ts, 0, 21))
 >fun : Symbol(fun, Decl(generatorTypeCheck45.ts, 0, 32))
->Iterator : Symbol(Iterator, Decl(lib.d.ts, 4363, 1))
+>Iterator : Symbol(Iterator, Decl(lib.d.ts, 4390, 1))
 >x : Symbol(x, Decl(generatorTypeCheck45.ts, 0, 54))
 >T : Symbol(T, Decl(generatorTypeCheck45.ts, 0, 21))
 >U : Symbol(U, Decl(generatorTypeCheck45.ts, 0, 23))

tests/baselines/reference/generatorTypeCheck46.symbols

@@ -6,7 +6,7 @@ declare function foo<T, U>(x: T, fun: () => Iterable<(x: T) => U>, fun2: (y: U)
 >x : Symbol(x, Decl(generatorTypeCheck46.ts, 0, 27))
 >T : Symbol(T, Decl(generatorTypeCheck46.ts, 0, 21))
 >fun : Symbol(fun, Decl(generatorTypeCheck46.ts, 0, 32))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4369, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1))
 >x : Symbol(x, Decl(generatorTypeCheck46.ts, 0, 54))
 >T : Symbol(T, Decl(generatorTypeCheck46.ts, 0, 21))
 >U : Symbol(U, Decl(generatorTypeCheck46.ts, 0, 23))

tests/baselines/reference/iterableArrayPattern30.symbols

@@ -4,5 +4,5 @@ const [[k1, v1], [k2, v2]] = new Map([["", true], ["hello", true]])
 >v1 : Symbol(v1, Decl(iterableArrayPattern30.ts, 0, 11))
 >k2 : Symbol(k2, Decl(iterableArrayPattern30.ts, 0, 18))
 >v2 : Symbol(v2, Decl(iterableArrayPattern30.ts, 0, 21))
->Map : Symbol(Map, Decl(lib.d.ts, 4608, 1), Decl(lib.d.ts, 4631, 11))
+>Map : Symbol(Map, Decl(lib.d.ts, 4635, 1), Decl(lib.d.ts, 4658, 11))
 

tests/baselines/reference/iterableContextualTyping1.symbols

@@ -1,7 +1,7 @@
 === tests/cases/conformance/expressions/contextualTyping/iterableContextualTyping1.ts ===
 var iter: Iterable<(x: string) => number> = [s => s.length];
 >iter : Symbol(iter, Decl(iterableContextualTyping1.ts, 0, 3))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4369, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1))
 >x : Symbol(x, Decl(iterableContextualTyping1.ts, 0, 20))
 >s : Symbol(s, Decl(iterableContextualTyping1.ts, 0, 45))
 >s.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))

tests/baselines/reference/iteratorSpreadInArray11.symbols

@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/spread/iteratorSpreadInArray11.ts ===
 var iter: Iterable<number>;
 >iter : Symbol(iter, Decl(iteratorSpreadInArray11.ts, 0, 3))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4369, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1))
 
 var array = [...iter];
 >array : Symbol(array, Decl(iteratorSpreadInArray11.ts, 1, 3))

tests/baselines/reference/promiseVoidErrorCallback.symbols

@@ -22,13 +22,13 @@ interface T3 {
 
 function f1(): Promise<T1> {
 >f1 : Symbol(f1, Decl(promiseVoidErrorCallback.ts, 10, 1))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
 >T1 : Symbol(T1, Decl(promiseVoidErrorCallback.ts, 0, 0))
 
     return Promise.resolve({ __t1: "foo_t1" });
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, 5109, 39), Decl(lib.d.ts, 5116, 54))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, 5109, 39), Decl(lib.d.ts, 5116, 54))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, 5136, 39), Decl(lib.d.ts, 5143, 54))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, 5136, 39), Decl(lib.d.ts, 5143, 54))
 >__t1 : Symbol(__t1, Decl(promiseVoidErrorCallback.ts, 13, 28))
 }
 
@@ -47,12 +47,12 @@ function f2(x: T1): T2 {
 
 var x3 = f1()
 >x3 : Symbol(x3, Decl(promiseVoidErrorCallback.ts, 20, 3))
->f1()    .then(f2, (e: Error) => {    throw e;})    .then : Symbol(Promise.then, Decl(lib.d.ts, 5046, 22), Decl(lib.d.ts, 5053, 158))
->f1()    .then : Symbol(Promise.then, Decl(lib.d.ts, 5046, 22), Decl(lib.d.ts, 5053, 158))
+>f1()    .then(f2, (e: Error) => {    throw e;})    .then : Symbol(Promise.then, Decl(lib.d.ts, 5073, 22), Decl(lib.d.ts, 5080, 158))
+>f1()    .then : Symbol(Promise.then, Decl(lib.d.ts, 5073, 22), Decl(lib.d.ts, 5080, 158))
 >f1 : Symbol(f1, Decl(promiseVoidErrorCallback.ts, 10, 1))
 
     .then(f2, (e: Error) => {
->then : Symbol(Promise.then, Decl(lib.d.ts, 5046, 22), Decl(lib.d.ts, 5053, 158))
+>then : Symbol(Promise.then, Decl(lib.d.ts, 5073, 22), Decl(lib.d.ts, 5080, 158))
 >f2 : Symbol(f2, Decl(promiseVoidErrorCallback.ts, 14, 1))
 >e : Symbol(e, Decl(promiseVoidErrorCallback.ts, 21, 15))
 >Error : Symbol(Error, Decl(lib.d.ts, 876, 38), Decl(lib.d.ts, 889, 11))
@@ -62,7 +62,7 @@ var x3 = f1()
 
 })
     .then((x: T2) => {
->then : Symbol(Promise.then, Decl(lib.d.ts, 5046, 22), Decl(lib.d.ts, 5053, 158))
+>then : Symbol(Promise.then, Decl(lib.d.ts, 5073, 22), Decl(lib.d.ts, 5080, 158))
 >x : Symbol(x, Decl(promiseVoidErrorCallback.ts, 24, 11))
 >T2 : Symbol(T2, Decl(promiseVoidErrorCallback.ts, 2, 1))
 

tests/baselines/reference/stringIncludes.symbols

@@ -5,11 +5,11 @@ var includes: boolean;
 
 includes = "abcde".includes("cd");
 >includes : Symbol(includes, Decl(stringIncludes.ts, 1, 3))
->"abcde".includes : Symbol(String.includes, Decl(lib.d.ts, 4222, 37))
->includes : Symbol(String.includes, Decl(lib.d.ts, 4222, 37))
+>"abcde".includes : Symbol(String.includes, Decl(lib.d.ts, 4249, 37))
+>includes : Symbol(String.includes, Decl(lib.d.ts, 4249, 37))
 
 includes = "abcde".includes("cd", 2);
 >includes : Symbol(includes, Decl(stringIncludes.ts, 1, 3))
->"abcde".includes : Symbol(String.includes, Decl(lib.d.ts, 4222, 37))
->includes : Symbol(String.includes, Decl(lib.d.ts, 4222, 37))
+>"abcde".includes : Symbol(String.includes, Decl(lib.d.ts, 4249, 37))
+>includes : Symbol(String.includes, Decl(lib.d.ts, 4249, 37))
 

tests/baselines/reference/templateStringWithEmbeddedNewOperatorES6.symbols

@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/templates/templateStringWithEmbeddedNewOperatorES6.ts ===
 var x = `abc${ new String("Hi") }def`;
 >x : Symbol(x, Decl(templateStringWithEmbeddedNewOperatorES6.ts, 0, 3))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4209, 1))
+>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4236, 1))
 

tests/baselines/reference/typeArgumentInferenceApparentType1.symbols

@@ -3,7 +3,7 @@ function method<T>(iterable: Iterable<T>): T {
 >method : Symbol(method, Decl(typeArgumentInferenceApparentType1.ts, 0, 0))
 >T : Symbol(T, Decl(typeArgumentInferenceApparentType1.ts, 0, 16))
 >iterable : Symbol(iterable, Decl(typeArgumentInferenceApparentType1.ts, 0, 19))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4369, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1))
 >T : Symbol(T, Decl(typeArgumentInferenceApparentType1.ts, 0, 16))
 >T : Symbol(T, Decl(typeArgumentInferenceApparentType1.ts, 0, 16))
 

tests/baselines/reference/typeArgumentInferenceApparentType2.symbols

@@ -3,14 +3,14 @@ function method<T>(iterable: Iterable<T>): T {
 >method : Symbol(method, Decl(typeArgumentInferenceApparentType2.ts, 0, 0))
 >T : Symbol(T, Decl(typeArgumentInferenceApparentType2.ts, 0, 16))
 >iterable : Symbol(iterable, Decl(typeArgumentInferenceApparentType2.ts, 0, 19))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4369, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1))
 >T : Symbol(T, Decl(typeArgumentInferenceApparentType2.ts, 0, 16))
 >T : Symbol(T, Decl(typeArgumentInferenceApparentType2.ts, 0, 16))
 
     function inner<U extends Iterable<T>>() {
 >inner : Symbol(inner, Decl(typeArgumentInferenceApparentType2.ts, 0, 46))
 >U : Symbol(U, Decl(typeArgumentInferenceApparentType2.ts, 1, 19))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4369, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1))
 >T : Symbol(T, Decl(typeArgumentInferenceApparentType2.ts, 0, 16))
 
         var u: U;

tests/baselines/reference/typedArrays.symbols

@@ -8,39 +8,39 @@ function CreateTypedArrayTypes() {
 
     typedArrays[0] = Int8Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4704, 1))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4731, 1))
 
     typedArrays[1] = Uint8Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4736, 1))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4763, 1))
 
     typedArrays[2] = Int16Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4804, 1))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4831, 1))
 
     typedArrays[3] = Uint16Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4840, 1))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4867, 1))
 
     typedArrays[4] = Int32Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4872, 1))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4899, 1))
 
     typedArrays[5] = Uint32Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4904, 1))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4931, 1))
 
     typedArrays[6] = Float32Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4936, 1))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4963, 1))
 
     typedArrays[7] = Float64Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4968, 1))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4995, 1))
 
     typedArrays[8] = Uint8ClampedArray;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4768, 1))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4795, 1))
 
     return typedArrays;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
@@ -55,47 +55,47 @@ function CreateTypedArrayInstancesFromLength(obj: number) {
 
     typedArrays[0] = new Int8Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4704, 1))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4731, 1))
 >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45))
 
     typedArrays[1] = new Uint8Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4736, 1))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4763, 1))
 >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45))
 
     typedArrays[2] = new Int16Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4804, 1))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4831, 1))
 >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45))
 
     typedArrays[3] = new Uint16Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4840, 1))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4867, 1))
 >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45))
 
     typedArrays[4] = new Int32Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4872, 1))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4899, 1))
 >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45))
 
     typedArrays[5] = new Uint32Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4904, 1))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4931, 1))
 >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45))
 
     typedArrays[6] = new Float32Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4936, 1))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4963, 1))
 >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45))
 
     typedArrays[7] = new Float64Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4968, 1))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4995, 1))
 >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45))
 
     typedArrays[8] = new Uint8ClampedArray(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4768, 1))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4795, 1))
 >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45))
 
     return typedArrays;
@@ -111,47 +111,47 @@ function CreateTypedArrayInstancesFromArray(obj: number[]) {
 
     typedArrays[0] = new Int8Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4704, 1))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4731, 1))
 >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44))
 
     typedArrays[1] = new Uint8Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4736, 1))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4763, 1))
 >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44))
 
     typedArrays[2] = new Int16Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4804, 1))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4831, 1))
 >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44))
 
     typedArrays[3] = new Uint16Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4840, 1))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4867, 1))
 >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44))
 
     typedArrays[4] = new Int32Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4872, 1))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4899, 1))
 >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44))
 
     typedArrays[5] = new Uint32Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4904, 1))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4931, 1))
 >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44))
 
     typedArrays[6] = new Float32Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4936, 1))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4963, 1))
 >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44))
 
     typedArrays[7] = new Float64Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4968, 1))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4995, 1))
 >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44))
 
     typedArrays[8] = new Uint8ClampedArray(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4768, 1))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4795, 1))
 >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44))
 
     return typedArrays;
@@ -167,65 +167,65 @@ function CreateIntegerTypedArraysFromArray2(obj:number[]) {
 
     typedArrays[0] = Int8Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4727, 48))
->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4704, 1))
->from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4727, 48))
+>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4754, 48))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4731, 1))
+>from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4754, 48))
 >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44))
 
     typedArrays[1] = Uint8Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4759, 49))
->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4736, 1))
->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4759, 49))
+>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4786, 49))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4763, 1))
+>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4786, 49))
 >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44))
 
     typedArrays[2] = Int16Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4831, 49))
->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4804, 1))
->from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4831, 49))
+>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4858, 49))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4831, 1))
+>from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4858, 49))
 >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44))
 
     typedArrays[3] = Uint16Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4863, 50))
->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4840, 1))
->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4863, 50))
+>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4890, 50))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4867, 1))
+>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4890, 50))
 >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44))
 
     typedArrays[4] = Int32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4895, 49))
->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4872, 1))
->from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4895, 49))
+>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4922, 49))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4899, 1))
+>from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4922, 49))
 >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44))
 
     typedArrays[5] = Uint32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4927, 50))
->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4904, 1))
->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4927, 50))
+>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4954, 50))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4931, 1))
+>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4954, 50))
 >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44))
 
     typedArrays[6] = Float32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4959, 51))
->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4936, 1))
->from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4959, 51))
+>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4986, 51))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4963, 1))
+>from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4986, 51))
 >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44))
 
     typedArrays[7] = Float64Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 4991, 51))
->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4968, 1))
->from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 4991, 51))
+>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 5018, 51))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4995, 1))
+>from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 5018, 51))
 >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44))
 
     typedArrays[8] = Uint8ClampedArray.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4794, 56))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4768, 1))
->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4794, 56))
+>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4821, 56))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4795, 1))
+>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4821, 56))
 >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44))
 
     return typedArrays;
@@ -242,65 +242,65 @@ function CreateIntegerTypedArraysFromArrayLike(obj:ArrayLike<number>) {
 
     typedArrays[0] = Int8Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4727, 48))
->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4704, 1))
->from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4727, 48))
+>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4754, 48))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4731, 1))
+>from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4754, 48))
 >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47))
 
     typedArrays[1] = Uint8Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4759, 49))
->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4736, 1))
->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4759, 49))
+>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4786, 49))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4763, 1))
+>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4786, 49))
 >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47))
 
     typedArrays[2] = Int16Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4831, 49))
->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4804, 1))
->from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4831, 49))
+>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4858, 49))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4831, 1))
+>from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4858, 49))
 >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47))
 
     typedArrays[3] = Uint16Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4863, 50))
->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4840, 1))
->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4863, 50))
+>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4890, 50))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4867, 1))
+>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4890, 50))
 >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47))
 
     typedArrays[4] = Int32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4895, 49))
->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4872, 1))
->from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4895, 49))
+>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4922, 49))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4899, 1))
+>from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4922, 49))
 >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47))
 
     typedArrays[5] = Uint32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4927, 50))
->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4904, 1))
->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4927, 50))
+>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4954, 50))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4931, 1))
+>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4954, 50))
 >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47))
 
     typedArrays[6] = Float32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4959, 51))
->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4936, 1))
->from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4959, 51))
+>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4986, 51))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4963, 1))
+>from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4986, 51))
 >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47))
 
     typedArrays[7] = Float64Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 4991, 51))
->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4968, 1))
->from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 4991, 51))
+>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 5018, 51))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4995, 1))
+>from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 5018, 51))
 >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47))
 
     typedArrays[8] = Uint8ClampedArray.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4794, 56))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4768, 1))
->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4794, 56))
+>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4821, 56))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4795, 1))
+>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4821, 56))
 >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47))
 
     return typedArrays;
@@ -333,55 +333,55 @@ function CreateTypedArraysOf2() {
     typedArrays[0] = Int8Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
 >Int8Array.of : Symbol(Int8ArrayConstructor.of, Decl(lib.d.ts, 1635, 30))
->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4704, 1))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4731, 1))
 >of : Symbol(Int8ArrayConstructor.of, Decl(lib.d.ts, 1635, 30))
 
     typedArrays[1] = Uint8Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
 >Uint8Array.of : Symbol(Uint8ArrayConstructor.of, Decl(lib.d.ts, 1909, 30))
->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4736, 1))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4763, 1))
 >of : Symbol(Uint8ArrayConstructor.of, Decl(lib.d.ts, 1909, 30))
 
     typedArrays[2] = Int16Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
 >Int16Array.of : Symbol(Int16ArrayConstructor.of, Decl(lib.d.ts, 2456, 30))
->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4804, 1))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4831, 1))
 >of : Symbol(Int16ArrayConstructor.of, Decl(lib.d.ts, 2456, 30))
 
     typedArrays[3] = Uint16Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
 >Uint16Array.of : Symbol(Uint16ArrayConstructor.of, Decl(lib.d.ts, 2730, 30))
->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4840, 1))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4867, 1))
 >of : Symbol(Uint16ArrayConstructor.of, Decl(lib.d.ts, 2730, 30))
 
     typedArrays[4] = Int32Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
 >Int32Array.of : Symbol(Int32ArrayConstructor.of, Decl(lib.d.ts, 3003, 30))
->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4872, 1))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4899, 1))
 >of : Symbol(Int32ArrayConstructor.of, Decl(lib.d.ts, 3003, 30))
 
     typedArrays[5] = Uint32Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
 >Uint32Array.of : Symbol(Uint32ArrayConstructor.of, Decl(lib.d.ts, 3276, 30))
->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4904, 1))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4931, 1))
 >of : Symbol(Uint32ArrayConstructor.of, Decl(lib.d.ts, 3276, 30))
 
     typedArrays[6] = Float32Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
 >Float32Array.of : Symbol(Float32ArrayConstructor.of, Decl(lib.d.ts, 3549, 30))
->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4936, 1))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4963, 1))
 >of : Symbol(Float32ArrayConstructor.of, Decl(lib.d.ts, 3549, 30))
 
     typedArrays[7] = Float64Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
 >Float64Array.of : Symbol(Float64ArrayConstructor.of, Decl(lib.d.ts, 3823, 30))
->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4968, 1))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4995, 1))
 >of : Symbol(Float64ArrayConstructor.of, Decl(lib.d.ts, 3823, 30))
 
     typedArrays[8] = Uint8ClampedArray.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
 >Uint8ClampedArray.of : Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.d.ts, 2183, 30))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4768, 1))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4795, 1))
 >of : Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.d.ts, 2183, 30))
 
     return typedArrays;
@@ -401,73 +401,73 @@ function CreateTypedArraysFromMapFn(obj:ArrayLike<number>, mapFn: (n:number, v:n
 
     typedArrays[0] = Int8Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4727, 48))
->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4704, 1))
->from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4727, 48))
+>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4754, 48))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4731, 1))
+>from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4754, 48))
 >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58))
 
     typedArrays[1] = Uint8Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4759, 49))
->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4736, 1))
->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4759, 49))
+>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4786, 49))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4763, 1))
+>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4786, 49))
 >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58))
 
     typedArrays[2] = Int16Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4831, 49))
->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4804, 1))
->from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4831, 49))
+>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4858, 49))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4831, 1))
+>from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4858, 49))
 >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58))
 
     typedArrays[3] = Uint16Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4863, 50))
->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4840, 1))
->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4863, 50))
+>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4890, 50))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4867, 1))
+>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4890, 50))
 >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58))
 
     typedArrays[4] = Int32Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4895, 49))
->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4872, 1))
->from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4895, 49))
+>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4922, 49))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4899, 1))
+>from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4922, 49))
 >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58))
 
     typedArrays[5] = Uint32Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4927, 50))
->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4904, 1))
->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4927, 50))
+>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4954, 50))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4931, 1))
+>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4954, 50))
 >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58))
 
     typedArrays[6] = Float32Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4959, 51))
->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4936, 1))
->from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4959, 51))
+>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4986, 51))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4963, 1))
+>from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4986, 51))
 >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58))
 
     typedArrays[7] = Float64Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 4991, 51))
->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4968, 1))
->from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 4991, 51))
+>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 5018, 51))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4995, 1))
+>from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 5018, 51))
 >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58))
 
     typedArrays[8] = Uint8ClampedArray.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4794, 56))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4768, 1))
->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4794, 56))
+>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4821, 56))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4795, 1))
+>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4821, 56))
 >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58))
 
@@ -489,81 +489,81 @@ function CreateTypedArraysFromThisObj(obj:ArrayLike<number>, mapFn: (n:number, v
 
     typedArrays[0] = Int8Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4727, 48))
->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4704, 1))
->from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4727, 48))
+>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4754, 48))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4731, 1))
+>from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4754, 48))
 >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98))
 
     typedArrays[1] = Uint8Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4759, 49))
->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4736, 1))
->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4759, 49))
+>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4786, 49))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4763, 1))
+>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4786, 49))
 >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98))
 
     typedArrays[2] = Int16Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4831, 49))
->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4804, 1))
->from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4831, 49))
+>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4858, 49))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4831, 1))
+>from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4858, 49))
 >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98))
 
     typedArrays[3] = Uint16Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4863, 50))
->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4840, 1))
->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4863, 50))
+>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4890, 50))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4867, 1))
+>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4890, 50))
 >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98))
 
     typedArrays[4] = Int32Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4895, 49))
->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4872, 1))
->from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4895, 49))
+>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4922, 49))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4899, 1))
+>from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4922, 49))
 >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98))
 
     typedArrays[5] = Uint32Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4927, 50))
->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4904, 1))
->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4927, 50))
+>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4954, 50))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4931, 1))
+>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4954, 50))
 >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98))
 
     typedArrays[6] = Float32Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4959, 51))
->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4936, 1))
->from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4959, 51))
+>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4986, 51))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4963, 1))
+>from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4986, 51))
 >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98))
 
     typedArrays[7] = Float64Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 4991, 51))
->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4968, 1))
->from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 4991, 51))
+>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 5018, 51))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4995, 1))
+>from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 5018, 51))
 >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98))
 
     typedArrays[8] = Uint8ClampedArray.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4794, 56))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4768, 1))
->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4794, 56))
+>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4821, 56))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4795, 1))
+>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4821, 56))
 >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98))

tests/cases/compiler/es3defaultAliasIsQuoted.ts

@@ -0,0 +1,15 @@
+// @module: commonjs
+// @target: es3
+
+// @Filename: es3defaultAliasQuoted_file0.ts
+export class Foo {
+    static CONSTANT = "Foo";
+}
+
+export default function assert(value: boolean) {
+    if (!value) throw new Error("Assertion failed!");
+}
+
+// @Filename: es3defaultAliasQuoted_file1.ts
+import {Foo, default as assert} from "./es3defaultAliasQuoted_file0";
+assert(Foo.CONSTANT === "Foo");

tslint.json

@@ -8,7 +8,8 @@
             "spaces"
         ],
         "one-line": [true,
-            "check-open-brace"
+            "check-open-brace",
+            "check-whitespace"
         ],
         "no-unreachable": true,
         "no-use-before-declare": true,
@@ -21,7 +22,8 @@
             "check-branch",
             "check-operator",
             "check-separator",
-            "check-type"
+            "check-type",
+            "check-module"
         ],
         "typedef-whitespace": [true, {
             "call-signature": "nospace",
@@ -29,6 +31,15 @@
             "parameter": "nospace",
             "property-declaration": "nospace",
             "variable-declaration": "nospace"
-        }]
+        }],
+        "next-line": [true, 
+            "check-catch",
+            "check-else"
+        ],
+        "no-internal-module": true,
+        "no-trailing-whitespace": true,
+        "no-inferrable-types": true,
+        "no-null": true,
+        "boolean-trivia": true
   }
 }