More robust circularity detection in node builder

src/compiler/checker.ts

@@ -3060,7 +3060,7 @@ namespace ts {
                     flags,
                     tracker: tracker && tracker.trackSymbol ? tracker : { trackSymbol: noop },
                     encounteredError: false,
-                    symbolStack: undefined,
+                    visitedSymbols: undefined,
                     inferTypeParameters: undefined
                 };
             }
@@ -3242,7 +3242,10 @@ namespace ts {
 
                 function createAnonymousTypeNode(type: ObjectType): TypeNode {
                     const symbol = type.symbol;
+                    let id: string;
                     if (symbol) {
+                        const isConstructorObject = getObjectFlags(type) & ObjectFlags.Anonymous && type.symbol && type.symbol.flags & SymbolFlags.Class;
+                        id = (isConstructorObject ? "+" : "") + getSymbolId(symbol);
                         if (isJavaScriptConstructor(symbol.valueDeclaration)) {
                             // Instance and static types share the same symbol; only add 'typeof' for the static side.
                             const isInstanceType = type === getInferredClassType(symbol) ? SymbolFlags.Type : SymbolFlags.Value;
@@ -3254,7 +3257,7 @@ namespace ts {
                             shouldWriteTypeOfFunctionSymbol()) {
                             return symbolToTypeNode(symbol, context, SymbolFlags.Value);
                         }
-                        else if (contains(context.symbolStack, symbol)) {
+                        else if (context.visitedSymbols && context.visitedSymbols.has(id)) {
                             // If type is an anonymous type literal in a type alias declaration, use type alias name
                             const typeAlias = getTypeAliasForTypeLiteral(type);
                             if (typeAlias) {
@@ -3268,20 +3271,14 @@ namespace ts {
                         else {
                             // Since instantiations of the same anonymous type have the same symbol, tracking symbols instead
                             // of types allows us to catch circular references to instantiations of the same anonymous type
-                            if (!context.symbolStack) {
-                                context.symbolStack = [];
+                            if (!context.visitedSymbols) {
+                                context.visitedSymbols = createMap<true>();
                             }
 
-                            const isConstructorObject = getObjectFlags(type) & ObjectFlags.Anonymous && type.symbol && type.symbol.flags & SymbolFlags.Class;
-                            if (isConstructorObject) {
-                                return createTypeNodeFromObjectType(type);
-                            }
-                            else {
-                                context.symbolStack.push(symbol);
-                                const result = createTypeNodeFromObjectType(type);
-                                context.symbolStack.pop();
-                                return result;
-                            }
+                            context.visitedSymbols.set(id, true);
+                            const result = createTypeNodeFromObjectType(type);
+                            context.visitedSymbols.delete(id);
+                            return result;
                         }
                     }
                     else {
@@ -3298,7 +3295,7 @@ namespace ts {
                                     declaration.parent.kind === SyntaxKind.SourceFile || declaration.parent.kind === SyntaxKind.ModuleBlock));
                         if (isStaticMethodSymbol || isNonLocalFunctionSymbol) {
                             // typeof is allowed only for static/non local functions
-                            return (!!(context.flags & NodeBuilderFlags.UseTypeOfFunction) || contains(context.symbolStack, symbol)) && // it is type of the symbol uses itself recursively
+                            return (!!(context.flags & NodeBuilderFlags.UseTypeOfFunction) || (context.visitedSymbols && context.visitedSymbols.has(id))) && // it is type of the symbol uses itself recursively
                                 (!(context.flags & NodeBuilderFlags.UseStructuralFallback) || isValueSymbolAccessible(symbol, context.enclosingDeclaration)); // And the build is going to succeed without visibility error or there is no structural fallback allowed
                         }
                     }
@@ -3997,7 +3994,7 @@ namespace ts {
 
             // State
             encounteredError: boolean;
-            symbolStack: Symbol[] | undefined;
+            visitedSymbols: Map<true> | undefined;
             inferTypeParameters: TypeParameter[] | undefined;
         }
 

tests/baselines/reference/classExpressionInClassStaticDeclarations.js

@@ -0,0 +1,37 @@
+//// [classExpressionInClassStaticDeclarations.ts]
+class C {
+    static D = class extends C {};
+}
+
+//// [classExpressionInClassStaticDeclarations.js]
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var C = /** @class */ (function () {
+    function C() {
+    }
+    C.D = /** @class */ (function (_super) {
+        __extends(class_1, _super);
+        function class_1() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        return class_1;
+    }(C));
+    return C;
+}());
+
+
+//// [classExpressionInClassStaticDeclarations.d.ts]
+declare class C {
+    static D: {
+        new (): {};
+        D: any;
+    };
+}

tests/baselines/reference/classExpressionInClassStaticDeclarations.symbols

@@ -0,0 +1,8 @@
+=== tests/cases/compiler/classExpressionInClassStaticDeclarations.ts ===
+class C {
+>C : Symbol(C, Decl(classExpressionInClassStaticDeclarations.ts, 0, 0))
+
+    static D = class extends C {};
+>D : Symbol(C.D, Decl(classExpressionInClassStaticDeclarations.ts, 0, 9))
+>C : Symbol(C, Decl(classExpressionInClassStaticDeclarations.ts, 0, 0))
+}

tests/baselines/reference/classExpressionInClassStaticDeclarations.types

@@ -0,0 +1,9 @@
+=== tests/cases/compiler/classExpressionInClassStaticDeclarations.ts ===
+class C {
+>C : C
+
+    static D = class extends C {};
+>D : typeof (Anonymous class)
+>class extends C {} : typeof (Anonymous class)
+>C : C
+}

tests/cases/compiler/classExpressionInClassStaticDeclarations.ts

@@ -0,0 +1,4 @@
+// @declaration: true
+class C {
+    static D = class extends C {};
+}