Merge branch 'master' into genericDefaults

Author: rbuckton

Jakefile.js

@@ -6,6 +6,8 @@ var path = require("path");
 var child_process = require("child_process");
 var fold = require("travis-fold");
 var runTestsInParallel = require("./scripts/mocha-parallel").runTestsInParallel;
+var ts = require("./lib/typescript");
+
 
 // Variables
 var compilerDirectory = "src/compiler/";
@@ -34,6 +36,24 @@ if (process.env.path !== undefined) {
     process.env.PATH = nodeModulesPathPrefix + process.env.PATH;
 }
 
+function filesFromConfig(configPath) {
+    var configText = fs.readFileSync(configPath).toString();
+    var config = ts.parseConfigFileTextToJson(configPath, configText, /*stripComments*/ true);
+    if (config.error) {
+        throw new Error(diagnosticsToString([config.error]));
+    }
+    const configFileContent = ts.parseJsonConfigFileContent(config.config, ts.sys, path.dirname(configPath));
+    if (configFileContent.errors && configFileContent.errors.length) {
+        throw new Error(diagnosticsToString(configFileContent.errors));
+    }
+
+    return configFileContent.fileNames;
+
+    function diagnosticsToString(s) {
+        return s.map(function(e) { return ts.flattenDiagnosticMessageText(e.messageText, ts.sys.newLine); }).join(ts.sys.newLine);
+    }
+}
+
 function toNs(diff) {
     return diff[0] * 1e9 + diff[1];
 }
@@ -56,173 +76,12 @@ function measure(marker) {
     console.log("travis_time:end:" + marker.id + ":start=" + toNs(marker.stamp) + ",finish=" + toNs(total) + ",duration=" + toNs(diff) + "\r");
 }
 
