Merge branch 'master' into constructor-functions-as-classes

Author: sandersn

package.json

@@ -2,7 +2,7 @@
     "name": "typescript",
     "author": "Microsoft Corp.",
     "homepage": "https://www.typescriptlang.org/",
-    "version": "3.6.0",
+    "version": "3.7.0",
     "license": "Apache-2.0",
     "description": "TypeScript is a language for application scale JavaScript development",
     "keywords": [

scripts/build/options.js

@@ -15,6 +15,7 @@ module.exports = minimist(process.argv.slice(2), {
         "r": "reporter",
         "c": "colors", "color": "colors",
         "skip-percent": "skipPercent",
+        "skippercent": "skipPercent",
         "w": "workers",
         "f": "fix"
     },

src/compiler/binder.ts

@@ -782,7 +782,7 @@ namespace ts {
         function isNarrowableReference(expr: Expression): boolean {
             return expr.kind === SyntaxKind.Identifier || expr.kind === SyntaxKind.ThisKeyword || expr.kind === SyntaxKind.SuperKeyword ||
                 (isPropertyAccessExpression(expr) || isNonNullExpression(expr) || isParenthesizedExpression(expr)) && isNarrowableReference(expr.expression) ||
-                isElementAccessExpression(expr) && expr.argumentExpression &&
+                isElementAccessExpression(expr) &&
                 (isStringLiteral(expr.argumentExpression) || isNumericLiteral(expr.argumentExpression)) &&
                 isNarrowableReference(expr.expression);
         }

src/compiler/checker.ts

@@ -1,7 +1,7 @@
 namespace ts {
     // WARNING: The script `configureNightly.ts` uses a regexp to parse out these values.
     // If changing the text in this section, be sure to test `configureNightly` too.
-    export const versionMajorMinor = "3.6";
+    export const versionMajorMinor = "3.7";
     /** The version of the TypeScript compiler release */
     export const version = `${versionMajorMinor}.0-dev`;
 }

src/compiler/core.ts

@@ -459,10 +459,6 @@
         "category": "Error",
         "code": 1149
     },
-    "'new T[]' cannot be used to create an array. Use 'new Array<T>()' instead.": {
-        "category": "Error",
-        "code": 1150
-    },
     "'const' declarations must be initialized.": {
         "category": "Error",
         "code": 1155

src/compiler/diagnosticMessages.json

@@ -5492,10 +5492,22 @@ namespace ts {
         }
 
         function parseDeclaration(): Statement {
+            const modifiers = lookAhead(() => (parseDecorators(), parseModifiers()));
+            // `parseListElement` attempted to get the reused node at this position,
+            // but the ambient context flag was not yet set, so the node appeared
+            // not reusable in that context.
+            const isAmbient = some(modifiers, isDeclareModifier);
+            if (isAmbient) {
+                const node = tryReuseAmbientDeclaration();
+                if (node) {
+                    return node;
+                }
+            }
+
             const node = <Statement>createNodeWithJSDoc(SyntaxKind.Unknown);
             node.decorators = parseDecorators();
             node.modifiers = parseModifiers();
-            if (some(node.modifiers, isDeclareModifier)) {
+            if (isAmbient) {
                 for (const m of node.modifiers!) {
                     m.flags |= NodeFlags.Ambient;
                 }
@@ -5506,6 +5518,15 @@ namespace ts {
             }
         }
 
+        function tryReuseAmbientDeclaration(): Statement | undefined {
+            return doInsideOfContext(NodeFlags.Ambient, () => {
+                const node = currentNode(parsingContext);
+                if (node) {
+                    return consumeNode(node) as Statement;
+                }
+            });
+        }
+
         function parseDeclarationWorker(node: Statement): Statement {
             switch (token()) {
                 case SyntaxKind.VarKeyword:

src/compiler/parser.ts

@@ -1145,7 +1145,7 @@ namespace ts {
             // If we change our policy of rechecking failed lookups on each program create,
             // we should adjust the value returned here.
             function moduleNameResolvesToAmbientModuleInNonModifiedFile(moduleName: string): boolean {
-                const resolutionToFile = getResolvedModule(oldSourceFile!, moduleName);
+                const resolutionToFile = getResolvedModule(oldSourceFile, moduleName);
                 const resolvedFile = resolutionToFile && oldProgram!.getSourceFile(resolutionToFile.resolvedFileName);
                 if (resolutionToFile && resolvedFile) {
                     // In the old program, we resolved to an ambient module that was in the same
@@ -1833,6 +1833,7 @@ namespace ts {
 
                     switch (parent.kind) {
                         case SyntaxKind.ClassDeclaration:
+                        case SyntaxKind.ClassExpression:
                         case SyntaxKind.MethodDeclaration:
                         case SyntaxKind.MethodSignature:
                         case SyntaxKind.Constructor:
@@ -1842,7 +1843,7 @@ namespace ts {
                         case SyntaxKind.FunctionDeclaration:
                         case SyntaxKind.ArrowFunction:
                             // Check type parameters
-                            if (nodes === (<ClassDeclaration | FunctionLikeDeclaration>parent).typeParameters) {
+                            if (nodes === (<ClassLikeDeclaration | FunctionLikeDeclaration>parent).typeParameters) {
                                 diagnostics.push(createDiagnosticForNodeArray(nodes, Diagnostics.type_parameter_declarations_can_only_be_used_in_a_ts_file));
                                 return;
                             }

src/compiler/program.ts

@@ -878,7 +878,7 @@ namespace ts {
 
         setText(text, start, length);
 
-        return {
+        const scanner: Scanner = {
             getStartPos: () => startPos,
             getTextPos: () => pos,
             getToken: () => token,
@@ -914,6 +914,17 @@ namespace ts {
             scanRange,
         };
 
+        if (Debug.isDebugging) {
+            Object.defineProperty(scanner, "__debugShowCurrentPositionInText", {
+                get: () => {
+                    const text = scanner.getText();
+                    return text.slice(0, scanner.getStartPos()) + "║" + text.slice(scanner.getStartPos());
+                },
+            });
+        }
+
+        return scanner;
+
         function error(message: DiagnosticMessage): void;
         function error(message: DiagnosticMessage, errPos: number, length: number): void;
         function error(message: DiagnosticMessage, errPos: number = pos, length?: number): void {
@@ -1472,7 +1483,7 @@ namespace ts {
 
         function scan(): SyntaxKind {
             startPos = pos;
-            tokenFlags = 0;
+            tokenFlags = TokenFlags.None;
             let asteriskSeen = false;
             while (true) {
                 tokenPos = pos;
@@ -2104,7 +2115,7 @@ namespace ts {
 
         function scanJsDocToken(): JSDocSyntaxKind {
             startPos = tokenPos = pos;
-            tokenFlags = 0;
+            tokenFlags = TokenFlags.None;
             if (pos >= end) {
                 return token = SyntaxKind.EndOfFileToken;
             }
@@ -2265,7 +2276,7 @@ namespace ts {
             tokenPos = textPos;
             token = SyntaxKind.Unknown;
             tokenValue = undefined!;
-            tokenFlags = 0;
+            tokenFlags = TokenFlags.None;
         }
 
         function setInJSDocType(inType: boolean) {

src/compiler/scanner.ts

@@ -3345,7 +3345,7 @@ namespace ts {
          * This should be called in a loop climbing parents of the symbol, so we'll get `N`.
          */
         /* @internal */ getAccessibleSymbolChain(symbol: Symbol, enclosingDeclaration: Node | undefined, meaning: SymbolFlags, useOnlyExternalAliasing: boolean): Symbol[] | undefined;
-        /* @internal */ getTypePredicateOfSignature(signature: Signature): TypePredicate;
+        /* @internal */ getTypePredicateOfSignature(signature: Signature): TypePredicate | undefined;
         /**
          * An external module with an 'export =' declaration resolves to the target of the 'export =' declaration,
          * and an external module with no 'export =' declaration resolves to the module itself.
@@ -4502,8 +4502,10 @@ namespace ts {
         LiteralKeyof                 = 1 << 5,  // Inference made from a string literal to a keyof T
         NoConstraints                = 1 << 6,  // Don't infer from constraints of instantiable types
         AlwaysStrict                 = 1 << 7,  // Always use strict rules for contravariant inferences
+        MaxValue                     = 1 << 8,  // Seed for inference priority tracking
 
         PriorityImpliesCombination = ReturnType | MappedTypeConstraint | LiteralKeyof,  // These priorities imply that the resulting type should be a combination of all candidates
+        Circularity = -1,  // Inference circularity (value less than all other priorities)
     }
 
     /* @internal */