PR feedback.

Author: CyrusNajmabadi

src/compiler/binder.ts

@@ -90,12 +90,12 @@ namespace ts {
         let lastContainer: Node;
         let symbolCount = 0;
         let Symbol = objectAllocator.getSymbolConstructor();
-        let typeNames: Map<string> = {}; 
+        let classifiableNames: Map<string> = {}; 
 
         if (!file.locals) {
             bind(file);
             file.symbolCount = symbolCount;
-            file.typeNames = typeNames;
+            file.classifiableNames = classifiableNames;
         }
 
         return;
@@ -197,8 +197,8 @@ namespace ts {
                     ? 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 (name && (includes & SymbolFlags.Classifiable)) {
+                    classifiableNames[name] = name;   
                 } 
 
                 if (symbol.flags & excludes) {

src/compiler/program.ts

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

src/compiler/types.ts

@@ -422,7 +422,6 @@ namespace 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 {
@@ -1173,6 +1172,8 @@ namespace ts {
         // Stores a line map for the file.
         // This field should never be used directly to obtain line map, use getLineMap function instead.
         /* @internal */ lineMap: number[];
+
+        /* @internal */ classifiableNames?: Map<string>;
     }
 
     export interface ScriptReferenceHost {
@@ -1224,7 +1225,7 @@ namespace ts {
         // language service).
         /* @internal */ getDiagnosticsProducingTypeChecker(): TypeChecker;
 
-        /* @internal */ getTypeNames(): Map<string>;
+        /* @internal */ getClassifiableNames(): Map<string>;
 
         /* @internal */ getNodeCount(): number;
         /* @internal */ getIdentifierCount(): number;
@@ -1522,6 +1523,11 @@ namespace ts {
 
         PropertyOrAccessor = Property | Accessor,
         Export = ExportNamespace | ExportType | ExportValue,
+
+        /* @internal */
+        // The set of things we consider semantically classifiable.  Used to speed up the LS during 
+        // classification.
+        Classifiable = Class | Enum | TypeAlias | Interface | TypeParameter | Module,
     }
 
     export interface Symbol {

src/services/services.ts

@@ -5992,7 +5992,7 @@ namespace ts {
             let typeChecker = program.getTypeChecker();
 
             let result: number[] = [];
-            let typeNames = program.getTypeNames();
+            let classifiableNames = program.getClassifiableNames();
             processNode(sourceFile);
 
             return { spans: result, endOfLineState: EndOfLineState.None };
@@ -6005,6 +6005,9 @@ namespace ts {
 
             function classifySymbol(symbol: Symbol, meaningAtPosition: SemanticMeaning): ClassificationType {
                 let flags = symbol.getFlags();
+                if ((flags & SymbolFlags.Classifiable) === 0) {
+                    return;
+                }
 
                 if (flags & SymbolFlags.Class) {
                     return ClassificationType.className;
@@ -6054,7 +6057,7 @@ namespace ts {
                         // Only bother calling into the typechecker if this is an identifier that
                         // could possibly resolve to a type name.  This makes classification run
                         // in a third of the time it would normally take.
-                        if (typeNames[identifier.text]) {
+                        if (classifiableNames[identifier.text]) {
                             let symbol = typeChecker.getSymbolAtLocation(node);
                             if (symbol) {
                                 let type = classifySymbol(symbol, getMeaningFromLocation(node));