Merge branch 'master' of https://github.com/Microsoft/TypeScript into typedefForJsdoc

Author: zhengbli

Jakefile.js

@@ -680,7 +680,7 @@ function cleanTestDirs() {
 }
 
 // used to pass data from jake command line directly to run.js
-function writeTestConfigFile(tests, light, taskConfigsFolder, workerCount, testConfigFile) {
+function writeTestConfigFile(tests, light, taskConfigsFolder, workerCount) {
     var testConfigContents = JSON.stringify({ test: tests ? [tests] : undefined, light: light, workerCount: workerCount, taskConfigsFolder: taskConfigsFolder });
     console.log('Running tests with config: ' + testConfigContents);
     fs.writeFileSync('test.config', testConfigContents);
@@ -716,7 +716,7 @@ function runConsoleTests(defaultReporter, runInParallel) {
     }
 
     if (tests || light || taskConfigsFolder) {
-        writeTestConfigFile(tests, light, taskConfigsFolder, workerCount, testConfigFile);
+        writeTestConfigFile(tests, light, taskConfigsFolder, workerCount);
     }
 
     if (tests && tests.toLocaleLowerCase() === "rwc") {
@@ -850,7 +850,7 @@ task("runtests-browser", ["tests", "browserify", builtLocalDirectory, servicesFi
         fs.unlinkSync(testConfigFile);
     }
     if(tests || light) {
-        writeTestConfigFile(tests, light, testConfigFile);
+        writeTestConfigFile(tests, light);
     }
 
     tests = tests ? tests : '';

src/compiler/checker.ts

@@ -8655,25 +8655,23 @@ namespace ts {
         function getContextuallyTypedParameterType(parameter: ParameterDeclaration): Type {
             const func = parameter.parent;
             if (isContextSensitiveFunctionOrObjectLiteralMethod(func)) {
-                if (func.kind === SyntaxKind.FunctionExpression || func.kind === SyntaxKind.ArrowFunction) {
-                    const iife = getImmediatelyInvokedFunctionExpression(func);
-                    if (iife) {
-                        const indexOfParameter = indexOf(func.parameters, parameter);
-                        if (iife.arguments && indexOfParameter < iife.arguments.length) {
-                            if (parameter.dotDotDotToken) {
-                                const restTypes: Type[] = [];
-                                for (let i = indexOfParameter; i < iife.arguments.length; i++) {
-                                    restTypes.push(getTypeOfExpression(iife.arguments[i]));
-                                }
-                                return createArrayType(getUnionType(restTypes));
+                const iife = getImmediatelyInvokedFunctionExpression(func);
+                if (iife) {
+                    const indexOfParameter = indexOf(func.parameters, parameter);
+                    if (iife.arguments && indexOfParameter < iife.arguments.length) {
+                        if (parameter.dotDotDotToken) {
+                            const restTypes: Type[] = [];
+                            for (let i = indexOfParameter; i < iife.arguments.length; i++) {
+                                restTypes.push(getTypeOfExpression(iife.arguments[i]));
                             }
-                            const links = getNodeLinks(iife);
-                            const cached = links.resolvedSignature;
-                            links.resolvedSignature = anySignature;
-                            const type = checkExpression(iife.arguments[indexOfParameter]);
-                            links.resolvedSignature = cached;
-                            return type;
+                            return createArrayType(getUnionType(restTypes));
                         }
+                        const links = getNodeLinks(iife);
+                        const cached = links.resolvedSignature;
+                        links.resolvedSignature = anySignature;
+                        const type = checkExpression(iife.arguments[indexOfParameter]);
+                        links.resolvedSignature = cached;
+                        return type;
                     }
                 }
                 const contextualSignature = getContextualSignature(func);

src/harness/fourslash.ts

@@ -1486,6 +1486,12 @@ namespace FourSlash {
             this.fixCaretPosition();
         }
 
+        public formatOnType(pos: number, key: string) {
+            const edits = this.languageService.getFormattingEditsAfterKeystroke(this.activeFile.fileName, pos, key, this.formatCodeOptions);
+            this.currentCaretPosition += this.applyEdits(this.activeFile.fileName, edits, /*isFormattingEdit*/ true);
+            this.fixCaretPosition();
+        }
+
         private updateMarkersForEdit(fileName: string, minChar: number, limChar: number, text: string) {
             for (let i = 0; i < this.testData.markers.length; i++) {
                 const marker = this.testData.markers[i];
@@ -3223,6 +3229,10 @@ namespace FourSlashInterface {
             this.state.formatSelection(this.state.getMarkerByName(startMarker).position, this.state.getMarkerByName(endMarker).position);
         }
 
+        public onType(posMarker: string, key: string) {
+            this.state.formatOnType(this.state.getMarkerByName(posMarker).position, key);
+        }
+
         public setOption(name: string, value: number): void;
         public setOption(name: string, value: string): void;
         public setOption(name: string, value: boolean): void;

src/harness/loggedIO.ts

@@ -226,13 +226,7 @@ namespace Playback {
             (path, extension, exclude) => findResultByPath(wrapper,
                     replayLog.directoriesRead.filter(
                         d => {
-                            if (d.extension === extension) {
-                                if (d.exclude) {
-                                    return ts.arrayIsEqualTo(d.exclude, exclude);
-                                }
-                                return true;
-                            }
-                            return false;
+                            return d.extension === extension;
                         }
                     ), path));
 

src/services/formatting/formatting.ts

@@ -81,6 +81,12 @@ namespace ts.formatting {
         while (isWhiteSpace(sourceFile.text.charCodeAt(endOfFormatSpan)) && !isLineBreak(sourceFile.text.charCodeAt(endOfFormatSpan))) {
             endOfFormatSpan--;
         }
+        // if the character at the end of the span is a line break, we shouldn't include it, because it indicates we don't want to
+        // touch the current line at all. Also, on some OSes the line break consists of two characters (\r\n), we should test if the
+        // previous character before the end of format span is line break character as well.
+        if (isLineBreak(sourceFile.text.charCodeAt(endOfFormatSpan))) {
+            endOfFormatSpan--;
+        }
         const span = {
             // get start position for the previous line
             pos: getStartPositionOfLine(line - 1, sourceFile),

tests/cases/fourslash/fourslash.ts

@@ -246,6 +246,7 @@ declare namespace FourSlashInterface {
         copyFormatOptions(): FormatCodeOptions;
         setFormatOptions(options: FormatCodeOptions): any;
         selection(startMarker: string, endMarker: string): void;
+        onType(posMarker: string, key: string): void;
         setOption(name: string, value: number): any;
         setOption(name: string, value: string): any;
         setOption(name: string, value: boolean): any;

tests/cases/fourslash/server/formatOnEnter.ts

@@ -0,0 +1,17 @@
+/// <reference path="fourslash.ts"/>
+
+/////*3*/function listAPIFiles (path : string): string[] {
+////    /*1*/
+////    /*2*/
+////}
+
+goTo.marker("1");
+format.onType("1", "\n");
+verify.currentLineContentIs("    ");
+
+goTo.marker("2");
+format.onType("2", "\n");
+verify.currentLineContentIs("    ");
+
+goTo.marker("3");
+verify.currentLineContentIs("function listAPIFiles(path: string): string[] {");