Merge branch 'master' into correctlyCacheTaggedTemplates

Author: DanielRosenwasser

.gitignore

@@ -59,4 +59,4 @@ internal/
 .idea
 yarn.lock
 package-lock.json
-.parallelperf.json
+.parallelperf.*

src/compiler/binder.ts

@@ -1456,11 +1456,6 @@ namespace ts {
         }
 
         function declareSymbolAndAddToSymbolTable(node: Declaration, symbolFlags: SymbolFlags, symbolExcludes: SymbolFlags): Symbol {
-            // Just call this directly so that the return type of this function stays "void".
-            return declareSymbolAndAddToSymbolTableWorker(node, symbolFlags, symbolExcludes);
-        }
-
-        function declareSymbolAndAddToSymbolTableWorker(node: Declaration, symbolFlags: SymbolFlags, symbolExcludes: SymbolFlags): Symbol {
             switch (container.kind) {
                 // Modules, source files, and classes need specialized handling for how their
                 // members are declared (for example, a member of a class will go into a specific
@@ -1683,6 +1678,9 @@ namespace ts {
 
         function bindAnonymousDeclaration(node: Declaration, symbolFlags: SymbolFlags, name: __String) {
             const symbol = createSymbol(symbolFlags, name);
+            if (symbolFlags & SymbolFlags.EnumMember) {
+                symbol.parent = container.symbol;
+            }
             addDeclarationToSymbol(symbol, node, symbolFlags);
         }
 

src/compiler/checker.ts

@@ -994,11 +994,6 @@ namespace ts {
 
     /**
      * Gets the owned, enumerable property keys of a map-like.
-     *
-     * NOTE: This is intended for use with MapLike<T> objects. For Map<T> objects, use
-     *       Object.keys instead as it offers better performance.
-     *
-     * @param map A map-like.
      */
     export function getOwnKeys<T>(map: MapLike<T>): string[] {
         const keys: string[] = [];
@@ -1011,6 +1006,17 @@ namespace ts {
         return keys;
     }
 
+    export function getOwnValues<T>(sparseArray: T[]): T[] {
+        const values: T[] = [];
+        for (const key in sparseArray) {
+            if (hasOwnProperty.call(sparseArray, key)) {
+                values.push(sparseArray[key]);
+            }
+        }
+
+        return values;
+    }
+
     /** Shims `Array.from`. */
     export function arrayFrom<T, U>(iterator: Iterator<T>, map: (t: T) => U): U[];
     export function arrayFrom<T>(iterator: Iterator<T>): T[];

src/compiler/core.ts

@@ -3507,6 +3507,10 @@
         "category": "Error",
         "code": 8020
     },
+    "JSDoc '@typedef' tag should either have a type annotation or be followed by '@property' or '@member' tags.": {
+        "category": "Error",
+        "code": 8021
+    },
     "Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clause.": {
         "category": "Error",
         "code": 9002

src/compiler/diagnosticMessages.json

@@ -1863,7 +1863,9 @@ namespace ts {
 
         function emitModuleDeclaration(node: ModuleDeclaration) {
             emitModifiers(node, node.modifiers);
-            write(node.flags & NodeFlags.Namespace ? "namespace " : "module ");
+            if (~node.flags & NodeFlags.GlobalAugmentation) {
+                write(node.flags & NodeFlags.Namespace ? "namespace " : "module ");
+            }
             emit(node.name);
 
             let body = node.body;

src/compiler/emitter.ts

@@ -1207,6 +1207,30 @@ namespace ts {
             : node;
     }
 
+    export function createTemplateHead(text: string) {
+        const node = <TemplateHead>createSynthesizedNode(SyntaxKind.TemplateHead);
+        node.text = text;
+        return node;
+    }
+
+    export function createTemplateMiddle(text: string) {
+        const node = <TemplateMiddle>createSynthesizedNode(SyntaxKind.TemplateMiddle);
+        node.text = text;
+        return node;
+    }
+
+    export function createTemplateTail(text: string) {
+        const node = <TemplateTail>createSynthesizedNode(SyntaxKind.TemplateTail);
+        node.text = text;
+        return node;
+    }
+
+    export function createNoSubstitutionTemplateLiteral(text: string) {
+        const node = <NoSubstitutionTemplateLiteral>createSynthesizedNode(SyntaxKind.NoSubstitutionTemplateLiteral);
+        node.text = text;
+        return node;
+    }
+
     export function createYield(expression?: Expression): YieldExpression;
     export function createYield(asteriskToken: AsteriskToken, expression: Expression): YieldExpression;
     export function createYield(asteriskTokenOrExpression?: AsteriskToken | Expression, expression?: Expression) {

src/compiler/factory.ts

@@ -6135,11 +6135,14 @@ namespace ts {
             }
 
             // Parses out a JSDoc type expression.
-            /* @internal */
-            export function parseJSDocTypeExpression(): JSDocTypeExpression {
+            export function parseJSDocTypeExpression(): JSDocTypeExpression;
+            export function parseJSDocTypeExpression(requireBraces: true): JSDocTypeExpression | undefined;
+            export function parseJSDocTypeExpression(requireBraces?: boolean): JSDocTypeExpression | undefined {
                 const result = <JSDocTypeExpression>createNode(SyntaxKind.JSDocTypeExpression, scanner.getTokenPos());
 
-                parseExpected(SyntaxKind.OpenBraceToken);
+                if (!parseExpected(SyntaxKind.OpenBraceToken) && requireBraces) {
+                    return undefined;
+                }
                 result.type = doInsideOfContext(NodeFlags.JSDoc, parseType);
                 parseExpected(SyntaxKind.CloseBraceToken);
 
@@ -6486,14 +6489,8 @@ namespace ts {
                 }
 
                 function tryParseTypeExpression(): JSDocTypeExpression | undefined {
-                    return tryParse(() => {
-                        skipWhitespace();
-                        if (token() !== SyntaxKind.OpenBraceToken) {
-                            return undefined;
-                        }
-
-                        return parseJSDocTypeExpression();
-                    });
+                    skipWhitespace();
+                    return token() === SyntaxKind.OpenBraceToken ? parseJSDocTypeExpression() : undefined;
                 }
 
                 function parseBracketNameInPropertyAndParamTag(): { name: EntityName, isBracketed: boolean } {
@@ -6602,12 +6599,12 @@ namespace ts {
                     const result = <JSDocTypeTag>createNode(SyntaxKind.JSDocTypeTag, atToken.pos);
                     result.atToken = atToken;
                     result.tagName = tagName;
-                    result.typeExpression = tryParseTypeExpression();
+                    result.typeExpression = parseJSDocTypeExpression(/*requireBraces*/ true);
                     return finishNode(result);
                 }
 
                 function parseAugmentsTag(atToken: AtToken, tagName: Identifier): JSDocAugmentsTag {
-                    const typeExpression = tryParseTypeExpression();
+                    const typeExpression = parseJSDocTypeExpression(/*requireBraces*/ true);
 
                     const result = <JSDocAugmentsTag>createNode(SyntaxKind.JSDocAugmentsTag, atToken.pos);
                     result.atToken = atToken;

src/compiler/parser.ts

@@ -1462,7 +1462,7 @@ namespace ts {
 
             // file.imports may not be undefined if there exists dynamic import
             let imports: StringLiteral[];
-            let moduleAugmentations: Array<StringLiteral | Identifier>;
+            let moduleAugmentations: (StringLiteral | Identifier)[];
             let ambientModules: string[];
 
             // If we are importing helpers, we need to add a synthetic reference to resolve the

src/compiler/program.ts

@@ -14,21 +14,29 @@ namespace ts {
         return getSymbolWalker;
 
         function getSymbolWalker(accept: (symbol: Symbol) => boolean = () => true): SymbolWalker {
-            const visitedTypes = createMap<Type>(); // Key is id as string
-            const visitedSymbols = createMap<Symbol>(); // Key is id as string
+            const visitedTypes: Type[] = []; // Sparse array from id to type
+            const visitedSymbols: Symbol[] = []; // Sparse array from id to symbol
 
             return {
                 walkType: type => {
-                    visitedTypes.clear();
-                    visitedSymbols.clear();
-                    visitType(type);
-                    return { visitedTypes: arrayFrom(visitedTypes.values()), visitedSymbols: arrayFrom(visitedSymbols.values()) };
+                    try {
+                        visitType(type);
+                        return { visitedTypes: getOwnValues(visitedTypes), visitedSymbols: getOwnValues(visitedSymbols) };
+                    }
+                    finally {
+                        clear(visitedTypes);
+                        clear(visitedSymbols);
+                    }
                 },
                 walkSymbol: symbol => {
-                    visitedTypes.clear();
-                    visitedSymbols.clear();
-                    visitSymbol(symbol);
-                    return { visitedTypes: arrayFrom(visitedTypes.values()), visitedSymbols: arrayFrom(visitedSymbols.values()) };
+                    try {
+                        visitSymbol(symbol);
+                        return { visitedTypes: getOwnValues(visitedTypes), visitedSymbols: getOwnValues(visitedSymbols) };
+                    }
+                    finally {
+                        clear(visitedTypes);
+                        clear(visitedSymbols);
+                    }
                 },
             };
 
@@ -37,11 +45,10 @@ namespace ts {
                     return;
                 }
 
-                const typeIdString = type.id.toString();
-                if (visitedTypes.has(typeIdString)) {
+                if (visitedTypes[type.id]) {
                     return;
                 }
-                visitedTypes.set(typeIdString, type);
+                visitedTypes[type.id] = type;
 
                 // Reuse visitSymbol to visit the type's symbol,
                 //  but be sure to bail on recuring into the type if accept declines the symbol.
@@ -79,26 +86,17 @@ namespace ts {
                 }
             }
 
-            function visitTypeList(types: Type[]): void {
-                if (!types) {
-                    return;
-                }
-                for (let i = 0; i < types.length; i++) {
-                    visitType(types[i]);
-                }
-            }
-
             function visitTypeReference(type: TypeReference): void {
                 visitType(type.target);
-                visitTypeList(type.typeArguments);
+                forEach(type.typeArguments, visitType);
             }
 
             function visitTypeParameter(type: TypeParameter): void {
                 visitType(getConstraintFromTypeParameter(type));
             }
 
             function visitUnionOrIntersectionType(type: UnionOrIntersectionType): void {
-                visitTypeList(type.types);
+                forEach(type.types, visitType);
             }
 
             function visitIndexType(type: IndexType): void {
@@ -122,7 +120,7 @@ namespace ts {
                 if (signature.typePredicate) {
                     visitType(signature.typePredicate.type);
                 }
-                visitTypeList(signature.typeParameters);
+                forEach(signature.typeParameters, visitType);
 
                 for (const parameter of signature.parameters){
                     visitSymbol(parameter);
@@ -133,8 +131,8 @@ namespace ts {
 
             function visitInterfaceType(interfaceT: InterfaceType): void {
                 visitObjectType(interfaceT);
-                visitTypeList(interfaceT.typeParameters);
-                visitTypeList(getBaseTypes(interfaceT));
+                forEach(interfaceT.typeParameters, visitType);
+                forEach(getBaseTypes(interfaceT), visitType);
                 visitType(interfaceT.thisType);
             }
 
@@ -161,11 +159,11 @@ namespace ts {
                 if (!symbol) {
                     return;
                 }
-                const symbolIdString = getSymbolId(symbol).toString();
-                if (visitedSymbols.has(symbolIdString)) {
+                const symbolId = getSymbolId(symbol);
+                if (visitedSymbols[symbolId]) {
                     return;
                 }
-                visitedSymbols.set(symbolIdString, symbol);
+                visitedSymbols[symbolId] = symbol;
                 if (!accept(symbol)) {
                     return true;
                 }