Do not report helper module errors in ambient contexts for Rest helper

microsoft · Dec 29, 2016 · bf7c51c · bf7c51c
1 parent 708f9e5
commit bf7c51c
Show file tree

Hide file tree

Showing 5 changed files with 378 additions and 2 deletions.
diff --git a/src/compiler/checker.ts b/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

diff --git a/tests/baselines/reference/importHelpersInAmbientContext.js b/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";
diff --git a/tests/baselines/reference/importHelpersInAmbientContext.symbols b/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, --, --))
+
diff --git a/tests/baselines/reference/importHelpersInAmbientContext.types b/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
+
diff --git a/tests/cases/compiler/importHelpersInAmbientContext.ts b/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;