merge the last version of typescript-project-services

fdecampredon · fdecampredon · commit a87b5b9d0307 · 2015-01-24T22:11:09.000+01:00
diff --git a/src/declarations/brackets.d.ts b/src/declarations/brackets.d.ts
@@ -1018,7 +1018,14 @@ declare module brackets {
     
     interface CodeInspection {
         register(languageId: string, provider: InspectionProvider): void;
-        Type: { [index: string]: string}
+        Type: { 
+            ERROR: string;
+            /** Maintainability issue, probable error / bad smell, etc. */
+            WARNING: string;
+            /** Inspector unable to continue, code too complex for static analysis, etc. Not counted in error/warning tally. */
+            META: string;
+
+        }
     }
     
     
diff --git a/src/declarations/typescript-project-services.d.ts b/src/declarations/typescript-project-services.d.ts
@@ -258,7 +258,7 @@ export type TypeScriptInfo = {
     typeScript: typeof ts;
     libLocation: string;
 };
-export function createProject(baseDirectory: string, config: TypeScriptProjectConfig, fileSystem: fs.IFileSystem, workingSet: ws.IWorkingSet, defaultLibLocation: string): TypeScriptProject;
+export function createProject(documentRegistry: ts.DocumentRegistry, baseDirectory: string, config: TypeScriptProjectConfig, fileSystem: fs.IFileSystem, workingSet: ws.IWorkingSet, defaultLibLocation: string): TypeScriptProject;
 
 
 }
@@ -590,10 +590,6 @@ import fs = require('typescript-project-services/lib/fileSystem');
 import ws = require('typescript-project-services/lib/workingSet');
 import project = require('typescript-project-services/lib/project');
 import console = require('typescript-project-services/lib/logger');
-export type Position = {
-    line: number;
-    ch: number;
-};
 export import Logger = console.Logger;
 export var injectLogger: typeof console.injectLogger;
 export var injectPromiseLibrary: typeof promise.injectPromiseLibrary;
