Merge pull request #13220 from Microsoft/mergeMaster1229

Merge master 12/29

src/compiler/checker.ts

@@ -1,4 +1,4 @@
-/// <reference path="moduleNameResolver.ts"/>
+/// <reference path="moduleNameResolver.ts"/>
 /// <reference path="binder.ts"/>
 
 /* @internal */
@@ -17233,7 +17233,7 @@ namespace ts {
             }
 
             if (node.kind === SyntaxKind.BindingElement) {
-                if (node.parent.kind === SyntaxKind.ObjectBindingPattern && languageVersion < ScriptTarget.ESNext) {
+                if (node.parent.kind === SyntaxKind.ObjectBindingPattern && languageVersion < ScriptTarget.ESNext && !isInAmbientContext(node)) {
                     checkExternalEmitHelpers(node, ExternalEmitHelpers.Rest);
                 }
                 // check computed properties inside property names of binding elements

src/compiler/visitor.ts

@@ -1328,7 +1328,7 @@ namespace ts {
     function aggregateTransformFlagsForSubtree(node: Node): TransformFlags {
         // We do not transform ambient declarations or types, so there is no need to
         // recursively aggregate transform flags.
-        if (hasModifier(node, ModifierFlags.Ambient) || isTypeNode(node)) {
+        if (hasModifier(node, ModifierFlags.Ambient) || (isTypeNode(node) && node.kind !== SyntaxKind.ExpressionWithTypeArguments)) {
             return TransformFlags.None;
         }
 

tests/baselines/reference/importHelpersInAmbientContext.js

@@ -0,0 +1,59 @@
+//// [tests/cases/compiler/importHelpersInAmbientContext.ts] ////
+
+//// [a.d.ts]
+
+export { };
+
+// Extends
+declare class C { }
+declare class D extends C { }
+
+// Destructuring
+interface I {
+    ({descendants, read}?: {
+        descendants?: boolean;
+        read?: any;
+    }): any;
+}
+
+
+// Object Rest
+interface Foo {
+    a: number; b: string;
+}
+export var { a, ...x } : Foo;
+
+//// [b.ts]
+export {};
+declare namespace N {
+	// Extends
+	class C { }
+	class D extends C { }
+
+	// Destructuring
+	interface I {
+		({descendants, read}?: {
+			descendants?: boolean;
+			read?: any;
+		}): any;
+	}
+
+
+	// Object Rest
+	interface Foo {
+		a: number; b: string;
+	}
+	export var { a, ...x } : Foo;
+}
+
+//// [tslib.d.ts]
+export declare function __extends(d: Function, b: Function): void;
+export declare function __assign(t: any, ...sources: any[]): any;
+export declare function __decorate(decorators: Function[], target: any, key?: string | symbol, desc?: any): any;
+export declare function __param(paramIndex: number, decorator: Function): Function;
+export declare function __metadata(metadataKey: any, metadataValue: any): Function;
+export declare function __awaiter(thisArg: any, _arguments: any, P: Function, generator: Function): any;
+
+
+//// [b.js]
+"use strict";

tests/baselines/reference/importHelpersInAmbientContext.symbols

@@ -0,0 +1,131 @@
+=== tests/cases/compiler/a.d.ts ===
+
+export { };
+
+// Extends
+declare class C { }
+>C : Symbol(C, Decl(a.d.ts, 1, 11))
+
+declare class D extends C { }
+>D : Symbol(D, Decl(a.d.ts, 4, 19))
+>C : Symbol(C, Decl(a.d.ts, 1, 11))
+
+// Destructuring
+interface I {
+>I : Symbol(I, Decl(a.d.ts, 5, 29))
+
+    ({descendants, read}?: {
+>descendants : Symbol(descendants, Decl(a.d.ts, 9, 6))
+>read : Symbol(read, Decl(a.d.ts, 9, 18))
+
+        descendants?: boolean;
+>descendants : Symbol(descendants, Decl(a.d.ts, 9, 28))
+
+        read?: any;
+>read : Symbol(read, Decl(a.d.ts, 10, 30))
+
+    }): any;
+}
+
+
+// Object Rest
+interface Foo {
+>Foo : Symbol(Foo, Decl(a.d.ts, 13, 1))
+
+    a: number; b: string;
+>a : Symbol(Foo.a, Decl(a.d.ts, 17, 15))
+>b : Symbol(Foo.b, Decl(a.d.ts, 18, 14))
+}
+export var { a, ...x } : Foo;
+>a : Symbol(a, Decl(a.d.ts, 20, 12))
+>x : Symbol(x, Decl(a.d.ts, 20, 15))
+>Foo : Symbol(Foo, Decl(a.d.ts, 13, 1))
+
+=== tests/cases/compiler/b.ts ===
+export {};
+declare namespace N {
+>N : Symbol(N, Decl(b.ts, 0, 10))
+
+	// Extends
+	class C { }
+>C : Symbol(C, Decl(b.ts, 1, 21))
+
+	class D extends C { }
+>D : Symbol(D, Decl(b.ts, 3, 12))
+>C : Symbol(C, Decl(b.ts, 1, 21))
+
+	// Destructuring
+	interface I {
+>I : Symbol(I, Decl(b.ts, 4, 22))
+
+		({descendants, read}?: {
+>descendants : Symbol(descendants, Decl(b.ts, 8, 4))
+>read : Symbol(read, Decl(b.ts, 8, 16))
+
+			descendants?: boolean;
+>descendants : Symbol(descendants, Decl(b.ts, 8, 26))
+
+			read?: any;
+>read : Symbol(read, Decl(b.ts, 9, 25))
+
+		}): any;
+	}
+
+
+	// Object Rest
+	interface Foo {
+>Foo : Symbol(Foo, Decl(b.ts, 12, 2))
+
+		a: number; b: string;
+>a : Symbol(Foo.a, Decl(b.ts, 16, 16))
+>b : Symbol(Foo.b, Decl(b.ts, 17, 12))
+	}
+	export var { a, ...x } : Foo;
+>a : Symbol(a, Decl(b.ts, 19, 13))
+>x : Symbol(x, Decl(b.ts, 19, 16))
+>Foo : Symbol(Foo, Decl(b.ts, 12, 2))
+}
+
+=== tests/cases/compiler/tslib.d.ts ===
+export declare function __extends(d: Function, b: Function): void;
+>__extends : Symbol(__extends, Decl(tslib.d.ts, --, --))
+>d : Symbol(d, Decl(tslib.d.ts, --, --))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>b : Symbol(b, Decl(tslib.d.ts, --, --))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+
+export declare function __assign(t: any, ...sources: any[]): any;
+>__assign : Symbol(__assign, Decl(tslib.d.ts, --, --))
+>t : Symbol(t, Decl(tslib.d.ts, --, --))
+>sources : Symbol(sources, Decl(tslib.d.ts, --, --))
+
+export declare function __decorate(decorators: Function[], target: any, key?: string | symbol, desc?: any): any;
+>__decorate : Symbol(__decorate, Decl(tslib.d.ts, --, --))
+>decorators : Symbol(decorators, Decl(tslib.d.ts, --, --))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>target : Symbol(target, Decl(tslib.d.ts, --, --))
+>key : Symbol(key, Decl(tslib.d.ts, --, --))
+>desc : Symbol(desc, Decl(tslib.d.ts, --, --))
+
+export declare function __param(paramIndex: number, decorator: Function): Function;
+>__param : Symbol(__param, Decl(tslib.d.ts, --, --))
+>paramIndex : Symbol(paramIndex, Decl(tslib.d.ts, --, --))
+>decorator : Symbol(decorator, Decl(tslib.d.ts, --, --))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+
+export declare function __metadata(metadataKey: any, metadataValue: any): Function;
+>__metadata : Symbol(__metadata, Decl(tslib.d.ts, --, --))
+>metadataKey : Symbol(metadataKey, Decl(tslib.d.ts, --, --))
+>metadataValue : Symbol(metadataValue, Decl(tslib.d.ts, --, --))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+
+export declare function __awaiter(thisArg: any, _arguments: any, P: Function, generator: Function): any;
+>__awaiter : Symbol(__awaiter, Decl(tslib.d.ts, --, --))
+>thisArg : Symbol(thisArg, Decl(tslib.d.ts, --, --))
+>_arguments : Symbol(_arguments, Decl(tslib.d.ts, --, --))
+>P : Symbol(P, Decl(tslib.d.ts, --, --))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>generator : Symbol(generator, Decl(tslib.d.ts, --, --))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+

tests/baselines/reference/importHelpersInAmbientContext.types

@@ -0,0 +1,131 @@
+=== tests/cases/compiler/a.d.ts ===
+
+export { };
+
+// Extends
+declare class C { }
+>C : C
+
+declare class D extends C { }
+>D : D
+>C : C
+
+// Destructuring
+interface I {
+>I : I
+
+    ({descendants, read}?: {
+>descendants : boolean
+>read : any
+
+        descendants?: boolean;
+>descendants : boolean
+
+        read?: any;
+>read : any
+
+    }): any;
+}
+
+
+// Object Rest
+interface Foo {
+>Foo : Foo
+
+    a: number; b: string;
+>a : number
+>b : string
+}
+export var { a, ...x } : Foo;
+>a : number
+>x : { b: string; }
+>Foo : Foo
+
+=== tests/cases/compiler/b.ts ===
+export {};
+declare namespace N {
+>N : typeof N
+
+	// Extends
+	class C { }
+>C : C
+
+	class D extends C { }
+>D : D
+>C : C
+
+	// Destructuring
+	interface I {
+>I : I
+
+		({descendants, read}?: {
+>descendants : boolean
+>read : any
+
+			descendants?: boolean;
+>descendants : boolean
+
+			read?: any;
+>read : any
+
+		}): any;
+	}
+
+
+	// Object Rest
+	interface Foo {
+>Foo : Foo
+
+		a: number; b: string;
+>a : number
+>b : string
+	}
+	export var { a, ...x } : Foo;
+>a : number
+>x : { b: string; }
+>Foo : Foo
+}
+
+=== tests/cases/compiler/tslib.d.ts ===
+export declare function __extends(d: Function, b: Function): void;
+>__extends : (d: Function, b: Function) => void
+>d : Function
+>Function : Function
+>b : Function
+>Function : Function
+
+export declare function __assign(t: any, ...sources: any[]): any;
+>__assign : (t: any, ...sources: any[]) => any
+>t : any
+>sources : any[]
+
+export declare function __decorate(decorators: Function[], target: any, key?: string | symbol, desc?: any): any;
+>__decorate : (decorators: Function[], target: any, key?: string | symbol, desc?: any) => any
+>decorators : Function[]
+>Function : Function
+>target : any
+>key : string | symbol
+>desc : any
+
+export declare function __param(paramIndex: number, decorator: Function): Function;
+>__param : (paramIndex: number, decorator: Function) => Function
+>paramIndex : number
+>decorator : Function
+>Function : Function
+>Function : Function
+
+export declare function __metadata(metadataKey: any, metadataValue: any): Function;
+>__metadata : (metadataKey: any, metadataValue: any) => Function
+>metadataKey : any
+>metadataValue : any
+>Function : Function
+
+export declare function __awaiter(thisArg: any, _arguments: any, P: Function, generator: Function): any;
+>__awaiter : (thisArg: any, _arguments: any, P: Function, generator: Function) => any
+>thisArg : any
+>_arguments : any
+>P : Function
+>Function : Function
+>generator : Function
+>Function : Function
+

tests/baselines/reference/jsxInExtendsClause.js

@@ -0,0 +1,35 @@
+//// [jsxInExtendsClause.tsx]
+// https://github.com/Microsoft/TypeScript/issues/13157
+declare namespace React {
+  interface ComponentClass<P> { new (): Component<P, {}>; }
+  class Component<A, B> {}
+}
+declare function createComponentClass<P>(factory: () => React.ComponentClass<P>): React.ComponentClass<P>;
+class Foo extends createComponentClass(() => class extends React.Component<{}, {}> {
+  render() {
+    return <span>Hello, world!</span>;
+  }
+}) {}
+
+//// [jsxInExtendsClause.js]
+var __extends = (this && this.__extends) || function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+};
+var Foo = (function (_super) {
+    __extends(Foo, _super);
+    function Foo() {
+        return _super.apply(this, arguments) || this;
+    }
+    return Foo;
+}(createComponentClass(function () { return (function (_super) {
+    __extends(class_1, _super);
+    function class_1() {
+        return _super.apply(this, arguments) || this;
+    }
+    class_1.prototype.render = function () {
+        return React.createElement("span", null, "Hello, world!");
+    };
+    return class_1;
+}(React.Component)); })));

tests/baselines/reference/jsxInExtendsClause.symbols

@@ -0,0 +1,42 @@
+=== tests/cases/compiler/jsxInExtendsClause.tsx ===
+// https://github.com/Microsoft/TypeScript/issues/13157
+declare namespace React {
+>React : Symbol(React, Decl(jsxInExtendsClause.tsx, 0, 0))
+
+  interface ComponentClass<P> { new (): Component<P, {}>; }
+>ComponentClass : Symbol(ComponentClass, Decl(jsxInExtendsClause.tsx, 1, 25))
+>P : Symbol(P, Decl(jsxInExtendsClause.tsx, 2, 27))
+>Component : Symbol(Component, Decl(jsxInExtendsClause.tsx, 2, 59))
+>P : Symbol(P, Decl(jsxInExtendsClause.tsx, 2, 27))
+
+  class Component<A, B> {}
+>Component : Symbol(Component, Decl(jsxInExtendsClause.tsx, 2, 59))
+>A : Symbol(A, Decl(jsxInExtendsClause.tsx, 3, 18))
+>B : Symbol(B, Decl(jsxInExtendsClause.tsx, 3, 20))
+}
+declare function createComponentClass<P>(factory: () => React.ComponentClass<P>): React.ComponentClass<P>;
+>createComponentClass : Symbol(createComponentClass, Decl(jsxInExtendsClause.tsx, 4, 1))
+>P : Symbol(P, Decl(jsxInExtendsClause.tsx, 5, 38))
+>factory : Symbol(factory, Decl(jsxInExtendsClause.tsx, 5, 41))
+>React : Symbol(React, Decl(jsxInExtendsClause.tsx, 0, 0))
+>ComponentClass : Symbol(React.ComponentClass, Decl(jsxInExtendsClause.tsx, 1, 25))
+>P : Symbol(P, Decl(jsxInExtendsClause.tsx, 5, 38))
+>React : Symbol(React, Decl(jsxInExtendsClause.tsx, 0, 0))
+>ComponentClass : Symbol(React.ComponentClass, Decl(jsxInExtendsClause.tsx, 1, 25))
+>P : Symbol(P, Decl(jsxInExtendsClause.tsx, 5, 38))
+
+class Foo extends createComponentClass(() => class extends React.Component<{}, {}> {
+>Foo : Symbol(Foo, Decl(jsxInExtendsClause.tsx, 5, 106))
+>createComponentClass : Symbol(createComponentClass, Decl(jsxInExtendsClause.tsx, 4, 1))
+>React.Component : Symbol(React.Component, Decl(jsxInExtendsClause.tsx, 2, 59))
+>React : Symbol(React, Decl(jsxInExtendsClause.tsx, 0, 0))
+>Component : Symbol(React.Component, Decl(jsxInExtendsClause.tsx, 2, 59))
+
+  render() {
+>render : Symbol((Anonymous class).render, Decl(jsxInExtendsClause.tsx, 6, 84))
+
+    return <span>Hello, world!</span>;
+>span : Symbol(unknown)
+>span : Symbol(unknown)
+  }
+}) {}

tests/baselines/reference/jsxInExtendsClause.types

@@ -0,0 +1,46 @@
+=== tests/cases/compiler/jsxInExtendsClause.tsx ===
+// https://github.com/Microsoft/TypeScript/issues/13157
+declare namespace React {
+>React : typeof React
+
+  interface ComponentClass<P> { new (): Component<P, {}>; }
+>ComponentClass : ComponentClass<P>
+>P : P
+>Component : Component<A, B>
+>P : P
+
+  class Component<A, B> {}
+>Component : Component<A, B>
+>A : A
+>B : B
+}
+declare function createComponentClass<P>(factory: () => React.ComponentClass<P>): React.ComponentClass<P>;
+>createComponentClass : <P>(factory: () => React.ComponentClass<P>) => React.ComponentClass<P>
+>P : P
+>factory : () => React.ComponentClass<P>
+>React : any
+>ComponentClass : React.ComponentClass<P>
+>P : P
+>React : any
+>ComponentClass : React.ComponentClass<P>
+>P : P
+
+class Foo extends createComponentClass(() => class extends React.Component<{}, {}> {
+>Foo : Foo
+>createComponentClass(() => class extends React.Component<{}, {}> {  render() {    return <span>Hello, world!</span>;  }}) : React.Component<{}, {}>
+>createComponentClass : <P>(factory: () => React.ComponentClass<P>) => React.ComponentClass<P>
+>() => class extends React.Component<{}, {}> {  render() {    return <span>Hello, world!</span>;  }} : () => typeof (Anonymous class)
+>class extends React.Component<{}, {}> {  render() {    return <span>Hello, world!</span>;  }} : typeof (Anonymous class)
+>React.Component : React.Component<{}, {}>
+>React : typeof React
+>Component : typeof React.Component
+
+  render() {
+>render : () => any
+
+    return <span>Hello, world!</span>;
+><span>Hello, world!</span> : any
+>span : any
+>span : any
+  }
+}) {}

tests/cases/compiler/importHelpersInAmbientContext.ts

@@ -0,0 +1,55 @@
+// @importHelpers: true
+// @target: es5
+
+// @filename: a.d.ts
+export { };
+
+// Extends
+declare class C { }
+declare class D extends C { }
+
+// Destructuring
+interface I {
+    ({descendants, read}?: {
+        descendants?: boolean;
+        read?: any;
+    }): any;
+}
+
+
+// Object Rest
+interface Foo {
+    a: number; b: string;
+}
+export var { a, ...x } : Foo;
+
+// @filename: b.ts
+export {};
+declare namespace N {
+	// Extends
+	class C { }
+	class D extends C { }
+
+	// Destructuring
+	interface I {
+		({descendants, read}?: {
+			descendants?: boolean;
+			read?: any;
+		}): any;
+	}
+
+
+	// Object Rest
+	interface Foo {
+		a: number; b: string;
+	}
+	export var { a, ...x } : Foo;
+}
+
+// @filename: tslib.d.ts
+export declare function __extends(d: Function, b: Function): void;
+export declare function __assign(t: any, ...sources: any[]): any;
+export declare function __decorate(decorators: Function[], target: any, key?: string | symbol, desc?: any): any;
+export declare function __param(paramIndex: number, decorator: Function): Function;
+export declare function __metadata(metadataKey: any, metadataValue: any): Function;
+export declare function __awaiter(thisArg: any, _arguments: any, P: Function, generator: Function): any;

tests/cases/compiler/jsxInExtendsClause.tsx

@@ -0,0 +1,12 @@
+// @jsx: react
+// https://github.com/Microsoft/TypeScript/issues/13157
+declare namespace React {
+  interface ComponentClass<P> { new (): Component<P, {}>; }
+  class Component<A, B> {}
+}
+declare function createComponentClass<P>(factory: () => React.ComponentClass<P>): React.ComponentClass<P>;
+class Foo extends createComponentClass(() => class extends React.Component<{}, {}> {
+  render() {
+    return <span>Hello, world!</span>;
+  }
+}) {}