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

# Conflicts:
#	src/compiler/program.ts
#	tests/cases/unittests/tsserverProjectSystem.ts

CONTRIBUTING.md

@@ -91,10 +91,10 @@ These two files represent the DOM typings and are auto-generated. To make any mo
 
 ## Running the Tests
 
-To run all tests, invoke the `runtests` target using jake:
+To run all tests, invoke the `runtests-parallel` target using jake:
 
 ```Shell
-jake runtests
+jake runtests-parallel
 ```
 
 This run will all tests; to run only a specific subset of tests, use:

Jakefile.js

@@ -276,6 +276,7 @@ var builtLocalCompiler = path.join(builtLocalDirectory, compilerFilename);
     * @param {boolean} opts.noResolve: true if compiler should not include non-rooted files in compilation
     * @param {boolean} opts.stripInternal: true if compiler should remove declarations marked as @internal
     * @param {boolean} opts.noMapRoot: true if compiler omit mapRoot option
+    * @param {boolean} opts.inlineSourceMap: true if compiler should inline sourceMap
     * @param callback: a function to execute after the compilation process ends
     */
 function compileFile(outFile, sources, prereqs, prefixes, useBuiltCompiler, opts, callback) {
@@ -313,7 +314,14 @@ function compileFile(outFile, sources, prereqs, prefixes, useBuiltCompiler, opts
         }
 
         if (useDebugMode) {
-            options += " --inlineSourceMap --inlineSources";
+            if (opts.inlineSourceMap) {
+                options += " --inlineSourceMap --inlineSources";
+            } else {
+                options += " -sourcemap";
+                if (!opts.noMapRoot) {
+                    options += " -mapRoot file:///" + path.resolve(path.dirname(outFile));
+                }
+            }
         } else {
             options += " --newLine LF";
         }
@@ -483,6 +491,7 @@ var tscFile = path.join(builtLocalDirectory, compilerFilename);
 compileFile(tscFile, compilerSources, [builtLocalDirectory, copyright].concat(compilerSources), [copyright], /*useBuiltCompiler:*/ false);
 
 var servicesFile = path.join(builtLocalDirectory, "typescriptServices.js");
+var servicesFileInBrowserTest = path.join(builtLocalDirectory, "typescriptServicesInBrowserTest.js");
 var standaloneDefinitionsFile = path.join(builtLocalDirectory, "typescriptServices.d.ts");
 var nodePackageFile = path.join(builtLocalDirectory, "typescript.js");
 var nodeDefinitionsFile = path.join(builtLocalDirectory, "typescript.d.ts");
@@ -491,7 +500,13 @@ var nodeStandaloneDefinitionsFile = path.join(builtLocalDirectory, "typescript_s
 compileFile(servicesFile, servicesSources,[builtLocalDirectory, copyright].concat(servicesSources),
             /*prefixes*/ [copyright],
             /*useBuiltCompiler*/ true,
-            { noOutFile: false, generateDeclarations: true, preserveConstEnums: true, keepComments: true, noResolve: false, stripInternal: true },
+            /*opts*/ { noOutFile: false,
+                generateDeclarations: true,
+                preserveConstEnums: true,
+                keepComments: true,
+                noResolve: false,
+                stripInternal: true
+            },
             /*callback*/ function () {
                 jake.cpR(servicesFile, nodePackageFile, {silent: true});
 
@@ -514,6 +529,21 @@ compileFile(servicesFile, servicesSources,[builtLocalDirectory, copyright].conca
                 fs.writeFileSync(nodeStandaloneDefinitionsFile, nodeStandaloneDefinitionsFileContents);
             });
 
+compileFile(
+    servicesFileInBrowserTest,
+    servicesSources,
+    [builtLocalDirectory, copyright].concat(servicesSources),
+    /*prefixes*/ [copyright],
+    /*useBuiltCompiler*/ true,
+    { noOutFile: false,
+      generateDeclarations: true,
+      preserveConstEnums: true,
+      keepComments: true,
+      noResolve: false,
+      stripInternal: true,
+      noMapRoot: true,
+      inlineSourceMap: true
+     });
 
 var serverFile = path.join(builtLocalDirectory, "tsserver.js");
 compileFile(serverFile, serverSources,[builtLocalDirectory, copyright].concat(serverSources), /*prefixes*/ [copyright], /*useBuiltCompiler*/ true);
@@ -614,7 +644,13 @@ directory(builtLocalDirectory);
 
 // Task to build the tests infrastructure using the built compiler
 var run = path.join(builtLocalDirectory, "run.js");
-compileFile(run, harnessSources, [builtLocalDirectory, tscFile].concat(libraryTargets).concat(harnessSources), [], /*useBuiltCompiler:*/ true);
+compileFile(
+    /*outFile*/ run,
+    /*source*/ harnessSources,
+    /*prereqs*/ [builtLocalDirectory, tscFile].concat(libraryTargets).concat(harnessSources),
+    /*prefixes*/ [],
+    /*useBuiltCompiler:*/ true,
+    /*opts*/ { inlineSourceMap: true });
 
 var internalTests = "internal/";
 
@@ -718,24 +754,34 @@ function runConsoleTests(defaultReporter, runInParallel) {
     colors = process.env.colors || process.env.color;
     colors = colors ? ' --no-colors ' : ' --colors ';
     reporter = process.env.reporter || process.env.r || defaultReporter;
+    var bail = (process.env.bail || process.env.b) ? "--bail" : "";
     var lintFlag = process.env.lint !== 'false';
 
     // timeout normally isn't necessary but Travis-CI has been timing out on compiler baselines occasionally
     // default timeout is 2sec which really should be enough, but maybe we just need a small amount longer
     if(!runInParallel) {
         tests = tests ? ' -g "' + tests + '"' : '';
-        var cmd = "mocha" + (debug ? " --debug-brk" : "") + " -R " + reporter + tests + colors + ' -t ' + testTimeout + ' ' + run;
+        var cmd = "mocha" + (debug ? " --debug-brk" : "") + " -R " + reporter + tests + colors + bail + ' -t ' + testTimeout + ' ' + run;
         console.log(cmd);
+
+        var savedNodeEnv = process.env.NODE_ENV;
+        process.env.NODE_ENV = "development";
         exec(cmd, function () {
+            process.env.NODE_ENV = savedNodeEnv;
             runLinter();
             finish();
         }, function(e, status) {
+            process.env.NODE_ENV = savedNodeEnv;
             finish(status);
         });
 
     }
     else {
+        var savedNodeEnv = process.env.NODE_ENV;
+        process.env.NODE_ENV = "development";
         runTestsInParallel(taskConfigsFolder, run, { testTimeout: testTimeout, noColors: colors === " --no-colors " }, function (err) {
+            process.env.NODE_ENV = savedNodeEnv;
+
             // last worker clean everything and runs linter in case if there were no errors
             deleteTemporaryProjectOutput();
             jake.rmRf(taskConfigsFolder);
@@ -780,7 +826,7 @@ task("runtests-parallel", ["build-rules", "tests", builtLocalDirectory], functio
     runConsoleTests('min', /*runInParallel*/ true);
 }, {async: true});
 
-desc("Runs the tests using the built run.js file. Optional arguments are: t[ests]=regex r[eporter]=[list|spec|json|<more>] d[ebug]=true color[s]=false lint=true.");
+desc("Runs the tests using the built run.js file. Optional arguments are: t[ests]=regex r[eporter]=[list|spec|json|<more>] d[ebug]=true color[s]=false lint=true bail=false.");
 task("runtests", ["build-rules", "tests", builtLocalDirectory], function() {
     runConsoleTests('mocha-fivemat-progress-reporter', /*runInParallel*/ false);
 }, {async: true});
@@ -804,7 +850,7 @@ task("browserify", ["tests", builtLocalDirectory, nodeServerOutFile], function()
 }, {async: true});
 
 desc("Runs the tests using the built run.js file like 'jake runtests'. Syntax is jake runtests-browser. Additional optional parameters tests=[regex], port=, browser=[chrome|IE]");
-task("runtests-browser", ["tests", "browserify", builtLocalDirectory, servicesFile], function() {
+task("runtests-browser", ["tests", "browserify", builtLocalDirectory, servicesFileInBrowserTest], function() {
     cleanTestDirs();
     host = "node";
     port = process.env.port || process.env.p || '8888';

lib/lib.d.ts

@@ -152,12 +152,24 @@ interface ObjectConstructor {
       */
     getOwnPropertyNames(o: any): string[];
 
+    /**
+      * Creates an object that has null prototype.
+      * @param o Object to use as a prototype. May be null
+      */
+    create(o: null): any;
+
+    /**
+      * Creates an object that has the specified prototype, and that optionally contains specified properties.
+      * @param o Object to use as a prototype. May be null
+      */
+    create<T>(o: T): T;
+
     /**
       * Creates an object that has the specified prototype, and that optionally contains specified properties.
       * @param o Object to use as a prototype. May be null
       * @param properties JavaScript object that contains one or more property descriptors.
       */
-    create(o: any, properties?: PropertyDescriptorMap): any;
+    create(o: any, properties: PropertyDescriptorMap): any;
 
     /**
       * Adds a property to an object, or modifies attributes of an existing property.

lib/lib.es2017.d.ts

@@ -15,4 +15,5 @@ and limitations under the License.
 
 /// <reference no-default-lib="true"/>
 /// <reference path="lib.es2016.d.ts" />
-/// <reference path="lib.es2017.object.d.ts" />
+/// <reference path="lib.es2017.object.d.ts" />
+/// <reference path="lib.es2017.sharedmemory.d.ts" />

lib/lib.es2017.sharedmemory.d.ts

@@ -0,0 +1,43 @@
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation. All rights reserved. 
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0  
+ 
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, 
+MERCHANTABLITY OR NON-INFRINGEMENT. 
+ 
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+
+/// <reference no-default-lib="true"/>
+/// <reference path="lib.es2015.symbol.d.ts" />
+/// <reference path="lib.es2015.symbol.wellknown.d.ts" />
+
+interface SharedArrayBuffer {
+    /**
+      * Read-only. The length of the ArrayBuffer (in bytes).
+      */
+    readonly byteLength: number;
+
+    /*
+     * The SharedArrayBuffer constructor's length property whose value is 1.
+     */
+    length: number;
+    /**
+      * Returns a section of an SharedArrayBuffer.
+      */ 
+    slice(begin:number, end?:number): SharedArrayBuffer;
+    readonly [Symbol.species]: SharedArrayBuffer;
+    readonly [Symbol.toStringTag]: "SharedArrayBuffer";
+}
+
+interface SharedArrayBufferConstructor {
+    readonly prototype: SharedArrayBuffer;
+    new (byteLength: number): SharedArrayBuffer;
+}
+
+declare var SharedArrayBuffer: SharedArrayBufferConstructor;

lib/lib.es5.d.ts

@@ -152,12 +152,24 @@ interface ObjectConstructor {
       */
     getOwnPropertyNames(o: any): string[];
 
+    /**
+      * Creates an object that has null prototype.
+      * @param o Object to use as a prototype. May be null
+      */
+    create(o: null): any;
+
+    /**
+      * Creates an object that has the specified prototype, and that optionally contains specified properties.
+      * @param o Object to use as a prototype. May be null
+      */
+    create<T>(o: T): T;
+
     /**
       * Creates an object that has the specified prototype, and that optionally contains specified properties.
       * @param o Object to use as a prototype. May be null
       * @param properties JavaScript object that contains one or more property descriptors.
       */
-    create(o: any, properties?: PropertyDescriptorMap): any;
+    create(o: any, properties: PropertyDescriptorMap): any;
 
     /**
       * Adds a property to an object, or modifies attributes of an existing property.

lib/lib.es6.d.ts

@@ -152,12 +152,24 @@ interface ObjectConstructor {
       */
     getOwnPropertyNames(o: any): string[];
 
+    /**
+      * Creates an object that has null prototype.
+      * @param o Object to use as a prototype. May be null
+      */
+    create(o: null): any;
+
+    /**
+      * Creates an object that has the specified prototype, and that optionally contains specified properties.
+      * @param o Object to use as a prototype. May be null
+      */
+    create<T>(o: T): T;
+
     /**
       * Creates an object that has the specified prototype, and that optionally contains specified properties.
       * @param o Object to use as a prototype. May be null
       * @param properties JavaScript object that contains one or more property descriptors.
       */
-    create(o: any, properties?: PropertyDescriptorMap): any;
+    create(o: any, properties: PropertyDescriptorMap): any;
 
     /**
       * Adds a property to an object, or modifies attributes of an existing property.

scripts/mocha-parallel.js

@@ -34,13 +34,7 @@ function discoverTests(run, options, cb) {
     console.log("Discovering tests...");
 
     var cmd = "mocha -R " + require.resolve("./mocha-none-reporter.js") + " " + run;
-    var p = child_process.spawn(
-        process.platform === "win32" ? "cmd" : "/bin/sh",
-        process.platform === "win32" ? ["/c", cmd] : ["-c", cmd], {
-            windowsVerbatimArguments: true,
-            env: { NODE_ENV: "development" }
-        });
-
+    var p = spawnProcess(cmd);
     p.on("exit", function (status) {
         if (status) {
             cb(new Error("Process exited with code " + status));
@@ -87,18 +81,11 @@ function runTests(taskConfigsFolder, run, options, cb) {
 
         // Start the background process.
         var cmd = "mocha -t " + (options.testTimeout || 20000) + " -R tap --no-colors " + run + " --config='" + partition.file + "'";
-        var p = child_process.spawn(
-            process.platform === "win32" ? "cmd" : "/bin/sh",
-            process.platform === "win32" ? ["/c", cmd] : ["-c", cmd], {
-                windowsVerbatimArguments: true,
-                env: { NODE_ENV: "development" }
-            });
-
+        var p = spawnProcess(cmd);
         var rl = readline.createInterface({
             input: p.stdout,
             terminal: false
         });
-
         rl.on("line", onmessage);
         p.on("exit", onexit)
 
@@ -206,7 +193,6 @@ function runTests(taskConfigsFolder, run, options, cb) {
         counter--;
 
         if (counter <= 0) {
-            var failed = 0;
             var reporter = new Base(),
                 stats = reporter.stats,
                 failures = reporter.failures;
@@ -237,8 +223,8 @@ function runTests(taskConfigsFolder, run, options, cb) {
                 reporter.epilogue();
             }
 
-            if (failed) {
-                return cb(new Error("Test failures reported: " + failed));
+            if (stats.failures) {
+                return cb(new Error("Test failures reported: " + stats.failures));
             }
             else {
                 return cb();
@@ -259,6 +245,12 @@ function runTests(taskConfigsFolder, run, options, cb) {
     }
 }
 
+function spawnProcess(cmd, options) {
+    var shell = process.platform === "win32" ? "cmd" : "/bin/sh";
+    var prefix = process.platform === "win32" ? "/c" : "-c";
+    return child_process.spawn(shell, [prefix, cmd], { windowsVerbatimArguments: true });
+}
+
 function ProgressBars(options) {
     if (!options) options = {};
     var open = options.open || '[';

src/compiler/binder.ts

@@ -53,7 +53,8 @@ namespace ts {
             return state;
         }
         else if (node.kind === SyntaxKind.ModuleDeclaration) {
-            return getModuleInstanceState((<ModuleDeclaration>node).body);
+            const body = (<ModuleDeclaration>node).body;
+            return body ? getModuleInstanceState(body) : ModuleInstanceState.Instantiated;
         }
         else {
             return ModuleInstanceState.Instantiated;
@@ -609,10 +610,11 @@ namespace ts {
                 case SyntaxKind.ExclamationEqualsToken:
                 case SyntaxKind.EqualsEqualsEqualsToken:
                 case SyntaxKind.ExclamationEqualsEqualsToken:
-                    if (isNarrowingExpression(expr.left) && (expr.right.kind === SyntaxKind.NullKeyword || expr.right.kind === SyntaxKind.Identifier)) {
+                    if ((isNarrowingExpression(expr.left) && (expr.right.kind === SyntaxKind.NullKeyword || expr.right.kind === SyntaxKind.Identifier)) ||
+                        (isNarrowingExpression(expr.right) && (expr.left.kind === SyntaxKind.NullKeyword || expr.left.kind === SyntaxKind.Identifier))) {
                         return true;
                     }
-                    if (expr.left.kind === SyntaxKind.TypeOfExpression && isNarrowingExpression((<TypeOfExpression>expr.left).expression) && expr.right.kind === SyntaxKind.StringLiteral) {
+                    if (isTypeOfNarrowingBinaryExpression(expr)) {
                         return true;
                     }
                     return false;
@@ -624,6 +626,20 @@ namespace ts {
             return false;
         }
 
+        function isTypeOfNarrowingBinaryExpression(expr: BinaryExpression) {
+            let typeOf: Expression;
+            if (expr.left.kind === SyntaxKind.StringLiteral) {
+                typeOf = expr.right;
+            }
+            else if (expr.right.kind === SyntaxKind.StringLiteral) {
+                typeOf = expr.left;
+            }
+            else {
+                typeOf = undefined;
+            }
+            return typeOf && typeOf.kind === SyntaxKind.TypeOfExpression && isNarrowingExpression((<TypeOfExpression>typeOf).expression);
+        }
+
         function createBranchLabel(): FlowLabel {
             return {
                 flags: FlowFlags.BranchLabel,
@@ -1258,7 +1274,7 @@ namespace ts {
 
         function hasExportDeclarations(node: ModuleDeclaration | SourceFile): boolean {
             const body = node.kind === SyntaxKind.SourceFile ? node : (<ModuleDeclaration>node).body;
-            if (body.kind === SyntaxKind.SourceFile || body.kind === SyntaxKind.ModuleBlock) {
+            if (body && (body.kind === SyntaxKind.SourceFile || body.kind === SyntaxKind.ModuleBlock)) {
                 for (const stat of (<Block>body).statements) {
                     if (stat.kind === SyntaxKind.ExportDeclaration || stat.kind === SyntaxKind.ExportAssignment) {
                         return true;
@@ -1945,7 +1961,7 @@ namespace ts {
             classPrototype.parent = leftSideOfAssignment;
 
             const funcSymbol = container.locals[constructorFunction.text];
-            if (!funcSymbol || !(funcSymbol.flags & SymbolFlags.Function)) {
+            if (!funcSymbol || !(funcSymbol.flags & SymbolFlags.Function || isDeclarationOfFunctionExpression(funcSymbol))) {
                 return;
             }
 

src/compiler/checker.ts

@@ -562,7 +562,8 @@ namespace ts {
             const declarationFile = getSourceFileOfNode(declaration);
             const useFile = getSourceFileOfNode(usage);
             if (declarationFile !== useFile) {
-                if (modulekind || (!compilerOptions.outFile && !compilerOptions.out)) {
+                if ((modulekind && (declarationFile.externalModuleIndicator || useFile.externalModuleIndicator)) ||
+                    (!compilerOptions.outFile && !compilerOptions.out)) {
                     // nodes are in different files and order cannot be determines
                     return true;
                 }
@@ -992,7 +993,9 @@ namespace ts {
             const moduleSymbol = resolveExternalModuleName(node, (<ImportDeclaration>node.parent).moduleSpecifier);
 
             if (moduleSymbol) {
-                const exportDefaultSymbol = moduleSymbol.exports["export="] ?
+                const exportDefaultSymbol = isShorthandAmbientModule(moduleSymbol.valueDeclaration) ?
+                    moduleSymbol :
+                    moduleSymbol.exports["export="] ?
                     getPropertyOfType(getTypeOfSymbol(moduleSymbol.exports["export="]), "default") :
                     resolveSymbol(moduleSymbol.exports["default"]);
 
@@ -1066,6 +1069,10 @@ namespace ts {
             if (targetSymbol) {
                 const name = specifier.propertyName || specifier.name;
                 if (name.text) {
+                    if (isShorthandAmbientModule(moduleSymbol.valueDeclaration)) {
+                        return moduleSymbol;
+                    }
+
                     let symbolFromVariable: Symbol;
                     // First check if module was specified with "export=". If so, get the member from the resolved type
                     if (moduleSymbol && moduleSymbol.exports && moduleSymbol.exports["export="]) {
@@ -3234,9 +3241,14 @@ namespace ts {
         function getTypeOfFuncClassEnumModule(symbol: Symbol): Type {
             const links = getSymbolLinks(symbol);
             if (!links.type) {
-                const type = createObjectType(TypeFlags.Anonymous, symbol);
-                links.type = strictNullChecks && symbol.flags & SymbolFlags.Optional ?
-                    addTypeKind(type, TypeFlags.Undefined) : type;
+                if (symbol.valueDeclaration.kind === SyntaxKind.ModuleDeclaration && isShorthandAmbientModule(<ModuleDeclaration>symbol.valueDeclaration)) {
+                    links.type = anyType;
+                }
+                else {
+                    const type = createObjectType(TypeFlags.Anonymous, symbol);
+                    links.type = strictNullChecks && symbol.flags & SymbolFlags.Optional ?
+                        addTypeKind(type, TypeFlags.Undefined) : type;
+                }
             }
             return links.type;
         }
@@ -7884,10 +7896,11 @@ namespace ts {
                     case SyntaxKind.ExclamationEqualsToken:
                     case SyntaxKind.EqualsEqualsEqualsToken:
                     case SyntaxKind.ExclamationEqualsEqualsToken:
-                        if (isNullOrUndefinedLiteral(expr.right)) {
+                        if (isNullOrUndefinedLiteral(expr.left) || isNullOrUndefinedLiteral(expr.right)) {
                             return narrowTypeByNullCheck(type, expr, assumeTrue);
                         }
-                        if (expr.left.kind === SyntaxKind.TypeOfExpression && expr.right.kind === SyntaxKind.StringLiteral) {
+                        if (expr.left.kind === SyntaxKind.TypeOfExpression && expr.right.kind === SyntaxKind.StringLiteral ||
+                            expr.left.kind === SyntaxKind.StringLiteral && expr.right.kind === SyntaxKind.TypeOfExpression) {
                             return narrowTypeByTypeof(type, expr, assumeTrue);
                         }
                         break;
@@ -7900,18 +7913,20 @@ namespace ts {
             }
 
             function narrowTypeByNullCheck(type: Type, expr: BinaryExpression, assumeTrue: boolean): Type {
-                // We have '==', '!=', '===', or '!==' operator with 'null' or 'undefined' on the right
+                // We have '==', '!=', '===', or '!==' operator with 'null' or 'undefined' on one side
                 const operator = expr.operatorToken.kind;
+                const nullLike = isNullOrUndefinedLiteral(expr.left) ? expr.left : expr.right;
+                const narrowed = isNullOrUndefinedLiteral(expr.left) ? expr.right : expr.left;
                 if (operator === SyntaxKind.ExclamationEqualsToken || operator === SyntaxKind.ExclamationEqualsEqualsToken) {
                     assumeTrue = !assumeTrue;
                 }
-                if (!strictNullChecks || !isMatchingReference(reference, getReferenceFromExpression(expr.left))) {
+                if (!strictNullChecks || !isMatchingReference(reference, getReferenceFromExpression(narrowed))) {
                     return type;
                 }
                 const doubleEquals = operator === SyntaxKind.EqualsEqualsToken || operator === SyntaxKind.ExclamationEqualsToken;
                 const facts = doubleEquals ?
                     assumeTrue ? TypeFacts.EQUndefinedOrNull : TypeFacts.NEUndefinedOrNull :
-                    expr.right.kind === SyntaxKind.NullKeyword ?
+                    nullLike.kind === SyntaxKind.NullKeyword ?
                         assumeTrue ? TypeFacts.EQNull : TypeFacts.NENull :
                         assumeTrue ? TypeFacts.EQUndefined : TypeFacts.NEUndefined;
                 return getTypeWithFacts(type, facts);
@@ -7920,12 +7935,12 @@ namespace ts {
             function narrowTypeByTypeof(type: Type, expr: BinaryExpression, assumeTrue: boolean): Type {
                 // We have '==', '!=', '====', or !==' operator with 'typeof xxx' on the left
                 // and string literal on the right
-                const left = getReferenceFromExpression((<TypeOfExpression>expr.left).expression);
-                const right = <LiteralExpression>expr.right;
-                if (!isMatchingReference(reference, left)) {
+                const narrowed = getReferenceFromExpression((<TypeOfExpression>(expr.left.kind === SyntaxKind.TypeOfExpression ? expr.left : expr.right)).expression);
+                const literal = <LiteralExpression>(expr.right.kind === SyntaxKind.StringLiteral ? expr.right : expr.left);
+                if (!isMatchingReference(reference, narrowed)) {
                     // For a reference of the form 'x.y', a 'typeof x === ...' type guard resets the
                     // narrowed type of 'y' to its declared type.
-                    if (containsMatchingReference(reference, left)) {
+                    if (containsMatchingReference(reference, narrowed)) {
                         return declaredType;
                     }
                     return type;
@@ -7938,14 +7953,14 @@ namespace ts {
                     // We narrow a non-union type to an exact primitive type if the non-union type
                     // is a supertype of that primtive type. For example, type 'any' can be narrowed
                     // to one of the primitive types.
-                    const targetType = getProperty(typeofTypesByName, right.text);
+                    const targetType = getProperty(typeofTypesByName, literal.text);
                     if (targetType && isTypeSubtypeOf(targetType, type)) {
                         return targetType;
                     }
                 }
                 const facts = assumeTrue ?
-                    getProperty(typeofEQFacts, right.text) || TypeFacts.TypeofEQHostObject :
-                    getProperty(typeofNEFacts, right.text) || TypeFacts.TypeofNEHostObject;
+                    getProperty(typeofEQFacts, literal.text) || TypeFacts.TypeofEQHostObject :
+                    getProperty(typeofNEFacts, literal.text) || TypeFacts.TypeofNEHostObject;
                 return getTypeWithFacts(type, facts);
             }
 
@@ -8416,7 +8431,10 @@ namespace ts {
             if (needToCaptureLexicalThis) {
                 captureLexicalThis(node, container);
             }
-            if (isFunctionLike(container)) {
+            if (isFunctionLike(container) &&
+                (!isInParameterInitializerBeforeContainingFunction(node) || getFunctionLikeThisParameter(container))) {
+                // Note: a parameter initializer should refer to class-this unless function-this is explicitly annotated.
+
                 // If this is a function in a JS file, it might be a class method. Check if it's the RHS
                 // of a x.prototype.y = function [name]() { .... }
                 if (container.kind === SyntaxKind.FunctionExpression &&
@@ -11478,8 +11496,12 @@ namespace ts {
                     // When resolved signature is a call signature (and not a construct signature) the result type is any, unless
                     // the declaring function had members created through 'x.prototype.y = expr' or 'this.y = expr' psuedodeclarations
                     // in a JS file
-                    const funcSymbol = checkExpression(node.expression).symbol;
-                    if (funcSymbol && funcSymbol.members && (funcSymbol.flags & SymbolFlags.Function)) {
+                    // Note:JS inferred classes might come from a variable declaration instead of a function declaration.
+                    // In this case, using getResolvedSymbol directly is required to avoid losing the members from the declaration.
+                    const funcSymbol = node.expression.kind === SyntaxKind.Identifier ?
+                        getResolvedSymbol(node.expression as Identifier) :
+                        checkExpression(node.expression).symbol;
+                    if (funcSymbol && funcSymbol.members && (funcSymbol.flags & SymbolFlags.Function || isDeclarationOfFunctionExpression(funcSymbol))) {
                         return getInferredClassType(funcSymbol);
                     }
                     else if (compilerOptions.noImplicitAny) {
@@ -11503,7 +11525,10 @@ namespace ts {
 
         function checkAssertion(node: AssertionExpression) {
             const exprType = getRegularTypeOfObjectLiteral(checkExpression(node.expression));
+
+            checkSourceElement(node.type);
             const targetType = getTypeFromTypeNode(node.type);
+
             if (produceDiagnostics && targetType !== unknownType) {
                 const widenedType = getWidenedType(exprType);
                 if (!isTypeComparableTo(targetType, widenedType)) {
@@ -13538,9 +13563,6 @@ namespace ts {
                 }
             }
 
-            // when checking exported function declarations across modules check only duplicate implementations
-            // names and consistency of modifiers are verified when we check local symbol
-            const isExportSymbolInsideModule = symbol.parent && symbol.parent.flags & SymbolFlags.Module;
             let duplicateFunctionDeclaration = false;
             let multipleConstructorImplementation = false;
             for (const current of declarations) {
@@ -13573,7 +13595,7 @@ namespace ts {
                             duplicateFunctionDeclaration = true;
                         }
                     }
-                    else if (!isExportSymbolInsideModule && previousDeclaration && previousDeclaration.parent === node.parent && previousDeclaration.end !== node.pos) {
+                    else if (previousDeclaration && previousDeclaration.parent === node.parent && previousDeclaration.end !== node.pos) {
                         reportImplementationExpectedError(previousDeclaration);
                     }
 
@@ -13607,7 +13629,7 @@ namespace ts {
             }
 
             // Abstract methods can't have an implementation -- in particular, they don't need one.
-            if (!isExportSymbolInsideModule && lastSeenNonAmbientDeclaration && !lastSeenNonAmbientDeclaration.body &&
+            if (lastSeenNonAmbientDeclaration && !lastSeenNonAmbientDeclaration.body &&
                 !(lastSeenNonAmbientDeclaration.flags & NodeFlags.Abstract) && !lastSeenNonAmbientDeclaration.questionToken) {
                 reportImplementationExpectedError(lastSeenNonAmbientDeclaration);
             }
@@ -16049,7 +16071,7 @@ namespace ts {
                         // - augmentation for a global scope is always applied
                         // - augmentation for some external module is applied if symbol for augmentation is merged (it was combined with target module).
                         const checkBody = isGlobalAugmentation || (getSymbolOfNode(node).flags & SymbolFlags.Merged);
-                        if (checkBody) {
+                        if (checkBody && node.body) {
                             // body of ambient external module is always a module block
                             for (const statement of (<ModuleBlock>node.body).statements) {
                                 checkModuleAugmentationElement(statement, isGlobalAugmentation);
@@ -16076,7 +16098,15 @@ namespace ts {
                     }
                 }
             }
-            checkSourceElement(node.body);
+
+            if (compilerOptions.noImplicitAny && !node.body) {
+                // Ambient shorthand module is an implicit any
+                reportImplicitAnyError(node, anyType);
+            }
+
+            if (node.body) {
+                checkSourceElement(node.body);
+            }
         }
 
         function checkModuleAugmentationElement(node: Node, isGlobalAugmentation: boolean): void {
@@ -16261,7 +16291,7 @@ namespace ts {
                 else {
                     if (modulekind === ModuleKind.ES6 && !isInAmbientContext(node)) {
                         // Import equals declaration is deprecated in es6 or above
-                        grammarErrorOnNode(node, Diagnostics.Import_assignment_cannot_be_used_when_targeting_ECMAScript_6_modules_Consider_using_import_Asterisk_as_ns_from_mod_import_a_from_mod_import_d_from_mod_or_another_module_format_instead);
+                        grammarErrorOnNode(node, Diagnostics.Import_assignment_cannot_be_used_when_targeting_ECMAScript_2015_modules_Consider_using_import_Asterisk_as_ns_from_mod_import_a_from_mod_import_d_from_mod_or_another_module_format_instead);
                     }
                 }
             }
@@ -16347,7 +16377,7 @@ namespace ts {
             if (node.isExportEquals && !isInAmbientContext(node)) {
                 if (modulekind === ModuleKind.ES6) {
                     // export assignment is not supported in es6 modules
-                    grammarErrorOnNode(node, Diagnostics.Export_assignment_cannot_be_used_when_targeting_ECMAScript_6_modules_Consider_using_export_default_or_another_module_format_instead);
+                    grammarErrorOnNode(node, Diagnostics.Export_assignment_cannot_be_used_when_targeting_ECMAScript_2015_modules_Consider_using_export_default_or_another_module_format_instead);
                 }
                 else if (modulekind === ModuleKind.System) {
                     // system modules does not support export assignment
@@ -17794,6 +17824,8 @@ namespace ts {
                 case SyntaxKind.ImportEqualsDeclaration:
                 case SyntaxKind.ExportDeclaration:
                 case SyntaxKind.ExportAssignment:
+                case SyntaxKind.FunctionExpression:
+                case SyntaxKind.ArrowFunction:
                 case SyntaxKind.Parameter:
                     break;
                 case SyntaxKind.FunctionDeclaration:
@@ -18025,7 +18057,7 @@ namespace ts {
 
         function checkGrammarAsyncModifier(node: Node, asyncModifier: Node): boolean {
             if (languageVersion < ScriptTarget.ES6) {
-                return grammarErrorOnNode(asyncModifier, Diagnostics.Async_functions_are_only_available_when_targeting_ECMAScript_6_and_higher);
+                return grammarErrorOnNode(asyncModifier, Diagnostics.Async_functions_are_only_available_when_targeting_ECMAScript_2015_or_higher);
             }
 
             switch (node.kind) {
@@ -18283,7 +18315,7 @@ namespace ts {
                     return grammarErrorOnNode(node.asteriskToken, Diagnostics.An_overload_signature_cannot_be_declared_as_a_generator);
                 }
                 if (languageVersion < ScriptTarget.ES6) {
-                    return grammarErrorOnNode(node.asteriskToken, Diagnostics.Generators_are_only_available_when_targeting_ECMAScript_6_or_higher);
+                    return grammarErrorOnNode(node.asteriskToken, Diagnostics.Generators_are_only_available_when_targeting_ECMAScript_2015_or_higher);
                 }
             }
         }
@@ -18505,6 +18537,14 @@ namespace ts {
             }
         }
 
+        function getFunctionLikeThisParameter(func: FunctionLikeDeclaration) {
+            if (func.parameters.length &&
+                func.parameters[0].name.kind === SyntaxKind.Identifier &&
+                (<Identifier>func.parameters[0].name).originalKeywordKind === SyntaxKind.ThisKeyword) {
+                return func.parameters[0];
+            }
+        }
+
         function checkGrammarForNonSymbolComputedProperty(node: DeclarationName, message: DiagnosticMessage) {
             if (isDynamicName(node)) {
                 return grammarErrorOnNode(node, message);

src/compiler/commandLineParser.ts

@@ -337,8 +337,13 @@ namespace ts {
             }
         },
         {
-            name: "typesRoot",
-            type: "string"
+            name: "typeRoots",
+            type: "list",
+            element: {
+                name: "typeRoots",
+                type: "string",
+                isFilePath: true
+            }
         },
         {
             name: "types",
@@ -492,13 +497,20 @@ namespace ts {
     }
 
     /* @internal */
-    export function parseListTypeOption(opt: CommandLineOptionOfListType, value: string, errors: Diagnostic[]): (string | number)[] {
-        const values = trimString((value || "")).split(",");
+    export function parseListTypeOption(opt: CommandLineOptionOfListType, value = "", errors: Diagnostic[]): (string | number)[] | undefined {
+        value = trimString(value);
+        if (startsWith(value, "-")) {
+            return undefined;
+        }
+        if (value === "") {
+            return [];
+        }
+        const values = value.split(",");
         switch (opt.element.type) {
             case "number":
-                return ts.map(values, parseInt);
+                return map(values, parseInt);
             case "string":
-                return ts.map(values, v => v || "");
+                return map(values, v => v || "");
             default:
                 return filter(map(values, v => parseCustomTypeOption(<CommandLineOptionOfCustomType>opt.element, v, errors)), v => !!v);
         }
@@ -559,8 +571,11 @@ namespace ts {
                                     i++;
                                     break;
                                 case "list":
-                                    options[opt.name] = parseListTypeOption(<CommandLineOptionOfListType>opt, args[i], errors);
-                                    i++;
+                                    const result = parseListTypeOption(<CommandLineOptionOfListType>opt, args[i], errors);
+                                    options[opt.name] = result || [];
+                                    if (result) {
+                                        i++;
+                                    }
                                     break;
                                 // If not a primitive, the possible types are specified in what is effectively a map of options.
                                 default:

src/compiler/declarationEmitter.ts

@@ -853,21 +853,26 @@ namespace ts {
                     writeTextOfNode(currentText, node.name);
                 }
             }
-            while (node.body.kind !== SyntaxKind.ModuleBlock) {
+            while (node.body && node.body.kind !== SyntaxKind.ModuleBlock) {
                 node = <ModuleDeclaration>node.body;
                 write(".");
                 writeTextOfNode(currentText, node.name);
             }
             const prevEnclosingDeclaration = enclosingDeclaration;
-            enclosingDeclaration = node;
-            write(" {");
-            writeLine();
-            increaseIndent();
-            emitLines((<ModuleBlock>node.body).statements);
-            decreaseIndent();
-            write("}");
-            writeLine();
-            enclosingDeclaration = prevEnclosingDeclaration;
+            if (node.body) {
+                enclosingDeclaration = node;
+                write(" {");
+                writeLine();
+                increaseIndent();
+                emitLines((<ModuleBlock>node.body).statements);
+                decreaseIndent();
+                write("}");
+                writeLine();
+                enclosingDeclaration = prevEnclosingDeclaration;
+            }
+            else {
+                write(";");
+            }
         }
 
         function writeTypeAliasDeclaration(node: TypeAliasDeclaration) {

src/compiler/diagnosticMessages.json

@@ -627,18 +627,14 @@
         "category": "Error",
         "code": 1200
     },
-    "Import assignment cannot be used when targeting ECMAScript 6 modules. Consider using 'import * as ns from \"mod\"', 'import {a} from \"mod\"', 'import d from \"mod\"', or another module format instead.": {
+    "Import assignment cannot be used when targeting ECMAScript 2015 modules. Consider using 'import * as ns from \"mod\"', 'import {a} from \"mod\"', 'import d from \"mod\"', or another module format instead.": {
         "category": "Error",
         "code": 1202
     },
-    "Export assignment cannot be used when targeting ECMAScript 6 modules. Consider using 'export default' or another module format instead.": {
+    "Export assignment cannot be used when targeting ECMAScript 2015 modules. Consider using 'export default' or another module format instead.": {
         "category": "Error",
         "code": 1203
     },
-    "Cannot compile modules into 'es2015' when targeting 'ES5' or lower.": {
-        "category": "Error",
-        "code": 1204
-    },
     "Decorators are not valid here.": {
         "category": "Error",
         "code": 1206
@@ -687,7 +683,7 @@
         "category": "Error",
         "code": 1219
     },
-    "Generators are only available when targeting ECMAScript 6 or higher.": {
+    "Generators are only available when targeting ECMAScript 2015 or higher.": {
         "category": "Error",
         "code": 1220
     },
@@ -831,7 +827,7 @@
         "category": "Error",
         "code": 1308
     },
-    "Async functions are only available when targeting ECMAScript 6 and higher.": {
+    "Async functions are only available when targeting ECMAScript 2015 or higher.": {
         "category": "Error",
         "code": 1311
     },
@@ -1935,6 +1931,10 @@
         "category": "Error",
         "code": 2687
     },
+    "Cannot find type definition file for '{0}'.": {
+        "category": "Error",
+        "code": 2688
+    },
     "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",
         "code": 4000
@@ -2260,7 +2260,7 @@
         "category": "Error",
         "code": 5047
     },
-    "Option 'inlineSources' can only be used when either option '--inlineSourceMap' or option '--sourceMap' is provided.": {
+    "Option '{0} can only be used when either option '--inlineSourceMap' or option '--sourceMap' is provided.": {
         "category": "Error",
         "code": 5051
     },
@@ -2921,10 +2921,6 @@
         "category": "Error",
         "code": 8012
     },
-    "'property declarations' can only be used in a .ts file.": {
-        "category": "Error",
-        "code": 8014
-    },
     "'enum declarations' can only be used in a .ts file.": {
         "category": "Error",
         "code": 8015

src/compiler/emitter.ts

@@ -2150,9 +2150,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             }
 
             // Return true if identifier resolves to an exported member of a namespace
-            function isNamespaceExportReference(node: Identifier) {
+            function isExportReference(node: Identifier) {
                 const container = resolver.getReferencedExportContainer(node);
-                return container && container.kind !== SyntaxKind.SourceFile;
+                return !!container;
             }
 
             // Return true if identifier resolves to an imported identifier
@@ -2185,10 +2185,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 //   const foo_1 = require('./foo');
                 //   exports.baz = { foo: foo_1.foo };
                 //
-                if (languageVersion < ScriptTarget.ES6 || (modulekind !== ModuleKind.ES6 && isImportedReference(node.name)) || isNamespaceExportReference(node.name) ) {
+                if (languageVersion < ScriptTarget.ES6 || (modulekind !== ModuleKind.ES6 && isImportedReference(node.name)) || isExportReference(node.name)) {
                     // Emit identifier as an identifier
                     write(": ");
-                    emit(node.name);
+                    emitExpressionIdentifier(node.name);
                 }
 
                 if (languageVersion >= ScriptTarget.ES6 && node.objectAssignmentInitializer) {
@@ -5613,7 +5613,11 @@ const _super = (function (geti, seti) {
             }
 
             function emitClassLikeDeclarationBelowES6(node: ClassLikeDeclaration) {
+                const isES6ExportedClass = isES6ExportedDeclaration(node);
                 if (node.kind === SyntaxKind.ClassDeclaration) {
+                    if (isES6ExportedClass && !(node.flags & NodeFlags.Default)) {
+                        write("export ");
+                    }
                     // source file level classes in system modules are hoisted so 'var's for them are already defined
                     if (!shouldHoistDeclarationInSystemJsModule(node)) {
                         write("var ");
@@ -5683,9 +5687,15 @@ const _super = (function (geti, seti) {
                 }
                 emitEnd(node);
 
-                if (node.kind === SyntaxKind.ClassDeclaration) {
+                if (node.kind === SyntaxKind.ClassDeclaration && !isES6ExportedClass) {
                     emitExportMemberAssignment(<ClassDeclaration>node);
                 }
+                else if (isES6ExportedClass && (node.flags & NodeFlags.Default)) {
+                    writeLine();
+                    write("export default ");
+                    emitDeclarationName(node);
+                    write(";");
+                }
             }
 
             function emitClassMemberPrefix(node: ClassLikeDeclaration, member: Node) {
@@ -6123,10 +6133,10 @@ const _super = (function (geti, seti) {
 
                                 if (parameters[i].dotDotDotToken) {
                                     let parameterType = parameters[i].type;
-                                    if (parameterType.kind === SyntaxKind.ArrayType) {
+                                    if (parameterType && parameterType.kind === SyntaxKind.ArrayType) {
                                         parameterType = (<ArrayTypeNode>parameterType).elementType;
                                     }
-                                    else if (parameterType.kind === SyntaxKind.TypeReference && (<TypeReferenceNode>parameterType).typeArguments && (<TypeReferenceNode>parameterType).typeArguments.length === 1) {
+                                    else if (parameterType && parameterType.kind === SyntaxKind.TypeReference && (<TypeReferenceNode>parameterType).typeArguments && (<TypeReferenceNode>parameterType).typeArguments.length === 1) {
                                         parameterType = (<TypeReferenceNode>parameterType).typeArguments[0];
                                     }
                                     else {
@@ -6146,9 +6156,15 @@ const _super = (function (geti, seti) {
 
             /** Serializes the return type of function. Used by the __metadata decorator for a method. */
             function emitSerializedReturnTypeOfNode(node: Node) {
-                if (node && isFunctionLike(node) && (<FunctionLikeDeclaration>node).type) {
-                    emitSerializedTypeNode((<FunctionLikeDeclaration>node).type);
-                    return;
+                if (node && isFunctionLike(node)) {
+                    if ((<FunctionLikeDeclaration>node).type) {
+                        emitSerializedTypeNode((<FunctionLikeDeclaration>node).type);
+                        return;
+                    }
+                    else if (isAsyncFunctionLike(<FunctionLikeDeclaration>node)) {
+                        write("Promise");
+                        return;
+                    }
                 }
 
                 write("void 0");
@@ -6300,7 +6316,7 @@ const _super = (function (geti, seti) {
             }
 
             function getInnerMostModuleDeclarationFromDottedModule(moduleDeclaration: ModuleDeclaration): ModuleDeclaration {
-                if (moduleDeclaration.body.kind === SyntaxKind.ModuleDeclaration) {
+                if (moduleDeclaration.body && moduleDeclaration.body.kind === SyntaxKind.ModuleDeclaration) {
                     const recursiveInnerModule = getInnerMostModuleDeclarationFromDottedModule(<ModuleDeclaration>moduleDeclaration.body);
                     return recursiveInnerModule || <ModuleDeclaration>moduleDeclaration.body;
                 }
@@ -6349,6 +6365,7 @@ const _super = (function (geti, seti) {
                 write(getGeneratedNameForNode(node));
                 emitEnd(node.name);
                 write(") ");
+                Debug.assert(node.body !== undefined); // node.body must exist, as this is a non-ambient module
                 if (node.body.kind === SyntaxKind.ModuleBlock) {
                     const saveConvertedLoopState = convertedLoopState;
                     const saveTempFlags = tempFlags;

src/compiler/parser.ts

@@ -5337,7 +5337,14 @@ namespace ts {
             else {
                 node.name = parseLiteralNode(/*internName*/ true);
             }
-            node.body = parseModuleBlock();
+
+            if (token === SyntaxKind.OpenBraceToken) {
+                node.body = parseModuleBlock();
+            }
+            else {
+                parseSemicolon();
+            }
+
             return finishNode(node);
         }
 

src/compiler/program.ts

@@ -8,17 +8,13 @@ namespace ts {
     /* @internal */ export let ioReadTime = 0;
     /* @internal */ export let ioWriteTime = 0;
 
-    const emptyArray: any[] = [];
-
-    const defaultLibrarySearchPaths = [
-        "types/",
-        "node_modules/",
-        "node_modules/@types/",
-    ];
-
     /** The version of the TypeScript compiler release */
     export const version = "1.9.0";
 
+    const emptyArray: any[] = [];
+
+    const defaultTypeRoots = ["node_modules/@types"];
+
     export function findConfigFile(searchPath: string, fileExists: (fileName: string) => boolean): string {
         while (true) {
             const fileName = combinePaths(searchPath, "tsconfig.json");
@@ -182,6 +178,11 @@ namespace ts {
 
     const typeReferenceExtensions = [".d.ts"];
 
+    function getEffectiveTypeRoots(options: CompilerOptions, host: ModuleResolutionHost) {
+        return options.typeRoots ||
+            defaultTypeRoots.map(d => combinePaths(options.configFilePath ? getDirectoryPath(options.configFilePath) : host.getCurrentDirectory(), d));
+    }
+
     /**
      * @param {string | undefined} containingFile - file that contains type reference directive, can be undefined if containing file is unknown.
      * This is possible in case if resolution is performed for directives specified via 'types' parameter. In this case initial path for secondary lookups
@@ -196,24 +197,22 @@ namespace ts {
             traceEnabled
         };
 
-        // use typesRoot and fallback to directory that contains tsconfig or current directory if typesRoot is not set
-        const rootDir = options.typesRoot || (options.configFilePath ? getDirectoryPath(options.configFilePath) : (host.getCurrentDirectory && host.getCurrentDirectory()));
-
+        const typeRoots = getEffectiveTypeRoots(options, host);
         if (traceEnabled) {
             if (containingFile === undefined) {
-                if (rootDir === undefined) {
+                if (typeRoots === undefined) {
                     trace(host, Diagnostics.Resolving_type_reference_directive_0_containing_file_not_set_root_directory_not_set, typeReferenceDirectiveName);
                 }
                 else {
-                    trace(host, Diagnostics.Resolving_type_reference_directive_0_containing_file_not_set_root_directory_1, typeReferenceDirectiveName, rootDir);
+                    trace(host, Diagnostics.Resolving_type_reference_directive_0_containing_file_not_set_root_directory_1, typeReferenceDirectiveName, typeRoots);
                 }
             }
             else {
-                if (rootDir === undefined) {
+                if (typeRoots === undefined) {
                     trace(host, Diagnostics.Resolving_type_reference_directive_0_containing_file_1_root_directory_not_set, typeReferenceDirectiveName, containingFile);
                 }
                 else {
-                    trace(host, Diagnostics.Resolving_type_reference_directive_0_containing_file_1_root_directory_2, typeReferenceDirectiveName, containingFile, rootDir);
+                    trace(host, Diagnostics.Resolving_type_reference_directive_0_containing_file_1_root_directory_2, typeReferenceDirectiveName, containingFile, typeRoots);
                 }
             }
         }
@@ -221,14 +220,13 @@ namespace ts {
         const failedLookupLocations: string[] = [];
 
         // Check primary library paths
-        if (rootDir !== undefined) {
-            const effectivePrimarySearchPaths = options.typesSearchPaths || defaultLibrarySearchPaths;
-            for (const searchPath of effectivePrimarySearchPaths) {
-                const primaryPath = combinePaths(rootDir, searchPath);
-                if (traceEnabled) {
-                    trace(host, Diagnostics.Resolving_with_primary_search_path_0, primaryPath);
-                }
-                const candidate = combinePaths(primaryPath, typeReferenceDirectiveName);
+        if (typeRoots.length) {
+            if (traceEnabled) {
+                trace(host, Diagnostics.Resolving_with_primary_search_path_0, typeRoots.join(", "));
+            }
+            const primarySearchPaths = typeRoots;
+            for (const typeRoot of primarySearchPaths) {
+                const candidate = combinePaths(typeRoot, typeReferenceDirectiveName);
                 const candidateDirectory = getDirectoryPath(candidate);
                 const resolvedFile = loadNodeModuleFromDirectory(typeReferenceExtensions, candidate, failedLookupLocations,
                     !directoryProbablyExists(candidateDirectory, host), moduleResolutionState);
@@ -255,9 +253,6 @@ namespace ts {
         if (containingFile) {
             initialLocationForSecondaryLookup = getDirectoryPath(containingFile);
         }
-        else {
-            initialLocationForSecondaryLookup = rootDir;
-        }
 
         if (initialLocationForSecondaryLookup !== undefined) {
             // check secondary locations
@@ -936,19 +931,6 @@ namespace ts {
             }
         }
 
-        function getDefaultTypeDirectiveNames(rootPath: string): string[] {
-            const localTypes = combinePaths(rootPath, "types");
-            const npmTypes = combinePaths(rootPath, "node_modules/@types");
-            let result: string[] = [];
-            if (sys.directoryExists(localTypes)) {
-                result = result.concat(sys.getDirectories(localTypes));
-            }
-            if (sys.directoryExists(npmTypes)) {
-                result = result.concat(sys.getDirectories(npmTypes));
-            }
-            return result;
-        }
-
         function getDefaultLibLocation(): string {
             return getDirectoryPath(normalizePath(sys.getExecutingFilePath()));
         }
@@ -957,7 +939,6 @@ namespace ts {
         const realpath = sys.realpath && ((path: string) => sys.realpath(path));
 
         return {
-            getDefaultTypeDirectiveNames,
             getSourceFile,
             getDefaultLibLocation,
             getDefaultLibFileName: options => combinePaths(getDefaultLibLocation(), getDefaultLibFileName(options)),
@@ -970,6 +951,7 @@ namespace ts {
             readFile: fileName => sys.readFile(fileName),
             trace: (s: string) => sys.write(s + newLine),
             directoryExists: directoryName => sys.directoryExists(directoryName),
+            getDirectories: (path: string) => sys.getDirectories(path),
             realpath
         };
     }
@@ -1033,21 +1015,35 @@ namespace ts {
         return resolutions;
     }
 
-    export function getDefaultTypeDirectiveNames(options: CompilerOptions, rootFiles: string[], host: CompilerHost): string[] {
+    function getInferredTypesRoot(options: CompilerOptions, rootFiles: string[], host: CompilerHost) {
+        return computeCommonSourceDirectoryOfFilenames(rootFiles, host.getCurrentDirectory(), f => host.getCanonicalFileName(f));
+    }
+
+    /**
+      * Given a set of options and a set of root files, returns the set of type directive names
+      *   that should be included for this program automatically.
+      * This list could either come from the config file,
+      *   or from enumerating the types root + initial secondary types lookup location.
+      * More type directives might appear in the program later as a result of loading actual source files;
+      *   this list is only the set of defaults that are implicitly included.
+      */
+    export function getAutomaticTypeDirectiveNames(options: CompilerOptions, rootFiles: string[], host: CompilerHost): string[] {
         // Use explicit type list from tsconfig.json
         if (options.types) {
             return options.types;
         }
 
-        // or load all types from the automatic type import fields
-        if (host && host.getDefaultTypeDirectiveNames) {
-            const commonRoot = computeCommonSourceDirectoryOfFilenames(rootFiles, host.getCurrentDirectory(), f => host.getCanonicalFileName(f));
-            if (commonRoot) {
-                return host.getDefaultTypeDirectiveNames(commonRoot);
+        // Walk the primary type lookup locations
+        let result: string[] = [];
+        if (host.directoryExists && host.getDirectories) {
+            const typeRoots = getEffectiveTypeRoots(options, host);
+            for (const root of typeRoots) {
+                if (host.directoryExists(root)) {
+                    result = result.concat(host.getDirectories(root));
+                }
             }
         }
-
-        return undefined;
+        return result;
     }
 
     export function createProgram(rootNames: string[], options: CompilerOptions, host?: CompilerHost, oldProgram?: Program): Program {
@@ -1099,11 +1095,13 @@ namespace ts {
         if (!tryReuseStructureFromOldProgram()) {
             forEach(rootNames, name => processRootFile(name, /*isDefaultLib*/ false));
 
-            // load type declarations specified via 'types' argument
-            const typeReferences: string[] = getDefaultTypeDirectiveNames(options, rootNames, host);
+            // load type declarations specified via 'types' argument or implicitly from types/ and node_modules/@types folders
+            const typeReferences: string[] = getAutomaticTypeDirectiveNames(options, rootNames, host);
 
             if (typeReferences) {
-                const resolutions = resolveTypeReferenceDirectiveNamesWorker(typeReferences, /*containingFile*/ undefined);
+                const inferredRoot = getInferredTypesRoot(options, rootNames, host);
+                const containingFilename = combinePaths(inferredRoot, "__inferred type names__.ts");
+                const resolutions = resolveTypeReferenceDirectiveNamesWorker(typeReferences, containingFilename);
                 for (let i = 0; i < typeReferences.length; i++) {
                     processTypeReferenceDirective(typeReferences[i], resolutions[i]);
                 }
@@ -1211,10 +1209,9 @@ namespace ts {
                 (oldOptions.jsx !== options.jsx) ||
                 (oldOptions.allowJs !== options.allowJs) ||
                 (oldOptions.rootDir !== options.rootDir) ||
-                (oldOptions.typesSearchPaths !== options.typesSearchPaths) ||
                 (oldOptions.configFilePath !== options.configFilePath) ||
                 (oldOptions.baseUrl !== options.baseUrl) ||
-                (oldOptions.typesRoot !== options.typesRoot) ||
+                !arrayIsEqualTo(oldOptions.typeRoots, oldOptions.typeRoots) ||
                 !arrayIsEqualTo(oldOptions.rootDirs, options.rootDirs) ||
                 !mapIsEqualTo(oldOptions.paths, options.paths)) {
                 return false;
@@ -1604,8 +1601,19 @@ namespace ts {
                             }
                             break;
                         case SyntaxKind.PropertyDeclaration:
-                            diagnostics.push(createDiagnosticForNode(node, Diagnostics.property_declarations_can_only_be_used_in_a_ts_file));
-                            return true;
+                            const propertyDeclaration = <PropertyDeclaration>node;
+                            if (propertyDeclaration.modifiers) {
+                                for (const modifier of propertyDeclaration.modifiers) {
+                                    if (modifier.kind !== SyntaxKind.StaticKeyword) {
+                                        diagnostics.push(createDiagnosticForNode(modifier, Diagnostics._0_can_only_be_used_in_a_ts_file, tokenToString(modifier.kind)));
+                                        return true;
+                                    }
+                                }
+                            }
+                            if (checkTypeAnnotation((<PropertyDeclaration>node).type)) {
+                                return true;
+                            }
+                            break;
                         case SyntaxKind.EnumDeclaration:
                             diagnostics.push(createDiagnosticForNode(node, Diagnostics.enum_declarations_can_only_be_used_in_a_ts_file));
                             return true;
@@ -1774,9 +1782,12 @@ namespace ts {
                                 // The StringLiteral must specify a top - level external module name.
                                 // Relative external module names are not permitted
 
-                                // NOTE: body of ambient module is always a module block
-                                for (const statement of (<ModuleBlock>(<ModuleDeclaration>node).body).statements) {
-                                    collectModuleReferences(statement, /*inAmbientModule*/ true);
+                                // NOTE: body of ambient module is always a module block, if it exists
+                                const body = <ModuleBlock>(<ModuleDeclaration>node).body;
+                                if (body) {
+                                    for (const statement of body.statements) {
+                                        collectModuleReferences(statement, /*inAmbientModule*/ true);
+                                    }
                                 }
                             }
                         }
@@ -1966,7 +1977,7 @@ namespace ts {
                 }
             }
             else {
-                fileProcessingDiagnostics.add(createDiagnostic(refFile, refPos, refEnd, Diagnostics.Cannot_find_name_0, typeReferenceDirective));
+                fileProcessingDiagnostics.add(createDiagnostic(refFile, refPos, refEnd, Diagnostics.Cannot_find_type_definition_file_for_0, typeReferenceDirective));
             }
 
             if (saveResolution) {
@@ -2104,12 +2115,12 @@ namespace ts {
                 }
             }
 
-            if (options.inlineSources) {
-                if (!options.sourceMap && !options.inlineSourceMap) {
-                    programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Option_inlineSources_can_only_be_used_when_either_option_inlineSourceMap_or_option_sourceMap_is_provided));
+            if (!options.sourceMap && !options.inlineSourceMap) {
+                if (options.inlineSources) {
+                    programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Option_0_can_only_be_used_when_either_option_inlineSourceMap_or_option_sourceMap_is_provided, "inlineSources"));
                 }
                 if (options.sourceRoot) {
-                    programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Option_0_cannot_be_specified_with_option_1, "sourceRoot", "inlineSources"));
+                    programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Option_0_can_only_be_used_when_either_option_inlineSourceMap_or_option_sourceMap_is_provided, "sourceRoot"));
                 }
             }
 
@@ -2117,14 +2128,9 @@ namespace ts {
                 programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Option_0_cannot_be_specified_with_option_1, "out", "outFile"));
             }
 
-            if (!options.sourceMap && (options.mapRoot || options.sourceRoot)) {
-                // Error to specify --mapRoot or --sourceRoot without mapSourceFiles
-                if (options.mapRoot) {
-                    programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "mapRoot", "sourceMap"));
-                }
-                if (options.sourceRoot && !options.inlineSourceMap) {
-                    programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "sourceRoot", "sourceMap"));
-                }
+            if (options.mapRoot && !options.sourceMap) {
+                // Error to specify --mapRoot without --sourcemap
+                programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "mapRoot", "sourceMap"));
             }
 
             if (options.declarationDir) {
@@ -2161,11 +2167,6 @@ namespace ts {
                 programDiagnostics.add(createFileDiagnostic(firstExternalModuleSourceFile, span.start, span.length, Diagnostics.Cannot_use_imports_exports_or_module_augmentations_when_module_is_none));
             }
 
-            // Cannot specify module gen target of es6 when below es6
-            if (options.module === ModuleKind.ES6 && languageVersion < ScriptTarget.ES6) {
-                programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Cannot_compile_modules_into_es2015_when_targeting_ES5_or_lower));
-            }
-
             // Cannot specify module gen that isn't amd or system with --out
             if (outFile) {
                 if (options.module && !(options.module === ModuleKind.AMD || options.module === ModuleKind.System)) {

src/compiler/types.ts

@@ -1301,7 +1301,7 @@ namespace ts {
     // @kind(SyntaxKind.ModuleDeclaration)
     export interface ModuleDeclaration extends DeclarationStatement {
         name: Identifier | LiteralExpression;
-        body: ModuleBlock | ModuleDeclaration;
+        body?: ModuleBlock | ModuleDeclaration;
     }
 
     // @kind(SyntaxKind.ModuleBlock)
@@ -2224,7 +2224,8 @@ namespace ts {
 
         /* @internal */
         Nullable = Undefined | Null,
-        Falsy = String | Number | Boolean | Void | Undefined | Null,
+        /* @internal */
+        Falsy = Void | Undefined | Null,       // TODO: Add false, 0, and ""
         /* @internal */
         Intrinsic = Any | String | Number | Boolean | ESSymbol | Void | Undefined | Null | Never,
         /* @internal */
@@ -2563,7 +2564,8 @@ namespace ts {
         traceResolution?: boolean;
         disableSizeLimit?: boolean;
         types?: string[];
-        /* @internal */ typesRoot?: string;
+        /** Paths used to used to compute primary types search locations */
+        typeRoots?: string[];
         typesSearchPaths?: string[];
         /*@internal*/ version?: boolean;
         /*@internal*/ watch?: boolean;
@@ -2872,6 +2874,7 @@ namespace ts {
         getDefaultTypeDirectiveNames?(rootPath: string): string[];
         writeFile: WriteFileCallback;
         getCurrentDirectory(): string;
+        getDirectories(path: string): string[];
         getCanonicalFileName(fileName: string): string;
         useCaseSensitiveFileNames(): boolean;
         getNewLine(): string;

src/compiler/utilities.ts

@@ -372,6 +372,11 @@ namespace ts {
             ((<ModuleDeclaration>node).name.kind === SyntaxKind.StringLiteral || isGlobalScopeAugmentation(<ModuleDeclaration>node));
     }
 
+    export function isShorthandAmbientModule(node: Node): boolean {
+        // The only kind of module that can be missing a body is a shorthand ambient module.
+        return node.kind === SyntaxKind.ModuleDeclaration && (!(<ModuleDeclaration>node).body);
+    }
+
     export function isBlockScopedContainerTopLevel(node: Node): boolean {
         return node.kind === SyntaxKind.SourceFile ||
             node.kind === SyntaxKind.ModuleDeclaration ||
@@ -825,6 +830,8 @@ namespace ts {
             case SyntaxKind.ConstructorType:
                 return true;
         }
+
+        return false;
     }
 
     export function introducesArgumentsExoticObject(node: Node) {
@@ -1257,6 +1264,18 @@ namespace ts {
         return charCode === CharacterCodes.singleQuote || charCode === CharacterCodes.doubleQuote;
     }
 
+    /**
+     * Returns true if the node is a variable declaration whose initializer is a function expression.
+     * This function does not test if the node is in a JavaScript file or not.
+     */
+    export function isDeclarationOfFunctionExpression(s: Symbol) {
+        if (s.valueDeclaration && s.valueDeclaration.kind === SyntaxKind.VariableDeclaration) {
+            const declaration = s.valueDeclaration as VariableDeclaration;
+            return declaration.initializer && declaration.initializer.kind === SyntaxKind.FunctionExpression;
+        }
+        return false;
+    }
+
     /// Given a BinaryExpression, returns SpecialPropertyAssignmentKind for the various kinds of property
     /// assignments we treat as special in the binder
     export function getSpecialPropertyAssignmentKind(expression: Node): SpecialPropertyAssignmentKind {

src/harness/fourslash.ts

@@ -246,8 +246,8 @@ namespace FourSlash {
             // Create a new Services Adapter
             this.cancellationToken = new TestCancellationToken();
             const compilationOptions = convertGlobalOptionsToCompilerOptions(this.testData.globalOptions);
-            if (compilationOptions.typesRoot) {
-                compilationOptions.typesRoot = ts.getNormalizedAbsolutePath(compilationOptions.typesRoot, this.basePath);
+            if (compilationOptions.typeRoots) {
+                compilationOptions.typeRoots = compilationOptions.typeRoots.map(p => ts.getNormalizedAbsolutePath(p, this.basePath));
             }
 
             const languageServiceAdapter = this.getLanguageServiceAdapter(testType, this.cancellationToken, compilationOptions);
@@ -717,6 +717,8 @@ namespace FourSlash {
         public verifyCompletionEntryDetails(entryName: string, expectedText: string, expectedDocumentation?: string, kind?: string) {
             const details = this.getCompletionEntryDetails(entryName);
 
+            assert(details, "no completion entry available");
+
             assert.equal(ts.displayPartsToString(details.displayParts), expectedText, this.assertionMessageAtLastKnownMarker("completion entry details text"));
 
             if (expectedDocumentation !== undefined) {
@@ -728,27 +730,6 @@ namespace FourSlash {
             }
         }
 
-        public verifyReferencesAtPositionListContains(fileName: string, start: number, end: number, isWriteAccess?: boolean) {
-            const references = this.getReferencesAtCaret();
-
-            if (!references || references.length === 0) {
-                this.raiseError("verifyReferencesAtPositionListContains failed - found 0 references, expected at least one.");
-            }
-
-            for (let i = 0; i < references.length; i++) {
-                const reference = references[i];
-                if (reference && reference.fileName === fileName && reference.textSpan.start === start && ts.textSpanEnd(reference.textSpan) === end) {
-                    if (typeof isWriteAccess !== "undefined" && reference.isWriteAccess !== isWriteAccess) {
-                        this.raiseError(`verifyReferencesAtPositionListContains failed - item isWriteAccess value does not match, actual: ${reference.isWriteAccess}, expected: ${isWriteAccess}.`);
-                    }
-                    return;
-                }
-            }
-
-            const missingItem = { fileName: fileName, start: start, end: end, isWriteAccess: isWriteAccess };
-            this.raiseError(`verifyReferencesAtPositionListContains failed - could not find the item: ${stringify(missingItem)} in the returned list: (${stringify(references)})`);
-        }
-
         public verifyReferencesCountIs(count: number, localFilesOnly = true) {
             const references = this.getReferencesAtCaret();
             let referencesCount = 0;
@@ -772,6 +753,73 @@ namespace FourSlash {
             }
         }
 
+        public verifyReferencesAre(expectedReferences: Range[]) {
+            const actualReferences = this.getReferencesAtCaret() || [];
+
+            if (actualReferences.length > expectedReferences.length) {
+                // Find the unaccounted-for reference.
+                for (const actual of actualReferences) {
+                    if (!ts.forEach(expectedReferences, r => r.start === actual.textSpan.start)) {
+                        this.raiseError(`A reference ${actual} is unaccounted for.`);
+                    }
+                }
+                // Probably will never reach here.
+                this.raiseError(`There are ${actualReferences.length} references but only ${expectedReferences.length} were expected.`);
+            }
+
+            for (const reference of expectedReferences) {
+                const {fileName, start, end} = reference;
+                if (reference.marker) {
+                    const {isWriteAccess, isDefinition} = reference.marker.data;
+                    this.verifyReferencesWorker(actualReferences, fileName, start, end, isWriteAccess, isDefinition);
+                }
+                else {
+                    this.verifyReferencesWorker(actualReferences, fileName, start, end);
+                }
+            }
+        }
+
+        public verifyReferencesOf({fileName, start}: Range, references: Range[]) {
+            this.openFile(fileName);
+            this.goToPosition(start);
+            this.verifyReferencesAre(references);
+        }
+
+        public verifyRangesReferenceEachOther(ranges?: Range[]) {
+            ranges = ranges || this.getRanges();
+            assert(ranges.length);
+            for (const range of ranges) {
+                this.verifyReferencesOf(range, ranges);
+            }
+        }
+
+        public verifyReferencesAtPositionListContains(fileName: string, start: number, end: number, isWriteAccess?: boolean, isDefinition?: boolean) {
+            const references = this.getReferencesAtCaret();
+            if (!references || references.length === 0) {
+                this.raiseError("verifyReferencesAtPositionListContains failed - found 0 references, expected at least one.");
+            }
+            this.verifyReferencesWorker(references, fileName, start, end, isWriteAccess, isDefinition);
+        }
+
+        private verifyReferencesWorker(references: ts.ReferenceEntry[], fileName: string, start: number, end: number, isWriteAccess?: boolean, isDefinition?: boolean) {
+            for (let i = 0; i < references.length; i++) {
+                const reference = references[i];
+                if (reference && reference.fileName === fileName && reference.textSpan.start === start && ts.textSpanEnd(reference.textSpan) === end) {
+                    if (typeof isWriteAccess !== "undefined" && reference.isWriteAccess !== isWriteAccess) {
+                        this.raiseError(`verifyReferencesAtPositionListContains failed - item isWriteAccess value does not match, actual: ${reference.isWriteAccess}, expected: ${isWriteAccess}.`);
+                    }
+                    if (typeof isDefinition !== "undefined" && reference.isDefinition !== isDefinition) {
+                        this.raiseError(`verifyReferencesAtPositionListContains failed - item isDefinition value does not match, actual: ${reference.isDefinition}, expected: ${isDefinition}.`);
+                    }
+                    return;
+                }
+            }
+
+            const missingItem = { fileName, start, end, isWriteAccess, isDefinition };
+            this.raiseError(`verifyReferencesAtPositionListContains failed - could not find the item: ${stringify(missingItem)} in the returned list: (${stringify(references)})`);
+
+        }
+
         private getMemberListAtCaret() {
             return this.languageService.getCompletionsAtPosition(this.activeFile.fileName, this.currentCaretPosition);
         }
@@ -2831,14 +2879,6 @@ namespace FourSlashInterface {
             this.state.verifyMemberListIsEmpty(this.negative);
         }
 
-        public referencesCountIs(count: number) {
-            this.state.verifyReferencesCountIs(count, /*localFilesOnly*/ false);
-        }
-
-        public referencesAtPositionContains(range: FourSlash.Range, isWriteAccess?: boolean) {
-            this.state.verifyReferencesAtPositionListContains(range.fileName, range.start, range.end, isWriteAccess);
-        }
-
         public signatureHelpPresent() {
             this.state.verifySignatureHelpPresent(!this.negative);
         }
@@ -2930,6 +2970,22 @@ namespace FourSlashInterface {
             this.state.verifyGetEmitOutputContentsForCurrentFile(expected);
         }
 
+        public referencesCountIs(count: number) {
+            this.state.verifyReferencesCountIs(count, /*localFilesOnly*/ false);
+        }
+
+        public referencesAre(ranges: FourSlash.Range[]) {
+            this.state.verifyReferencesAre(ranges);
+        }
+
+        public referencesOf(start: FourSlash.Range, references: FourSlash.Range[]) {
+            this.state.verifyReferencesOf(start, references);
+        }
+
+        public rangesReferenceEachOther(ranges?: FourSlash.Range[]) {
+            this.state.verifyRangesReferenceEachOther(ranges);
+        }
+
         public currentParameterHelpArgumentNameIs(name: string) {
             this.state.verifyCurrentParameterHelpName(name);
         }

src/harness/harness.ts

@@ -432,6 +432,7 @@ namespace Harness {
         readFile(path: string): string;
         writeFile(path: string, contents: string): void;
         directoryName(path: string): string;
+        getDirectories(path: string): string[];
         createDirectory(path: string): void;
         fileExists(fileName: string): boolean;
         directoryExists(path: string): boolean;
@@ -477,6 +478,7 @@ namespace Harness {
             export const readFile: typeof IO.readFile = path => ts.sys.readFile(path);
             export const writeFile: typeof IO.writeFile = (path, content) => ts.sys.writeFile(path, content);
             export const directoryName: typeof IO.directoryName = fso.GetParentFolderName;
+            export const getDirectories: typeof IO.getDirectories = dir => ts.sys.getDirectories(dir);
             export const directoryExists: typeof IO.directoryExists = fso.FolderExists;
             export const fileExists: typeof IO.fileExists = fso.FileExists;
             export const log: typeof IO.log = global.WScript && global.WScript.StdOut.WriteLine;
@@ -543,6 +545,7 @@ namespace Harness {
             export const args = () => ts.sys.args;
             export const getExecutingFilePath = () => ts.sys.getExecutingFilePath();
             export const exit = (exitCode: number) => ts.sys.exit(exitCode);
+            export const getDirectories: typeof IO.getDirectories = path => ts.sys.getDirectories(path);
 
             export const readFile: typeof IO.readFile = path => ts.sys.readFile(path);
             export const writeFile: typeof IO.writeFile = (path, content) => ts.sys.writeFile(path, content);
@@ -616,6 +619,7 @@ namespace Harness {
             export const args = () => <string[]>[];
             export const getExecutingFilePath = () => "";
             export const exit = (exitCode: number) => { };
+            export const getDirectories = () => <string[]>[];
 
             export let log = (s: string) => console.log(s);
 
@@ -861,7 +865,7 @@ namespace Harness {
             // Local get canonical file name function, that depends on passed in parameter for useCaseSensitiveFileNames
             const getCanonicalFileName = ts.createGetCanonicalFileName(useCaseSensitiveFileNames);
 
-            let realPathMap: ts.FileMap<string>;
+            const realPathMap: ts.FileMap<string> = ts.createFileMap<string>();
             const fileMap: ts.FileMap<() => ts.SourceFile> = ts.createFileMap<() => ts.SourceFile>();
             for (const file of inputFiles) {
                 if (file.content !== undefined) {
@@ -870,9 +874,6 @@ namespace Harness {
                     if (file.fileOptions && file.fileOptions["symlink"]) {
                         const link = file.fileOptions["symlink"];
                         const linkPath = ts.toPath(link, currentDirectory, getCanonicalFileName);
-                        if (!realPathMap) {
-                            realPathMap = ts.createFileMap<string>();
-                        }
                         realPathMap.set(linkPath, fileName);
                         fileMap.set(path, (): ts.SourceFile => { throw new Error("Symlinks should always be resolved to a realpath first"); });
                     }
@@ -906,20 +907,6 @@ namespace Harness {
 
 
             return {
-                getDefaultTypeDirectiveNames: (path: string) => {
-                    const results: string[] = [];
-                    fileMap.forEachValue((key, value) => {
-                        const rx = /node_modules\/@types\/(\w+)/;
-                        const typeNameResult = rx.exec(key);
-                        if (typeNameResult) {
-                            const typeName = typeNameResult[1];
-                            if (results.indexOf(typeName) < 0) {
-                                results.push(typeName);
-                            }
-                        }
-                    });
-                    return results;
-                },
                 getCurrentDirectory: () => currentDirectory,
                 getSourceFile,
                 getDefaultLibFileName,
@@ -937,7 +924,37 @@ namespace Harness {
                 realpath: realPathMap && ((f: string) => {
                     const path = ts.toPath(f, currentDirectory, getCanonicalFileName);
                     return realPathMap.contains(path) ? realPathMap.get(path) : path;
-                })
+                }),
+                directoryExists: dir => {
+                    let path = ts.toPath(dir, currentDirectory, getCanonicalFileName);
+                    // Strip trailing /, which may exist if the path is a drive root
+                    if (path[path.length - 1] === "/") {
+                        path = <ts.Path>path.substr(0, path.length - 1);
+                    }
+                    let exists = false;
+                    fileMap.forEachValue(key => {
+                        if (key.indexOf(path) === 0 && key[path.length] === "/") {
+                            exists = true;
+                        }
+                    });
+                    return exists;
+                },
+                getDirectories: d => {
+                    const path = ts.toPath(d, currentDirectory, getCanonicalFileName);
+                    const result: string[] = [];
+                    fileMap.forEachValue((key, value) => {
+                        if (key.indexOf(path) === 0 && key.lastIndexOf("/") > path.length) {
+                            let dirName = key.substr(path.length, key.indexOf("/", path.length + 1) - path.length);
+                            if (dirName[0] === "/") {
+                                dirName = dirName.substr(1);
+                            }
+                            if (result.indexOf(dirName) < 0) {
+                                result.push(dirName);
+                            }
+                        }
+                    });
+                    return result;
+                }
             };
         }
 
@@ -1036,7 +1053,9 @@ namespace Harness {
             options.noErrorTruncation = true;
             options.skipDefaultLibCheck = true;
 
-            currentDirectory = currentDirectory || Harness.IO.getCurrentDirectory();
+            if (typeof currentDirectory === "undefined") {
+                currentDirectory = Harness.IO.getCurrentDirectory();
+            }
 
             // Parse settings
             if (harnessSettings) {

src/harness/harnessLanguageService.ts

@@ -246,16 +246,21 @@ namespace Harness.LanguageService {
                 };
                 this.getTypeReferenceDirectiveResolutionsForFile = (fileName) => {
                     const scriptInfo = this.getScriptInfo(fileName);
-                    const preprocessInfo = ts.preProcessFile(scriptInfo.content, /*readImportFiles*/ false);
-                    const resolutions: ts.Map<ts.ResolvedTypeReferenceDirective> = {};
-                    const settings = this.nativeHost.getCompilationSettings();
-                    for (const typeReferenceDirective of preprocessInfo.typeReferenceDirectives) {
-                        const resolutionInfo = ts.resolveTypeReferenceDirective(typeReferenceDirective.fileName, fileName, settings, moduleResolutionHost);
-                        if (resolutionInfo.resolvedTypeReferenceDirective.resolvedFileName) {
-                            resolutions[typeReferenceDirective.fileName] = resolutionInfo.resolvedTypeReferenceDirective;
+                    if (scriptInfo) {
+                        const preprocessInfo = ts.preProcessFile(scriptInfo.content, /*readImportFiles*/ false);
+                        const resolutions: ts.Map<ts.ResolvedTypeReferenceDirective> = {};
+                        const settings = this.nativeHost.getCompilationSettings();
+                        for (const typeReferenceDirective of preprocessInfo.typeReferenceDirectives) {
+                            const resolutionInfo = ts.resolveTypeReferenceDirective(typeReferenceDirective.fileName, fileName, settings, moduleResolutionHost);
+                            if (resolutionInfo.resolvedTypeReferenceDirective.resolvedFileName) {
+                                resolutions[typeReferenceDirective.fileName] = resolutionInfo.resolvedTypeReferenceDirective;
+                            }
                         }
+                        return JSON.stringify(resolutions);
+                    }
+                    else {
+                        return "[]";
                     }
-                    return JSON.stringify(resolutions);
                 };
             }
         }

src/harness/projectsRunner.ts

@@ -185,7 +185,8 @@ class ProjectRunner extends RunnerBase {
                     useCaseSensitiveFileNames: () => Harness.IO.useCaseSensitiveFileNames(),
                     getNewLine: () => Harness.IO.newLine(),
                     fileExists: fileName => fileName === Harness.Compiler.defaultLibFileName ||  getSourceFileText(fileName) !== undefined,
-                    readFile: fileName => Harness.IO.readFile(fileName)
+                    readFile: fileName => Harness.IO.readFile(fileName),
+                    getDirectories: path => Harness.IO.getDirectories(path)
                 };
             }
         }

src/server/client.ts

@@ -376,6 +376,7 @@ namespace ts.server {
                     fileName: fileName,
                     textSpan: ts.createTextSpanFromBounds(start, end),
                     isWriteAccess: entry.isWriteAccess,
+                    isDefinition: entry.isDefinition,
                 };
             });
         }
@@ -536,6 +537,7 @@ namespace ts.server {
                     fileName,
                     textSpan: ts.createTextSpanFromBounds(start, end),
                     isWriteAccess: entry.isWriteAccess,
+                    isDefinition: false
                 };
             });
         }

src/server/editorServices.ts

@@ -317,6 +317,10 @@ namespace ts.server {
             return this.host.directoryExists(path);
         }
 
+        getDirectories(path: string): string[] {
+            return this.host.getDirectories(path);
+        }
+
         /**
          *  @param line 1 based index
          */
@@ -890,6 +894,7 @@ namespace ts.server {
             else {
                 this.findReferencingProjects(info);
                 if (info.defaultProject) {
+                    info.defaultProject.addOpenRef();
                     this.openFilesReferenced.push(info);
                 }
                 else {

src/server/protocol.d.ts

@@ -308,6 +308,11 @@ declare namespace ts.server.protocol {
           * True if reference is a write location, false otherwise.
           */
         isWriteAccess: boolean;
+
+        /**
+         * True if reference is a definition, false otherwise.
+         */
+        isDefinition: boolean;
     }
 
     /**

src/server/session.ts

@@ -379,7 +379,7 @@ namespace ts.server {
                     start,
                     end,
                     file: fileName,
-                    isWriteAccess
+                    isWriteAccess,
                 };
             });
         }
@@ -560,7 +560,8 @@ namespace ts.server {
                             start: start,
                             lineText: lineText,
                             end: compilerService.host.positionToLineOffset(ref.fileName, ts.textSpanEnd(ref.textSpan)),
-                            isWriteAccess: ref.isWriteAccess
+                            isWriteAccess: ref.isWriteAccess,
+                            isDefinition: ref.isDefinition
                         };
                     });
                 },

src/services/navigationBar.ts

@@ -188,7 +188,10 @@ namespace ts.NavigationBar {
                     case SyntaxKind.ModuleDeclaration:
                         let moduleDeclaration = <ModuleDeclaration>node;
                         topLevelNodes.push(node);
-                        addTopLevelNodes((<Block>getInnermostModule(moduleDeclaration).body).statements, topLevelNodes);
+                        const inner = getInnermostModule(moduleDeclaration);
+                        if (inner.body) {
+                            addTopLevelNodes((<Block>inner.body).statements, topLevelNodes);
+                        }
                         break;
 
                     case SyntaxKind.FunctionDeclaration:
@@ -453,7 +456,8 @@ namespace ts.NavigationBar {
             function createModuleItem(node: ModuleDeclaration): NavigationBarItem {
                 const moduleName = getModuleName(node);
 
-                const childItems = getItemsWorker(getChildNodes((<Block>getInnermostModule(node).body).statements), createChildItem);
+                const body = <Block>getInnermostModule(node).body;
+                const childItems = body ? getItemsWorker(getChildNodes(body.statements), createChildItem) : [];
 
                 return getNavigationBarItem(moduleName,
                     ts.ScriptElementKind.moduleElement,
@@ -611,7 +615,7 @@ namespace ts.NavigationBar {
         }
 
         function getInnermostModule(node: ModuleDeclaration): ModuleDeclaration {
-            while (node.body.kind === SyntaxKind.ModuleDeclaration) {
+            while (node.body && node.body.kind === SyntaxKind.ModuleDeclaration) {
                 node = <ModuleDeclaration>node.body;
             }
 

src/services/services.ts

@@ -1,4 +1,5 @@
 /// <reference path="..\compiler\program.ts"/>
+/// <reference path="..\compiler\commandLineParser.ts"/>
 
 /// <reference path='breakpoints.ts' />
 /// <reference path='outliningElementsCollector.ts' />
@@ -414,7 +415,7 @@ namespace ts {
                     }
 
                     // If this is left side of dotted module declaration, there is no doc comments associated with this node
-                    if (declaration.kind === SyntaxKind.ModuleDeclaration && (<ModuleDeclaration>declaration).body.kind === SyntaxKind.ModuleDeclaration) {
+                    if (declaration.kind === SyntaxKind.ModuleDeclaration && (<ModuleDeclaration>declaration).body && (<ModuleDeclaration>declaration).body.kind === SyntaxKind.ModuleDeclaration) {
                         return;
                     }
 
@@ -1077,6 +1078,7 @@ namespace ts {
         resolveModuleNames?(moduleNames: string[], containingFile: string): ResolvedModule[];
         resolveTypeReferenceDirectives?(typeDirectiveNames: string[], containingFile: string): ResolvedTypeReferenceDirective[];
         directoryExists?(directoryName: string): boolean;
+        getDirectories?(directoryName: string): string[];
     }
 
     //
@@ -1208,6 +1210,7 @@ namespace ts {
         textSpan: TextSpan;
         fileName: string;
         isWriteAccess: boolean;
+        isDefinition: boolean;
     }
 
     export interface DocumentHighlights {
@@ -1941,17 +1944,17 @@ namespace ts {
 
 
 
-    let commandLineOptions_stringToEnum: CommandLineOptionOfCustomType[];
+    let commandLineOptionsStringToEnum: CommandLineOptionOfCustomType[];
 
     /** JS users may pass in string values for enum compiler options (such as ModuleKind), so convert. */
     function fixupCompilerOptions(options: CompilerOptions, diagnostics: Diagnostic[]): CompilerOptions {
         // Lazily create this value to fix module loading errors.
-        commandLineOptions_stringToEnum = commandLineOptions_stringToEnum || <CommandLineOptionOfCustomType[]>filter(optionDeclarations, o =>
+        commandLineOptionsStringToEnum = commandLineOptionsStringToEnum || <CommandLineOptionOfCustomType[]>filter(optionDeclarations, o =>
             typeof o.type === "object" && !forEachValue(<Map<any>> o.type, v => typeof v !== "number"));
 
         options = clone(options);
 
-        for (const opt of commandLineOptions_stringToEnum) {
+        for (const opt of commandLineOptionsStringToEnum) {
             if (!hasProperty(options, opt.name)) {
                 continue;
             }
@@ -1999,6 +2002,10 @@ namespace ts {
         // so pass --noLib to avoid reporting a file not found error.
         options.noLib = true;
 
+        // Clear out the lib and types option as well
+        options.lib = undefined;
+        options.types = undefined;
+
         // We are not doing a full typecheck, we are not resolving the whole context,
         // so pass --noResolve to avoid reporting missing file errors.
         options.noResolve = true;
@@ -2038,7 +2045,8 @@ namespace ts {
             getNewLine: () => newLine,
             fileExists: (fileName): boolean => fileName === inputFileName,
             readFile: (fileName): string => "",
-            directoryExists: directoryExists => true
+            directoryExists: directoryExists => true,
+            getDirectories: (path: string) => []
         };
 
         const program = createProgram([inputFileName], options, compilerHost);
@@ -2139,7 +2147,7 @@ namespace ts {
         const getCanonicalFileName = createGetCanonicalFileName(!!useCaseSensitiveFileNames);
 
         function getKeyForCompilationSettings(settings: CompilerOptions): DocumentRegistryBucketKey {
-            return <DocumentRegistryBucketKey>`_${settings.target}|${settings.module}|${settings.noResolve}|${settings.jsx}|${settings.allowJs}|${settings.baseUrl}|${settings.typesRoot}|${settings.typesSearchPaths}|${JSON.stringify(settings.rootDirs)}|${JSON.stringify(settings.paths)}`;
+            return <DocumentRegistryBucketKey>`_${settings.target}|${settings.module}|${settings.noResolve}|${settings.jsx}|${settings.allowJs}|${settings.baseUrl}|${JSON.stringify(settings.typeRoots)}|${JSON.stringify(settings.rootDirs)}|${JSON.stringify(settings.paths)}`;
         }
 
         function getBucketForCompilationSettings(key: DocumentRegistryBucketKey, createIfMissing: boolean): FileMap<DocumentRegistryEntry> {
@@ -3000,8 +3008,10 @@ namespace ts {
                     return entry && entry.scriptSnapshot.getText(0, entry.scriptSnapshot.getLength());
                 },
                 directoryExists: directoryName => {
-                    Debug.assert(!host.resolveModuleNames || !host.resolveTypeReferenceDirectives);
                     return directoryProbablyExists(directoryName, host);
+                },
+                getDirectories: path => {
+                    return host.getDirectories ? host.getDirectories(path) : [];
                 }
             };
             if (host.trace) {
@@ -4138,7 +4148,7 @@ namespace ts {
 
                     if (!uniqueNames[name]) {
                         uniqueNames[name] = name;
-                        const displayName = getCompletionEntryDisplayName(name, target, /*performCharacterChecks*/ true);
+                        const displayName = getCompletionEntryDisplayName(unescapeIdentifier(name), target, /*performCharacterChecks*/ true);
                         if (displayName) {
                             const entry = {
                                 name: displayName,
@@ -5750,7 +5760,8 @@ namespace ts {
                         result.push({
                             fileName: entry.fileName,
                             textSpan: highlightSpan.textSpan,
-                            isWriteAccess: highlightSpan.kind === HighlightSpanKind.writtenReference
+                            isWriteAccess: highlightSpan.kind === HighlightSpanKind.writtenReference,
+                            isDefinition: false
                         });
                     }
                 }
@@ -6184,7 +6195,8 @@ namespace ts {
                                     references: [{
                                         fileName: sourceFile.fileName,
                                         textSpan: createTextSpan(position, searchText.length),
-                                        isWriteAccess: false
+                                        isWriteAccess: false,
+                                        isDefinition: false
                                     }]
                                 });
                             }
@@ -6738,7 +6750,8 @@ namespace ts {
             return {
                 fileName: node.getSourceFile().fileName,
                 textSpan: createTextSpanFromBounds(start, end),
-                isWriteAccess: isWriteAccess(node)
+                isWriteAccess: isWriteAccess(node),
+                isDefinition: isDeclarationName(node) || isLiteralComputedPropertyDeclarationName(node)
             };
         }
 

src/services/shims.ts

@@ -164,7 +164,7 @@ namespace ts {
 
         /**
          * Returns a JSON-encoded value of the type:
-         * { fileName: string; textSpan: { start: number; length: number}; isWriteAccess: boolean }[]
+         * { fileName: string; textSpan: { start: number; length: number}; isWriteAccess: boolean, isDefinition?: boolean }[]
          */
         getReferencesAtPosition(fileName: string, position: number): string;
 
@@ -1141,4 +1141,4 @@ namespace TypeScript.Services {
 /* @internal */
 const toolsVersion = "1.9";
 
-/* tslint:enable:no-unused-variable */
+/* tslint:enable:no-unused-variable */

tests/baselines/reference/FunctionDeclaration11_es6.errors.txt

@@ -1,8 +1,8 @@
-tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration11_es6.ts(1,10): error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration11_es6.ts(1,10): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
 
 
 ==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration11_es6.ts (1 errors) ====
     function * yield() {
              ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
     }

tests/baselines/reference/FunctionDeclaration13_es6.errors.txt

@@ -1,11 +1,11 @@
-tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration13_es6.ts(1,10): error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration13_es6.ts(1,10): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
 tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration13_es6.ts(3,11): error TS2304: Cannot find name 'yield'.
 
 
 ==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration13_es6.ts (2 errors) ====
     function * foo() {
              ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
        // Legal to use 'yield' in a type context.
        var v: yield;
               ~~~~~

tests/baselines/reference/FunctionDeclaration1_es6.errors.txt

@@ -1,8 +1,8 @@
-tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration1_es6.ts(1,10): error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration1_es6.ts(1,10): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
 
 
 ==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration1_es6.ts (1 errors) ====
     function * foo() {
              ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
     }

tests/baselines/reference/FunctionDeclaration6_es6.errors.txt

@@ -1,11 +1,11 @@
-tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration6_es6.ts(1,9): error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration6_es6.ts(1,9): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
 tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration6_es6.ts(1,18): error TS2523: 'yield' expressions cannot be used in a parameter initializer.
 
 
 ==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration6_es6.ts (2 errors) ====
     function*foo(a = yield) {
             ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
                      ~~~~~
 !!! error TS2523: 'yield' expressions cannot be used in a parameter initializer.
     }

tests/baselines/reference/FunctionDeclaration7_es6.errors.txt

@@ -1,16 +1,16 @@
-tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts(1,9): error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
-tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts(3,11): error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts(1,9): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
+tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts(3,11): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
 tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts(3,20): error TS2523: 'yield' expressions cannot be used in a parameter initializer.
 
 
 ==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts (3 errors) ====
     function*bar() {
             ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
       // 'yield' here is an identifier, and not a yield expression.
       function*foo(a = yield) {
               ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
                        ~~~~~
 !!! error TS2523: 'yield' expressions cannot be used in a parameter initializer.
       }

tests/baselines/reference/FunctionDeclaration9_es6.errors.txt

@@ -1,9 +1,9 @@
-tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration9_es6.ts(1,10): error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration9_es6.ts(1,10): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
 
 
 ==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration9_es6.ts (1 errors) ====
     function * foo() {
              ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
       var v = { [yield]: foo }
     }

tests/baselines/reference/FunctionExpression1_es6.errors.txt

@@ -1,7 +1,7 @@
-tests/cases/conformance/es6/functionExpressions/FunctionExpression1_es6.ts(1,18): error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+tests/cases/conformance/es6/functionExpressions/FunctionExpression1_es6.ts(1,18): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
 
 
 ==== tests/cases/conformance/es6/functionExpressions/FunctionExpression1_es6.ts (1 errors) ====
     var v = function * () { }
                      ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.

tests/baselines/reference/FunctionExpression2_es6.errors.txt

@@ -1,7 +1,7 @@
-tests/cases/conformance/es6/functionExpressions/FunctionExpression2_es6.ts(1,18): error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+tests/cases/conformance/es6/functionExpressions/FunctionExpression2_es6.ts(1,18): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
 
 
 ==== tests/cases/conformance/es6/functionExpressions/FunctionExpression2_es6.ts (1 errors) ====
     var v = function * foo() { }
                      ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.

tests/baselines/reference/FunctionPropertyAssignments1_es6.errors.txt

@@ -1,7 +1,7 @@
-tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments1_es6.ts(1,11): error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments1_es6.ts(1,11): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
 
 
 ==== tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments1_es6.ts (1 errors) ====
     var v = { *foo() { } }
               ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.

tests/baselines/reference/FunctionPropertyAssignments5_es6.errors.txt

@@ -1,10 +1,10 @@
-tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments5_es6.ts(1,11): error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments5_es6.ts(1,11): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
 tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments5_es6.ts(1,13): error TS2304: Cannot find name 'foo'.
 
 
 ==== tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments5_es6.ts (2 errors) ====
     var v = { *[foo()]() { } }
               ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
                 ~~~
 !!! error TS2304: Cannot find name 'foo'.

tests/baselines/reference/MemberFunctionDeclaration1_es6.errors.txt

@@ -1,9 +1,9 @@
-tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration1_es6.ts(2,4): error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration1_es6.ts(2,4): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
 
 
 ==== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration1_es6.ts (1 errors) ====
     class C {
        *foo() { }
        ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
     }

tests/baselines/reference/MemberFunctionDeclaration2_es6.errors.txt

@@ -1,9 +1,9 @@
-tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration2_es6.ts(2,11): error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration2_es6.ts(2,11): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
 
 
 ==== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration2_es6.ts (1 errors) ====
     class C {
        public * foo() { }
               ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
     }

tests/baselines/reference/MemberFunctionDeclaration3_es6.errors.txt

@@ -1,4 +1,4 @@
-tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration3_es6.ts(2,4): error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration3_es6.ts(2,4): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
 tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration3_es6.ts(2,6): error TS2304: Cannot find name 'foo'.
 
 
@@ -6,7 +6,7 @@ tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration
     class C {
        *[foo]() { }
        ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
          ~~~
 !!! error TS2304: Cannot find name 'foo'.
     }

tests/baselines/reference/MemberFunctionDeclaration7_es6.errors.txt

@@ -1,9 +1,9 @@
-tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration7_es6.ts(2,4): error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration7_es6.ts(2,4): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
 
 
 ==== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration7_es6.ts (1 errors) ====
     class C {
        *foo<T>() { }
        ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
     }

tests/baselines/reference/YieldExpression10_es6.errors.txt

@@ -1,11 +1,11 @@
-tests/cases/conformance/es6/yieldExpressions/YieldExpression10_es6.ts(1,11): error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+tests/cases/conformance/es6/yieldExpressions/YieldExpression10_es6.ts(1,11): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
 tests/cases/conformance/es6/yieldExpressions/YieldExpression10_es6.ts(2,11): error TS2304: Cannot find name 'foo'.
 
 
 ==== tests/cases/conformance/es6/yieldExpressions/YieldExpression10_es6.ts (2 errors) ====
     var v = { * foo() {
               ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
         yield(foo);
               ~~~
 !!! error TS2304: Cannot find name 'foo'.

tests/baselines/reference/YieldExpression11_es6.errors.txt

@@ -1,4 +1,4 @@
-tests/cases/conformance/es6/yieldExpressions/YieldExpression11_es6.ts(2,3): error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+tests/cases/conformance/es6/yieldExpressions/YieldExpression11_es6.ts(2,3): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
 tests/cases/conformance/es6/yieldExpressions/YieldExpression11_es6.ts(3,11): error TS2663: Cannot find name 'foo'. Did you mean the instance member 'this.foo'?
 
 
@@ -6,7 +6,7 @@ tests/cases/conformance/es6/yieldExpressions/YieldExpression11_es6.ts(3,11): err
     class C {
       *foo() {
       ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
         yield(foo);
               ~~~
 !!! error TS2663: Cannot find name 'foo'. Did you mean the instance member 'this.foo'?

tests/baselines/reference/YieldExpression13_es6.errors.txt

@@ -1,7 +1,7 @@
-tests/cases/conformance/es6/yieldExpressions/YieldExpression13_es6.ts(1,9): error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+tests/cases/conformance/es6/yieldExpressions/YieldExpression13_es6.ts(1,9): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
 
 
 ==== tests/cases/conformance/es6/yieldExpressions/YieldExpression13_es6.ts (1 errors) ====
     function* foo() { yield }
             ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.

tests/baselines/reference/YieldExpression16_es6.errors.txt

@@ -1,11 +1,11 @@
-tests/cases/conformance/es6/yieldExpressions/YieldExpression16_es6.ts(1,9): error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+tests/cases/conformance/es6/yieldExpressions/YieldExpression16_es6.ts(1,9): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
 tests/cases/conformance/es6/yieldExpressions/YieldExpression16_es6.ts(3,5): error TS1163: A 'yield' expression is only allowed in a generator body.
 
 
 ==== tests/cases/conformance/es6/yieldExpressions/YieldExpression16_es6.ts (2 errors) ====
     function* foo() {
             ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
       function bar() {
         yield foo;
         ~~~~~

tests/baselines/reference/YieldExpression19_es6.errors.txt

@@ -1,15 +1,15 @@
-tests/cases/conformance/es6/yieldExpressions/YieldExpression19_es6.ts(1,9): error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
-tests/cases/conformance/es6/yieldExpressions/YieldExpression19_es6.ts(3,13): error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+tests/cases/conformance/es6/yieldExpressions/YieldExpression19_es6.ts(1,9): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
+tests/cases/conformance/es6/yieldExpressions/YieldExpression19_es6.ts(3,13): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
 
 
 ==== tests/cases/conformance/es6/yieldExpressions/YieldExpression19_es6.ts (2 errors) ====
     function*foo() {
             ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
       function bar() {
         function* quux() {
                 ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
           yield(foo);
         }
       }

tests/baselines/reference/YieldExpression3_es6.errors.txt

@@ -1,10 +1,10 @@
-tests/cases/conformance/es6/yieldExpressions/YieldExpression3_es6.ts(1,9): error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+tests/cases/conformance/es6/yieldExpressions/YieldExpression3_es6.ts(1,9): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
 
 
 ==== tests/cases/conformance/es6/yieldExpressions/YieldExpression3_es6.ts (1 errors) ====
     function* foo() {
             ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
       yield
       yield
     }

tests/baselines/reference/YieldExpression4_es6.errors.txt

@@ -1,10 +1,10 @@
-tests/cases/conformance/es6/yieldExpressions/YieldExpression4_es6.ts(1,9): error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+tests/cases/conformance/es6/yieldExpressions/YieldExpression4_es6.ts(1,9): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
 
 
 ==== tests/cases/conformance/es6/yieldExpressions/YieldExpression4_es6.ts (1 errors) ====
     function* foo() {
             ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
       yield;
       yield;
     }

tests/baselines/reference/YieldExpression6_es6.errors.txt

@@ -1,11 +1,11 @@
-tests/cases/conformance/es6/yieldExpressions/YieldExpression6_es6.ts(1,9): error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+tests/cases/conformance/es6/yieldExpressions/YieldExpression6_es6.ts(1,9): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
 tests/cases/conformance/es6/yieldExpressions/YieldExpression6_es6.ts(2,9): error TS2488: Type must have a '[Symbol.iterator]()' method that returns an iterator.
 
 
 ==== tests/cases/conformance/es6/yieldExpressions/YieldExpression6_es6.ts (2 errors) ====
     function* foo() {
             ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
       yield*foo
             ~~~
 !!! error TS2488: Type must have a '[Symbol.iterator]()' method that returns an iterator.

tests/baselines/reference/YieldExpression7_es6.errors.txt

@@ -1,9 +1,9 @@
-tests/cases/conformance/es6/yieldExpressions/YieldExpression7_es6.ts(1,9): error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+tests/cases/conformance/es6/yieldExpressions/YieldExpression7_es6.ts(1,9): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
 
 
 ==== tests/cases/conformance/es6/yieldExpressions/YieldExpression7_es6.ts (1 errors) ====
     function* foo() {
             ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
       yield foo
     }

tests/baselines/reference/YieldExpression8_es6.errors.txt

@@ -1,5 +1,5 @@
 tests/cases/conformance/es6/yieldExpressions/YieldExpression8_es6.ts(1,1): error TS2304: Cannot find name 'yield'.
-tests/cases/conformance/es6/yieldExpressions/YieldExpression8_es6.ts(2,9): error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+tests/cases/conformance/es6/yieldExpressions/YieldExpression8_es6.ts(2,9): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
 
 
 ==== tests/cases/conformance/es6/yieldExpressions/YieldExpression8_es6.ts (2 errors) ====
@@ -8,6 +8,6 @@ tests/cases/conformance/es6/yieldExpressions/YieldExpression8_es6.ts(2,9): error
 !!! error TS2304: Cannot find name 'yield'.
     function* foo() {
             ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
       yield(foo);
     }

tests/baselines/reference/YieldExpression9_es6.errors.txt

@@ -1,11 +1,11 @@
-tests/cases/conformance/es6/yieldExpressions/YieldExpression9_es6.ts(1,17): error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+tests/cases/conformance/es6/yieldExpressions/YieldExpression9_es6.ts(1,17): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
 tests/cases/conformance/es6/yieldExpressions/YieldExpression9_es6.ts(2,9): error TS2304: Cannot find name 'foo'.
 
 
 ==== tests/cases/conformance/es6/yieldExpressions/YieldExpression9_es6.ts (2 errors) ====
     var v = function*() {
                     ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
       yield(foo);
             ~~~
 !!! error TS2304: Cannot find name 'foo'.

tests/baselines/reference/YieldStarExpression4_es6.errors.txt

@@ -1,11 +1,11 @@
-tests/cases/conformance/es6/yieldExpressions/YieldStarExpression4_es6.ts(1,10): error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+tests/cases/conformance/es6/yieldExpressions/YieldStarExpression4_es6.ts(1,10): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
 tests/cases/conformance/es6/yieldExpressions/YieldStarExpression4_es6.ts(2,13): error TS2488: Type must have a '[Symbol.iterator]()' method that returns an iterator.
 
 
 ==== tests/cases/conformance/es6/yieldExpressions/YieldStarExpression4_es6.ts (2 errors) ====
     function *g() {
              ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 6 or higher.
+!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
         yield * [];
                 ~~
 !!! error TS2488: Type must have a '[Symbol.iterator]()' method that returns an iterator.

tests/baselines/reference/ambientShorthand.js

@@ -0,0 +1,22 @@
+//// [tests/cases/conformance/ambient/ambientShorthand.ts] ////
+
+//// [declarations.d.ts]
+declare module "jquery"
+// Semicolon is optional
+declare module "fs";
+
+//// [user.ts]
+///<reference path="declarations.d.ts"/>
+import foo, {bar} from "jquery";
+import * as baz from "fs";
+import boom = require("jquery");
+foo(bar, baz, boom);
+
+
+//// [user.js]
+"use strict";
+///<reference path="declarations.d.ts"/>
+var jquery_1 = require("jquery");
+var baz = require("fs");
+var boom = require("jquery");
+jquery_1["default"](jquery_1.bar, baz, boom);

tests/baselines/reference/ambientShorthand.symbols

@@ -0,0 +1,24 @@
+=== tests/cases/conformance/ambient/user.ts ===
+///<reference path="declarations.d.ts"/>
+import foo, {bar} from "jquery";
+>foo : Symbol(foo, Decl(user.ts, 1, 6))
+>bar : Symbol(bar, Decl(user.ts, 1, 13))
+
+import * as baz from "fs";
+>baz : Symbol(baz, Decl(user.ts, 2, 6))
+
+import boom = require("jquery");
+>boom : Symbol(boom, Decl(user.ts, 2, 26))
+
+foo(bar, baz, boom);
+>foo : Symbol(foo, Decl(user.ts, 1, 6))
+>bar : Symbol(bar, Decl(user.ts, 1, 13))
+>baz : Symbol(baz, Decl(user.ts, 2, 6))
+>boom : Symbol(boom, Decl(user.ts, 2, 26))
+
+=== tests/cases/conformance/ambient/declarations.d.ts ===
+declare module "jquery"
+No type information for this code.// Semicolon is optional
+No type information for this code.declare module "fs";
+No type information for this code.
+No type information for this code.

tests/baselines/reference/ambientShorthand.types

@@ -0,0 +1,25 @@
+=== tests/cases/conformance/ambient/user.ts ===
+///<reference path="declarations.d.ts"/>
+import foo, {bar} from "jquery";
+>foo : any
+>bar : any
+
+import * as baz from "fs";
+>baz : any
+
+import boom = require("jquery");
+>boom : any
+
+foo(bar, baz, boom);
+>foo(bar, baz, boom) : any
+>foo : any
+>bar : any
+>baz : any
+>boom : any
+
+=== tests/cases/conformance/ambient/declarations.d.ts ===
+declare module "jquery"
+No type information for this code.// Semicolon is optional
+No type information for this code.declare module "fs";
+No type information for this code.
+No type information for this code.

tests/baselines/reference/ambientShorthand_declarationEmit.js

@@ -0,0 +1,9 @@
+//// [ambientShorthand_declarationEmit.ts]
+declare module "foo";
+
+
+//// [ambientShorthand_declarationEmit.js]
+
+
+//// [ambientShorthand_declarationEmit.d.ts]
+declare module "foo";

tests/baselines/reference/ambientShorthand_declarationEmit.symbols

@@ -0,0 +1,4 @@
+=== tests/cases/conformance/ambient/ambientShorthand_declarationEmit.ts ===
+declare module "foo";
+No type information for this code.
+No type information for this code.

tests/baselines/reference/ambientShorthand_declarationEmit.types

@@ -0,0 +1,4 @@
+=== tests/cases/conformance/ambient/ambientShorthand_declarationEmit.ts ===
+declare module "foo";
+No type information for this code.
+No type information for this code.

tests/baselines/reference/ambientShorthand_duplicate.js

@@ -0,0 +1,16 @@
+//// [tests/cases/conformance/ambient/ambientShorthand_duplicate.ts] ////
+
+//// [declarations1.d.ts]
+declare module "foo";
+
+//// [declarations2.d.ts]
+declare module "foo";
+
+//// [user.ts]
+///<reference path="declarations1.d.ts" />
+///<reference path="declarations1.d.ts" />
+import foo from "foo";
+
+
+//// [user.js]
+"use strict";

tests/baselines/reference/ambientShorthand_duplicate.symbols

@@ -0,0 +1,10 @@
+=== tests/cases/conformance/ambient/user.ts ===
+///<reference path="declarations1.d.ts" />
+///<reference path="declarations1.d.ts" />
+import foo from "foo";
+>foo : Symbol(foo, Decl(user.ts, 2, 6))
+
+=== tests/cases/conformance/ambient/declarations1.d.ts ===
+declare module "foo";
+No type information for this code.
+No type information for this code.

tests/baselines/reference/ambientShorthand_duplicate.types

@@ -0,0 +1,10 @@
+=== tests/cases/conformance/ambient/user.ts ===
+///<reference path="declarations1.d.ts" />
+///<reference path="declarations1.d.ts" />
+import foo from "foo";
+>foo : any
+
+=== tests/cases/conformance/ambient/declarations1.d.ts ===
+declare module "foo";
+No type information for this code.
+No type information for this code.

tests/baselines/reference/ambientShorthand_isImplicitAny.errors.txt

@@ -0,0 +1,8 @@
+tests/cases/conformance/ambient/ambientShorthand_isImplicitAny.ts(1,16): error TS7005: Variable '"jquery"' implicitly has an 'any' type.
+
+
+==== tests/cases/conformance/ambient/ambientShorthand_isImplicitAny.ts (1 errors) ====
+    declare module "jquery";
+                   ~~~~~~~~
+!!! error TS7005: Variable '"jquery"' implicitly has an 'any' type.
+    

tests/baselines/reference/ambientShorthand_isImplicitAny.js

@@ -0,0 +1,5 @@
+//// [ambientShorthand_isImplicitAny.ts]
+declare module "jquery";
+
+
+//// [ambientShorthand_isImplicitAny.js]

tests/baselines/reference/ambientShorthand_merging.js

@@ -0,0 +1,18 @@
+//// [tests/cases/conformance/ambient/ambientShorthand_merging.ts] ////
+
+//// [declarations1.d.ts]
+declare module "foo";
+
+//// [declarations2.d.ts]
+declare module "foo" {
+    export const bar: number;
+}
+
+//// [user.ts]
+///<reference path="declarations1.d.ts" />
+///<reference path="declarations1.d.ts" />
+import foo, {bar} from "foo";
+
+
+//// [user.js]
+"use strict";

tests/baselines/reference/ambientShorthand_merging.symbols

@@ -0,0 +1,11 @@
+=== tests/cases/conformance/ambient/user.ts ===
+///<reference path="declarations1.d.ts" />
+///<reference path="declarations1.d.ts" />
+import foo, {bar} from "foo";
+>foo : Symbol(foo, Decl(user.ts, 2, 6))
+>bar : Symbol(bar, Decl(user.ts, 2, 13))
+
+=== tests/cases/conformance/ambient/declarations1.d.ts ===
+declare module "foo";
+No type information for this code.
+No type information for this code.

tests/baselines/reference/ambientShorthand_merging.types

@@ -0,0 +1,11 @@
+=== tests/cases/conformance/ambient/user.ts ===
+///<reference path="declarations1.d.ts" />
+///<reference path="declarations1.d.ts" />
+import foo, {bar} from "foo";
+>foo : any
+>bar : any
+
+=== tests/cases/conformance/ambient/declarations1.d.ts ===
+declare module "foo";
+No type information for this code.
+No type information for this code.

tests/baselines/reference/ambientShorthand_reExport.js

@@ -0,0 +1,30 @@
+//// [tests/cases/conformance/ambient/ambientShorthand_reExport.ts] ////
+
+//// [declarations.d.ts]
+declare module "jquery";
+
+//// [reExportX.ts]
+export {x} from "jquery";
+
+//// [reExportAll.ts]
+export * from "jquery";
+
+//// [reExportUser.ts]
+import {x} from "./reExportX";
+import * as $ from "./reExportAll";
+// '$' is not callable, it is an object.
+x($);
+
+
+//// [reExportX.js]
+"use strict";
+var jquery_1 = require("jquery");
+exports.x = jquery_1.x;
+//// [reExportAll.js]
+"use strict";
+//// [reExportUser.js]
+"use strict";
+var reExportX_1 = require("./reExportX");
+var $ = require("./reExportAll");
+// '$' is not callable, it is an object.
+reExportX_1.x($);

tests/baselines/reference/ambientShorthand_reExport.symbols

@@ -0,0 +1,22 @@
+=== tests/cases/conformance/ambient/declarations.d.ts ===
+declare module "jquery";
+No type information for this code.
+No type information for this code.=== tests/cases/conformance/ambient/reExportX.ts ===
+export {x} from "jquery";
+>x : Symbol(x, Decl(reExportX.ts, 0, 8))
+
+=== tests/cases/conformance/ambient/reExportAll.ts ===
+export * from "jquery";
+No type information for this code.
+No type information for this code.=== tests/cases/conformance/ambient/reExportUser.ts ===
+import {x} from "./reExportX";
+>x : Symbol(x, Decl(reExportUser.ts, 0, 8))
+
+import * as $ from "./reExportAll";
+>$ : Symbol($, Decl(reExportUser.ts, 1, 6))
+
+// '$' is not callable, it is an object.
+x($);
+>x : Symbol(x, Decl(reExportUser.ts, 0, 8))
+>$ : Symbol($, Decl(reExportUser.ts, 1, 6))
+

tests/baselines/reference/ambientShorthand_reExport.types

@@ -0,0 +1,23 @@
+=== tests/cases/conformance/ambient/declarations.d.ts ===
+declare module "jquery";
+No type information for this code.
+No type information for this code.=== tests/cases/conformance/ambient/reExportX.ts ===
+export {x} from "jquery";
+>x : any
+
+=== tests/cases/conformance/ambient/reExportAll.ts ===
+export * from "jquery";
+No type information for this code.
+No type information for this code.=== tests/cases/conformance/ambient/reExportUser.ts ===
+import {x} from "./reExportX";
+>x : any
+
+import * as $ from "./reExportAll";
+>$ : typeof $
+
+// '$' is not callable, it is an object.
+x($);
+>x($) : any
+>x : any
+>$ : typeof $
+

tests/baselines/reference/commonSourceDir5.js

@@ -1,6 +1,7 @@
 //// [tests/cases/compiler/commonSourceDir5.ts] ////
 
 //// [bar.ts]
+
 import {z} from "./foo";
 export var x = z + z;
 

tests/baselines/reference/commonSourceDir5.symbols

@@ -1,11 +1,12 @@
 === A:/bar.ts ===
+
 import {z} from "./foo";
->z : Symbol(z, Decl(bar.ts, 0, 8))
+>z : Symbol(z, Decl(bar.ts, 1, 8))
 
 export var x = z + z;
->x : Symbol(x, Decl(bar.ts, 1, 10))
->z : Symbol(z, Decl(bar.ts, 0, 8))
->z : Symbol(z, Decl(bar.ts, 0, 8))
+>x : Symbol(x, Decl(bar.ts, 2, 10))
+>z : Symbol(z, Decl(bar.ts, 1, 8))
+>z : Symbol(z, Decl(bar.ts, 1, 8))
 
 === A:/foo.ts ===
 import {pi} from "B:/baz";

tests/baselines/reference/commonSourceDir5.types

@@ -1,4 +1,5 @@
 === A:/bar.ts ===
+
 import {z} from "./foo";
 >z : number
 

tests/baselines/reference/constDeclarations-useBeforeDefinition2.errors.txt

@@ -0,0 +1,11 @@
+tests/cases/compiler/file1.ts(2,1): error TS2448: Block-scoped variable 'c' used before its declaration.
+
+
+==== tests/cases/compiler/file1.ts (1 errors) ====
+    
+    c;
+    ~
+!!! error TS2448: Block-scoped variable 'c' used before its declaration.
+    
+==== tests/cases/compiler/file2.ts (0 errors) ====
+    const c = 0;

tests/baselines/reference/decoratorMetadataPromise.js

@@ -0,0 +1,59 @@
+//// [decoratorMetadataPromise.ts]
+
+declare const decorator: MethodDecorator;
+
+class A {
+    @decorator
+    async foo() {}
+    @decorator
+    async bar(): Promise<number> { return 0; }
+    @decorator
+    baz(n: Promise<number>): Promise<number> { return n; }
+}
+
+
+//// [decoratorMetadataPromise.js]
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator.throw(value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments)).next());
+    });
+};
+class A {
+    foo() {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    bar() {
+        return __awaiter(this, void 0, void 0, function* () { return 0; });
+    }
+    baz(n) { return n; }
+}
+__decorate([
+    decorator, 
+    __metadata('design:type', Function), 
+    __metadata('design:paramtypes', []), 
+    __metadata('design:returntype', Promise)
+], A.prototype, "foo", null);
+__decorate([
+    decorator, 
+    __metadata('design:type', Function), 
+    __metadata('design:paramtypes', []), 
+    __metadata('design:returntype', Promise)
+], A.prototype, "bar", null);
+__decorate([
+    decorator, 
+    __metadata('design:type', Function), 
+    __metadata('design:paramtypes', [Promise]), 
+    __metadata('design:returntype', Promise)
+], A.prototype, "baz", null);

tests/baselines/reference/decoratorMetadataPromise.symbols

@@ -0,0 +1,33 @@
+=== tests/cases/compiler/decoratorMetadataPromise.ts ===
+
+declare const decorator: MethodDecorator;
+>decorator : Symbol(decorator, Decl(decoratorMetadataPromise.ts, 1, 13))
+>MethodDecorator : Symbol(MethodDecorator, Decl(lib.es5.d.ts, --, --))
+
+class A {
+>A : Symbol(A, Decl(decoratorMetadataPromise.ts, 1, 41))
+
+    @decorator
+>decorator : Symbol(decorator, Decl(decoratorMetadataPromise.ts, 1, 13))
+
+    async foo() {}
+>foo : Symbol(A.foo, Decl(decoratorMetadataPromise.ts, 3, 9))
+
+    @decorator
+>decorator : Symbol(decorator, Decl(decoratorMetadataPromise.ts, 1, 13))
+
+    async bar(): Promise<number> { return 0; }
+>bar : Symbol(A.bar, Decl(decoratorMetadataPromise.ts, 5, 18))
+>Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+
+    @decorator
+>decorator : Symbol(decorator, Decl(decoratorMetadataPromise.ts, 1, 13))
+
+    baz(n: Promise<number>): Promise<number> { return n; }
+>baz : Symbol(A.baz, Decl(decoratorMetadataPromise.ts, 7, 46))
+>n : Symbol(n, Decl(decoratorMetadataPromise.ts, 9, 8))
+>Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>n : Symbol(n, Decl(decoratorMetadataPromise.ts, 9, 8))
+}
+

tests/baselines/reference/decoratorMetadataPromise.types

@@ -0,0 +1,34 @@
+=== tests/cases/compiler/decoratorMetadataPromise.ts ===
+
+declare const decorator: MethodDecorator;
+>decorator : <T>(target: Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T> | void
+>MethodDecorator : <T>(target: Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T> | void
+
+class A {
+>A : A
+
+    @decorator
+>decorator : <T>(target: Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T> | void
+
+    async foo() {}
+>foo : () => Promise<void>
+
+    @decorator
+>decorator : <T>(target: Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T> | void
+
+    async bar(): Promise<number> { return 0; }
+>bar : () => Promise<number>
+>Promise : Promise<T>
+>0 : number
+
+    @decorator
+>decorator : <T>(target: Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T> | void
+
+    baz(n: Promise<number>): Promise<number> { return n; }
+>baz : (n: Promise<number>) => Promise<number>
+>n : Promise<number>
+>Promise : Promise<T>
+>Promise : Promise<T>
+>n : Promise<number>
+}
+

tests/baselines/reference/defaultValueInFunctionTypes.errors.txt

@@ -1,8 +1,11 @@
 tests/cases/compiler/defaultValueInFunctionTypes.ts(1,9): error TS2371: A parameter initializer is only allowed in a function or constructor implementation.
+tests/cases/compiler/defaultValueInFunctionTypes.ts(2,11): error TS2371: A parameter initializer is only allowed in a function or constructor implementation.
 
 
-==== tests/cases/compiler/defaultValueInFunctionTypes.ts (1 errors) ====
+==== tests/cases/compiler/defaultValueInFunctionTypes.ts (2 errors) ====
     var x: (a: number = 1) => number;
             ~~~~~~~~~~~~~
 !!! error TS2371: A parameter initializer is only allowed in a function or constructor implementation.
-    var y = <(a : string = "") => any>(undefined)
+    var y = <(a : string = "") => any>(undefined)
+              ~~~~~~~~~~~~~~~
+!!! error TS2371: A parameter initializer is only allowed in a function or constructor implementation.

tests/baselines/reference/disallowAsyncModifierInES5.errors.txt

@@ -0,0 +1,27 @@
+error TS2318: Cannot find global type 'Promise'.
+tests/cases/compiler/disallowAsyncModifierInES5.ts(2,1): error TS1311: Async functions are only available when targeting ECMAScript 2015 or higher.
+tests/cases/compiler/disallowAsyncModifierInES5.ts(2,16): error TS1057: An async function or method must have a valid awaitable return type.
+tests/cases/compiler/disallowAsyncModifierInES5.ts(3,11): error TS1057: An async function or method must have a valid awaitable return type.
+tests/cases/compiler/disallowAsyncModifierInES5.ts(3,11): error TS1311: Async functions are only available when targeting ECMAScript 2015 or higher.
+tests/cases/compiler/disallowAsyncModifierInES5.ts(4,11): error TS1311: Async functions are only available when targeting ECMAScript 2015 or higher.
+tests/cases/compiler/disallowAsyncModifierInES5.ts(4,11): error TS1057: An async function or method must have a valid awaitable return type.
+
+
+!!! error TS2318: Cannot find global type 'Promise'.
+==== tests/cases/compiler/disallowAsyncModifierInES5.ts (6 errors) ====
+    
+    async function foo() { return 42; } // ERROR: Async functions are only available in ES6+
+    ~~~~~
+!!! error TS1311: Async functions are only available when targeting ECMAScript 2015 or higher.
+                   ~~~
+!!! error TS1057: An async function or method must have a valid awaitable return type.
+    let bar = async function () { return 42; } // OK, but should be an error
+              ~~~~~
+!!! error TS1057: An async function or method must have a valid awaitable return type.
+              ~~~~~
+!!! error TS1311: Async functions are only available when targeting ECMAScript 2015 or higher.
+    let baz = async () => 42; // OK, but should be an error
+              ~~~~~
+!!! error TS1311: Async functions are only available when targeting ECMAScript 2015 or higher.
+              ~~~~~~~~~~~~~~
+!!! error TS1057: An async function or method must have a valid awaitable return type.

tests/baselines/reference/disallowAsyncModifierInES5.js

@@ -0,0 +1,22 @@
+//// [disallowAsyncModifierInES5.ts]
+
+async function foo() { return 42; } // ERROR: Async functions are only available in ES6+
+let bar = async function () { return 42; } // OK, but should be an error
+let baz = async () => 42; // OK, but should be an error
+
+//// [disallowAsyncModifierInES5.js]
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator.throw(value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments)).next());
+    });
+};
+function foo() {
+    return __awaiter(this, void 0, void 0, function* () { return 42; });
+} // ERROR: Async functions are only available in ES6+
+var bar = function () {
+    return __awaiter(this, void 0, void 0, function* () { return 42; });
+}; // OK, but should be an error
+var baz = function () __awaiter(this, void 0, void 0, function* () { return 42; }); // OK, but should be an error

tests/baselines/reference/duplicatePropertiesInTypeAssertions01.errors.txt

@@ -0,0 +1,11 @@
+tests/cases/conformance/expressions/typeAssertions/duplicatePropertiesInTypeAssertions01.ts(2,11): error TS2300: Duplicate identifier 'a'.
+tests/cases/conformance/expressions/typeAssertions/duplicatePropertiesInTypeAssertions01.ts(2,22): error TS2300: Duplicate identifier 'a'.
+
+
+==== tests/cases/conformance/expressions/typeAssertions/duplicatePropertiesInTypeAssertions01.ts (2 errors) ====
+    
+    let x = <{a: number; a: number}>{};
+              ~
+!!! error TS2300: Duplicate identifier 'a'.
+                         ~
+!!! error TS2300: Duplicate identifier 'a'.

tests/baselines/reference/duplicatePropertiesInTypeAssertions01.js

@@ -0,0 +1,12 @@
+//// [duplicatePropertiesInTypeAssertions01.ts]
+
+let x = <{a: number; a: number}>{};
+
+//// [duplicatePropertiesInTypeAssertions01.js]
+var x = {};
+
+
+//// [duplicatePropertiesInTypeAssertions01.d.ts]
+declare let x: {
+    a: number;
+};

tests/baselines/reference/duplicatePropertiesInTypeAssertions02.errors.txt

@@ -0,0 +1,11 @@
+tests/cases/conformance/expressions/typeAssertions/duplicatePropertiesInTypeAssertions02.ts(2,16): error TS2300: Duplicate identifier 'a'.
+tests/cases/conformance/expressions/typeAssertions/duplicatePropertiesInTypeAssertions02.ts(2,27): error TS2300: Duplicate identifier 'a'.
+
+
+==== tests/cases/conformance/expressions/typeAssertions/duplicatePropertiesInTypeAssertions02.ts (2 errors) ====
+    
+    let x = {} as {a: number; a: number};
+                   ~
+!!! error TS2300: Duplicate identifier 'a'.
+                              ~
+!!! error TS2300: Duplicate identifier 'a'.

tests/baselines/reference/duplicatePropertiesInTypeAssertions02.js

@@ -0,0 +1,12 @@
+//// [duplicatePropertiesInTypeAssertions02.ts]
+
+let x = {} as {a: number; a: number};
+
+//// [duplicatePropertiesInTypeAssertions02.js]
+var x = {};
+
+
+//// [duplicatePropertiesInTypeAssertions02.d.ts]
+declare let x: {
+    a: number;
+};

tests/baselines/reference/emitDecoratorMetadata_restArgs.js

@@ -0,0 +1,80 @@
+//// [emitDecoratorMetadata_restArgs.ts]
+
+declare const MyClassDecorator: ClassDecorator;
+declare const MyMethodDecorator: MethodDecorator;
+
+@MyClassDecorator
+class A {
+    constructor(...args) {}
+    @MyMethodDecorator
+    method(...args) {}
+}
+
+@MyClassDecorator
+class B {
+    constructor(...args: number[]) {}
+    @MyMethodDecorator
+    method(...args: string[]) {}
+}
+
+
+//// [emitDecoratorMetadata_restArgs.js]
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var A = (function () {
+    function A() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i - 0] = arguments[_i];
+        }
+    }
+    A.prototype.method = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i - 0] = arguments[_i];
+        }
+    };
+    __decorate([
+        MyMethodDecorator, 
+        __metadata('design:type', Function), 
+        __metadata('design:paramtypes', [Object]), 
+        __metadata('design:returntype', void 0)
+    ], A.prototype, "method", null);
+    A = __decorate([
+        MyClassDecorator, 
+        __metadata('design:paramtypes', [Object])
+    ], A);
+    return A;
+}());
+var B = (function () {
+    function B() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i - 0] = arguments[_i];
+        }
+    }
+    B.prototype.method = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i - 0] = arguments[_i];
+        }
+    };
+    __decorate([
+        MyMethodDecorator, 
+        __metadata('design:type', Function), 
+        __metadata('design:paramtypes', [String]), 
+        __metadata('design:returntype', void 0)
+    ], B.prototype, "method", null);
+    B = __decorate([
+        MyClassDecorator, 
+        __metadata('design:paramtypes', [Number])
+    ], B);
+    return B;
+}());

tests/baselines/reference/emitDecoratorMetadata_restArgs.symbols

@@ -0,0 +1,44 @@
+=== tests/cases/compiler/emitDecoratorMetadata_restArgs.ts ===
+
+declare const MyClassDecorator: ClassDecorator;
+>MyClassDecorator : Symbol(MyClassDecorator, Decl(emitDecoratorMetadata_restArgs.ts, 1, 13))
+>ClassDecorator : Symbol(ClassDecorator, Decl(lib.d.ts, --, --))
+
+declare const MyMethodDecorator: MethodDecorator;
+>MyMethodDecorator : Symbol(MyMethodDecorator, Decl(emitDecoratorMetadata_restArgs.ts, 2, 13))
+>MethodDecorator : Symbol(MethodDecorator, Decl(lib.d.ts, --, --))
+
+@MyClassDecorator
+>MyClassDecorator : Symbol(MyClassDecorator, Decl(emitDecoratorMetadata_restArgs.ts, 1, 13))
+
+class A {
+>A : Symbol(A, Decl(emitDecoratorMetadata_restArgs.ts, 2, 49))
+
+    constructor(...args) {}
+>args : Symbol(args, Decl(emitDecoratorMetadata_restArgs.ts, 6, 16))
+
+    @MyMethodDecorator
+>MyMethodDecorator : Symbol(MyMethodDecorator, Decl(emitDecoratorMetadata_restArgs.ts, 2, 13))
+
+    method(...args) {}
+>method : Symbol(A.method, Decl(emitDecoratorMetadata_restArgs.ts, 6, 27))
+>args : Symbol(args, Decl(emitDecoratorMetadata_restArgs.ts, 8, 11))
+}
+
+@MyClassDecorator
+>MyClassDecorator : Symbol(MyClassDecorator, Decl(emitDecoratorMetadata_restArgs.ts, 1, 13))
+
+class B {
+>B : Symbol(B, Decl(emitDecoratorMetadata_restArgs.ts, 9, 1))
+
+    constructor(...args: number[]) {}
+>args : Symbol(args, Decl(emitDecoratorMetadata_restArgs.ts, 13, 16))
+
+    @MyMethodDecorator
+>MyMethodDecorator : Symbol(MyMethodDecorator, Decl(emitDecoratorMetadata_restArgs.ts, 2, 13))
+
+    method(...args: string[]) {}
+>method : Symbol(B.method, Decl(emitDecoratorMetadata_restArgs.ts, 13, 37))
+>args : Symbol(args, Decl(emitDecoratorMetadata_restArgs.ts, 15, 11))
+}
+

tests/baselines/reference/emitDecoratorMetadata_restArgs.types

@@ -0,0 +1,44 @@
+=== tests/cases/compiler/emitDecoratorMetadata_restArgs.ts ===
+
+declare const MyClassDecorator: ClassDecorator;
+>MyClassDecorator : <TFunction extends Function>(target: TFunction) => TFunction | void
+>ClassDecorator : <TFunction extends Function>(target: TFunction) => TFunction | void
+
+declare const MyMethodDecorator: MethodDecorator;
+>MyMethodDecorator : <T>(target: Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T> | void
+>MethodDecorator : <T>(target: Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T> | void
+
+@MyClassDecorator
+>MyClassDecorator : <TFunction extends Function>(target: TFunction) => TFunction | void
+
+class A {
+>A : A
+
+    constructor(...args) {}
+>args : any[]
+
+    @MyMethodDecorator
+>MyMethodDecorator : <T>(target: Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T> | void
+
+    method(...args) {}
+>method : (...args: any[]) => void
+>args : any[]
+}
+
+@MyClassDecorator
+>MyClassDecorator : <TFunction extends Function>(target: TFunction) => TFunction | void
+
+class B {
+>B : B
+
+    constructor(...args: number[]) {}
+>args : number[]
+
+    @MyMethodDecorator
+>MyMethodDecorator : <T>(target: Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T> | void
+
+    method(...args: string[]) {}
+>method : (...args: string[]) => void
+>args : string[]
+}
+

tests/baselines/reference/emptyTuplesTypeAssertion01.errors.txt

@@ -0,0 +1,9 @@
+tests/cases/conformance/types/tuple/emptyTuples/emptyTuplesTypeAssertion01.ts(2,10): error TS1122: A tuple type element list cannot be empty.
+
+
+==== tests/cases/conformance/types/tuple/emptyTuples/emptyTuplesTypeAssertion01.ts (1 errors) ====
+    
+    let x = <[]>[];
+             ~~
+!!! error TS1122: A tuple type element list cannot be empty.
+    let y = x[0];

tests/baselines/reference/emptyTuplesTypeAssertion01.js

@@ -0,0 +1,13 @@
+//// [emptyTuplesTypeAssertion01.ts]
+
+let x = <[]>[];
+let y = x[0];
+
+//// [emptyTuplesTypeAssertion01.js]
+var x = [];
+var y = x[0];
+
+
+//// [emptyTuplesTypeAssertion01.d.ts]
+declare let x: [];
+declare let y: never;

tests/baselines/reference/emptyTuplesTypeAssertion02.errors.txt

@@ -0,0 +1,9 @@
+tests/cases/conformance/types/tuple/emptyTuples/emptyTuplesTypeAssertion02.ts(2,15): error TS1122: A tuple type element list cannot be empty.
+
+
+==== tests/cases/conformance/types/tuple/emptyTuples/emptyTuplesTypeAssertion02.ts (1 errors) ====
+    
+    let x = [] as [];
+                  ~~
+!!! error TS1122: A tuple type element list cannot be empty.
+    let y = x[0];