@@ -630,81 +626,28 @@ export function updateProjectConfigs(configs: {
  * dispose the service
  */
 export function dispose(): void;
-/**
- * Represent definition info of a symbol
- */
-export type DefinitionInfo = {
-    /**
-     * full name of the symbol
-     */
-    name: string;
-    /**
-     * line at which the symbol definition start
-     */
-    lineStart: number;
-    /**
-     * charachter at which the symbol definition start
-     */
-    charStart: number;
-    /**
-     * line at which the symbol definition end
-     */
-    lineEnd: number;
-    /**
-     * charachter at which the symbol definition end
-     */
-    charEnd: number;
-    /**
-     * path of the file where the symbol is defined
-     */
-    fileName: string;
+export type TextSpan = {
+    start: number;
+    length: number;
 };
-/**
- * Retrieve definition info of a symbol at a given position in a given file.
- * return a promise resolving to a list of definition info.
- *
- * @param fileName the absolute path of the file
- * @param position in the file where you want to retrieve definition info
- *
- */
-export function getDefinitionAtPosition(fileName: string, position: Position): promise.Promise<DefinitionInfo[]>;
-export const enum DiagnosticCategory {
-    Warning = 0,
-    Error = 1,
-    Message = 2,
-}
-export type TSError = {
-    pos: Position;
-    endPos: Position;
-    message: string;
-    type: DiagnosticCategory;
+export type Diagnostics = {
+    fileName: string;
+    start: number;
+    length: number;
+    messageText: string;
+    category: ts.DiagnosticCategory;
+    code: number;
 };
 /**
  * Retrieve a list of errors for a given file
  * return a promise resolving to a list of errors
  *
  * @param fileName the absolute path of the file
+ * @param allErrors by default errors are checked in 3 phases, options check, syntax check,
+ *   semantic check, is allErrors is set to false, the service won't check the nex phase
+ *   if there is error in the precedent one
  */
-export function getErrorsForFile(fileName: string): promise.Promise<TSError[]>;
-export type TextEdit = {
-    start: number;
-    end: number;
-    newText: string;
-};
-/**
- * Retrieve formating information for a givent file.
- * return a promise resolving to a list of TextEdit
- *
- * @param fileName the absolute path of the file
- * @param options formation options
- * @param startPos an option start position for the formating range
- * @param endPos an optional end position for the formating range
- *
- */
-export function getFormatingForFile(fileName: string, options: ts.FormatCodeOptions, startPos?: Position, endPos?: Position): promise.Promise<TextEdit[]>;
-/**
- * Represent a completion result
- */
+export function getDiagnosticsForFile(fileName: string, allErrors?: boolean): promise.Promise<Diagnostics[]>;
 export type CompletionResult = {
     /**
      * the matched string portion
@@ -725,27 +668,84 @@ export type CompletionResult = {
  * @param skip the number of proposition this service should skip
  *
  */
-export function getCompletionAtPosition(fileName: string, position: Position, limit?: number, skip?: number): promise.Promise<CompletionResult>;
+export function getCompletionAtPosition(fileName: string, position: number, limit?: number, skip?: number): promise.Promise<CompletionResult>;
+export type QuickInfo = {
+    kind: string;
+    kindModifiers: string;
+    textSpan: TextSpan;
+    displayParts: ts.SymbolDisplayPart[];
+    documentation: ts.SymbolDisplayPart[];
+};
+export function getQuickInfoAtPosition(fileName: string, position: number): promise.Promise<QuickInfo>;
+export type SignatureHelpItems = {
+    items: ts.SignatureHelpItem[];
+    applicableSpan: TextSpan;
+    selectedItemIndex: number;
+    argumentIndex: number;
+    argumentCount: number;
+};
+export function getSignatureHelpItems(fileName: string, position: number): promise.Promise<SignatureHelpItems>;
+export type RenameInfo = {
+    canRename: boolean;
+    localizedErrorMessage: string;
+    displayName: string;
+    fullDisplayName: string;
+    kind: string;
+    kindModifiers: string;
+    triggerSpan: TextSpan;
+};
+export function getRenameInfo(fileName: string, position: number): promise.Promise<RenameInfo>;
+export function findRenameLocations(fileName: string, position: number, findInStrings: boolean, findInComments: boolean): promise.Promise<{
+    textSpan: TextSpan;
+    fileName: string;
+}[]>;
+export type DefinitionInfo = {
+    fileName: string;
+    textSpan: TextSpan;
+    kind: string;
+    name: string;
+    containerKind: string;
+    containerName: string;
+};
+export function getDefinitionAtPosition(fileName: string, position: number): promise.Promise<DefinitionInfo[]>;
+export type ReferenceEntry = {
+    textSpan: TextSpan;
+    fileName: string;
+    isWriteAccess: boolean;
+};
+export function getReferencesAtPosition(fileName: string, position: number): promise.Promise<ReferenceEntry[]>;
+export function getOccurrencesAtPosition(fileName: string, position: number): promise.Promise<ReferenceEntry[]>;
+export type NavigateToItem = {
+    name: string;
+    kind: string;
+    kindModifiers: string;
+    matchKind: string;
+    fileName: string;
+    textSpan: TextSpan;
+    containerName: string;
+    containerKind: string;
+};
+export function getNavigateToItems(fileName: string, search: string): promise.Promise<NavigateToItem[]>;
 export type NavigationBarItem = {
     text: string;
     kind: string;
     kindModifiers: string;
-    positions: {
+    spans: {
         start: number;
-        end: number;
+        length: number;
     }[];
     childItems: NavigationBarItem[];
     indent: number;
     bolded: boolean;
     grayed: boolean;
 };
-/**
- * Retrieve NavigationBarItems
- *
- * @param fileName the absolute path of the file
- *
- */
 export function getNavigationBarItems(fileName: string): promise.Promise<NavigationBarItem[]>;
+export type TextChange = {
+    span: TextSpan;
+    newText: string;
+};
+export function getFormattingEditsForFile(fileName: string, options: ts.FormatCodeOptions, start: number, end: number): promise.Promise<TextChange[]>;
+export function getEmitOutput(fileName: string): promise.Promise<ts.EmitOutput>;
 
 
 }
diff --git a/src/main/codeHintProvider.ts b/src/main/codeHintProvider.ts
@@ -51,7 +51,7 @@ export function hasHints(hostEditor: brackets.Editor, implicitChar: string): boo
     //TODO we should find a better test here that limits more the implicit request
     if (!implicitChar || /[\w.\($_]/.test(implicitChar)) {
         editor = hostEditor;
-        return true;  
+        return true;
     }
     return false;
 }
@@ -68,7 +68,9 @@ export function getHints(implicitChar: string): JQueryDeferred<brackets.HintResu
     } else {
 
         ServiceConsumer.getService().then(service => {
-            service.getCompletionAtPosition(currentFileName, position).then(result => {
+            var index = editor.indexFromPos(position)
+            
+            service.getCompletionAtPosition(currentFileName, index).then(result => {
                 deferred.resolve({
                     hints: result.entries.map(entry => {
                         var text = entry.name,
diff --git a/src/main/errorReporter.ts b/src/main/errorReporter.ts
@@ -14,10 +14,12 @@
 
 'use strict';
 
-//TODO that part of the application is not well tested and just 'work' it needs to be refactored
+var DocumentManager = brackets.getModule('document/DocumentManager');
+var CodeInspection = brackets.getModule('language/CodeInspection');
 
 import ServiceConsumer = require('./serviceConsumer');
 import immediate = require('./immediate');
+import ts = require('typescript');
 
 
 //--------------------------------------------------------------------------
@@ -26,6 +28,17 @@ import immediate = require('./immediate');
 //
 //--------------------------------------------------------------------------
 
+function diagCategoryToType(category: ts.DiagnosticCategory): string {
+    switch(category) {
+        case ts.DiagnosticCategory.Message:
+            return CodeInspection.Type.META;
+        case ts.DiagnosticCategory.Error:
+            return CodeInspection.Type.ERROR;
+        case ts.DiagnosticCategory.Warning:
+            return CodeInspection.Type.WARNING;
+    }
+}
+
 /**
  * TypeScript Inspection Provider
  */
@@ -42,19 +55,23 @@ export function scanFileAsync(content: string, path: string): JQueryPromise<{ er
     return $.Deferred(deferred => {
         immediate.setImmediate(() => {
             ServiceConsumer.getService().then(service => {
-                service.getErrorsForFile(path).then(
-                    result => {
+                service.getDiagnosticsForFile(path)
+                    .then(diagnostics => {
+                        var document: any = DocumentManager.getOpenDocumentForPath(path);
+                        document._ensureMasterEditor();
+                        var codeMirror = document._masterEditor._codeMirror;
                         deferred.resolve({
-                            errors: result,
+                            errors: diagnostics.map(diagnostic => ({
+                                pos: codeMirror.posFromIndex(diagnostic.start),
+                                endPos: codeMirror.posFromIndex(diagnostic.start + diagnostic.length),
+                                message: diagnostic.messageText,
+                                type: diagCategoryToType(diagnostic.category)
+                            })),
                             aborted: false
                         });
-                    }, () => {
-                        deferred.resolve({ 
-                            errors: [], 
-                            aborted : false
-                        });
-                    }
-                );
+                    }, (e) => {
+                        deferred.reject(e);
+                    });
             });    
         });
     }).promise();
diff --git a/src/main/formattingManager.ts b/src/main/formattingManager.ts
@@ -49,20 +49,24 @@ export function format() {
         startPos = currentRange ? currentRange.start : undefined,
         endPos = currentRange ? currentRange.end : undefined;
 
-    if (startPos && endPos && startPos.line === endPos.line && startPos.ch === endPos.ch) {
-        startPos = endPos = undefined;
-    }
 
 
     ServiceConsumer.getService().then(service => {
-        service.getFormatingForFile(editor.document.file.fullPath, options, startPos, endPos).then(textEdits => {
+        var start: number;
+        var end: number;
+        if (startPos && endPos && (startPos.line !== endPos.line || startPos.ch !== endPos.ch)) {
+            start = editor.indexFromPos(startPos);
+            end = editor.indexFromPos(endPos);
+        }
+        
+        service.getFormattingEditsForFile(editor.document.file.fullPath, options, start, end).then(textEdits => {
             if (EditorManager.getCurrentFullEditor() !== editor) {
                 return;
             }
             var pos = editor.getCursorPos();
             var scrollPos = editor.getScrollPos();
             var newText = textEdits.reduce((text, edit) => {
-                return text.substr(0, edit.start) + edit.newText + text.substr(edit.end);
+                return text.substr(0, edit.span.start) + edit.newText + text.substr(edit.span.start + edit.span.length);
             }, editor.document.getText());
             
             editor.document.setText(newText);
diff --git a/src/main/inlineEditorProvider.ts b/src/main/inlineEditorProvider.ts
@@ -35,13 +35,21 @@ var DocumentManager = brackets.getModule('document/DocumentManager'),
     var deferred = $.Deferred();
     ServiceConsumer.getService().then(service => {
         var fileName = hostEditor.document.file.fullPath;
-        service.getDefinitionAtPosition(fileName, pos).then(definitions => {
+        
+        service.getDefinitionAtPosition(fileName, hostEditor.indexFromPos(pos)).then(definitions => {
             if (!definitions || definitions.length === 0) {
                 deferred.reject();
             }
 
+            var codeMirror = (<any>hostEditor._codeMirror);
+            if (codeMirror) {
+                definitions = definitions.filter(definition => 
+                    definition.fileName !== fileName || 
+                    codeMirror.posFromIndex(definition.textSpan.start).line !== pos.line
+                );
+            }
 
-            definitions.filter(definition => definition.fileName !== fileName || definition.lineStart !== pos.line);
+           
             if (definitions.length === 0) {
                 deferred.reject();
             }
@@ -50,15 +58,22 @@ var DocumentManager = brackets.getModule('document/DocumentManager'),
                 ranges: brackets.MultiRangeInlineEditorRange[] = [];
 
             definitions.forEach(definition => {
-                promises.push(DocumentManager.getDocumentForPath(definition.fileName).then(doc => {
-                    ranges.push({
-                        document : doc,
-                        name: definition.name,
-                        lineStart: definition.lineStart,  
-                        lineEnd: definition.lineEnd,
-                        fileName: definition.fileName
-                    });    
-                }));
+                promises.push(
+                    DocumentManager.getDocumentForPath(definition.fileName)
+                        .then(doc => {
+                            (<any>doc)._ensureMasterEditor();
+                            var codeMirror = (<any>doc)._masterEditor._codeMirror;
+                            var lineStart = codeMirror.posFromIndex(definition.textSpan.start).line;
+                            var lineEnd = codeMirror.posFromIndex(definition.textSpan.start + definition.textSpan.length).line
+                            ranges.push({
+                                document : doc,
+                                name: definition.name,
+                                lineStart: lineStart,  
+                                lineEnd: lineEnd,
+                                fileName: definition.fileName
+                            });    
+                        })
+                );
             });
 
             return $.when.apply($, promises).then(() => {
diff --git a/src/main/jumpToDefProvider.ts b/src/main/jumpToDefProvider.ts
diff --git a/src/main/quickFindDefinition.ts b/src/main/quickFindDefinition.ts
