Merge branch 'master' into computedProperties

src/compiler/checker.ts

@@ -10071,8 +10071,8 @@ module ts {
             if (symbol && (symbol.flags & SymbolFlags.EnumMember)) {
                 var declaration = symbol.valueDeclaration;
                 var constantValue: number;
-                if (declaration.kind === SyntaxKind.EnumMember && (constantValue = getNodeLinks(declaration).enumMemberValue) !== undefined) {
-                    return constantValue;
+                if (declaration.kind === SyntaxKind.EnumMember) {
+                    return getEnumMemberValue(<EnumMember>declaration);
                 }
             }
 

src/harness/fourslash.ts

@@ -548,6 +548,18 @@ module FourSlash {
             }
         }
 
+        public verifyGetEmitOutputForCurrentFile(expected: string): void {
+            var emit = this.languageService.getEmitOutput(this.activeFile.fileName);
+            if (emit.outputFiles.length !== 1) {
+                throw new Error("Expected exactly one output from emit of " + this.activeFile.fileName);
+            }
+            this.taoInvalidReason = 'verifyGetEmitOutputForCurrentFile impossible';
+            var actual = emit.outputFiles[0].text;
+            if (actual !== expected) {
+                this.raiseError("Expected emit output to be '" + expected + "', but got '" + actual + "'");
+            }
+        }
+
         public verifyMemberListContains(symbol: string, text?: string, documentation?: string, kind?: string) {
             this.scenarioActions.push('<ShowCompletionList />');
             this.scenarioActions.push('<VerifyCompletionContainsItem ItemName="' + symbol + '"/>');

src/services/services.ts

@@ -59,7 +59,7 @@ module ts {
         isOpen: boolean;
         version: string;
         scriptSnapshot: IScriptSnapshot;
-
+        nameTable: Map<string>;
         getNamedDeclarations(): Declaration[];
     }
 
@@ -750,6 +750,7 @@ module ts {
         public isOpen: boolean;
         public languageVersion: ScriptTarget;
         public identifiers: Map<string>;
+        public nameTable: Map<string>;
 
         private namedDeclarations: Declaration[];
 
@@ -1546,6 +1547,8 @@ module ts {
     export function createLanguageServiceSourceFile(filename: string, scriptSnapshot: IScriptSnapshot, scriptTarget: ScriptTarget, version: string, isOpen: boolean, setNodeParents: boolean): SourceFile {
         var sourceFile = createSourceFile(filename, scriptSnapshot.getText(0, scriptSnapshot.getLength()), scriptTarget, setNodeParents);
         setSourceFileFields(sourceFile, scriptSnapshot, version, isOpen);
+        // after full parsing we can use table with interned strings as name table
+        sourceFile.nameTable = sourceFile.identifiers;
         return sourceFile;
     }
 
@@ -1577,6 +1580,9 @@ module ts {
                 if (!disableIncrementalParsing) {
                     var newSourceFile = sourceFile.update(scriptSnapshot.getText(0, scriptSnapshot.getLength()), textChangeRange);
                     setSourceFileFields(newSourceFile, scriptSnapshot, version, isOpen);
+                    // after incremental parsing nameTable might not be up-to-date
+                    // drop it so it can be lazily recreated later
+                    newSourceFile.nameTable = undefined;
                     return newSourceFile;
                 }
             }
@@ -3235,7 +3241,7 @@ module ts {
 
             if (node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.ThisKeyword || node.kind === SyntaxKind.SuperKeyword ||
                 isLiteralNameOfPropertyDeclarationOrIndexAccess(node) || isNameOfExternalModuleImportOrDeclaration(node)) {
-                return getReferencesForNode(node, [sourceFile], /*findInStrings:*/ false, /*findInComments:*/ false);
+                return getReferencesForNode(node, [sourceFile], /*searchOnlyInCurrentFile*/ true, /*findInStrings:*/ false, /*findInComments:*/ false);
             }
 
             switch (node.kind) {
@@ -3788,10 +3794,31 @@ module ts {
             }
 
             Debug.assert(node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.NumericLiteral || node.kind === SyntaxKind.StringLiteral);
-            return getReferencesForNode(node, program.getSourceFiles(), findInStrings, findInComments);
+            return getReferencesForNode(node, program.getSourceFiles(), /*searchOnlyInCurrentFile*/ false, findInStrings, findInComments);
         }
 
-        function getReferencesForNode(node: Node, sourceFiles: SourceFile[], findInStrings: boolean, findInComments: boolean): ReferenceEntry[] {
+        function initializeNameTable(sourceFile: SourceFile): void {
+            var nameTable: Map<string> = {};
+
+            walk(sourceFile);
+            sourceFile.nameTable = nameTable;
+
+            function walk(node: Node) {
+                switch (node.kind) {
+                    case SyntaxKind.Identifier:
+                        nameTable[(<Identifier>node).text] = (<Identifier>node).text;
+                        break;
+                    case SyntaxKind.StringLiteral:
+                    case SyntaxKind.NumericLiteral:
+                        nameTable[(<LiteralExpression>node).text] = (<LiteralExpression>node).text;
+                        break;
+                    default:
+                        forEachChild(node, walk);
+                }
+            } 
+        }
+
+        function getReferencesForNode(node: Node, sourceFiles: SourceFile[], searchOnlyInCurrentFile: boolean, findInStrings: boolean, findInComments: boolean): ReferenceEntry[] {
             // Labels
             if (isLabelName(node)) {
                 if (isJumpStatementTarget(node)) {
@@ -3847,15 +3874,28 @@ module ts {
                 getReferencesInNode(scope, symbol, declaredName, node, searchMeaning, findInStrings, findInComments, result);
             }
             else {
-                var internedName = getInternedName(symbol, declarations)
-                forEach(sourceFiles, sourceFile => {
-                    cancellationToken.throwIfCancellationRequested();
+                if (searchOnlyInCurrentFile) {
+                    Debug.assert(sourceFiles.length === 1);
+                    result = [];
+                    getReferencesInNode(sourceFiles[0], symbol, declaredName, node, searchMeaning, findInStrings, findInComments, result);
+                }
+                else {
+                    var internedName = getInternedName(symbol, declarations)
+                    forEach(sourceFiles, sourceFile => {
+                        cancellationToken.throwIfCancellationRequested();
 
-                    if (lookUp(sourceFile.identifiers, internedName)) {
-                        result = result || [];
-                        getReferencesInNode(sourceFile, symbol, declaredName, node, searchMeaning, findInStrings, findInComments, result);
-                    }
-                });
+                        if (!sourceFile.nameTable) {
+                            initializeNameTable(sourceFile)
+                        }
+
+                        Debug.assert(sourceFile.nameTable !== undefined);
+
+                        if (lookUp(sourceFile.nameTable, internedName)) {
+                            result = result || [];
+                            getReferencesInNode(sourceFile, symbol, declaredName, node, searchMeaning, findInStrings, findInComments, result);
+                        }
+                    });
+                }
             }
 
             return result;

tests/cases/fourslash/constEnumsEmitOutputInMultipleFiles.ts

@@ -0,0 +1,18 @@
+/// <reference path='fourslash.ts'/>
+
+// @Filename: a.ts
+////const enum TestEnum {   
+////    Foo, Bar
+////}
+////var testFirstFile = TestEnum.Bar;
+
+// @Filename: b.ts
+/////// <reference path="a.ts" />
+/////*1*/
+////var testInOtherFile = TestEnum.Bar;
+
+goTo.marker("1");
+verify.verifyGetEmitOutputForCurrentFile(
+"/// <reference path=\"a.ts\" />\r\n\
+var testInOtherFile = 1 /* Bar */;\r\n"
+    )

tests/cases/fourslash/findReferencesAfterEdit.ts

@@ -0,0 +1,22 @@
+/// <reference path='fourslash.ts'/>
+
+// @Filename: a.ts
+////interface A {
+////    foo: string;
+////}
+
+// @Filename: b.ts
+///////<reference path='a.ts'/>
+/////*0*/
+////function foo(x: A) {
+////    x.f/*1*/oo
+////}
+
+goTo.marker("1");
+verify.referencesCountIs(2);
+
+goTo.marker("0");
+edit.insert("\r\n");
+
+goTo.marker("1");
+verify.referencesCountIs(2);

tests/cases/fourslash/fourslash.ts

@@ -264,6 +264,10 @@ module FourSlashInterface {
             FourSlash.currentTestState.verifyCurrentFileContent(text);
         }
 
+        public verifyGetEmitOutputForCurrentFile(expected: string): void {
+            FourSlash.currentTestState.verifyGetEmitOutputForCurrentFile(expected);
+        }
+
         public currentParameterHelpArgumentNameIs(name: string) {
             FourSlash.currentTestState.verifyCurrentParameterHelpName(name);
         }

tests/cases/fourslash/getOccurrencesAfterEdit.ts

@@ -0,0 +1,18 @@
+/// <reference path='fourslash.ts'/>
+
+/////*0*/
+////interface A {
+////    foo: string;
+////}
+////function foo(x: A) {
+////    x.f/*1*/oo
+////}
+
+goTo.marker("1");
+verify.occurrencesAtPositionCount(2);
+
+goTo.marker("0");
+edit.insert("\r\n");
+
+goTo.marker("1");
+verify.occurrencesAtPositionCount(2);