Reuse program structure

Jakefile.js

@@ -138,7 +138,8 @@ var harnessSources = [
     "services/patternMatcher.ts",
     "versionCache.ts",
     "convertToBase64.ts",
-    "transpile.ts"
+    "transpile.ts",
+    "reuseProgramStructure.ts"
 ].map(function (f) {
     return path.join(unittestsDirectory, f);
 })).concat([

src/compiler/checker.ts

@@ -892,28 +892,19 @@ namespace ts {
             // Escape the name in the "require(...)" clause to ensure we find the right symbol.
             let moduleName = escapeIdentifier(moduleReferenceLiteral.text);
 
-            if (!moduleName) return;
+            if (!moduleName) {
+                return;
+            }
             let isRelative = isExternalModuleNameRelative(moduleName);
             if (!isRelative) {
                 let symbol = getSymbol(globals, '"' + moduleName + '"', SymbolFlags.ValueModule);
                 if (symbol) {
                     return symbol;
                 }
             }
-            let fileName: string;
-            let sourceFile: SourceFile;
-            while (true) {
-                fileName = normalizePath(combinePaths(searchPath, moduleName));
-                sourceFile = forEach(supportedExtensions, extension => host.getSourceFile(fileName + extension));
-                if (sourceFile || isRelative) {
-                    break;
-                }
-                let parentPath = getDirectoryPath(searchPath);
-                if (parentPath === searchPath) {
-                    break;
-                }
-                searchPath = parentPath;
-            }
+
+            let fileName = getResolvedModuleFileName(getSourceFile(location), moduleReferenceLiteral);
+            let sourceFile = fileName && host.getSourceFile(fileName);
             if (sourceFile) {
                 if (sourceFile.symbol) {
                     return sourceFile.symbol;

src/compiler/parser.ts

@@ -5634,7 +5634,7 @@ namespace ts {
             // will immediately bail out of walking any subtrees when we can see that their parents
             // are already correct.
             let result = Parser.parseSourceFile(sourceFile.fileName, newText, sourceFile.languageVersion, syntaxCursor, /* setParentNode */ true)
-
+            
             return result;
         }
 

src/compiler/types.ts

@@ -1176,8 +1176,11 @@ 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>;
+        // Stores a mapping 'external module reference text' -> 'resolved file name' | undefined
+        // Content of this fiels should never be used directly - use getResolvedModuleFileName/setResolvedModuleFileName functions instead
+        /* @internal */ resolvedModules: Map<string>;
+        /* @internal */ imports: LiteralExpression[];
     }
 
     export interface ScriptReferenceHost {
@@ -1195,6 +1198,12 @@ namespace ts {
     }
 
     export interface Program extends ScriptReferenceHost {
+
+        /**
+         * Get a list of root file names that were passed to a 'createProgram'
+         */
+        getRootFileNames(): string[]
+
         /**
          * Get a list of files in the program
          */
@@ -1235,6 +1244,7 @@ namespace ts {
         /* @internal */ getIdentifierCount(): number;
         /* @internal */ getSymbolCount(): number;
         /* @internal */ getTypeCount(): number;
+        /* @internal */ structureIsReused?: boolean;
     }
 
     export interface SourceMapSpan {
@@ -1881,7 +1891,7 @@ namespace ts {
         CarriageReturnLineFeed = 0,
         LineFeed = 1,
     }
-	
+    
     export interface LineAndCharacter {
         line: number;
         /*
@@ -2065,6 +2075,7 @@ namespace ts {
         getCanonicalFileName(fileName: string): string;
         useCaseSensitiveFileNames(): boolean;
         getNewLine(): string;
+        hasChanges?(oldFile: SourceFile): boolean;
     }
 
     export interface TextSpan {

src/compiler/utilities.ts

@@ -78,6 +78,40 @@ namespace ts {
         return node.end - node.pos;
     }
 
+    export function arrayIsEqualTo<T>(arr1: T[], arr2: T[], comparer: (a: T, b: T) => boolean): boolean {
+        if (!arr1 || !arr2) {
+            return arr1 === arr2;
+        }
+
+        if (arr1.length !== arr2.length) {
+            return false;
+        }
+
+        for (let i = 0; i < arr1.length; ++i) {
+            if (!comparer(arr1[i], arr2[i])) {
+                return false;
+            }
+        }
+
+        return true;
+    }    
+
+    export function hasResolvedModuleName(sourceFile: SourceFile, moduleName: LiteralExpression): boolean {
+        return sourceFile.resolvedModules && hasProperty(sourceFile.resolvedModules, moduleName.text);
+    }
+
+    export function getResolvedModuleFileName(sourceFile: SourceFile, moduleName: LiteralExpression): string {
+        return sourceFile.resolvedModules && sourceFile.resolvedModules[moduleName.text];
+    }
+
+    export function setResolvedModuleName(sourceFile: SourceFile, moduleName: LiteralExpression, resolvedFileName: string): void {
+        if (!sourceFile.resolvedModules) {
+            sourceFile.resolvedModules = {};
+        }
+
+        sourceFile.resolvedModules[moduleName.text] = resolvedFileName;
+    }
+
     // Returns true if this node contains a parse error anywhere underneath it.
     export function containsParseError(node: Node): boolean {
         aggregateChildData(node);

src/services/services.ts

@@ -753,7 +753,8 @@ namespace ts {
         public languageVersion: ScriptTarget;
         public identifiers: Map<string>;
         public nameTable: Map<string>;
-
+        public resolvedModules: Map<string>;
+        public imports: LiteralExpression[];
         private namedDeclarations: Map<Declaration[]>;
 
         public update(newText: string, textChangeRange: TextChangeRange): SourceFile {
@@ -2471,6 +2472,8 @@ namespace ts {
             let newSettings = hostCache.compilationSettings();
             let changesInCompilationSettingsAffectSyntax = oldSettings && oldSettings.target !== newSettings.target;
 
+            let reusableOldProgram = changesInCompilationSettingsAffectSyntax ? undefined : program;
+
             // Now create a new compiler
             let newProgram = createProgram(hostCache.getRootFileNames(), newSettings, {
                 getSourceFile: getOrCreateSourceFile,
@@ -2480,8 +2483,9 @@ namespace ts {
                 getNewLine: () => host.getNewLine ? host.getNewLine() : "\r\n",
                 getDefaultLibFileName: (options) => host.getDefaultLibFileName(options),
                 writeFile: (fileName, data, writeByteOrderMark) => { },
-                getCurrentDirectory: () => host.getCurrentDirectory()
-            });
+                getCurrentDirectory: () => host.getCurrentDirectory(),
+                hasChanges: oldFile => oldFile.version !== hostCache.getVersion(oldFile.fileName)
+            }, reusableOldProgram);
 
             // Release any files we have acquired in the old program but are 
             // not part of the new program.