Merge pull request #430 from Microsoft/outlining

enable outlining atop of new compiler

Author: vladima

src/harness/fourslash.ts

@@ -1419,8 +1419,8 @@ module FourSlash {
             for (var i = 0; i < spans.length; i++) {
                 var expectedSpan = spans[i];
                 var actualSpan = actual[i];
-                if (expectedSpan.start !== actualSpan.start() || expectedSpan.end !== actualSpan.end()) {
-                    throw new Error('verifyOutliningSpans failed - span ' + (i + 1) + ' expected: (' + expectedSpan.start + ',' + expectedSpan.end + '),  actual: (' + actualSpan.start() + ',' + actualSpan.end() + ')');
+                if (expectedSpan.start !== actualSpan.textSpan.start() || expectedSpan.end !== actualSpan.textSpan.end()) {
+                    throw new Error('verifyOutliningSpans failed - span ' + (i + 1) + ' expected: (' + expectedSpan.start + ',' + expectedSpan.end + '),  actual: (' + actualSpan.textSpan.start() + ',' + actualSpan.textSpan.end() + ')');
                 }
             }
         }

src/services/outliningElementsCollector.ts

@@ -15,95 +15,75 @@
 
 ///<reference path='references.ts' />
 
-module TypeScript.Services {
-    export class OutliningElementsCollector extends TypeScript.DepthLimitedWalker {
-        // The maximum depth for collecting spans; this will cause us to miss deeply nested function/modules spans, 
-        // but will guarantee performance will not be closely tied to tree depth.
-        private static MaximumDepth: number = 10;
-        private inObjectLiteralExpression: boolean = false;
-
-        private elements: TypeScript.TextSpan[] = [];
-
-        constructor() {
-            super(OutliningElementsCollector.MaximumDepth);
-        }
-
-        public visitClassDeclaration(node: TypeScript.ClassDeclarationSyntax): void {
-            this.addOutlineRange(node, node.openBraceToken, node.closeBraceToken);
-            super.visitClassDeclaration(node);
-        }
-
-        public visitInterfaceDeclaration(node: TypeScript.InterfaceDeclarationSyntax): void {
-            this.addOutlineRange(node, node.body.openBraceToken, node.body.closeBraceToken);
-            super.visitInterfaceDeclaration(node);
-        }
-
-        public visitModuleDeclaration(node: TypeScript.ModuleDeclarationSyntax): void {
-            this.addOutlineRange(node, node.openBraceToken, node.closeBraceToken);
-            super.visitModuleDeclaration(node);
-        }
-
-        public visitEnumDeclaration(node: TypeScript.EnumDeclarationSyntax): void {
-            this.addOutlineRange(node, node.openBraceToken, node.closeBraceToken);
-            super.visitEnumDeclaration(node);
-        }
-
-        public visitFunctionDeclaration(node: TypeScript.FunctionDeclarationSyntax): void {
-            this.addOutlineRange(node, node.block, node.block);
-            super.visitFunctionDeclaration(node);
-        }
-
-        public visitFunctionExpression(node: TypeScript.FunctionExpressionSyntax): void {
-            this.addOutlineRange(node, node.block, node.block);
-            super.visitFunctionExpression(node);
-        }
-
-        public visitConstructorDeclaration(node: TypeScript.ConstructorDeclarationSyntax): void {
-            this.addOutlineRange(node, node.block, node.block);
-            super.visitConstructorDeclaration(node);
-        }
-
-        public visitMemberFunctionDeclaration(node: TypeScript.MemberFunctionDeclarationSyntax): void {
-            this.addOutlineRange(node, node.block, node.block);
-            super.visitMemberFunctionDeclaration(node);
-        }
-
-        public visitGetAccessor(node: TypeScript.GetAccessorSyntax): void {
-            if (!this.inObjectLiteralExpression) {
-                this.addOutlineRange(node, node.block, node.block);
-            }
-            super.visitGetAccessor(node);
-        }
+module ts {
+
+    export interface OutliningSpan {
+        /** 
+         * @param textSpan The span of the document to actually collapse.
+         * @param hintSpan The span of the document to display when the user hovers over the 
+         *       collapsed span.
+         * @param bannerText The text to display in the editor for the collapsed region.
+         * @param autoCollapse Whether or not this region should be automatically collapsed when 
+         *        the 'Collapse to Definitions' command is invoked.
+         */
+        textSpan: TypeScript.TextSpan;
+        hintSpan: TypeScript.TextSpan;
+        bannerText: string;
+        autoCollapse: boolean;
+    }
 
-        public visitSetAccessor(node: TypeScript.SetAccessorSyntax): void {
-            if (!this.inObjectLiteralExpression) {
-                this.addOutlineRange(node, node.block, node.block);
+    export module OutliningElementsCollector {
+        export function collectElements(sourceFile: SourceFile): OutliningSpan[] {
+            var elements: OutliningSpan[] = [];
+
+            function addOutlineRange(node: Node, startElement: Node, endElement: Node) {
+                if (node && startElement && endElement) {
+                    var span: OutliningSpan = {
+                        textSpan: TypeScript.TextSpan.fromBounds(startElement.pos, endElement.end),
+                        hintSpan: TypeScript.TextSpan.fromBounds(node.getStart(), node.end),
+                        bannerText: "...",
+                        autoCollapse: false
+                    };
+                    elements.push(span);
+                }
             }
-            super.visitSetAccessor(node);
-        }
 
-        public visitObjectLiteralExpression(node: TypeScript.ObjectLiteralExpressionSyntax): void {
-            var savedInObjectLiteralExpression = this.inObjectLiteralExpression;
-            this.inObjectLiteralExpression = true;
-            super.visitObjectLiteralExpression(node);
-            this.inObjectLiteralExpression = savedInObjectLiteralExpression;
-        }
-
-        private addOutlineRange(node: TypeScript.ISyntaxNode, startElement: TypeScript.ISyntaxNodeOrToken, endElement: TypeScript.ISyntaxNodeOrToken) {
-            if (startElement && endElement && !isShared(startElement) && !isShared(endElement)) {
-                // Compute the position
-                var start = TypeScript.start(startElement);
-                var end = TypeScript.end(endElement);
-
-                // Push the new range
-                this.elements.push(TypeScript.TextSpan.fromBounds(start, end));
+            var depth = 0;
+            var maxDepth = 10;
+            function walk(n: Node): void {
+                if (depth >= maxDepth) {
+                    return;
+                }
+                switch (n.kind) {
+                    case SyntaxKind.ClassDeclaration:
+                    case SyntaxKind.InterfaceDeclaration:
+                    case SyntaxKind.ModuleDeclaration:
+                    case SyntaxKind.EnumDeclaration:
+                    case SyntaxKind.ObjectLiteral:
+                        var openBrace = forEach(n.getChildren(), c => c.kind === SyntaxKind.OpenBraceToken && c);
+                        var closeBrace = forEach(n.getChildren(), c => c.kind === SyntaxKind.CloseBraceToken && c);
+                        addOutlineRange(n, openBrace, closeBrace);
+                        break;
+                    case SyntaxKind.Constructor:
+                    case SyntaxKind.FunctionDeclaration:
+                    case SyntaxKind.Method:
+                    case SyntaxKind.GetAccessor:
+                    case SyntaxKind.SetAccessor:
+                        var body = (<FunctionDeclaration>n).body;
+                        if (body) {
+                            var openBrace = forEach(body.getChildren(), c => c.kind === SyntaxKind.OpenBraceToken && c);
+                            var closeBrace = forEach(body.getChildren(), c => c.kind === SyntaxKind.CloseBraceToken && c);
+                            addOutlineRange(n, openBrace, closeBrace);
+                        }
+                        break;
+                }
+                depth++;
+                forEachChild(n, walk);
+                depth--;
             }
-        }
 
-        public static collectElements(node: TypeScript.SourceUnitSyntax): TypeScript.TextSpan[] {
-            var collector = new OutliningElementsCollector();
-            visitNodeOrToken(collector, node);
-            return collector.elements;
+            walk(sourceFile);
+            return elements;
         }
     }
-}
+}

src/services/services.ts

@@ -482,7 +482,7 @@ module ts {
         getNavigateToItems(searchValue: string): NavigateToItem[];
         getScriptLexicalStructure(fileName: string): NavigateToItem[];
 
-        getOutliningRegions(fileName: string): TypeScript.TextSpan[];
+        getOutliningRegions(fileName: string): OutliningSpan[];
         getBraceMatchingAtPosition(fileName: string, position: number): TypeScript.TextSpan[];
         getIndentationAtPosition(fileName: string, position: number, options: EditorOptions): number;
 
@@ -962,39 +962,79 @@ module ts {
         // currently edited file.  
         private currentfilename: string = "";
         private currentFileVersion: number = -1;
+        private currentSourceFile: SourceFile = null;
         private currentFileSyntaxTree: TypeScript.SyntaxTree = null;
         private currentFileScriptSnapshot: TypeScript.IScriptSnapshot = null;
 
         constructor(private host: LanguageServiceHost) {
             this.hostCache = new HostCache(host);
         }
 
-        public getCurrentFileSyntaxTree(filename: string): TypeScript.SyntaxTree {
+        private initialize(filename: string) {
+            // ensure that both source file and syntax tree are either initialized or not initialized
+            Debug.assert(!!this.currentFileSyntaxTree === !!this.currentSourceFile);
             this.hostCache = new HostCache(this.host);
 
             var version = this.hostCache.getVersion(filename);
             var syntaxTree: TypeScript.SyntaxTree = null;
+            var sourceFile: SourceFile;
 
             if (this.currentFileSyntaxTree === null || this.currentfilename !== filename) {
                 var scriptSnapshot = this.hostCache.getScriptSnapshot(filename);
                 syntaxTree = this.createSyntaxTree(filename, scriptSnapshot);
+                sourceFile = createSourceFileFromScriptSnapshot(filename, scriptSnapshot, getDefaultCompilerOptions(), version, /*isOpen*/ true);
+
+                fixupParentReferences(sourceFile);
             }
             else if (this.currentFileVersion !== version) {
                 var scriptSnapshot = this.hostCache.getScriptSnapshot(filename);
                 syntaxTree = this.updateSyntaxTree(filename, scriptSnapshot, this.currentFileSyntaxTree, this.currentFileVersion);
+
+                var editRange = this.hostCache.getScriptTextChangeRangeSinceVersion(filename, this.currentFileVersion);
+                sourceFile = !editRange 
+                    ? createSourceFileFromScriptSnapshot(filename, scriptSnapshot, getDefaultCompilerOptions(), version, /*isOpen*/ true)
+                    : this.currentSourceFile.update(scriptSnapshot, version, /*isOpen*/ true, editRange);
+
+                fixupParentReferences(sourceFile);
             }
 
             if (syntaxTree !== null) {
+                Debug.assert(sourceFile);
                 // All done, ensure state is up to date
                 this.currentFileScriptSnapshot = scriptSnapshot;
                 this.currentFileVersion = version;
                 this.currentfilename = filename;
                 this.currentFileSyntaxTree = syntaxTree;
+                this.currentSourceFile = sourceFile;
             }
 
+            function fixupParentReferences(sourceFile: SourceFile) {
+                // normally parent references are set during binding.
+                // however here SourceFile data is used only for syntactic features so running the whole binding process is an overhead.
+                // walk over the nodes and set parent references
+                var parent: Node = sourceFile;
+                function walk(n: Node): void {
+                    n.parent = parent;
+
+                    var saveParent = parent;
+                    parent = n;
+                    forEachChild(n, walk);
+                    parent = saveParent;
+                }
+                forEachChild(sourceFile, walk);
+            }
+        }
+
+        public getCurrentFileSyntaxTree(filename: string): TypeScript.SyntaxTree {
+            this.initialize(filename);
             return this.currentFileSyntaxTree;
         }
 
+        public getCurrentSourceFile(filename: string): SourceFile {
+            this.initialize(filename);
+            return this.currentSourceFile;
+        }
+
         public getCurrentScriptSnapshot(filename: string): TypeScript.IScriptSnapshot {
             // update currentFileScriptSnapshot as a part of 'getCurrentFileSyntaxTree' call
             this.getCurrentFileSyntaxTree(filename);
@@ -1093,6 +1133,10 @@ module ts {
         }
     }
 
+    function createSourceFileFromScriptSnapshot(filename: string, scriptSnapshot: TypeScript.IScriptSnapshot, settings: CompilerOptions, version: number, isOpen: boolean) {
+        return createSourceFile(filename, scriptSnapshot.getText(0, scriptSnapshot.getLength()), settings.target, version, isOpen);
+    }
+
     export function createDocumentRegistry(): DocumentRegistry {
         var buckets: Map<Map<DocumentRegistryEntry>> = {};
 
@@ -1140,7 +1184,7 @@ module ts {
             var bucket = getBucketForCompilationSettings(compilationSettings, /*createIfMissing*/ true);
             var entry = lookUp(bucket, filename);
             if (!entry) {
-                var sourceFile = createSourceFile(filename, scriptSnapshot.getText(0, scriptSnapshot.getLength()), compilationSettings.target, version, isOpen);
+                var sourceFile = createSourceFileFromScriptSnapshot(filename, scriptSnapshot, compilationSettings, version, isOpen);
 
                 bucket[filename] = entry = {
                     sourceFile: sourceFile,
@@ -2024,6 +2068,12 @@ module ts {
             return syntaxTreeCache.getCurrentFileSyntaxTree(filename);
         }
 
+        function getCurrentSourceFile(filename: string): SourceFile {
+            filename = TypeScript.switchToForwardSlashes(filename);
+            var currentSourceFile = syntaxTreeCache.getCurrentSourceFile(filename);
+            return currentSourceFile;
+        }
+
         function getNameOrDottedNameSpan(filename: string, startPos: number, endPos: number): SpanInfo {
             function getTypeInfoEligiblePath(filename: string, position: number, isConstructorValidPosition: boolean) {
                 var sourceUnit = syntaxTreeCache.getCurrentFileSyntaxTree(filename).sourceUnit();
@@ -2097,11 +2147,11 @@ module ts {
             return items;
         }
 
-        function getOutliningRegions(filename: string) {
+        function getOutliningRegions(filename: string): OutliningSpan[] {
             // doesn't use compiler - no need to synchronize with host
             filename = TypeScript.switchToForwardSlashes(filename);
-            var syntaxTree = getSyntaxTree(filename);
-            return TypeScript.Services.OutliningElementsCollector.collectElements(syntaxTree.sourceUnit());
+            var sourceFile = getCurrentSourceFile(filename);
+            return OutliningElementsCollector.collectElements(sourceFile);
         }
 
         function getBraceMatchingAtPosition(filename: string, position: number) {

src/services/shims.ts

@@ -726,7 +726,10 @@ module ts {
                 "getOutliningRegions(\"" + fileName + "\")",
                 () => {
                     var items = this.languageService.getOutliningRegions(fileName);
-                    return items;
+                    // return just the part of data that language service v2 can understand
+                    // language service v2 will use the entire OutliningSpan
+                    var spans = forEach(items, i => i.textSpan);
+                    return spans;
                 });
         }