Refactoring language service to use short-hand

src/services/formatting.ts

@@ -361,8 +361,8 @@ module ts.formatting {
                 delta = Math.min(options.IndentSize, parentDynamicIndentation.getDelta() + delta);
             }
             return {
-                indentation: indentation,
-                delta: delta
+                indentation,
+                delta
             }
         }
 
@@ -834,7 +834,7 @@ module ts.formatting {
         }
 
         function newTextChange(start: number, len: number, newText: string): TextChange {
-            return { span: new TextSpan(start, len), newText: newText }
+            return { span: new TextSpan(start, len), newText }
         }
 
         function recordDelete(start: number, len: number) {

src/services/navigationBar.ts

@@ -262,12 +262,12 @@ module ts.NavigationBar {
             }
 
             return {
-                text: text,
-                kind: kind,
-                kindModifiers: kindModifiers,
-                spans: spans,
-                childItems: childItems,
-                indent: indent,
+                text,
+                kind,
+                kindModifiers,
+                spans,
+                childItems,
+                indent,
                 bolded: false,
                 grayed: false
             };

src/services/services.ts

@@ -1369,8 +1369,8 @@ module ts {
             writeSpace: text => writeKind(text, SymbolDisplayPartKind.space),
             writeStringLiteral: text => writeKind(text, SymbolDisplayPartKind.stringLiteral),
             writeParameter: text => writeKind(text, SymbolDisplayPartKind.parameterName),
-            writeSymbol: writeSymbol,
-            writeLine: writeLine,
+            writeSymbol,
+            writeLine,
             increaseIndent: () => { indent++; },
             decreaseIndent: () => { indent--; },
             clear: resetWriter,
@@ -1760,7 +1760,7 @@ module ts {
                 sourceFiles.sort((x, y) => y.refCount - x.refCount);
                 return {
                     bucket: name,
-                    sourceFiles: sourceFiles
+                    sourceFiles
                 };
             });
             return JSON.stringify(bucketInfoArray, null, 2);
@@ -1826,10 +1826,10 @@ module ts {
         }
 
         return {
-            acquireDocument: acquireDocument,
-            updateDocument: updateDocument,
-            releaseDocument: releaseDocument,
-            reportStats: reportStats
+            acquireDocument,
+            updateDocument,
+            releaseDocument,
+            reportStats
         };
     }
 
@@ -1892,7 +1892,7 @@ module ts {
             processImport();
         }
         processTripleSlashDirectives();
-        return { referencedFiles: referencedFiles, importedFiles: importedFiles, isLibFile: isNoDefaultLib };
+        return { referencedFiles, importedFiles, isLibFile: isNoDefaultLib };
     }
 
     /// Helpers
@@ -2291,7 +2291,7 @@ module ts {
                 // Get emitter-diagnostics requires calling TypeChecker.emitFiles so we have to define CompilerHost.writer which does nothing because emitFiles function has side effects defined by CompilerHost.writer
                 var savedWriter = writer;
                 writer = (filename: string, data: string, writeByteOrderMark: boolean) => { };
-                allDiagnostics = allDiagnostics.concat(checker.emitFiles(targetSourceFile).errors);
+                allDiagnostics = allDiagnostics.concat(checker.invokeEmitter(targetSourceFile).errors);
                 writer = savedWriter;
             }
             return allDiagnostics
