Don't bother trying to semantically classify names that could never be typenames.

Author: CyrusNajmabadi

src/compiler/binder.ts

@@ -90,10 +90,12 @@ module ts {
         let lastContainer: Node;
         let symbolCount = 0;
         let Symbol = objectAllocator.getSymbolConstructor();
+        let typeNames: Map<string> = {}; 
 
         if (!file.locals) {
             bind(file);
             file.symbolCount = symbolCount;
+            file.typeNames = typeNames;
         }
 
         return;
@@ -194,6 +196,11 @@ module ts {
                 symbol = hasProperty(symbolTable, name)
                     ? symbolTable[name]
                     : (symbolTable[name] = createSymbol(SymbolFlags.None, name));
+                
+                if (name && (includes & (SymbolFlags.Class | SymbolFlags.Enum | SymbolFlags.TypeAlias | SymbolFlags.Interface | SymbolFlags.TypeParameter | SymbolFlags.Module))) {
+                    typeNames[name] = name;   
+                } 
+
                 if (symbol.flags & excludes) {
                     if (node.name) {
                         node.name.parent = node;

src/compiler/program.ts

@@ -148,6 +148,7 @@ module ts {
         let commonSourceDirectory: string;
         let diagnosticsProducingTypeChecker: TypeChecker;
         let noDiagnosticsTypeChecker: TypeChecker;
+        let typeNames: Map<string>;
 
         let start = new Date().getTime();
 
@@ -172,6 +173,7 @@ module ts {
             getDeclarationDiagnostics,
             getCompilerOptionsDiagnostics,
             getTypeChecker,
+            getTypeNames,
             getDiagnosticsProducingTypeChecker,
             getCommonSourceDirectory: () => commonSourceDirectory,
             emit,
@@ -183,6 +185,20 @@ module ts {
         };
         return program;
 
+        function getTypeNames() {
+            if (!typeNames) {
+                // Initialize a checker so that all our files are bound.
+                getTypeChecker();
+                typeNames = {};
+
+                for (let sourceFile of files) {
+                    copyMap(sourceFile.typeNames, typeNames);
+                }
+            }
+
+            return typeNames;
+        }
+
         function getEmitHost(writeFileCallback?: WriteFileCallback): EmitHost {
             return {
                 getCanonicalFileName: fileName => host.getCanonicalFileName(fileName),

src/compiler/types.ts

@@ -422,6 +422,7 @@ module ts {
         /* @internal */ locals?: SymbolTable;           // Locals associated with node (initialized by binding)
         /* @internal */ nextContainer?: Node;           // Next container in declaration order (initialized by binding)
         /* @internal */ localSymbol?: Symbol;           // Local symbol declared by node (initialized by binding only for exported nodes)
+        /* @internal */ typeNames?: Map<string>;
     }
 
     export interface NodeArray<T> extends Array<T>, TextRange {
@@ -1223,6 +1224,8 @@ module ts {
         // language service).
         /* @internal */ getDiagnosticsProducingTypeChecker(): TypeChecker;
 
+        /* @internal */ getTypeNames(): Map<string>;
+
         /* @internal */ getNodeCount(): number;
         /* @internal */ getIdentifierCount(): number;
         /* @internal */ getSymbolCount(): number;

src/services/services.ts

@@ -5992,6 +5992,7 @@ module ts {
             let typeChecker = program.getTypeChecker();
 
             let result: number[] = [];
+            let typeNames = program.getTypeNames();
             processNode(sourceFile);
 
             return { spans: result, endOfLineState: EndOfLineState.None };
@@ -6048,11 +6049,14 @@ module ts {
                 // Only walk into nodes that intersect the requested span.
                 if (node && textSpanIntersectsWith(span, node.getFullStart(), node.getFullWidth())) {
                     if (node.kind === SyntaxKind.Identifier && !nodeIsMissing(node)) {
-                        let symbol = typeChecker.getSymbolAtLocation(node);
-                        if (symbol) {
-                            let type = classifySymbol(symbol, getMeaningFromLocation(node));
-                            if (type) {
-                                pushClassification(node.getStart(), node.getWidth(), type);
+                        let identifier = <Identifier>node;
+                        if (typeNames[identifier.text]) {
+                            let symbol = typeChecker.getSymbolAtLocation(node);
+                            if (symbol) {
+                                let type = classifySymbol(symbol, getMeaningFromLocation(node));
+                                if (type) {
+                                    pushClassification(node.getStart(), node.getWidth(), type);
+                                }
                             }
                         }
                     }