Merge branch 'master' into master-jsxChildren

# Conflicts:
#	src/compiler/checker.ts
#	src/compiler/diagnosticMessages.json

Author: Kanchalai Tanglertsampan

.travis.yml

@@ -18,12 +18,12 @@ branches:
   - master
   - release-2.1
   - release-2.2
+  - release-2.3
 
 install:
   - npm uninstall typescript
   - npm uninstall tslint
   - npm install
-  - npm update
 
 cache:
   directories:

Gulpfile.ts

@@ -41,6 +41,7 @@ const cmdLineOptions = minimist(process.argv.slice(2), {
     boolean: ["debug", "inspect", "light", "colors", "lint", "soft"],
     string: ["browser", "tests", "host", "reporter", "stackTraceLimit"],
     alias: {
+        b: "browser",
         d: "debug",
         t: "tests",
         test: "tests",
@@ -162,7 +163,10 @@ const librarySourceMap = [
 
     // JavaScript + all host library
     { target: "lib.d.ts", sources: ["header.d.ts", "es5.d.ts"].concat(hostsLibrarySources) },
-    { target: "lib.es6.d.ts", sources: ["header.d.ts", "es5.d.ts"].concat(es2015LibrarySources, hostsLibrarySources, "dom.iterable.d.ts") }
+    { target: "lib.es6.d.ts", sources: ["header.d.ts", "es5.d.ts"].concat(es2015LibrarySources, hostsLibrarySources, "dom.iterable.d.ts") },
+    { target: "lib.es2016.full.d.ts", sources: ["header.d.ts", "es2016.d.ts"].concat(es2015LibrarySources, hostsLibrarySources, "dom.iterable.d.ts") },
+    { target: "lib.es2017.full.d.ts", sources: ["header.d.ts", "es2017.d.ts"].concat(es2015LibrarySources, hostsLibrarySources, "dom.iterable.d.ts") },
+    { target: "lib.esnext.full.d.ts", sources: ["header.d.ts", "esnext.d.ts"].concat(es2015LibrarySources, hostsLibrarySources, "dom.iterable.d.ts") },
 ].concat(es2015LibrarySourceMap, es2016LibrarySourceMap, es2017LibrarySourceMap, esnextLibrarySourceMap);
 
 const libraryTargets = librarySourceMap.map(function(f) {
@@ -384,7 +388,7 @@ function prependCopyright(outputCopyright: boolean = !useDebugMode) {
 }
 
 gulp.task(builtLocalCompiler, /*help*/ false, [servicesFile], () => {
-    const localCompilerProject = tsc.createProject("src/compiler/tsconfig.json", getCompilerSettings({}, /*useBuiltCompiler*/true));
+    const localCompilerProject = tsc.createProject("src/compiler/tsconfig.json", getCompilerSettings({}, /*useBuiltCompiler*/ true));
     return localCompilerProject.src()
         .pipe(newer(builtLocalCompiler))
         .pipe(sourcemaps.init())
@@ -395,14 +399,14 @@ gulp.task(builtLocalCompiler, /*help*/ false, [servicesFile], () => {
 });
 
 gulp.task(servicesFile, /*help*/ false, ["lib", "generate-diagnostics"], () => {
-    const servicesProject = tsc.createProject("src/services/tsconfig.json", getCompilerSettings({ removeComments: false }, /*useBuiltCompiler*/false));
+    const servicesProject = tsc.createProject("src/services/tsconfig.json", getCompilerSettings({ removeComments: false }, /*useBuiltCompiler*/ false));
     const {js, dts} = servicesProject.src()
         .pipe(newer(servicesFile))
         .pipe(sourcemaps.init())
         .pipe(servicesProject());
     const completedJs = js.pipe(prependCopyright())
         .pipe(sourcemaps.write("."));
-    const completedDts = dts.pipe(prependCopyright(/*outputCopyright*/true))
+    const completedDts = dts.pipe(prependCopyright(/*outputCopyright*/ true))
         .pipe(insert.transform((contents, file) => {
             file.path = standaloneDefinitionsFile;
             return contents.replace(/^(\s*)(export )?const enum (\S+) {(\s*)$/gm, "$1$2enum $3 {$4");
@@ -429,7 +433,7 @@ gulp.task(servicesFile, /*help*/ false, ["lib", "generate-diagnostics"], () => {
 // cancellationToken.js
 const cancellationTokenJs = path.join(builtLocalDirectory, "cancellationToken.js");
 gulp.task(cancellationTokenJs, /*help*/ false, [servicesFile], () => {
-    const cancellationTokenProject = tsc.createProject("src/server/cancellationToken/tsconfig.json", getCompilerSettings({}, /*useBuiltCompiler*/true));
+    const cancellationTokenProject = tsc.createProject("src/server/cancellationToken/tsconfig.json", getCompilerSettings({}, /*useBuiltCompiler*/ true));
     return cancellationTokenProject.src()
         .pipe(newer(cancellationTokenJs))
         .pipe(sourcemaps.init())
@@ -442,7 +446,7 @@ gulp.task(cancellationTokenJs, /*help*/ false, [servicesFile], () => {
 // typingsInstallerFile.js
 const typingsInstallerJs = path.join(builtLocalDirectory, "typingsInstaller.js");
 gulp.task(typingsInstallerJs, /*help*/ false, [servicesFile], () => {
-    const cancellationTokenProject = tsc.createProject("src/server/typingsInstaller/tsconfig.json", getCompilerSettings({}, /*useBuiltCompiler*/true));
+    const cancellationTokenProject = tsc.createProject("src/server/typingsInstaller/tsconfig.json", getCompilerSettings({}, /*useBuiltCompiler*/ true));
     return cancellationTokenProject.src()
         .pipe(newer(typingsInstallerJs))
         .pipe(sourcemaps.init())
@@ -455,7 +459,7 @@ gulp.task(typingsInstallerJs, /*help*/ false, [servicesFile], () => {
 const serverFile = path.join(builtLocalDirectory, "tsserver.js");
 
 gulp.task(serverFile, /*help*/ false, [servicesFile, typingsInstallerJs, cancellationTokenJs], () => {
-    const serverProject = tsc.createProject("src/server/tsconfig.json", getCompilerSettings({}, /*useBuiltCompiler*/true));
+    const serverProject = tsc.createProject("src/server/tsconfig.json", getCompilerSettings({}, /*useBuiltCompiler*/ true));
     return serverProject.src()
         .pipe(newer(serverFile))
         .pipe(sourcemaps.init())
@@ -479,7 +483,7 @@ gulp.task(tsserverLibraryFile, /*help*/ false, [servicesFile], (done) => {
         js.pipe(prependCopyright())
             .pipe(sourcemaps.write("."))
             .pipe(gulp.dest("src/server")),
-        dts.pipe(prependCopyright(/*outputCopyright*/true))
+        dts.pipe(prependCopyright(/*outputCopyright*/ true))
             .pipe(insert.transform((content) => {
                 return content + "\r\nexport = ts;\r\nexport as namespace ts;";
             }))
@@ -551,7 +555,7 @@ gulp.task("LKG", "Makes a new LKG out of the built js files", ["clean", "dontUse
 // Task to build the tests infrastructure using the built compiler
 const run = path.join(builtLocalDirectory, "run.js");
 gulp.task(run, /*help*/ false, [servicesFile], () => {
-    const testProject = tsc.createProject("src/harness/tsconfig.json", getCompilerSettings({}, /*useBuiltCompiler*/true));
+    const testProject = tsc.createProject("src/harness/tsconfig.json", getCompilerSettings({}, /*useBuiltCompiler*/ true));
     return testProject.src()
         .pipe(newer(run))
         .pipe(sourcemaps.init())
@@ -757,7 +761,7 @@ gulp.task("browserify", "Runs browserify on run.js to produce a file suitable fo
             browserify(intoStream(file.contents), { debug: true })
                 .bundle((err, res) => {
                     // assumes file.contents is a Buffer
-                    const maps = JSON.parse(convertMap.fromSource(res.toString(), /*largeSource*/true).toJSON());
+                    const maps = JSON.parse(convertMap.fromSource(res.toString(), /*largeSource*/ true).toJSON());
                     delete maps.sourceRoot;
                     maps.sources = maps.sources.map(s => path.resolve(s === "_stream_0.js" ? "built/local/_stream_0.js" : s));
                     // Strip browserify's inline comments away (could probably just let sorcery do this, but then we couldn't fix the paths)
@@ -775,7 +779,7 @@ gulp.task("browserify", "Runs browserify on run.js to produce a file suitable fo
                     });
                     const finalMap = chain.apply();
                     file.sourceMap = finalMap;
-                    next(undefined, file);
+                    next(/*err*/ undefined, file);
                 });
         }))
         .pipe(sourcemaps.write(".", { includeContent: false }))
@@ -1024,7 +1028,7 @@ gulp.task("lint", "Runs tslint on the compiler sources. Optional arguments are:
     const fileMatcher = cmdLineOptions["files"];
     const files = fileMatcher
         ? `src/**/${fileMatcher}`
-        : "Gulpfile.ts 'src/**/*.ts' --exclude src/lib/es5.d.ts --exclude 'src/lib/*.generated.d.ts'";
+        : "Gulpfile.ts 'scripts/tslint/*.ts' 'src/**/*.ts' --exclude src/lib/es5.d.ts --exclude 'src/lib/*.generated.d.ts'";
     const cmd = `node node_modules/tslint/bin/tslint ${files} --format stylish`;
     console.log("Linting: " + cmd);
     child_process.execSync(cmd, { stdio: [0, 1, 2] });

Jakefile.js

@@ -205,7 +205,10 @@ var librarySourceMap = [
 
     // JavaScript + all host library
     { target: "lib.d.ts", sources: ["header.d.ts", "es5.d.ts"].concat(hostsLibrarySources) },
-    { target: "lib.es6.d.ts", sources: ["header.d.ts", "es5.d.ts"].concat(es2015LibrarySources, hostsLibrarySources, "dom.iterable.d.ts") }
+    { target: "lib.es6.d.ts", sources: ["header.d.ts", "es5.d.ts"].concat(es2015LibrarySources, hostsLibrarySources, "dom.iterable.d.ts") },
+    { target: "lib.es2016.full.d.ts", sources: ["header.d.ts", "es2016.d.ts"].concat(hostsLibrarySources, "dom.iterable.d.ts") },
+    { target: "lib.es2017.full.d.ts", sources: ["header.d.ts", "es2017.d.ts"].concat(hostsLibrarySources, "dom.iterable.d.ts") },
+    { target: "lib.esnext.full.d.ts", sources: ["header.d.ts", "esnext.d.ts"].concat(hostsLibrarySources, "dom.iterable.d.ts") },
 ].concat(es2015LibrarySourceMap, es2016LibrarySourceMap, es2017LibrarySourceMap, esnextLibrarySourceMap);
 
 var libraryTargets = librarySourceMap.map(function (f) {
@@ -1197,7 +1200,7 @@ task("lint", ["build-rules"], () => {
     const fileMatcher = process.env.f || process.env.file || process.env.files;
     const files = fileMatcher
         ? `src/**/${fileMatcher}`
-        : "Gulpfile.ts 'src/**/*.ts' --exclude src/lib/es5.d.ts --exclude 'src/lib/*.generated.d.ts'";
+        : "Gulpfile.ts 'scripts/tslint/*.ts' 'src/**/*.ts' --exclude src/lib/es5.d.ts --exclude 'src/lib/*.generated.d.ts'";
     const cmd = `node node_modules/tslint/bin/tslint ${files} --format stylish`;
     console.log("Linting: " + cmd);
     jake.exec([cmd], { interactive: true }, () => {

scripts/tslint/booleanTriviaRule.ts

@@ -8,43 +8,88 @@ export class Rule extends Lint.Rules.AbstractRule {
 }
 
 function walk(ctx: Lint.WalkContext<void>): void {
-    ts.forEachChild(ctx.sourceFile, recur);
-    function recur(node: ts.Node): void {
+    const { sourceFile } = ctx;
+    ts.forEachChild(sourceFile, function recur(node: ts.Node): void {
         if (node.kind === ts.SyntaxKind.CallExpression) {
             checkCall(node as ts.CallExpression);
         }
         ts.forEachChild(node, recur);
-    }
+    });
 
     function checkCall(node: ts.CallExpression): void {
-        for (const arg of node.arguments) {
-            if (arg.kind !== ts.SyntaxKind.TrueKeyword && arg.kind !== ts.SyntaxKind.FalseKeyword) {
-                continue;
+        if (!shouldIgnoreCalledExpression(node.expression)) {
+            for (const arg of node.arguments) {
+                checkArg(arg);
             }
+        }
+    }
 
-            if (node.expression.kind === ts.SyntaxKind.PropertyAccessExpression) {
-                const methodName = (node.expression as ts.PropertyAccessExpression).name.text
-                // Skip certain method names whose parameter names are not informative
-                if (methodName === 'set' ||
-                    methodName === 'equal' ||
-                    methodName === 'fail' ||
-                    methodName === 'isTrue' ||
-                    methodName === 'assert') {
-                    continue;
-                }
+    /** Skip certain function/method names whose parameter names are not informative. */
+    function shouldIgnoreCalledExpression(expression: ts.Expression): boolean {
+        if (expression.kind === ts.SyntaxKind.PropertyAccessExpression) {
+            const methodName = (expression as ts.PropertyAccessExpression).name.text;
+            if (methodName.indexOf("set") === 0) {
+                return true;
             }
-            else if (node.expression.kind === ts.SyntaxKind.Identifier) {
-                const functionName = (node.expression as ts.Identifier).text;
-                // Skip certain function names whose parameter names are not informative
-                if (functionName === 'assert') {
-                    continue;
-                }
+            switch (methodName) {
+                case "apply":
+                case "assert":
+                case "call":
+                case "equal":
+                case "fail":
+                case "isTrue":
+                case "output":
+                case "stringify":
+                    return true;
             }
-
-            const ranges = ts.getLeadingCommentRanges(arg.getFullText(), 0);
-            if (!(ranges && ranges.length === 1 && ranges[0].kind === ts.SyntaxKind.MultiLineCommentTrivia)) {
-                ctx.addFailureAtNode(arg, 'Tag boolean argument with parameter name');
+        }
+        else if (expression.kind === ts.SyntaxKind.Identifier) {
+            const functionName = (expression as ts.Identifier).text;
+            if (functionName.indexOf("set") === 0) {
+                return true;
+            }
+            switch (functionName) {
+                case "assert":
+                case "contains":
+                case "createAnonymousType":
+                case "createImportSpecifier":
+                case "createProperty":
+                case "createSignature":
+                case "resolveName":
+                    return true;
             }
         }
+        return false;
+    }
+
+    function checkArg(arg: ts.Expression): void {
+        if (!isTrivia(arg)) {
+            return;
+        }
+
+        const ranges = ts.getTrailingCommentRanges(sourceFile.text, arg.pos) || ts.getLeadingCommentRanges(sourceFile.text, arg.pos);
+        if (ranges === undefined || ranges.length !== 1 || ranges[0].kind !== ts.SyntaxKind.MultiLineCommentTrivia) {
+            ctx.addFailureAtNode(arg, "Tag boolean argument with parameter name");
+            return;
+        }
+
+        const range = ranges[0];
+        const argStart = arg.getStart(sourceFile);
+        if (range.end + 1 !== argStart && sourceFile.text.slice(range.end, argStart).indexOf("\n") === -1) {
+            ctx.addFailureAtNode(arg, "There should be 1 space between an argument and its comment.");
+        }
+    }
+
+    function isTrivia(arg: ts.Expression): boolean {
+        switch (arg.kind) {
+            case ts.SyntaxKind.TrueKeyword:
+            case ts.SyntaxKind.FalseKeyword:
+            case ts.SyntaxKind.NullKeyword:
+                return true;
+            case ts.SyntaxKind.Identifier:
+                return (arg as ts.Identifier).originalKeywordKind === ts.SyntaxKind.UndefinedKeyword;
+            default:
+                return false;
+        }
     }
 }

src/compiler/binder.ts

@@ -418,7 +418,7 @@ namespace ts {
                     return declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes);
                 }
                 else {
-                    return declareSymbol(container.locals, undefined, node, symbolFlags, symbolExcludes);
+                    return declareSymbol(container.locals, /*parent*/ undefined, node, symbolFlags, symbolExcludes);
                 }
             }
             else {
@@ -447,13 +447,13 @@ namespace ts {
                         (symbolFlags & SymbolFlags.Value ? SymbolFlags.ExportValue : 0) |
                         (symbolFlags & SymbolFlags.Type ? SymbolFlags.ExportType : 0) |
                         (symbolFlags & SymbolFlags.Namespace ? SymbolFlags.ExportNamespace : 0);
-                    const local = declareSymbol(container.locals, undefined, node, exportKind, symbolExcludes);
+                    const local = declareSymbol(container.locals, /*parent*/ undefined, node, exportKind, symbolExcludes);
                     local.exportSymbol = declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes);
                     node.localSymbol = local;
                     return local;
                 }
                 else {
-                    return declareSymbol(container.locals, undefined, node, symbolFlags, symbolExcludes);
+                    return declareSymbol(container.locals, /*parent*/ undefined, node, symbolFlags, symbolExcludes);
                 }
             }
         }
@@ -1545,7 +1545,7 @@ namespace ts {
         function declareSourceFileMember(node: Declaration, symbolFlags: SymbolFlags, symbolExcludes: SymbolFlags) {
             return isExternalModule(file)
                 ? declareModuleMember(node, symbolFlags, symbolExcludes)
-                : declareSymbol(file.locals, undefined, node, symbolFlags, symbolExcludes);
+                : declareSymbol(file.locals, /*parent*/ undefined, node, symbolFlags, symbolExcludes);
         }
 
         function hasExportDeclarations(node: ModuleDeclaration | SourceFile): boolean {
@@ -1721,7 +1721,7 @@ namespace ts {
                         blockScopeContainer.locals = createMap<Symbol>();
                         addToContainerChain(blockScopeContainer);
                     }
-                    declareSymbol(blockScopeContainer.locals, undefined, node, symbolFlags, symbolExcludes);
+                    declareSymbol(blockScopeContainer.locals, /*parent*/ undefined, node, symbolFlags, symbolExcludes);
             }
         }
 
@@ -2298,7 +2298,7 @@ namespace ts {
 
         function isNameOfExportsOrModuleExportsAliasDeclaration(node: Node) {
             if (node.kind === SyntaxKind.Identifier) {
-                const symbol = container.locals.get((<Identifier>node).text);
+                const symbol = lookupSymbolForName((<Identifier>node).text);
                 if (symbol && symbol.valueDeclaration && symbol.valueDeclaration.kind === SyntaxKind.VariableDeclaration) {
                     const declaration = symbol.valueDeclaration as VariableDeclaration;
                     if (declaration.initializer) {
@@ -2333,7 +2333,7 @@ namespace ts {
 
         function bindThisPropertyAssignment(node: BinaryExpression) {
             Debug.assert(isInJavaScriptFile(node));
-            const container = getThisContainer(node, /*includeArrowFunctions*/false);
+            const container = getThisContainer(node, /*includeArrowFunctions*/ false);
             switch (container.kind) {
                 case SyntaxKind.FunctionDeclaration:
                 case SyntaxKind.FunctionExpression:
@@ -2400,8 +2400,12 @@ namespace ts {
             }
         }
 
+        function lookupSymbolForName(name: string) {
+            return (container.symbol && container.symbol.exports && container.symbol.exports.get(name)) || container.locals.get(name);
+        }
+
         function bindPropertyAssignment(functionName: string, propertyAccessExpression: PropertyAccessExpression, isPrototypeProperty: boolean) {
-            let targetSymbol = container.locals.get(functionName);
+            let targetSymbol = lookupSymbolForName(functionName);
 
             if (targetSymbol && isDeclarationOfFunctionOrClassExpression(targetSymbol)) {
                 targetSymbol = (targetSymbol.valueDeclaration as VariableDeclaration).initializer.symbol;
@@ -2423,7 +2427,7 @@ namespace ts {
         function bindCallExpression(node: CallExpression) {
             // We're only inspecting call expressions to detect CommonJS modules, so we can skip
             // this check if we've already seen the module indicator
-            if (!file.commonJsModuleIndicator && isRequireCall(node, /*checkArgumentIsStringLiteral*/false)) {
+            if (!file.commonJsModuleIndicator && isRequireCall(node, /*checkArgumentIsStringLiteral*/ false)) {
                 setCommonJsModuleIndicator(node);
             }
         }