@@ -2496,7 +2496,7 @@ module ts {
             host.log("getCompletionsAtPosition: Semantic work: " + (new Date().getTime() - semanticStart));
 
             return {
-                isMemberCompletion: isMemberCompletion,
+                isMemberCompletion,
                 entries: activeCompletionSession.entries
             };
 
@@ -3156,7 +3156,7 @@ module ts {
                 documentation = symbol.getDocumentationComment();
             }
 
-            return { displayParts: displayParts, documentation: documentation, symbolKind: symbolKind };
+            return { displayParts, documentation, symbolKind };
 
             function addNewLineIfDisplayPartsExist() {
                 if (displayParts.length) {
@@ -3257,7 +3257,7 @@ module ts {
                     kind: symbolKind,
                     name: symbolName,
                     containerKind: undefined,
-                    containerName: containerName
+                    containerName
                 };
             }
 
@@ -4639,7 +4639,7 @@ module ts {
             // Perform semantic and force a type check before emit to ensure that all symbols are updated
             // EmitFiles will report if there is an error from TypeChecker and Emitter
             // Depend whether we will have to emit into a single file or not either emit only selected file in the project, emit all files into a single file
-            var emitFilesResult = getFullTypeCheckChecker().emitFiles(targetSourceFile);
+            var emitFilesResult = getFullTypeCheckChecker().invokeEmitter(targetSourceFile);
             emitOutput.emitOutputStatus = emitFilesResult.emitResultStatus;
 
             // Reset writer back to undefined to make sure that we produce an error message if CompilerHost.writeFile method is called when we are not in getEmitOutput
@@ -5420,46 +5420,46 @@ module ts {
                 return {
                     canRename: true,
                     localizedErrorMessage: undefined,
-                    displayName: displayName,
-                    fullDisplayName: fullDisplayName,
-                    kind: kind,
-                    kindModifiers: kindModifiers,
-                    triggerSpan: triggerSpan
+                    displayName,
+                    fullDisplayName,
+                    kind,
+                    kindModifiers,
+                    triggerSpan
                 };
             }
         }
 
         return {
-            dispose: dispose,
-            cleanupSemanticCache: cleanupSemanticCache,
-            getSyntacticDiagnostics: getSyntacticDiagnostics,
-            getSemanticDiagnostics: getSemanticDiagnostics,
-            getCompilerOptionsDiagnostics: getCompilerOptionsDiagnostics,
-            getSyntacticClassifications: getSyntacticClassifications,
-            getSemanticClassifications: getSemanticClassifications,
-            getCompletionsAtPosition: getCompletionsAtPosition,
-            getCompletionEntryDetails: getCompletionEntryDetails,
-            getSignatureHelpItems: getSignatureHelpItems,
-            getQuickInfoAtPosition: getQuickInfoAtPosition,
-            getDefinitionAtPosition: getDefinitionAtPosition,
-            getReferencesAtPosition: getReferencesAtPosition,
-            getOccurrencesAtPosition: getOccurrencesAtPosition,
+            dispose,
+            cleanupSemanticCache,
+            getSyntacticDiagnostics,
+            getSemanticDiagnostics,
+            getCompilerOptionsDiagnostics,
+            getSyntacticClassifications,
+            getSemanticClassifications,
+            getCompletionsAtPosition,
+            getCompletionEntryDetails,
+            getSignatureHelpItems,
+            getQuickInfoAtPosition,
+            getDefinitionAtPosition,
+            getReferencesAtPosition,
+            getOccurrencesAtPosition,
             getImplementorsAtPosition: (filename, position) => [],
-            getNameOrDottedNameSpan: getNameOrDottedNameSpan,
-            getBreakpointStatementAtPosition: getBreakpointStatementAtPosition,
-            getNavigateToItems: getNavigateToItems,
-            getRenameInfo: getRenameInfo,
-            findRenameLocations: findRenameLocations,
-            getNavigationBarItems: getNavigationBarItems,
-            getOutliningSpans: getOutliningSpans,
-            getTodoComments: getTodoComments,
-            getBraceMatchingAtPosition: getBraceMatchingAtPosition,
-            getIndentationAtPosition: getIndentationAtPosition,
-            getFormattingEditsForRange: getFormattingEditsForRange,
-            getFormattingEditsForDocument: getFormattingEditsForDocument,
-            getFormattingEditsAfterKeystroke: getFormattingEditsAfterKeystroke,
-            getEmitOutput: getEmitOutput,
-            getSignatureAtPosition: getSignatureAtPosition,
+            getNameOrDottedNameSpan,
+            getBreakpointStatementAtPosition,
+            getNavigateToItems,
+            getRenameInfo,
+            findRenameLocations,
+            getNavigationBarItems,
+            getOutliningSpans,
+            getTodoComments,
+            getBraceMatchingAtPosition,
+            getIndentationAtPosition,
+            getFormattingEditsForRange,
+            getFormattingEditsForDocument,
+            getFormattingEditsAfterKeystroke,
+            getEmitOutput,
+            getSignatureAtPosition,
         };
     }
 
@@ -5757,9 +5757,7 @@ module ts {
             }
         }
 