-var compilerSources = [
-    "core.ts",
-    "performance.ts",
-    "sys.ts",
-    "types.ts",
-    "scanner.ts",
-    "parser.ts",
-    "utilities.ts",
-    "binder.ts",
-    "checker.ts",
-    "factory.ts",
-    "visitor.ts",
-    "transformers/destructuring.ts",
-    "transformers/ts.ts",
-    "transformers/jsx.ts",
-    "transformers/esnext.ts",
-    "transformers/es2017.ts",
-    "transformers/es2016.ts",
-    "transformers/es2015.ts",
-    "transformers/generators.ts",
-    "transformers/es5.ts",
-    "transformers/module/es2015.ts",
-    "transformers/module/system.ts",
-    "transformers/module/module.ts",
-    "transformer.ts",
-    "sourcemap.ts",
-    "comments.ts",
-    "declarationEmitter.ts",
-    "emitter.ts",
-    "program.ts",
-    "commandLineParser.ts",
-    "tsc.ts",
-    "diagnosticInformationMap.generated.ts"
-].map(function (f) {
-    return path.join(compilerDirectory, f);
-});
-
-var servicesSources = [
-    "core.ts",
-    "performance.ts",
-    "sys.ts",
-    "types.ts",
-    "scanner.ts",
-    "parser.ts",
-    "utilities.ts",
-    "binder.ts",
-    "checker.ts",
-    "factory.ts",
-    "visitor.ts",
-    "transformers/destructuring.ts",
-    "transformers/ts.ts",
-    "transformers/jsx.ts",
-    "transformers/esnext.ts",
-    "transformers/es2017.ts",
-    "transformers/es2016.ts",
-    "transformers/es2015.ts",
-    "transformers/generators.ts",
-    "transformers/es5.ts",
-    "transformers/module/es2015.ts",
-    "transformers/module/system.ts",
-    "transformers/module/module.ts",
-    "transformer.ts",
-    "sourcemap.ts",
-    "comments.ts",
-    "declarationEmitter.ts",
-    "emitter.ts",
-    "program.ts",
-    "commandLineParser.ts",
-    "diagnosticInformationMap.generated.ts"
-].map(function (f) {
-    return path.join(compilerDirectory, f);
-}).concat([
-    "types.ts",
-    "utilities.ts",
-    "breakpoints.ts",
-    "classifier.ts",
-    "completions.ts",
-    "documentHighlights.ts",
-    "documentRegistry.ts",
-    "findAllReferences.ts",
-    "goToDefinition.ts",
-    "goToImplementation.ts",
-    "jsDoc.ts",
-    "jsTyping.ts",
-    "navigateTo.ts",
-    "navigationBar.ts",
-    "outliningElementsCollector.ts",
-    "patternMatcher.ts",
-    "preProcess.ts",
-    "rename.ts",
-    "services.ts",
-    "shims.ts",
-    "signatureHelp.ts",
-    "symbolDisplay.ts",
-    "transpile.ts",
-    // Formatting
-    "formatting/formatting.ts",
-    "formatting/formattingContext.ts",
-    "formatting/formattingRequestKind.ts",
-    "formatting/formattingScanner.ts",
-    "formatting/references.ts",
-    "formatting/rule.ts",
-    "formatting/ruleAction.ts",
-    "formatting/ruleDescriptor.ts",
-    "formatting/ruleFlag.ts",
-    "formatting/ruleOperation.ts",
-    "formatting/ruleOperationContext.ts",
-    "formatting/rules.ts",
-    "formatting/rulesMap.ts",
-    "formatting/rulesProvider.ts",
-    "formatting/smartIndenter.ts",
-    "formatting/tokenRange.ts",
-    // CodeFixes
-    "codeFixProvider.ts",
-    "codefixes/fixes.ts",
-    "codefixes/fixExtendsInterfaceBecomesImplements.ts",
-    "codefixes/fixClassIncorrectlyImplementsInterface.ts",
-    "codefixes/fixClassDoesntImplementInheritedAbstractMember.ts",
-    "codefixes/fixClassSuperMustPrecedeThisAccess.ts",
-    "codefixes/fixConstructorForDerivedNeedSuperCall.ts",
-    "codefixes/helpers.ts",
-    "codefixes/importFixes.ts",
-    "codefixes/unusedIdentifierFixes.ts"
-].map(function (f) {
-    return path.join(servicesDirectory, f);
-}));
-
-var baseServerCoreSources = [
-	"builder.ts",
-    "editorServices.ts",
-    "lsHost.ts",
-    "project.ts",
-    "protocol.ts",
-    "scriptInfo.ts",
-    "scriptVersionCache.ts",
-    "session.ts",
-    "shared.ts",
-    "types.ts",
-    "typingsCache.ts",
-    "utilities.ts",
-].map(function (f) {
-    return path.join(serverDirectory, f);
-});
-
-var serverCoreSources = [
-    "server.ts"
-].map(function (f) {
-    return path.join(serverDirectory, f);
-}).concat(baseServerCoreSources);
-
-var cancellationTokenSources = [
-    "cancellationToken.ts"
-].map(function (f) {
-    return path.join(cancellationTokenDirectory, f);
-});
-
-var typingsInstallerSources = [
-    "../types.ts",
-    "../shared.ts",
-    "typingsInstaller.ts",
-    "nodeTypingsInstaller.ts"
-].map(function (f) {
-    return path.join(typingsInstallerDirectory, f);
-});
-
-var serverSources = serverCoreSources.concat(servicesSources);
-var languageServiceLibrarySources = baseServerCoreSources.concat(servicesSources);
+var compilerSources = filesFromConfig("./src/compiler/tsconfig.json");
+var servicesSources = filesFromConfig("./src/services/tsconfig.json");
+var cancellationTokenSources = filesFromConfig(path.join(serverDirectory, "cancellationToken/tsconfig.json"));
+var typingsInstallerSources = filesFromConfig(path.join(serverDirectory, "typingsInstaller/tsconfig.json"));
+var serverSources = filesFromConfig(path.join(serverDirectory, "tsconfig.json"))
+var languageServiceLibrarySources = filesFromConfig(path.join(serverDirectory, "tsconfig.library.json"));
 
 var harnessCoreSources = [
     "harness.ts",
@@ -1230,13 +1089,16 @@ var lintTargets = compilerSources
     .concat(harnessSources)
     // Other harness sources
     .concat(["instrumenter.ts"].map(function (f) { return path.join(harnessDirectory, f) }))
-    .concat(serverCoreSources)
+    .concat(serverSources)
     .concat(tslintRulesFiles)
     .concat(servicesSources)
     .concat(typingsInstallerSources)
     .concat(cancellationTokenSources)
     .concat(["Gulpfile.ts"])
-    .concat([nodeServerInFile, perftscPath, "tests/perfsys.ts", webhostPath]);
+    .concat([nodeServerInFile, perftscPath, "tests/perfsys.ts", webhostPath])
+    .map(function (p) { return path.resolve(p) });
+// keep only unique items
+lintTargets = Array.from(new Set(lintTargets));
 
 function sendNextFile(files, child, callback, failures) {
     var file = files.pop();

package.json

@@ -2,7 +2,7 @@
     "name": "typescript",
     "author": "Microsoft Corp.",
     "homepage": "http://typescriptlang.org/",
-    "version": "2.2.0",
+    "version": "2.3.0",
     "license": "Apache-2.0",
     "description": "TypeScript is a language for application scale JavaScript development",
     "keywords": [

scripts/buildProtocol.ts

@@ -167,7 +167,7 @@ function generateProtocolFile(protocolTs: string, typeScriptServicesDts: string)
     const sanityCheckProgram = getProgramWithProtocolText(protocolDts, /*includeTypeScriptServices*/ false);
     const diagnostics = [...sanityCheckProgram.getSyntacticDiagnostics(), ...sanityCheckProgram.getSemanticDiagnostics(), ...sanityCheckProgram.getGlobalDiagnostics()];
     if (diagnostics.length) {
-        const flattenedDiagnostics = diagnostics.map(d => ts.flattenDiagnosticMessageText(d.messageText, "\n")).join("\n");
+        const flattenedDiagnostics = diagnostics.map(d => `${ts.flattenDiagnosticMessageText(d.messageText, "\n")} at ${d.file.fileName} line ${d.start}`).join("\n");
         throw new Error(`Unexpected errors during sanity check: ${flattenedDiagnostics}`);
     }
     return protocolDts;

src/compiler/binder.ts

@@ -1045,7 +1045,35 @@ namespace ts {
             if (node.finallyBlock) {
                 // in finally flow is combined from pre-try/flow from try/flow from catch
                 // pre-flow is necessary to make sure that finally is reachable even if finally flows in both try and finally blocks are unreachable
-                addAntecedent(preFinallyLabel, preTryFlow);
+
+                // also for finally blocks we inject two extra edges into the flow graph.
+                // first -> edge that connects pre-try flow with the label at the beginning of the finally block, it has lock associated with it
+                // second -> edge that represents post-finally flow.
+                // these edges are used in following scenario:
+                // let a; (1)
+                // try { a = someOperation(); (2)} 
+                // finally { (3) console.log(a) } (4) 
+                // (5) a
+
+                // flow graph for this case looks roughly like this (arrows show ):
+                // (1-pre-try-flow) <--.. <-- (2-post-try-flow)
+                //  ^                                ^
+                //  |*****(3-pre-finally-label) -----|
+                //                ^
+                //                |-- ... <-- (4-post-finally-label) <--- (5)
+                // In case when we walk the flow starting from inside the finally block we want to take edge '*****' into account
+                // since it ensures that finally is always reachable. However when we start outside the finally block and go through label (5)
+                // then edge '*****' should be discarded because label 4 is only reachable if post-finally label-4 is reachable
+                // Simply speaking code inside finally block is treated as reachable as pre-try-flow 
+                // since we conservatively assume that any line in try block can throw or return in which case we'll enter finally.
+                // However code after finally is reachable only if control flow was not abrupted in try/catch or finally blocks - it should be composed from
+                // final flows of these blocks without taking pre-try flow into account.
+                // 
+                // extra edges that we inject allows to control this behavior
+                // if when walking the flow we step on post-finally edge - we can mark matching pre-finally edge as locked so it will be skipped.
+                const preFinallyFlow: PreFinallyFlow = { flags: FlowFlags.PreFinally, antecedent: preTryFlow, lock: {} };
+                addAntecedent(preFinallyLabel, preFinallyFlow);
+
                 currentFlow = finishFlowLabel(preFinallyLabel);
                 bind(node.finallyBlock);
                 // if flow after finally is unreachable - keep it
@@ -1061,6 +1089,11 @@ namespace ts {
                             : unreachableFlow;
                     }
                 }
+                if (!(currentFlow.flags & FlowFlags.Unreachable)) {
+                    const afterFinallyFlow: AfterFinallyFlow = { flags: FlowFlags.AfterFinally, antecedent: currentFlow };
+                    preFinallyFlow.lock = afterFinallyFlow;
+                    currentFlow = afterFinallyFlow;
+                }
             }
             else {
                 currentFlow = finishFlowLabel(preFinallyLabel);