Improved circularity detection for types

Author: ahejlsberg

src/compiler/checker.ts

@@ -93,7 +93,7 @@ module ts {
         let emptyObjectType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined);
         let anyFunctionType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined);
         let noConstraintType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined);
-        
+
         let anySignature = createSignature(undefined, undefined, emptyArray, anyType, 0, false, false);
         let unknownSignature = createSignature(undefined, undefined, emptyArray, unknownType, 0, false, false);
 
@@ -118,14 +118,18 @@ module ts {
         let getGlobalParameterDecoratorType: () => ObjectType;
         let getGlobalPropertyDecoratorType: () => ObjectType;
         let getGlobalMethodDecoratorType: () => ObjectType;
-        
+
         let tupleTypes: Map<TupleType> = {};
         let unionTypes: Map<UnionType> = {};
         let stringLiteralTypes: Map<StringLiteralType> = {};
         let emitExtends = false;
         let emitDecorate = false;
         let emitParam = false;
 
+        let resolutionTargets: Object[] = [];
+        let resolutionResults: boolean[] = [];
+        let resolutionCount = 0;
+
         let mergedSymbols: Symbol[] = [];
         let symbolLinks: SymbolLinks[] = [];
         let nodeLinks: NodeLinks[] = [];
@@ -1980,7 +1984,7 @@ module ts {
             }
         }
 
