merge with origin/master

src/compiler/checker.ts

@@ -1024,7 +1024,7 @@ namespace ts {
         }
 
         function getDeclarationOfAliasSymbol(symbol: Symbol): Declaration {
-            return find(symbol.declarations, d => isAliasSymbolDeclaration(d) ? d : undefined);
+            return findMap(symbol.declarations, d => isAliasSymbolDeclaration(d) ? d : undefined);
         }
 
         function getTargetOfImportEqualsDeclaration(node: ImportEqualsDeclaration): Symbol {
@@ -1361,7 +1361,14 @@ namespace ts {
 
             if (moduleNotFoundError) {
                 // report errors only if it was requested
-                error(moduleReferenceLiteral, moduleNotFoundError, moduleName);
+                const tsExtension = tryExtractTypeScriptExtension(moduleName);
+                if (tsExtension) {
+                    const diag = Diagnostics.An_import_path_cannot_end_with_a_0_extension_Consider_importing_1_instead;
+                    error(moduleReferenceLiteral, diag, tsExtension, removeExtension(moduleName, tsExtension));
+                }
+                else {
+                    error(moduleReferenceLiteral, moduleNotFoundError, moduleName);
+                }
             }
             return undefined;
         }
@@ -3083,7 +3090,7 @@ namespace ts {
 
             // If the declaration specifies a binding pattern, use the type implied by the binding pattern
             if (isBindingPattern(declaration.name)) {
-                return getTypeFromBindingPattern(<BindingPattern>declaration.name, /*includePatternInType*/ false);
+                return getTypeFromBindingPattern(<BindingPattern>declaration.name, /*includePatternInType*/ false, /*reportErrors*/ true);
             }
 
             // No type specified and nothing can be inferred
@@ -3093,23 +3100,21 @@ namespace ts {
         // Return the type implied by a binding pattern element. This is the type of the initializer of the element if
         // one is present. Otherwise, if the element is itself a binding pattern, it is the type implied by the binding
         // pattern. Otherwise, it is the type any.
-        function getTypeFromBindingElement(element: BindingElement, includePatternInType?: boolean): Type {
+        function getTypeFromBindingElement(element: BindingElement, includePatternInType?: boolean, reportErrors?: boolean): Type {
             if (element.initializer) {
-                const type = checkExpressionCached(element.initializer);
-                reportErrorsFromWidening(element, type);
-                return getWidenedType(type);
+                return checkExpressionCached(element.initializer);
             }
             if (isBindingPattern(element.name)) {
-                return getTypeFromBindingPattern(<BindingPattern>element.name, includePatternInType);
+                return getTypeFromBindingPattern(<BindingPattern>element.name, includePatternInType, reportErrors);
             }
-            if (compilerOptions.noImplicitAny && !declarationBelongsToPrivateAmbientMember(element)) {
+            if (reportErrors && compilerOptions.noImplicitAny && !declarationBelongsToPrivateAmbientMember(element)) {
                 reportImplicitAnyError(element, anyType);
             }
             return anyType;
         }
 
         // Return the type implied by an object binding pattern
-        function getTypeFromObjectBindingPattern(pattern: BindingPattern, includePatternInType: boolean): Type {
+        function getTypeFromObjectBindingPattern(pattern: BindingPattern, includePatternInType: boolean, reportErrors: boolean): Type {
             const members = createMap<Symbol>();
             let hasComputedProperties = false;
             forEach(pattern.elements, e => {
@@ -3123,7 +3128,7 @@ namespace ts {
                 const text = getTextOfPropertyName(name);
                 const flags = SymbolFlags.Property | SymbolFlags.Transient | (e.initializer ? SymbolFlags.Optional : 0);
                 const symbol = <TransientSymbol>createSymbol(flags, text);
-                symbol.type = getTypeFromBindingElement(e, includePatternInType);
+                symbol.type = getTypeFromBindingElement(e, includePatternInType, reportErrors);
                 symbol.bindingElement = e;
                 members[symbol.name] = symbol;
             });
@@ -3138,13 +3143,13 @@ namespace ts {
         }
 
         // Return the type implied by an array binding pattern
-        function getTypeFromArrayBindingPattern(pattern: BindingPattern, includePatternInType: boolean): Type {
+        function getTypeFromArrayBindingPattern(pattern: BindingPattern, includePatternInType: boolean, reportErrors: boolean): Type {
             const elements = pattern.elements;
             if (elements.length === 0 || elements[elements.length - 1].dotDotDotToken) {
                 return languageVersion >= ScriptTarget.ES6 ? createIterableType(anyType) : anyArrayType;
             }
             // If the pattern has at least one element, and no rest element, then it should imply a tuple type.
-            const elementTypes = map(elements, e => e.kind === SyntaxKind.OmittedExpression ? anyType : getTypeFromBindingElement(e, includePatternInType));
+            const elementTypes = map(elements, e => e.kind === SyntaxKind.OmittedExpression ? anyType : getTypeFromBindingElement(e, includePatternInType, reportErrors));
             if (includePatternInType) {
                 const result = createNewTupleType(elementTypes);
                 result.pattern = pattern;
@@ -3160,10 +3165,10 @@ namespace ts {
         // used as the contextual type of an initializer associated with the binding pattern. Also, for a destructuring
         // parameter with no type annotation or initializer, the type implied by the binding pattern becomes the type of
         // the parameter.
-        function getTypeFromBindingPattern(pattern: BindingPattern, includePatternInType?: boolean): Type {
+        function getTypeFromBindingPattern(pattern: BindingPattern, includePatternInType?: boolean, reportErrors?: boolean): Type {
             return pattern.kind === SyntaxKind.ObjectBindingPattern
-                ? getTypeFromObjectBindingPattern(pattern, includePatternInType)
-                : getTypeFromArrayBindingPattern(pattern, includePatternInType);
+                ? getTypeFromObjectBindingPattern(pattern, includePatternInType, reportErrors)
+                : getTypeFromArrayBindingPattern(pattern, includePatternInType, reportErrors);
         }
 
         // Return the type associated with a variable, parameter, or property declaration. In the simple case this is the type
@@ -9414,7 +9419,7 @@ namespace ts {
                     }
                 }
                 if (isBindingPattern(declaration.name)) {
-                    return getTypeFromBindingPattern(<BindingPattern>declaration.name, /*includePatternInType*/ true);
+                    return getTypeFromBindingPattern(<BindingPattern>declaration.name, /*includePatternInType*/ true, /*reportErrors*/ false);
                 }
                 if (isBindingPattern(declaration.parent)) {
                     const parentDeclaration = declaration.parent.parent;

src/compiler/core.ts

@@ -113,8 +113,22 @@ namespace ts {
         return undefined;
     }
 
-    /** Like `forEach`, but assumes existence of array and fails if no truthy value is found. */
-    export function find<T, U>(array: T[], callback: (element: T, index: number) => U | undefined): U {
+    /** Works like Array.prototype.find, returning `undefined` if no element satisfying the predicate is found. */
+    export function find<T>(array: T[], predicate: (element: T, index: number) => boolean): T | undefined {
+        for (let i = 0, len = array.length; i < len; i++) {
+            const value = array[i];
+            if (predicate(value, i)) {
+                return value;
+            }
+        }
+        return undefined;
+    }
+
+    /**
+     * Returns the first truthy result of `callback`, or else fails.
+     * This is like `forEach`, but never returns undefined.
+     */
+    export function findMap<T, U>(array: T[], callback: (element: T, index: number) => U | undefined): U {
         for (let i = 0, len = array.length; i < len; i++) {
             const result = callback(array[i], i);
             if (result) {
@@ -1316,6 +1330,8 @@ namespace ts {
      *  List of supported extensions in order of file resolution precedence.
      */
     export const supportedTypeScriptExtensions = [".ts", ".tsx", ".d.ts"];
+    /** Must have ".d.ts" first because if ".ts" goes first, that will be detected as the extension instead of ".d.ts". */
+    export const supportedTypescriptExtensionsForExtractExtension = [".d.ts", ".ts", ".tsx"];
     export const supportedJavascriptExtensions = [".js", ".jsx"];
     const allSupportedExtensions  = supportedTypeScriptExtensions.concat(supportedJavascriptExtensions);
 
@@ -1406,8 +1422,12 @@ namespace ts {
         return path;
     }
 
-    export function tryRemoveExtension(path: string, extension: string): string {
-        return fileExtensionIs(path, extension) ? path.substring(0, path.length - extension.length) : undefined;
+    export function tryRemoveExtension(path: string, extension: string): string | undefined {
+        return fileExtensionIs(path, extension) ? removeExtension(path, extension) : undefined;
+    }
+
+    export function removeExtension(path: string, extension: string): string {
+        return path.substring(0, path.length - extension.length);
     }
 
     export function isJsxOrTsxExtension(ext: string): boolean {

src/compiler/diagnosticMessages.json

@@ -1951,6 +1951,10 @@
         "category": "Error",
         "code": 2690
     },
+    "An import path cannot end with a '{0}' extension. Consider importing '{1}' instead.": {
+        "category": "Error",
+        "code": 2691
+    },
     "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",
         "code": 4000

src/compiler/parser.ts

@@ -3418,6 +3418,7 @@ namespace ts {
          *      6) - UnaryExpression[?yield]
          *      7) ~ UnaryExpression[?yield]
          *      8) ! UnaryExpression[?yield]
+         *      9) [+Await] await UnaryExpression[?yield]
          */
         function parseSimpleUnaryExpression(): UnaryExpression {
             switch (token()) {
@@ -3432,6 +3433,8 @@ namespace ts {
                     return parseTypeOfExpression();
                 case SyntaxKind.VoidKeyword:
                     return parseVoidExpression();
+                case SyntaxKind.AwaitKeyword:
+                    return parseAwaitExpression();
                 case SyntaxKind.LessThanToken:
                     // This is modified UnaryExpression grammar in TypeScript
                     //  UnaryExpression (modified):

src/compiler/program.ts

@@ -661,24 +661,27 @@ namespace ts {
      * @param {boolean} onlyRecordFailures - if true then function won't try to actually load files but instead record all attempts as failures. This flag is necessary
      * in cases when we know upfront that all load attempts will fail (because containing folder does not exists) however we still need to record all failed lookup locations.
      */
-    function loadModuleFromFile(candidate: string, extensions: string[], failedLookupLocation: string[], onlyRecordFailures: boolean, state: ModuleResolutionState): string {
-        // First try to keep/add an extension: importing "./foo.ts" can be matched by a file "./foo.ts", and "./foo" by "./foo.d.ts"
-        const resolvedByAddingOrKeepingExtension = loadModuleFromFileWorker(candidate, extensions, failedLookupLocation, onlyRecordFailures, state);
-        if (resolvedByAddingOrKeepingExtension) {
-            return resolvedByAddingOrKeepingExtension;
+    function loadModuleFromFile(candidate: string, extensions: string[], failedLookupLocation: string[], onlyRecordFailures: boolean, state: ModuleResolutionState): string | undefined {
+        // First, try adding an extension. An import of "foo" could be matched by a file "foo.ts", or "foo.js" by "foo.js.ts"
+        const resolvedByAddingExtension = tryAddingExtensions(candidate, extensions, failedLookupLocation, onlyRecordFailures, state);
+        if (resolvedByAddingExtension) {
+            return resolvedByAddingExtension;
         }
-        // Then try stripping a ".js" or ".jsx" extension and replacing it with a TypeScript one, e.g. "./foo.js" can be matched by "./foo.ts" or "./foo.d.ts"
+
+        // If that didn't work, try stripping a ".js" or ".jsx" extension and replacing it with a TypeScript one;
+        // e.g. "./foo.js" can be matched by "./foo.ts" or "./foo.d.ts"
         if (hasJavaScriptFileExtension(candidate)) {
             const extensionless = removeFileExtension(candidate);
             if (state.traceEnabled) {
                 const extension = candidate.substring(extensionless.length);
                 trace(state.host, Diagnostics.File_name_0_has_a_1_extension_stripping_it, candidate, extension);
             }
-            return loadModuleFromFileWorker(extensionless, extensions, failedLookupLocation, onlyRecordFailures, state);
+            return tryAddingExtensions(extensionless, extensions, failedLookupLocation, onlyRecordFailures, state);
         }
     }
 
-    function loadModuleFromFileWorker(candidate: string, extensions: string[], failedLookupLocation: string[], onlyRecordFailures: boolean, state: ModuleResolutionState): string {
+    /** Try to return an existing file that adds one of the `extensions` to `candidate`. */
+    function tryAddingExtensions(candidate: string, extensions: string[], failedLookupLocation: string[], onlyRecordFailures: boolean, state: ModuleResolutionState): string | undefined {
         if (!onlyRecordFailures) {
             // check if containing folder exists - if it doesn't then just record failures for all supported extensions without disk probing
             const directory = getDirectoryPath(candidate);
@@ -686,26 +689,24 @@ namespace ts {
                 onlyRecordFailures = !directoryProbablyExists(directory, state.host);
             }
         }
-        return forEach(extensions, tryLoad);
+        return forEach(extensions, ext =>
+            !(state.skipTsx && isJsxOrTsxExtension(ext)) && tryFile(candidate + ext, failedLookupLocation, onlyRecordFailures, state));
+    }
 
-        function tryLoad(ext: string): string {
-            if (state.skipTsx && isJsxOrTsxExtension(ext)) {
-                return undefined;
+    /** Return the file if it exists. */
+    function tryFile(fileName: string, failedLookupLocation: string[], onlyRecordFailures: boolean, state: ModuleResolutionState): string | undefined {
+        if (!onlyRecordFailures && state.host.fileExists(fileName)) {
+            if (state.traceEnabled) {
+                trace(state.host, Diagnostics.File_0_exist_use_it_as_a_name_resolution_result, fileName);
             }
-            const fileName = fileExtensionIs(candidate, ext) ? candidate : candidate + ext;
-            if (!onlyRecordFailures && state.host.fileExists(fileName)) {
-                if (state.traceEnabled) {
-                    trace(state.host, Diagnostics.File_0_exist_use_it_as_a_name_resolution_result, fileName);
-                }
-                return fileName;
-            }
-            else {
-                if (state.traceEnabled) {
-                    trace(state.host, Diagnostics.File_0_does_not_exist, fileName);
-                }
-                failedLookupLocation.push(fileName);
-                return undefined;
+            return fileName;
+        }
+        else {
+            if (state.traceEnabled) {
+                trace(state.host, Diagnostics.File_0_does_not_exist, fileName);
             }
+            failedLookupLocation.push(fileName);
+            return undefined;
         }
     }
 
@@ -718,7 +719,9 @@ namespace ts {
             }
             const typesFile = tryReadTypesSection(packageJsonPath, candidate, state);
             if (typesFile) {
-                const result = loadModuleFromFile(typesFile, extensions, failedLookupLocation, !directoryProbablyExists(getDirectoryPath(typesFile), state.host), state);
+                const onlyRecordFailures = !directoryProbablyExists(getDirectoryPath(typesFile), state.host);
+                // The package.json "typings" property must specify the file with extension, so just try that exact filename.
+                const result = tryFile(typesFile, failedLookupLocation, onlyRecordFailures, state);
                 if (result) {
                     return result;
                 }

src/compiler/utilities.ts

@@ -2686,6 +2686,10 @@ namespace ts {
         return symbol && symbol.valueDeclaration && (symbol.valueDeclaration.flags & NodeFlags.Default) ? symbol.valueDeclaration.localSymbol : undefined;
     }
 
+    /** Return ".ts", ".d.ts", or ".tsx", if that is the extension. */
+    export function tryExtractTypeScriptExtension(fileName: string): string | undefined {
+        return find(supportedTypescriptExtensionsForExtractExtension, extension => fileExtensionIs(fileName, extension));
+    }
     /**
      * Replace each instance of non-ascii characters by one, two, three, or four escape sequences
      * representing the UTF-8 encoding of the character, and return the expanded char code list.

src/harness/unittests/moduleResolution.ts

@@ -446,8 +446,8 @@ export = C;
                 "/a/B/c/moduleB.ts": `import a = require("./moduleC")`,
                 "/a/B/c/moduleC.ts": "export var x",
                 "/a/B/c/moduleD.ts": `
-import a = require("./moduleA.ts");
-import b = require("./moduleB.ts");
+import a = require("./moduleA");
+import b = require("./moduleB");
                 `
             });
             test(files, { module: ts.ModuleKind.CommonJS, forceConsistentCasingInFileNames: true },  "/a/B/c", /*useCaseSensitiveFileNames*/ false, ["moduleD.ts"], [1149]);
@@ -458,8 +458,8 @@ import b = require("./moduleB.ts");
                 "/a/B/c/moduleB.ts": `import a = require("./moduleC")`,
                 "/a/B/c/moduleC.ts": "export var x",
                 "/a/B/c/moduleD.ts": `
-import a = require("./moduleA.ts");
-import b = require("./moduleB.ts");
+import a = require("./moduleA");
+import b = require("./moduleB");
                 `
             });
             test(files, { module: ts.ModuleKind.CommonJS, forceConsistentCasingInFileNames: true },  "/a/B/c", /*useCaseSensitiveFileNames*/ false, ["moduleD.ts"], []);

src/harness/unittests/tsserverProjectSystem.ts

@@ -1127,8 +1127,8 @@ namespace ts {
             const file1 = {
                 path: "/a/b/f1.ts",
                 content: `
-                export * from "../c/f2.ts";
-                export * from "../d/f3.ts";`
+                export * from "../c/f2";
+                export * from "../d/f3";`
             };
             const file2 = {
                 path: "/a/c/f2.ts",

src/services/shims.ts

@@ -1188,6 +1188,6 @@ namespace TypeScript.Services {
 // TODO: it should be moved into a namespace though.
 
 /* @internal */
-const toolsVersion = "1.9";
+const toolsVersion = "2.1";
 
 /* tslint:enable:no-unused-variable */

tests/baselines/reference/castOfAwait.js

@@ -0,0 +1,28 @@
+//// [castOfAwait.ts]
+async function f() {
+    <number> await 0;
+    typeof await 0;
+    void await 0;
+    await void <string> typeof <number> void await 0;
+    await await 0;
+}
+
+
+//// [castOfAwait.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 f() {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield 0;
+        typeof yield 0;
+        void yield 0;
+        yield void typeof void yield 0;
+        yield yield 0;
+    });
+}

tests/baselines/reference/castOfAwait.symbols

@@ -0,0 +1,11 @@
+=== tests/cases/compiler/castOfAwait.ts ===
+async function f() {
+>f : Symbol(f, Decl(castOfAwait.ts, 0, 0))
+
+    <number> await 0;
+    typeof await 0;
+    void await 0;
+    await void <string> typeof <number> void await 0;
+    await await 0;
+}
+

tests/baselines/reference/castOfAwait.types

@@ -0,0 +1,35 @@
+=== tests/cases/compiler/castOfAwait.ts ===
+async function f() {
+>f : () => Promise<void>
+
+    <number> await 0;
+><number> await 0 : number
+>await 0 : number
+>0 : number
+
+    typeof await 0;
+>typeof await 0 : string
+>await 0 : number
+>0 : number
+
+    void await 0;
+>void await 0 : undefined
+>await 0 : number
+>0 : number
+
+    await void <string> typeof <number> void await 0;
+>await void <string> typeof <number> void await 0 : any
+>void <string> typeof <number> void await 0 : undefined
+><string> typeof <number> void await 0 : string
+>typeof <number> void await 0 : string
+><number> void await 0 : number
+>void await 0 : undefined
+>await 0 : number
+>0 : number
+
+    await await 0;
+>await await 0 : number
+>await 0 : number
+>0 : number
+}
+

tests/baselines/reference/castOfYield.errors.txt

@@ -0,0 +1,12 @@
+tests/cases/compiler/castOfYield.ts(4,14): error TS1109: Expression expected.
+
+
+==== tests/cases/compiler/castOfYield.ts (1 errors) ====
+    function* f() {
+        <number> (yield 0);
+        // Unlike await, yield is not allowed to appear in a simple unary expression.
+        <number> yield 0;
+                 ~~~~~
+!!! error TS1109: Expression expected.
+    }
+    

tests/baselines/reference/castOfYield.js

@@ -0,0 +1,15 @@
+//// [castOfYield.ts]
+function* f() {
+    <number> (yield 0);
+    // Unlike await, yield is not allowed to appear in a simple unary expression.
+    <number> yield 0;
+}
+
+
+//// [castOfYield.js]
+function f() {
+    (yield 0);
+    // Unlike await, yield is not allowed to appear in a simple unary expression.
+    ;
+    yield 0;
+}

tests/baselines/reference/exportDefaultProperty2.js

@@ -13,7 +13,7 @@ namespace C {
 export default C.B;
 
 //// [b.ts]
-import B from "./a.ts";
+import B from "./a";
 const x: B = { c: B };
 
 
@@ -29,5 +29,5 @@ exports.__esModule = true;
 exports["default"] = C.B;
 //// [b.js]
 "use strict";
-var a_ts_1 = require("./a.ts");
-var x = { c: a_ts_1["default"] };
+var a_1 = require("./a");
+var x = { c: a_1["default"] };

tests/baselines/reference/exportDefaultProperty2.symbols

@@ -21,7 +21,7 @@ export default C.B;
 >B : Symbol(default, Decl(a.ts, 2, 9), Decl(a.ts, 5, 13))
 
 === tests/cases/compiler/b.ts ===
-import B from "./a.ts";
+import B from "./a";
 >B : Symbol(B, Decl(b.ts, 0, 6))
 
 const x: B = { c: B };

tests/baselines/reference/exportDefaultProperty2.types

@@ -21,7 +21,7 @@ export default C.B;
 >B : number
 
 === tests/cases/compiler/b.ts ===
-import B from "./a.ts";
+import B from "./a";
 >B : number
 
 const x: B = { c: B };

tests/baselines/reference/exportEqualsProperty2.js

@@ -13,7 +13,7 @@ namespace C {
 export = C.B;
 
 //// [b.ts]
-import B = require("./a.ts");
+import B = require("./a");
 const x: B = { c: B };
 
 
@@ -28,5 +28,5 @@ var C = (function () {
 module.exports = C.B;
 //// [b.js]
 "use strict";
-var B = require("./a.ts");
+var B = require("./a");
 var x = { c: B };

tests/baselines/reference/exportEqualsProperty2.symbols

@@ -1,5 +1,5 @@
 === tests/cases/compiler/b.ts ===
-import B = require("./a.ts");
+import B = require("./a");
 >B : Symbol(B, Decl(b.ts, 0, 0))
 
 const x: B = { c: B };

tests/baselines/reference/exportEqualsProperty2.types

@@ -1,5 +1,5 @@
 === tests/cases/compiler/b.ts ===
-import B = require("./a.ts");
+import B = require("./a");
 >B : number
 
 const x: B = { c: B };

tests/baselines/reference/missingFunctionImplementation2.errors.txt

@@ -4,7 +4,7 @@ tests/cases/compiler/missingFunctionImplementation2_b.ts(1,17): error TS2391: Fu
 
 ==== tests/cases/compiler/missingFunctionImplementation2_a.ts (1 errors) ====
     export {};
-    declare module "./missingFunctionImplementation2_b.ts" {
+    declare module "./missingFunctionImplementation2_b" {
       export function f(a, b): void;
                       ~
 !!! error TS2384: Overload signatures must all be ambient or non-ambient.

tests/baselines/reference/missingFunctionImplementation2.js

@@ -2,7 +2,7 @@
 
 //// [missingFunctionImplementation2_a.ts]
 export {};
-declare module "./missingFunctionImplementation2_b.ts" {
+declare module "./missingFunctionImplementation2_b" {
   export function f(a, b): void;
 }
 

tests/baselines/reference/moduleResolutionNoTs.errors.txt

@@ -0,0 +1,31 @@
+tests/cases/compiler/user.ts(1,15): error TS2691: An import path cannot end with a '.ts' extension. Consider importing './x' instead.
+tests/cases/compiler/user.ts(2,15): error TS2691: An import path cannot end with a '.tsx' extension. Consider importing './y' instead.
+tests/cases/compiler/user.ts(3,15): error TS2691: An import path cannot end with a '.d.ts' extension. Consider importing './z' instead.
+
+
+==== tests/cases/compiler/x.ts (0 errors) ====
+    export default 0;
+    
+==== tests/cases/compiler/y.tsx (0 errors) ====
+    export default 0;
+    
+==== tests/cases/compiler/z.d.ts (0 errors) ====
+    declare const x: number;
+    export default x;
+    
+==== tests/cases/compiler/user.ts (3 errors) ====
+    import x from "./x.ts";
+                  ~~~~~~~~
+!!! error TS2691: An import path cannot end with a '.ts' extension. Consider importing './x' instead.
+    import y from "./y.tsx";
+                  ~~~~~~~~~
+!!! error TS2691: An import path cannot end with a '.tsx' extension. Consider importing './y' instead.
+    import z from "./z.d.ts";
+                  ~~~~~~~~~~
+!!! error TS2691: An import path cannot end with a '.d.ts' extension. Consider importing './z' instead.
+    
+    // Making sure the suggested fixes are valid:
+    import x2 from "./x";
+    import y2 from "./y";
+    import z2 from "./z";
+    

tests/baselines/reference/moduleResolutionNoTs.js

@@ -0,0 +1,33 @@
+//// [tests/cases/compiler/moduleResolutionNoTs.ts] ////
+
+//// [x.ts]
+export default 0;
+
+//// [y.tsx]
+export default 0;
+
+//// [z.d.ts]
+declare const x: number;
+export default x;
+
+//// [user.ts]
+import x from "./x.ts";
+import y from "./y.tsx";
+import z from "./z.d.ts";
+
+// Making sure the suggested fixes are valid:
+import x2 from "./x";
+import y2 from "./y";
+import z2 from "./z";
+
+
+//// [x.js]
+"use strict";
+exports.__esModule = true;
+exports["default"] = 0;
+//// [y.js]
+"use strict";
+exports.__esModule = true;
+exports["default"] = 0;
+//// [user.js]
+"use strict";

tests/baselines/reference/moduleResolutionWithExtensions.js

@@ -8,10 +8,6 @@ export default 0;
 //// [b.ts]
 import a from './a';
 
-// Matching extension
-//// [c.ts]
-import a from './a.ts';
-
 // '.js' extension: stripped and replaced with '.ts'
 //// [d.ts]
 import a from './a.js';
@@ -36,9 +32,6 @@ exports["default"] = 0;
 // No extension: '.ts' added 
 //// [b.js]
 "use strict";
-// Matching extension 
-//// [c.js]
-"use strict";
 // '.js' extension: stripped and replaced with '.ts' 
 //// [d.js]
 "use strict";

tests/baselines/reference/moduleResolutionWithExtensions.symbols

@@ -7,11 +7,6 @@ No type information for this code.=== /src/b.ts ===
 import a from './a';
 >a : Symbol(a, Decl(b.ts, 0, 6))
 
-// Matching extension
-=== /src/c.ts ===
-import a from './a.ts';
->a : Symbol(a, Decl(c.ts, 0, 6))
-
 // '.js' extension: stripped and replaced with '.ts'
 === /src/d.ts ===
 import a from './a.js';

tests/baselines/reference/moduleResolutionWithExtensions.trace.json

@@ -5,12 +5,6 @@
     "File '/src/a.ts' exist - use it as a name resolution result.",
     "Resolving real path for '/src/a.ts', result '/src/a.ts'",
     "======== Module name './a' was successfully resolved to '/src/a.ts'. ========",
-    "======== Resolving module './a.ts' from '/src/c.ts'. ========",
-    "Module resolution kind is not specified, using 'NodeJs'.",
-    "Loading module as file / folder, candidate module location '/src/a.ts'.",
-    "File '/src/a.ts' exist - use it as a name resolution result.",
-    "Resolving real path for '/src/a.ts', result '/src/a.ts'",
-    "======== Module name './a.ts' was successfully resolved to '/src/a.ts'. ========",
     "======== Resolving module './a.js' from '/src/d.ts'. ========",
     "Module resolution kind is not specified, using 'NodeJs'.",
     "Loading module as file / folder, candidate module location '/src/a.js'.",

tests/baselines/reference/moduleResolutionWithExtensions.types

@@ -7,11 +7,6 @@ No type information for this code.=== /src/b.ts ===
 import a from './a';
 >a : number
 
-// Matching extension
-=== /src/c.ts ===
-import a from './a.ts';
->a : number
-
 // '.js' extension: stripped and replaced with '.ts'
 === /src/d.ts ===
 import a from './a.js';

tests/baselines/reference/noImplicitAnyDestructuringVarDeclaration.errors.txt

@@ -15,11 +15,14 @@ tests/cases/compiler/noImplicitAnyDestructuringVarDeclaration.ts(5,18): error TS
 tests/cases/compiler/noImplicitAnyDestructuringVarDeclaration.ts(7,5): error TS1182: A destructuring declaration must have an initializer.
 tests/cases/compiler/noImplicitAnyDestructuringVarDeclaration.ts(7,13): error TS7008: Member 'b3' implicitly has an 'any' type.
 tests/cases/compiler/noImplicitAnyDestructuringVarDeclaration.ts(7,25): error TS7008: Member 'b3' implicitly has an 'any' type.
-tests/cases/compiler/noImplicitAnyDestructuringVarDeclaration.ts(9,6): error TS7031: Binding element 'a1' implicitly has an 'any' type.
-tests/cases/compiler/noImplicitAnyDestructuringVarDeclaration.ts(9,26): error TS7031: Binding element 'b1' implicitly has an 'any' type.
+tests/cases/compiler/noImplicitAnyDestructuringVarDeclaration.ts(9,6): error TS7031: Binding element 'a4' implicitly has an 'any' type.
+tests/cases/compiler/noImplicitAnyDestructuringVarDeclaration.ts(9,26): error TS7031: Binding element 'b4' implicitly has an 'any' type.
+tests/cases/compiler/noImplicitAnyDestructuringVarDeclaration.ts(9,46): error TS7005: Variable 'c4' implicitly has an 'any' type.
+tests/cases/compiler/noImplicitAnyDestructuringVarDeclaration.ts(9,62): error TS7005: Variable 'd4' implicitly has an 'any' type.
+tests/cases/compiler/noImplicitAnyDestructuringVarDeclaration.ts(11,6): error TS7031: Binding element 'a5' implicitly has an 'any' type.
 
 
-==== tests/cases/compiler/noImplicitAnyDestructuringVarDeclaration.ts (19 errors) ====
+==== tests/cases/compiler/noImplicitAnyDestructuringVarDeclaration.ts (22 errors) ====
     var [a], {b}, c, d; // error
         ~~~
 !!! error TS1182: A destructuring declaration must have an initializer.
@@ -62,8 +65,16 @@ tests/cases/compiler/noImplicitAnyDestructuringVarDeclaration.ts(9,26): error TS
                             ~~
 !!! error TS7008: Member 'b3' implicitly has an 'any' type.
     
-    var [a1] = [undefined], {b1} = { b1: null }, c1 = undefined, d1 = null; // error
+    var [a4] = [undefined], {b4} = { b4: null }, c4 = undefined, d4 = null; // error
          ~~
-!!! error TS7031: Binding element 'a1' implicitly has an 'any' type.
+!!! error TS7031: Binding element 'a4' implicitly has an 'any' type.
                              ~~
-!!! error TS7031: Binding element 'b1' implicitly has an 'any' type.
+!!! error TS7031: Binding element 'b4' implicitly has an 'any' type.
+                                                 ~~
+!!! error TS7005: Variable 'c4' implicitly has an 'any' type.
+                                                                 ~~
+!!! error TS7005: Variable 'd4' implicitly has an 'any' type.
+    
+    var [a5 = undefined] = []; // error
+         ~~
+!!! error TS7031: Binding element 'a5' implicitly has an 'any' type.

tests/baselines/reference/noImplicitAnyDestructuringVarDeclaration.js

@@ -7,11 +7,14 @@ var [a2]: [any], {b2}: { b2: any }, c2: any, d2: any;
 
 var {b3}: { b3 }, c3: { b3 }; // error in type instead
 
-var [a1] = [undefined], {b1} = { b1: null }, c1 = undefined, d1 = null; // error
+var [a4] = [undefined], {b4} = { b4: null }, c4 = undefined, d4 = null; // error
+
+var [a5 = undefined] = []; // error
 
 //// [noImplicitAnyDestructuringVarDeclaration.js]
 var a = (void 0)[0], b = (void 0).b, c, d; // error
 var _a = (void 0)[0], a1 = _a === void 0 ? undefined : _a, _b = (void 0).b1, b1 = _b === void 0 ? null : _b, c1 = undefined, d1 = null; // error
 var a2 = (void 0)[0], b2 = (void 0).b2, c2, d2;
 var b3 = (void 0).b3, c3; // error in type instead
-var a1 = [undefined][0], b1 = { b1: null }.b1, c1 = undefined, d1 = null; // error
+var a4 = [undefined][0], b4 = { b4: null }.b4, c4 = undefined, d4 = null; // error
+var _c = [][0], a5 = _c === void 0 ? undefined : _c; // error

tests/baselines/reference/noImplicitAnyDestructuringVarDeclaration2.js

@@ -0,0 +1,25 @@
+//// [noImplicitAnyDestructuringVarDeclaration2.ts]
+let [a, b, c] = [1, 2, 3]; // no error
+let [a1 = 10, b1 = 10, c1 = 10] = [1, 2, 3]; // no error
+let [a2 = undefined, b2 = undefined, c2 = undefined] = [1, 2, 3]; // no error
+let [a3 = <any>undefined, b3 = <any>null, c3 = <any>undefined] = [1, 2, 3]; // no error
+let [a4] = [<any>undefined], [b4] = [<any>null], c4 = <any>undefined, d4 = <any>null; // no error
+
+let {x, y, z} = { x: 1, y: 2, z: 3 }; // no error
+let {x1 = 10, y1 = 10, z1 = 10} = { x1: 1, y1: 2, z1: 3 }; // no error
+let {x2 = undefined, y2 = undefined, z2 = undefined} = { x2: 1, y2: 2, z2: 3 }; // no error
+let {x3 = <any>undefined, y3 = <any>null, z3 = <any>undefined} = { x3: 1, y3: 2, z3: 3 }; // no error
+let {x4} = { x4: <any>undefined }, {y4} = { y4: <any>null }; // no error
+
+
+//// [noImplicitAnyDestructuringVarDeclaration2.js]
+var _a = [1, 2, 3], a = _a[0], b = _a[1], c = _a[2]; // no error
+var _b = [1, 2, 3], _c = _b[0], a1 = _c === void 0 ? 10 : _c, _d = _b[1], b1 = _d === void 0 ? 10 : _d, _e = _b[2], c1 = _e === void 0 ? 10 : _e; // no error
+var _f = [1, 2, 3], _g = _f[0], a2 = _g === void 0 ? undefined : _g, _h = _f[1], b2 = _h === void 0 ? undefined : _h, _j = _f[2], c2 = _j === void 0 ? undefined : _j; // no error
+var _k = [1, 2, 3], _l = _k[0], a3 = _l === void 0 ? undefined : _l, _m = _k[1], b3 = _m === void 0 ? null : _m, _o = _k[2], c3 = _o === void 0 ? undefined : _o; // no error
+var a4 = [undefined][0], b4 = [null][0], c4 = undefined, d4 = null; // no error
+var _p = { x: 1, y: 2, z: 3 }, x = _p.x, y = _p.y, z = _p.z; // no error
+var _q = { x1: 1, y1: 2, z1: 3 }, _r = _q.x1, x1 = _r === void 0 ? 10 : _r, _s = _q.y1, y1 = _s === void 0 ? 10 : _s, _t = _q.z1, z1 = _t === void 0 ? 10 : _t; // no error
+var _u = { x2: 1, y2: 2, z2: 3 }, _v = _u.x2, x2 = _v === void 0 ? undefined : _v, _w = _u.y2, y2 = _w === void 0 ? undefined : _w, _x = _u.z2, z2 = _x === void 0 ? undefined : _x; // no error
+var _y = { x3: 1, y3: 2, z3: 3 }, _z = _y.x3, x3 = _z === void 0 ? undefined : _z, _0 = _y.y3, y3 = _0 === void 0 ? null : _0, _1 = _y.z3, z3 = _1 === void 0 ? undefined : _1; // no error
+var x4 = { x4: undefined }.x4, y4 = { y4: null }.y4; // no error

tests/baselines/reference/noImplicitAnyDestructuringVarDeclaration2.symbols

@@ -0,0 +1,78 @@
+=== tests/cases/compiler/noImplicitAnyDestructuringVarDeclaration2.ts ===
+let [a, b, c] = [1, 2, 3]; // no error
+>a : Symbol(a, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 0, 5))
+>b : Symbol(b, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 0, 7))
+>c : Symbol(c, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 0, 10))
+
+let [a1 = 10, b1 = 10, c1 = 10] = [1, 2, 3]; // no error
+>a1 : Symbol(a1, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 1, 5))
+>b1 : Symbol(b1, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 1, 13))
+>c1 : Symbol(c1, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 1, 22))
+
+let [a2 = undefined, b2 = undefined, c2 = undefined] = [1, 2, 3]; // no error
+>a2 : Symbol(a2, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 2, 5))
+>undefined : Symbol(undefined)
+>b2 : Symbol(b2, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 2, 20))
+>undefined : Symbol(undefined)
+>c2 : Symbol(c2, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 2, 36))
+>undefined : Symbol(undefined)
+
+let [a3 = <any>undefined, b3 = <any>null, c3 = <any>undefined] = [1, 2, 3]; // no error
+>a3 : Symbol(a3, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 3, 5))
+>undefined : Symbol(undefined)
+>b3 : Symbol(b3, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 3, 25))
+>c3 : Symbol(c3, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 3, 41))
+>undefined : Symbol(undefined)
+
+let [a4] = [<any>undefined], [b4] = [<any>null], c4 = <any>undefined, d4 = <any>null; // no error
+>a4 : Symbol(a4, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 4, 5))
+>undefined : Symbol(undefined)
+>b4 : Symbol(b4, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 4, 30))
+>c4 : Symbol(c4, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 4, 48))
+>undefined : Symbol(undefined)
+>d4 : Symbol(d4, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 4, 69))
+
+let {x, y, z} = { x: 1, y: 2, z: 3 }; // no error
+>x : Symbol(x, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 6, 5))
+>y : Symbol(y, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 6, 7))
+>z : Symbol(z, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 6, 10))
+>x : Symbol(x, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 6, 17))
+>y : Symbol(y, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 6, 23))
+>z : Symbol(z, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 6, 29))
+
+let {x1 = 10, y1 = 10, z1 = 10} = { x1: 1, y1: 2, z1: 3 }; // no error
+>x1 : Symbol(x1, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 7, 5))
+>y1 : Symbol(y1, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 7, 13))
+>z1 : Symbol(z1, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 7, 22))
+>x1 : Symbol(x1, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 7, 35))
+>y1 : Symbol(y1, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 7, 42))
+>z1 : Symbol(z1, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 7, 49))
+
+let {x2 = undefined, y2 = undefined, z2 = undefined} = { x2: 1, y2: 2, z2: 3 }; // no error
+>x2 : Symbol(x2, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 8, 5))
+>undefined : Symbol(undefined)
+>y2 : Symbol(y2, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 8, 20))
+>undefined : Symbol(undefined)
+>z2 : Symbol(z2, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 8, 36))
+>undefined : Symbol(undefined)
+>x2 : Symbol(x2, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 8, 56))
+>y2 : Symbol(y2, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 8, 63))
+>z2 : Symbol(z2, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 8, 70))
+
+let {x3 = <any>undefined, y3 = <any>null, z3 = <any>undefined} = { x3: 1, y3: 2, z3: 3 }; // no error
+>x3 : Symbol(x3, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 9, 5))
+>undefined : Symbol(undefined)
+>y3 : Symbol(y3, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 9, 25))
+>z3 : Symbol(z3, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 9, 41))
+>undefined : Symbol(undefined)
+>x3 : Symbol(x3, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 9, 66))
+>y3 : Symbol(y3, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 9, 73))
+>z3 : Symbol(z3, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 9, 80))
+
+let {x4} = { x4: <any>undefined }, {y4} = { y4: <any>null }; // no error
+>x4 : Symbol(x4, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 10, 5))
+>x4 : Symbol(x4, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 10, 12))
+>undefined : Symbol(undefined)
+>y4 : Symbol(y4, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 10, 36))
+>y4 : Symbol(y4, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 10, 43))
+

tests/baselines/reference/noImplicitAnyDestructuringVarDeclaration2.types

@@ -0,0 +1,137 @@
+=== tests/cases/compiler/noImplicitAnyDestructuringVarDeclaration2.ts ===
+let [a, b, c] = [1, 2, 3]; // no error
+>a : number
+>b : number
+>c : number
+>[1, 2, 3] : [number, number, number]
+>1 : number
+>2 : number
+>3 : number
+
+let [a1 = 10, b1 = 10, c1 = 10] = [1, 2, 3]; // no error
+>a1 : number
+>10 : number
+>b1 : number
+>10 : number
+>c1 : number
+>10 : number
+>[1, 2, 3] : [number, number, number]
+>1 : number
+>2 : number
+>3 : number
+
+let [a2 = undefined, b2 = undefined, c2 = undefined] = [1, 2, 3]; // no error
+>a2 : number
+>undefined : undefined
+>b2 : number
+>undefined : undefined
+>c2 : number
+>undefined : undefined
+>[1, 2, 3] : [number, number, number]
+>1 : number
+>2 : number
+>3 : number
+
+let [a3 = <any>undefined, b3 = <any>null, c3 = <any>undefined] = [1, 2, 3]; // no error
+>a3 : number
+><any>undefined : any
+>undefined : undefined
+>b3 : number
+><any>null : any
+>null : null
+>c3 : number
+><any>undefined : any
+>undefined : undefined
+>[1, 2, 3] : [number, number, number]
+>1 : number
+>2 : number
+>3 : number
+
+let [a4] = [<any>undefined], [b4] = [<any>null], c4 = <any>undefined, d4 = <any>null; // no error
+>a4 : any
+>[<any>undefined] : [any]
+><any>undefined : any
+>undefined : undefined
+>b4 : any
+>[<any>null] : [any]
+><any>null : any
+>null : null
+>c4 : any
+><any>undefined : any
+>undefined : undefined
+>d4 : any
+><any>null : any
+>null : null
+
+let {x, y, z} = { x: 1, y: 2, z: 3 }; // no error
+>x : number
+>y : number
+>z : number
+>{ x: 1, y: 2, z: 3 } : { x: number; y: number; z: number; }
+>x : number
+>1 : number
+>y : number
+>2 : number
+>z : number
+>3 : number
+
+let {x1 = 10, y1 = 10, z1 = 10} = { x1: 1, y1: 2, z1: 3 }; // no error
+>x1 : number
+>10 : number
+>y1 : number
+>10 : number
+>z1 : number
+>10 : number
+>{ x1: 1, y1: 2, z1: 3 } : { x1?: number; y1?: number; z1?: number; }
+>x1 : number
+>1 : number
+>y1 : number
+>2 : number
+>z1 : number
+>3 : number
+
+let {x2 = undefined, y2 = undefined, z2 = undefined} = { x2: 1, y2: 2, z2: 3 }; // no error
+>x2 : number
+>undefined : undefined
+>y2 : number
+>undefined : undefined
+>z2 : number
+>undefined : undefined
+>{ x2: 1, y2: 2, z2: 3 } : { x2?: number; y2?: number; z2?: number; }
+>x2 : number
+>1 : number
+>y2 : number
+>2 : number
+>z2 : number
+>3 : number
+
+let {x3 = <any>undefined, y3 = <any>null, z3 = <any>undefined} = { x3: 1, y3: 2, z3: 3 }; // no error
+>x3 : number
+><any>undefined : any
+>undefined : undefined
+>y3 : number
+><any>null : any
+>null : null
+>z3 : number
+><any>undefined : any
+>undefined : undefined
+>{ x3: 1, y3: 2, z3: 3 } : { x3?: number; y3?: number; z3?: number; }
+>x3 : number
+>1 : number
+>y3 : number
+>2 : number
+>z3 : number
+>3 : number
+
+let {x4} = { x4: <any>undefined }, {y4} = { y4: <any>null }; // no error
+>x4 : any
+>{ x4: <any>undefined } : { x4: any; }
+>x4 : any
+><any>undefined : any
+>undefined : undefined
+>y4 : any
+>{ y4: <any>null } : { y4: any; }
+>y4 : any
+><any>null : any
+>null : null
+

tests/baselines/reference/staticInstanceResolution5.errors.txt

@@ -4,7 +4,7 @@ tests/cases/compiler/staticInstanceResolution5_1.ts(6,16): error TS2304: Cannot
 
 
 ==== tests/cases/compiler/staticInstanceResolution5_1.ts (3 errors) ====
-    import WinJS = require('staticInstanceResolution5_0.ts');
+    import WinJS = require('staticInstanceResolution5_0');
     
     // these 3 should be errors
     var x = (w1: WinJS) => { };

tests/baselines/reference/staticInstanceResolution5.js

@@ -8,7 +8,7 @@ export class Promise {
 }
 
 //// [staticInstanceResolution5_1.ts]
-import WinJS = require('staticInstanceResolution5_0.ts');
+import WinJS = require('staticInstanceResolution5_0');
 
 // these 3 should be errors
 var x = (w1: WinJS) => { };

tests/cases/compiler/castOfAwait.ts

@@ -0,0 +1,8 @@
+// @target: es6
+async function f() {
+    <number> await 0;
+    typeof await 0;
+    void await 0;
+    await void <string> typeof <number> void await 0;
+    await await 0;
+}

tests/cases/compiler/castOfYield.ts

@@ -0,0 +1,5 @@
+function* f() {
+    <number> (yield 0);
+    // Unlike await, yield is not allowed to appear in a simple unary expression.
+    <number> yield 0;
+}

tests/cases/compiler/exportDefaultProperty2.ts

@@ -11,5 +11,5 @@ namespace C {
 export default C.B;
 
 // @Filename: b.ts
-import B from "./a.ts";
+import B from "./a";
 const x: B = { c: B };

tests/cases/compiler/exportEqualsProperty2.ts

@@ -11,5 +11,5 @@ namespace C {
 export = C.B;
 
 // @Filename: b.ts
-import B = require("./a.ts");
+import B = require("./a");
 const x: B = { c: B };

tests/cases/compiler/missingFunctionImplementation2.ts

@@ -1,6 +1,6 @@
 // @Filename: missingFunctionImplementation2_a.ts
 export {};
-declare module "./missingFunctionImplementation2_b.ts" {
+declare module "./missingFunctionImplementation2_b" {
   export function f(a, b): void;
 }
 

tests/cases/compiler/moduleResolutionNoTs.ts

@@ -0,0 +1,19 @@
+// @filename: x.ts
+export default 0;
+
+// @filename: y.tsx
+export default 0;
+
+// @filename: z.d.ts
+declare const x: number;
+export default x;
+
+// @filename: user.ts
+import x from "./x.ts";
+import y from "./y.tsx";
+import z from "./z.d.ts";
+
+// Making sure the suggested fixes are valid:
+import x2 from "./x";
+import y2 from "./y";
+import z2 from "./z";

tests/cases/compiler/noImplicitAnyDestructuringVarDeclaration.ts

@@ -7,4 +7,6 @@ var [a2]: [any], {b2}: { b2: any }, c2: any, d2: any;
 
 var {b3}: { b3 }, c3: { b3 }; // error in type instead
 
-var [a1] = [undefined], {b1} = { b1: null }, c1 = undefined, d1 = null; // error
+var [a4] = [undefined], {b4} = { b4: null }, c4 = undefined, d4 = null; // error
+
+var [a5 = undefined] = []; // error

tests/cases/compiler/noImplicitAnyDestructuringVarDeclaration2.ts

@@ -0,0 +1,12 @@
+// @noimplicitany: true
+let [a, b, c] = [1, 2, 3]; // no error
+let [a1 = 10, b1 = 10, c1 = 10] = [1, 2, 3]; // no error
+let [a2 = undefined, b2 = undefined, c2 = undefined] = [1, 2, 3]; // no error
+let [a3 = <any>undefined, b3 = <any>null, c3 = <any>undefined] = [1, 2, 3]; // no error
+let [a4] = [<any>undefined], [b4] = [<any>null], c4 = <any>undefined, d4 = <any>null; // no error
+
+let {x, y, z} = { x: 1, y: 2, z: 3 }; // no error
+let {x1 = 10, y1 = 10, z1 = 10} = { x1: 1, y1: 2, z1: 3 }; // no error
+let {x2 = undefined, y2 = undefined, z2 = undefined} = { x2: 1, y2: 2, z2: 3 }; // no error
+let {x3 = <any>undefined, y3 = <any>null, z3 = <any>undefined} = { x3: 1, y3: 2, z3: 3 }; // no error
+let {x4} = { x4: <any>undefined }, {y4} = { y4: <any>null }; // no error

tests/cases/compiler/staticInstanceResolution5.ts

@@ -7,7 +7,7 @@ export class Promise {
 }
 
 // @Filename: staticInstanceResolution5_1.ts
-import WinJS = require('staticInstanceResolution5_0.ts');
+import WinJS = require('staticInstanceResolution5_0');
 
 // these 3 should be errors
 var x = (w1: WinJS) => { };

tests/cases/conformance/externalModules/moduleResolutionWithExtensions.ts

@@ -7,10 +7,6 @@ export default 0;
 // @Filename: /src/b.ts
 import a from './a';
 
-// Matching extension
-// @Filename: /src/c.ts
-import a from './a.ts';
-
 // '.js' extension: stripped and replaced with '.ts'
 // @Filename: /src/d.ts
 import a from './a.js';