-        return {
-            getClassificationsForLine: getClassificationsForLine
-        };
+        return { getClassificationsForLine };
     }
 
     function initializeServices() {

src/services/signatureHelp.ts

@@ -221,7 +221,7 @@ module ts.SignatureHelp {
                 var list = getChildListThatStartsWithOpenerToken(parent, node, sourceFile);
                 Debug.assert(list !== undefined);
                 return {
-                    list: list,
+                    list,
                     listItemIndex: 0
                 };
             }
@@ -303,40 +303,40 @@ module ts.SignatureHelp {
             var callTargetDisplayParts = callTargetSymbol && symbolToDisplayParts(typeInfoResolver, callTargetSymbol, /*enclosingDeclaration*/ undefined, /*meaning*/ undefined);
             var items: SignatureHelpItem[] = map(candidates, candidateSignature => {
                 var signatureHelpParameters: SignatureHelpParameter[];
-                var prefixParts: SymbolDisplayPart[] = [];
-                var suffixParts: SymbolDisplayPart[] = [];
+                var prefixDisplayParts: SymbolDisplayPart[] = [];
+                var suffixDisplayParts: SymbolDisplayPart[] = [];
 
                 if (callTargetDisplayParts) {
-                    prefixParts.push.apply(prefixParts, callTargetDisplayParts);
+                    prefixDisplayParts.push.apply(prefixDisplayParts, callTargetDisplayParts);
                 }
 
                 if (isTypeParameterHelp) {
-                    prefixParts.push(punctuationPart(SyntaxKind.LessThanToken));
+                    prefixDisplayParts.push(punctuationPart(SyntaxKind.LessThanToken));
                     var typeParameters = candidateSignature.typeParameters;
                     signatureHelpParameters = typeParameters && typeParameters.length > 0 ? map(typeParameters, createSignatureHelpParameterForTypeParameter) : emptyArray;
-                    suffixParts.push(punctuationPart(SyntaxKind.GreaterThanToken));
+                    suffixDisplayParts.push(punctuationPart(SyntaxKind.GreaterThanToken));
                     var parameterParts = mapToDisplayParts(writer =>
                         typeInfoResolver.getSymbolDisplayBuilder().buildDisplayForParametersAndDelimiters(candidateSignature.parameters, writer, argumentListOrTypeArgumentList));
-                    suffixParts.push.apply(suffixParts, parameterParts);
+                    suffixDisplayParts.push.apply(suffixDisplayParts, parameterParts);
                 }
                 else {
                     var typeParameterParts = mapToDisplayParts(writer =>
                         typeInfoResolver.getSymbolDisplayBuilder().buildDisplayForTypeParametersAndDelimiters(candidateSignature.typeParameters, writer, argumentListOrTypeArgumentList));
-                    prefixParts.push.apply(prefixParts, typeParameterParts);
-                    prefixParts.push(punctuationPart(SyntaxKind.OpenParenToken));
+                    prefixDisplayParts.push.apply(prefixDisplayParts, typeParameterParts);
+                    prefixDisplayParts.push(punctuationPart(SyntaxKind.OpenParenToken));
                     var parameters = candidateSignature.parameters;
                     signatureHelpParameters = parameters.length > 0 ? map(parameters, createSignatureHelpParameterForParameter) : emptyArray;
-                    suffixParts.push(punctuationPart(SyntaxKind.CloseParenToken));
+                    suffixDisplayParts.push(punctuationPart(SyntaxKind.CloseParenToken));
                 }
 
                 var returnTypeParts = mapToDisplayParts(writer =>
                     typeInfoResolver.getSymbolDisplayBuilder().buildReturnTypeDisplay(candidateSignature, writer, argumentListOrTypeArgumentList));
-                suffixParts.push.apply(suffixParts, returnTypeParts);
+                suffixDisplayParts.push.apply(suffixDisplayParts, returnTypeParts);
                 
                 return {
                     isVariadic: candidateSignature.hasRestParameter,
-                    prefixDisplayParts: prefixParts,
-                    suffixDisplayParts: suffixParts,
+                    prefixDisplayParts,
+                    suffixDisplayParts,
                     separatorDisplayParts: [punctuationPart(SyntaxKind.CommaToken), spacePart()],
                     parameters: signatureHelpParameters,
                     documentation: candidateSignature.getDocumentationComment()
@@ -378,11 +378,11 @@ module ts.SignatureHelp {
             }
 
             return {
-                items: items,
-                applicableSpan: applicableSpan,
-                selectedItemIndex: selectedItemIndex,
-                argumentIndex: argumentIndex,
-                argumentCount: argumentCount
+                items,
+                applicableSpan,
+                selectedItemIndex,
+                argumentIndex,
+                argumentCount
             };
 
             function createSignatureHelpParameterForParameter(parameter: Symbol): SignatureHelpParameter {
@@ -394,8 +394,8 @@ module ts.SignatureHelp {
                 return {
                     name: parameter.name,
                     documentation: parameter.getDocumentationComment(),
-                    displayParts: displayParts,
-                    isOptional: isOptional
+                    displayParts,
+                    isOptional
                 };
             }
 
@@ -406,7 +406,7 @@ module ts.SignatureHelp {
                 return {
                     name: typeParameter.symbol.name,
                     documentation: emptyArray,
-                    displayParts: displayParts,
+                    displayParts,
                     isOptional: false
                 };
             }

src/services/utilities.ts

@@ -66,22 +66,22 @@ module ts {
     }
 
     export function findListItemInfo(node: Node): ListItemInfo {
-        var syntaxList = findContainingList(node);
+        var list = findContainingList(node);
 
         // It is possible at this point for syntaxList to be undefined, either if
         // node.parent had no list child, or if none of its list children contained
         // the span of node. If this happens, return undefined. The caller should
         // handle this case.
-        if (!syntaxList) {
+        if (!list) {
             return undefined;
         }
 
-        var children = syntaxList.getChildren();
-        var index = indexOf(children, node);
+        var children = list.getChildren();
+        var listItemIndex = indexOf(children, node);
 
         return {
-            listItemIndex: index,
-            list: syntaxList
+            listItemIndex,
+            list
         };
     }