-        function collectLinkedAliases(node: Identifier): Node[]{
+        function collectLinkedAliases(node: Identifier): Node[] {
             var exportSymbol: Symbol;
             if (node.parent && node.parent.kind === SyntaxKind.ExportAssignment) {
                 exportSymbol = resolveName(node.parent, node.text, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace, Diagnostics.Cannot_find_name_0, node);
@@ -2014,6 +2018,34 @@ module ts {
             }
         }
 
+        // Push an entry on the type resolution stack. If an entry with the given target is not already on the stack,
+        // a new entry with that target and an associated result value of true is pushed on the stack, and the value
+        // true is returned. Otherwise, a circularity has occurred and the result values of the existing entry and
+        // all entries pushed after it are changed to false, and the value false is returned. The target object has
+        // no significance other than to provide a unique identity for a particular type resolution result.
+        function pushTypeResolution(target: Object): boolean {
+            for (let i = 0; i < resolutionCount; i++) {
+                if (resolutionTargets[i] === target) {
+                    do {
+                        resolutionResults[i++] = false;
+                    }
+                    while (i < resolutionCount);
+                    return false;
+                }
+            }
+            resolutionTargets[resolutionCount] = target;
+            resolutionResults[resolutionCount] = true;
+            resolutionCount++;
+            return true;
+        }
+
+        // Pop an entry from the type resolution stack and return its associated result value. The result value will
+        // be true if no circularities were detected, or false if a circularity was found.
+        function popTypeResolution(): boolean {
+            resolutionTargets[--resolutionCount] = undefined;
+            return resolutionResults[resolutionCount];
+        }
+
         function getRootDeclaration(node: Node): Node {
             while (node.kind === SyntaxKind.BindingElement) {
                 node = node.parent.parent;
@@ -2271,27 +2303,27 @@ module ts {
                     return links.type = checkExpression((<ExportAssignment>declaration).expression);
                 }
                 // Handle variable, parameter or property
-                links.type = resolvingType;
-                let type = getWidenedTypeForVariableLikeDeclaration(<VariableLikeDeclaration>declaration, /*reportErrors*/ true);
-                if (links.type === resolvingType) {
-                    links.type = type;
-                }
-            }
-            else if (links.type === resolvingType) {
-                if ((<VariableLikeDeclaration>symbol.valueDeclaration).type) {
-                    // Variable has type annotation that circularly references the variable itself
-                    links.type = unknownType;
-                    error(symbol.valueDeclaration, Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_type_annotation,
-                        symbolToString(symbol));
+                if (!pushTypeResolution(symbol)) {
+                    return unknownType;
                 }
-                else {
-                    // Variable has initializer that circularly references the variable itself
-                    links.type = anyType;
-                    if (compilerOptions.noImplicitAny) {
-                        error(symbol.valueDeclaration, Diagnostics._0_implicitly_has_type_any_because_it_is_does_not_have_a_type_annotation_and_is_referenced_directly_or_indirectly_in_its_own_initializer,
+                let type = getWidenedTypeForVariableLikeDeclaration(<VariableLikeDeclaration>declaration, /*reportErrors*/ true);
+                if (!popTypeResolution()) {
+                    if ((<VariableLikeDeclaration>symbol.valueDeclaration).type) {
+                        // Variable has type annotation that circularly references the variable itself
+                        type = unknownType;
+                        error(symbol.valueDeclaration, Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_type_annotation,
                             symbolToString(symbol));
                     }
+                    else {
+                        // Variable has initializer that circularly references the variable itself
+                        type = anyType;
+                        if (compilerOptions.noImplicitAny) {
+                            error(symbol.valueDeclaration, Diagnostics._0_implicitly_has_type_any_because_it_is_does_not_have_a_type_annotation_and_is_referenced_directly_or_indirectly_in_its_own_initializer,
+                                symbolToString(symbol));
+                        }
+                    }
                 }
+                links.type = type;
             }
             return links.type;
         }
@@ -2315,19 +2347,13 @@ module ts {
 
         function getTypeOfAccessors(symbol: Symbol): Type {
             let links = getSymbolLinks(symbol);
-            checkAndStoreTypeOfAccessors(symbol, links);
-            return links.type;
-        }
-
-        function checkAndStoreTypeOfAccessors(symbol: Symbol, links?: SymbolLinks) {
-            links = links || getSymbolLinks(symbol);
             if (!links.type) {
-                links.type = resolvingType;
+                if (!pushTypeResolution(symbol)) {
+                    return unknownType;
+                }
                 let getter = <AccessorDeclaration>getDeclarationOfKind(symbol, SyntaxKind.GetAccessor);
                 let setter = <AccessorDeclaration>getDeclarationOfKind(symbol, SyntaxKind.SetAccessor);
-
                 let type: Type;
-
                 // First try to see if the user specified a return type on the get-accessor.
                 let getterReturnType = getAnnotatedAccessorType(getter);
                 if (getterReturnType) {
@@ -2349,23 +2375,20 @@ module ts {
                             if (compilerOptions.noImplicitAny) {
                                 error(setter, Diagnostics.Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_type_annotation, symbolToString(symbol));
                             }
-
                             type = anyType;
                         }
                     }
                 }
-
-                if (links.type === resolvingType) {
-                    links.type = type;
-                }
-            }
-            else if (links.type === resolvingType) {
-                links.type = anyType;
-                if (compilerOptions.noImplicitAny) {
-                    let getter = <AccessorDeclaration>getDeclarationOfKind(symbol, SyntaxKind.GetAccessor);
-                    error(getter, Diagnostics._0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions, symbolToString(symbol));
+                if (!popTypeResolution()) {
+                    type = anyType;
+                    if (compilerOptions.noImplicitAny) {
+                        let getter = <AccessorDeclaration>getDeclarationOfKind(symbol, SyntaxKind.GetAccessor);
+                        error(getter, Diagnostics._0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions, symbolToString(symbol));
+                    }
                 }
+                links.type = type;
             }
+            return links.type;
         }
 
         function getTypeOfFuncClassEnumModule(symbol: Symbol): Type {
@@ -2458,7 +2481,7 @@ module ts {
             return result;
         }
 
-        function getBaseTypes(type: InterfaceType): ObjectType[]{
+        function getBaseTypes(type: InterfaceType): ObjectType[] {
             let typeWithBaseTypes = <InterfaceTypeWithBaseTypes>type;
             if (!typeWithBaseTypes.baseTypes) {
                 if (type.symbol.flags & SymbolFlags.Class) {
@@ -2543,17 +2566,18 @@ module ts {
         function getDeclaredTypeOfTypeAlias(symbol: Symbol): Type {
             let links = getSymbolLinks(symbol);
             if (!links.declaredType) {
-                links.declaredType = resolvingType;
+                // Note that we use the links object as the target here because the symbol object is used as the unique
+                // identity for resolution of the 'type' property in SymbolLinks.
+                if (!pushTypeResolution(links)) {
+                    return unknownType;
+                }
                 let declaration = <TypeAliasDeclaration>getDeclarationOfKind(symbol, SyntaxKind.TypeAliasDeclaration);
                 let type = getTypeFromTypeNode(declaration.type);
-                if (links.declaredType === resolvingType) {
-                    links.declaredType = type;
+                if (!popTypeResolution()) {
+                    type = unknownType;
+                    error(declaration.name, Diagnostics.Type_alias_0_circularly_references_itself, symbolToString(symbol));
                 }
-            }
-            else if (links.declaredType === resolvingType) {
-                links.declaredType = unknownType;
-                let declaration = <TypeAliasDeclaration>getDeclarationOfKind(symbol, SyntaxKind.TypeAliasDeclaration);
-                error(declaration.name, Diagnostics.Type_alias_0_circularly_references_itself, symbolToString(symbol));
+                links.declaredType = type;
             }
             return links.declaredType;
         }
@@ -3157,7 +3181,9 @@ module ts {
 
         function getReturnTypeOfSignature(signature: Signature): Type {
             if (!signature.resolvedReturnType) {
-                signature.resolvedReturnType = resolvingType;
+                if (!pushTypeResolution(signature)) {
+                    return unknownType;
+                }
                 let type: Type;
                 if (signature.target) {
                     type = instantiateType(getReturnTypeOfSignature(signature.target), signature.mapper);
@@ -3168,21 +3194,19 @@ module ts {
                 else {
                     type = getReturnTypeFromBody(<FunctionLikeDeclaration>signature.declaration);
                 }
-                if (signature.resolvedReturnType === resolvingType) {
-                    signature.resolvedReturnType = type;
-                }
-            }
-            else if (signature.resolvedReturnType === resolvingType) {
-                signature.resolvedReturnType = anyType;
-                if (compilerOptions.noImplicitAny) {
-                    let declaration = <Declaration>signature.declaration;
-                    if (declaration.name) {
-                        error(declaration.name, Diagnostics._0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions, declarationNameToString(declaration.name));
-                    }
-                    else {
-                        error(declaration, Diagnostics.Function_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions);
+                if (!popTypeResolution()) {
+                    type = anyType;
+                    if (compilerOptions.noImplicitAny) {
+                        let declaration = <Declaration>signature.declaration;
+                        if (declaration.name) {
+                            error(declaration.name, Diagnostics._0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions, declarationNameToString(declaration.name));
+                        }
+                        else {
+                            error(declaration, Diagnostics.Function_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions);
+                        }
                     }
                 }
+                signature.resolvedReturnType = type;
             }
             return signature.resolvedReturnType;
         }
@@ -8366,8 +8390,7 @@ module ts {
                         }
                     }
                 }
-
-                checkAndStoreTypeOfAccessors(getSymbolOfNode(node));
+                getTypeOfAccessors(getSymbolOfNode(node));
             }
 
             checkFunctionLikeDeclaration(node);