From eff81b933c38cb7cb89686a4652a33a34f9a0e69 Mon Sep 17 00:00:00 2001 From: Kanchalai Tanglertsampan Date: Mon, 28 Mar 2016 14:28:27 -0700 Subject: [PATCH] Add compiler-baseline tests and associated baselines for --lib flag Add --lib compiler tests and baselines Remove old compiler baselines --- ...singES6ArrayWithOnlyES6ArrayLib.errors.txt | 30 +++ ...rorFromUsingES6ArrayWithOnlyES6ArrayLib.js | 16 ++ ...mUsingES6FeaturesWithOnlyES5Lib.errors.txt | 94 +++++++ ...ErrorFromUsingES6FeaturesWithOnlyES5Lib.js | 101 ++++++++ ...bolWithOutES6WellknownSymbolLib.errors.txt | 17 ++ ...knownSymbolWithOutES6WellknownSymbolLib.js | 17 ++ ...rizeLibrary_NoErrorDuplicateLibOptions1.js | 158 ++++++++++++ ...ibrary_NoErrorDuplicateLibOptions1.symbols | 184 ++++++++++++++ ...eLibrary_NoErrorDuplicateLibOptions1.types | 231 ++++++++++++++++++ ...rizeLibrary_NoErrorDuplicateLibOptions2.js | 158 ++++++++++++ ...ibrary_NoErrorDuplicateLibOptions2.symbols | 184 ++++++++++++++ ...eLibrary_NoErrorDuplicateLibOptions2.types | 231 ++++++++++++++++++ .../modularizeLibrary_TargetES5UsingES6Lib.js | 158 ++++++++++++ ...larizeLibrary_TargetES5UsingES6Lib.symbols | 184 ++++++++++++++ ...dularizeLibrary_TargetES5UsingES6Lib.types | 231 ++++++++++++++++++ .../modularizeLibrary_TargetES6UsingES6Lib.js | 99 ++++++++ ...larizeLibrary_TargetES6UsingES6Lib.symbols | 126 ++++++++++ ...dularizeLibrary_TargetES6UsingES6Lib.types | 154 ++++++++++++ ...larizeLibrary_UsingES5LibAndES6ArrayLib.js | 15 ++ ...eLibrary_UsingES5LibAndES6ArrayLib.symbols | 19 ++ ...izeLibrary_UsingES5LibAndES6ArrayLib.types | 24 ++ ...izeLibrary_UsingES5LibAndES6FeatureLibs.js | 27 ++ ...brary_UsingES5LibAndES6FeatureLibs.symbols | 33 +++ ...Library_UsingES5LibAndES6FeatureLibs.types | 45 ++++ ...gES5LibES6ArrayLibES6WellknownSymbolLib.js | 17 ++ ...ibES6ArrayLibES6WellknownSymbolLib.symbols | 27 ++ ...5LibES6ArrayLibES6WellknownSymbolLib.types | 38 +++ ...rorFromUsingES6ArrayWithOnlyES6ArrayLib.ts | 9 + ...ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts | 57 +++++ ...knownSymbolWithOutES6WellknownSymbolLib.ts | 9 + ...rizeLibrary_NoErrorDuplicateLibOptions1.ts | 83 +++++++ ...rizeLibrary_NoErrorDuplicateLibOptions2.ts | 83 +++++++ .../modularizeLibrary_TargetES5UsingES6Lib.ts | 83 +++++++ .../modularizeLibrary_TargetES6UsingES6Lib.ts | 56 +++++ ...larizeLibrary_UsingES5LibAndES6ArrayLib.ts | 9 + ...izeLibrary_UsingES5LibAndES6FeatureLibs.ts | 15 ++ ...gES5LibES6ArrayLibES6WellknownSymbolLib.ts | 9 + 37 files changed, 3031 insertions(+) create mode 100644 tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6ArrayWithOnlyES6ArrayLib.errors.txt create mode 100644 tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6ArrayWithOnlyES6ArrayLib.js create mode 100644 tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.errors.txt create mode 100644 tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.js create mode 100644 tests/baselines/reference/modularizeLibrary_ErrorFromUsingWellknownSymbolWithOutES6WellknownSymbolLib.errors.txt create mode 100644 tests/baselines/reference/modularizeLibrary_ErrorFromUsingWellknownSymbolWithOutES6WellknownSymbolLib.js create mode 100644 tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.js create mode 100644 tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.symbols create mode 100644 tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types create mode 100644 tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.js create mode 100644 tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.symbols create mode 100644 tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types create mode 100644 tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.js create mode 100644 tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.symbols create mode 100644 tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types create mode 100644 tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.js create mode 100644 tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.symbols create mode 100644 tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.types create mode 100644 tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6ArrayLib.js create mode 100644 tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6ArrayLib.symbols create mode 100644 tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6ArrayLib.types create mode 100644 tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.js create mode 100644 tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.symbols create mode 100644 tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.types create mode 100644 tests/baselines/reference/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.js create mode 100644 tests/baselines/reference/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.symbols create mode 100644 tests/baselines/reference/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.types create mode 100644 tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6ArrayWithOnlyES6ArrayLib.ts create mode 100644 tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts create mode 100644 tests/cases/compiler/modularizeLibrary_ErrorFromUsingWellknownSymbolWithOutES6WellknownSymbolLib.ts create mode 100644 tests/cases/compiler/modularizeLibrary_NoErrorDuplicateLibOptions1.ts create mode 100644 tests/cases/compiler/modularizeLibrary_NoErrorDuplicateLibOptions2.ts create mode 100644 tests/cases/compiler/modularizeLibrary_TargetES5UsingES6Lib.ts create mode 100644 tests/cases/compiler/modularizeLibrary_TargetES6UsingES6Lib.ts create mode 100644 tests/cases/compiler/modularizeLibrary_UsingES5LibAndES6ArrayLib.ts create mode 100644 tests/cases/compiler/modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts create mode 100644 tests/cases/compiler/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.ts diff --git a/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6ArrayWithOnlyES6ArrayLib.errors.txt b/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6ArrayWithOnlyES6ArrayLib.errors.txt new file mode 100644 index 00000000000..3fb82ebb5f2 --- /dev/null +++ b/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6ArrayWithOnlyES6ArrayLib.errors.txt @@ -0,0 +1,30 @@ +error TS2318: Cannot find global type 'Boolean'. +error TS2318: Cannot find global type 'Function'. +error TS2318: Cannot find global type 'IArguments'. +error TS2318: Cannot find global type 'Number'. +error TS2318: Cannot find global type 'Object'. +error TS2318: Cannot find global type 'RegExp'. +error TS2318: Cannot find global type 'String'. +lib.es6.array.d.ts(68,27): error TS2304: Cannot find name 'ArrayLike'. +lib.es6.array.d.ts(75,24): error TS2304: Cannot find name 'ArrayLike'. +tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6ArrayWithOnlyES6ArrayLib.ts(4,12): error TS2304: Cannot find name 'Array'. + + +!!! error TS2318: Cannot find global type 'Boolean'. +!!! error TS2318: Cannot find global type 'Function'. +!!! error TS2318: Cannot find global type 'IArguments'. +!!! error TS2318: Cannot find global type 'Number'. +!!! error TS2318: Cannot find global type 'Object'. +!!! error TS2318: Cannot find global type 'RegExp'. +!!! error TS2318: Cannot find global type 'String'. +==== tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6ArrayWithOnlyES6ArrayLib.ts (1 errors) ==== + + // Error missing basic JavaScript objects + function f(x: number, y: number, z: number) { + return Array.from(arguments); + ~~~~~ +!!! error TS2304: Cannot find name 'Array'. + } + + f(1, 2, 3); + \ No newline at end of file diff --git a/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6ArrayWithOnlyES6ArrayLib.js b/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6ArrayWithOnlyES6ArrayLib.js new file mode 100644 index 00000000000..61591a5f7e1 --- /dev/null +++ b/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6ArrayWithOnlyES6ArrayLib.js @@ -0,0 +1,16 @@ +//// [modularizeLibrary_ErrorFromUsingES6ArrayWithOnlyES6ArrayLib.ts] + +// Error missing basic JavaScript objects +function f(x: number, y: number, z: number) { + return Array.from(arguments); +} + +f(1, 2, 3); + + +//// [modularizeLibrary_ErrorFromUsingES6ArrayWithOnlyES6ArrayLib.js] +// Error missing basic JavaScript objects +function f(x, y, z) { + return Array.from(arguments); +} +f(1, 2, 3); diff --git a/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.errors.txt b/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.errors.txt new file mode 100644 index 00000000000..c8a69546ee0 --- /dev/null +++ b/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.errors.txt @@ -0,0 +1,94 @@ +tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(5,18): error TS2339: Property 'from' does not exist on type 'ArrayConstructor'. +tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(11,13): error TS2304: Cannot find name 'Map'. +tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(18,5): error TS2339: Property 'name' does not exist on type '() => void'. +tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(21,6): error TS2339: Property 'sign' does not exist on type 'Math'. +tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(26,6): error TS2304: Cannot find name 'Symbol'. +tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(30,18): error TS2304: Cannot find name 'Symbol'. +tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(34,13): error TS2304: Cannot find name 'Proxy'. +tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(37,1): error TS2304: Cannot find name 'Reflect'. +tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(41,5): error TS2339: Property 'flags' does not exist on type 'RegExp'. +tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(45,5): error TS2339: Property 'includes' does not exist on type 'string'. +tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(48,9): error TS2304: Cannot find name 'Symbol'. +tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts(52,6): error TS2304: Cannot find name 'Symbol'. + + +==== tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts (12 errors) ==== + + // All will be error from using ES6 features but only include ES5 library + // Using Es6 array + function f(x: number, y: number, z: number) { + return Array.from(arguments); + ~~~~ +!!! error TS2339: Property 'from' does not exist on type 'ArrayConstructor'. + } + + f(1, 2, 3); // no error + + // Using ES6 collection + var m = new Map(); + ~~~ +!!! error TS2304: Cannot find name 'Map'. + m.clear(); + // Using ES6 iterable + m.keys(); + + // Using ES6 function + function Baz() { } + Baz.name; + ~~~~ +!!! error TS2339: Property 'name' does not exist on type '() => void'. + + // Using ES6 math + Math.sign(1); + ~~~~ +!!! error TS2339: Property 'sign' does not exist on type 'Math'. + + // Using ES6 object + var o = { + a: 2, + [Symbol.hasInstance](value: any) { + ~~~~~~ +!!! error TS2304: Cannot find name 'Symbol'. + return false; + } + }; + o.hasOwnProperty(Symbol.hasInstance); + ~~~~~~ +!!! error TS2304: Cannot find name 'Symbol'. + + // Using Es6 proxy + var t = {} + var p = new Proxy(t, {}); + ~~~~~ +!!! error TS2304: Cannot find name 'Proxy'. + + // Using ES6 reflect + Reflect.isExtensible({}); + ~~~~~~~ +!!! error TS2304: Cannot find name 'Reflect'. + + // Using Es6 regexp + var reg = new RegExp("/s"); + reg.flags; + ~~~~~ +!!! error TS2339: Property 'flags' does not exist on type 'RegExp'. + + // Using ES6 string + var str = "Hello world"; + str.includes("hello", 0); + ~~~~~~~~ +!!! error TS2339: Property 'includes' does not exist on type 'string'. + + // Using ES6 symbol + var s = Symbol(); + ~~~~~~ +!!! error TS2304: Cannot find name 'Symbol'. + + // Using ES6 wellknown-symbol + const o1 = { + [Symbol.hasInstance](value: any) { + ~~~~~~ +!!! error TS2304: Cannot find name 'Symbol'. + return false; + } + } \ No newline at end of file diff --git a/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.js b/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.js new file mode 100644 index 00000000000..257df4278fe --- /dev/null +++ b/tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.js @@ -0,0 +1,101 @@ +//// [modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts] + +// All will be error from using ES6 features but only include ES5 library +// Using Es6 array +function f(x: number, y: number, z: number) { + return Array.from(arguments); +} + +f(1, 2, 3); // no error + +// Using ES6 collection +var m = new Map(); +m.clear(); +// Using ES6 iterable +m.keys(); + +// Using ES6 function +function Baz() { } +Baz.name; + +// Using ES6 math +Math.sign(1); + +// Using ES6 object +var o = { + a: 2, + [Symbol.hasInstance](value: any) { + return false; + } +}; +o.hasOwnProperty(Symbol.hasInstance); + +// Using Es6 proxy +var t = {} +var p = new Proxy(t, {}); + +// Using ES6 reflect +Reflect.isExtensible({}); + +// Using Es6 regexp +var reg = new RegExp("/s"); +reg.flags; + +// Using ES6 string +var str = "Hello world"; +str.includes("hello", 0); + +// Using ES6 symbol +var s = Symbol(); + +// Using ES6 wellknown-symbol +const o1 = { + [Symbol.hasInstance](value: any) { + return false; + } +} + +//// [modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.js] +// All will be error from using ES6 features but only include ES5 library +// Using Es6 array +function f(x, y, z) { + return Array.from(arguments); +} +f(1, 2, 3); // no error +// Using ES6 collection +var m = new Map(); +m.clear(); +// Using ES6 iterable +m.keys(); +// Using ES6 function +function Baz() { } +Baz.name; +// Using ES6 math +Math.sign(1); +// Using ES6 object +var o = { + a: 2, + [Symbol.hasInstance](value) { + return false; + } +}; +o.hasOwnProperty(Symbol.hasInstance); +// Using Es6 proxy +var t = {}; +var p = new Proxy(t, {}); +// Using ES6 reflect +Reflect.isExtensible({}); +// Using Es6 regexp +var reg = new RegExp("/s"); +reg.flags; +// Using ES6 string +var str = "Hello world"; +str.includes("hello", 0); +// Using ES6 symbol +var s = Symbol(); +// Using ES6 wellknown-symbol +const o1 = { + [Symbol.hasInstance](value) { + return false; + } +}; diff --git a/tests/baselines/reference/modularizeLibrary_ErrorFromUsingWellknownSymbolWithOutES6WellknownSymbolLib.errors.txt b/tests/baselines/reference/modularizeLibrary_ErrorFromUsingWellknownSymbolWithOutES6WellknownSymbolLib.errors.txt new file mode 100644 index 00000000000..b5da9f97867 --- /dev/null +++ b/tests/baselines/reference/modularizeLibrary_ErrorFromUsingWellknownSymbolWithOutES6WellknownSymbolLib.errors.txt @@ -0,0 +1,17 @@ +tests/cases/compiler/modularizeLibrary_ErrorFromUsingWellknownSymbolWithOutES6WellknownSymbolLib.ts(8,1): error TS2322: Type 'boolean' is not assignable to type 'string'. +tests/cases/compiler/modularizeLibrary_ErrorFromUsingWellknownSymbolWithOutES6WellknownSymbolLib.ts(8,3): error TS2304: Cannot find name 'Symbol'. + + +==== tests/cases/compiler/modularizeLibrary_ErrorFromUsingWellknownSymbolWithOutES6WellknownSymbolLib.ts (2 errors) ==== + + function f(x: number, y: number, z: number) { + return Array.from(arguments); + } + + f(1, 2, 3); // no error + let a = ['c', 'd']; + a[Symbol.isConcatSpreadable] = false; + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2322: Type 'boolean' is not assignable to type 'string'. + ~~~~~~ +!!! error TS2304: Cannot find name 'Symbol'. \ No newline at end of file diff --git a/tests/baselines/reference/modularizeLibrary_ErrorFromUsingWellknownSymbolWithOutES6WellknownSymbolLib.js b/tests/baselines/reference/modularizeLibrary_ErrorFromUsingWellknownSymbolWithOutES6WellknownSymbolLib.js new file mode 100644 index 00000000000..e150560cc6a --- /dev/null +++ b/tests/baselines/reference/modularizeLibrary_ErrorFromUsingWellknownSymbolWithOutES6WellknownSymbolLib.js @@ -0,0 +1,17 @@ +//// [modularizeLibrary_ErrorFromUsingWellknownSymbolWithOutES6WellknownSymbolLib.ts] + +function f(x: number, y: number, z: number) { + return Array.from(arguments); +} + +f(1, 2, 3); // no error +let a = ['c', 'd']; +a[Symbol.isConcatSpreadable] = false; + +//// [modularizeLibrary_ErrorFromUsingWellknownSymbolWithOutES6WellknownSymbolLib.js] +function f(x, y, z) { + return Array.from(arguments); +} +f(1, 2, 3); // no error +var a = ['c', 'd']; +a[Symbol.isConcatSpreadable] = false; diff --git a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.js b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.js new file mode 100644 index 00000000000..9a5ed619b2d --- /dev/null +++ b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.js @@ -0,0 +1,158 @@ +//// [modularizeLibrary_NoErrorDuplicateLibOptions1.ts] + +// Using Es6 array +function f(x: number, y: number, z: number) { + return Array.from(arguments); +} + +f(1, 2, 3); // no error + +// Using ES6 collection +var m = new Map(); +m.clear(); +// Using ES6 iterable +m.keys(); + +// Using ES6 function +function Baz() { } +Baz.name; + +// Using ES6 generator +function* gen() { + let i = 0; + while (i < 10) { + yield i; + i++; + } +} + +function* gen2() { + let i = 0; + while (i < 10) { + yield i; + i++; + } +} + +// Using ES6 math +Math.sign(1); + +// Using ES6 object +var o = { + a: 2, + [Symbol.hasInstance](value: any) { + return false; + } +}; +o.hasOwnProperty(Symbol.hasInstance); + +// Using ES6 promise +async function out() { + return new Promise(function (resolve, reject) {}); +} + +declare var console: any; +out().then(() => { + console.log("Yea!"); +}); + +// Using Es6 proxy +var t = {} +var p = new Proxy(t, {}); + +// Using ES6 reflect +Reflect.isExtensible({}); + +// Using Es6 regexp +var reg = new RegExp("/s"); +reg.flags; + +// Using ES6 string +var str = "Hello world"; +str.includes("hello", 0); + +// Using ES6 symbol +var s = Symbol(); + +// Using ES6 wellknown-symbol +const o1 = { + [Symbol.hasInstance](value: any) { + return false; + } +} + +//// [modularizeLibrary_NoErrorDuplicateLibOptions1.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()); + }); +}; +// Using Es6 array +function f(x, y, z) { + return Array.from(arguments); +} +f(1, 2, 3); // no error +// Using ES6 collection +var m = new Map(); +m.clear(); +// Using ES6 iterable +m.keys(); +// Using ES6 function +function Baz() { } +Baz.name; +// Using ES6 generator +function* gen() { + let i = 0; + while (i < 10) { + yield i; + i++; + } +} +function* gen2() { + let i = 0; + while (i < 10) { + yield i; + i++; + } +} +// Using ES6 math +Math.sign(1); +// Using ES6 object +var o = { + a: 2, + [Symbol.hasInstance](value) { + return false; + } +}; +o.hasOwnProperty(Symbol.hasInstance); +// Using ES6 promise +function out() { + return __awaiter(this, void 0, void 0, function* () { + return new Promise(function (resolve, reject) { }); + }); +} +out().then(() => { + console.log("Yea!"); +}); +// Using Es6 proxy +var t = {}; +var p = new Proxy(t, {}); +// Using ES6 reflect +Reflect.isExtensible({}); +// Using Es6 regexp +var reg = new RegExp("/s"); +reg.flags; +// Using ES6 string +var str = "Hello world"; +str.includes("hello", 0); +// Using ES6 symbol +var s = Symbol(); +// Using ES6 wellknown-symbol +const o1 = { + [Symbol.hasInstance](value) { + return false; + } +}; diff --git a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.symbols b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.symbols new file mode 100644 index 00000000000..709d2740587 --- /dev/null +++ b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.symbols @@ -0,0 +1,184 @@ +=== tests/cases/compiler/modularizeLibrary_NoErrorDuplicateLibOptions1.ts === + +// Using Es6 array +function f(x: number, y: number, z: number) { +>f : Symbol(f, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 0, 0)) +>x : Symbol(x, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 2, 11)) +>y : Symbol(y, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 2, 21)) +>z : Symbol(z, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 2, 32)) + + return Array.from(arguments); +>Array.from : Symbol(ArrayConstructor.from, Decl(lib.es6.iterable.d.ts, --, --), Decl(lib.es6.iterable.d.ts, --, --), Decl(lib.es6.array.d.ts, --, --), Decl(lib.es6.array.d.ts, --, --)) +>Array : Symbol(Array, Decl(lib.es6.symbol.wellknown.d.ts, --, --), Decl(lib.es6.iterable.d.ts, --, --), Decl(lib.es6.array.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>from : Symbol(ArrayConstructor.from, Decl(lib.es6.iterable.d.ts, --, --), Decl(lib.es6.iterable.d.ts, --, --), Decl(lib.es6.array.d.ts, --, --), Decl(lib.es6.array.d.ts, --, --)) +>arguments : Symbol(arguments) +} + +f(1, 2, 3); // no error +>f : Symbol(f, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 0, 0)) + +// Using ES6 collection +var m = new Map(); +>m : Symbol(m, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 9, 3)) +>Map : Symbol(Map, Decl(lib.es6.symbol.wellknown.d.ts, --, --), Decl(lib.es6.iterable.d.ts, --, --), Decl(lib.es6.collection.d.ts, --, --), Decl(lib.es6.collection.d.ts, --, --)) + +m.clear(); +>m.clear : Symbol(Map.clear, Decl(lib.es6.collection.d.ts, --, --)) +>m : Symbol(m, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 9, 3)) +>clear : Symbol(Map.clear, Decl(lib.es6.collection.d.ts, --, --)) + +// Using ES6 iterable +m.keys(); +>m.keys : Symbol(Map.keys, Decl(lib.es6.iterable.d.ts, --, --)) +>m : Symbol(m, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 9, 3)) +>keys : Symbol(Map.keys, Decl(lib.es6.iterable.d.ts, --, --)) + +// Using ES6 function +function Baz() { } +>Baz : Symbol(Baz, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 12, 9)) + +Baz.name; +>Baz.name : Symbol(Function.name, Decl(lib.es6.function.d.ts, --, --)) +>Baz : Symbol(Baz, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 12, 9)) +>name : Symbol(Function.name, Decl(lib.es6.function.d.ts, --, --)) + +// Using ES6 generator +function* gen() { +>gen : Symbol(gen, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 16, 9)) + + let i = 0; +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 20, 7)) + + while (i < 10) { +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 20, 7)) + + yield i; +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 20, 7)) + + i++; +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 20, 7)) + } +} + +function* gen2() { +>gen2 : Symbol(gen2, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 25, 1)) + + let i = 0; +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 28, 7)) + + while (i < 10) { +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 28, 7)) + + yield i; +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 28, 7)) + + i++; +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 28, 7)) + } +} + +// Using ES6 math +Math.sign(1); +>Math.sign : Symbol(Math.sign, Decl(lib.es6.math.d.ts, --, --)) +>Math : Symbol(Math, Decl(lib.es6.symbol.wellknown.d.ts, --, --), Decl(lib.es6.math.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>sign : Symbol(Math.sign, Decl(lib.es6.math.d.ts, --, --)) + +// Using ES6 object +var o = { +>o : Symbol(o, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 39, 3)) + + a: 2, +>a : Symbol(a, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 39, 9)) + + [Symbol.hasInstance](value: any) { +>Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es6.symbol.wellknown.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.es6.symbol.wellknown.d.ts, --, --), Decl(lib.es6.symbol.d.ts, --, --), Decl(lib.es6.symbol.d.ts, --, --)) +>hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es6.symbol.wellknown.d.ts, --, --)) +>value : Symbol(value, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 41, 25)) + + return false; + } +}; +o.hasOwnProperty(Symbol.hasInstance); +>o.hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.es6.object.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>o : Symbol(o, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 39, 3)) +>hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.es6.object.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es6.symbol.wellknown.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.es6.symbol.wellknown.d.ts, --, --), Decl(lib.es6.symbol.d.ts, --, --), Decl(lib.es6.symbol.d.ts, --, --)) +>hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es6.symbol.wellknown.d.ts, --, --)) + +// Using ES6 promise +async function out() { +>out : Symbol(out, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 45, 37)) + + return new Promise(function (resolve, reject) {}); +>Promise : Symbol(Promise, Decl(lib.es6.symbol.wellknown.d.ts, --, --), Decl(lib.es6.promise.d.ts, --, --), Decl(lib.es6.promise.d.ts, --, --), Decl(lib.es6.iterable.d.ts, --, --)) +>resolve : Symbol(resolve, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 49, 33)) +>reject : Symbol(reject, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 49, 41)) +} + +declare var console: any; +>console : Symbol(console, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 52, 11)) + +out().then(() => { +>out().then : Symbol(Promise.then, Decl(lib.es6.promise.d.ts, --, --), Decl(lib.es6.promise.d.ts, --, --)) +>out : Symbol(out, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 45, 37)) +>then : Symbol(Promise.then, Decl(lib.es6.promise.d.ts, --, --), Decl(lib.es6.promise.d.ts, --, --)) + + console.log("Yea!"); +>console : Symbol(console, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 52, 11)) + +}); + +// Using Es6 proxy +var t = {} +>t : Symbol(t, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 58, 3)) + +var p = new Proxy(t, {}); +>p : Symbol(p, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 59, 3)) +>Proxy : Symbol(Proxy, Decl(lib.es6.proxy.d.ts, --, --)) +>t : Symbol(t, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 58, 3)) + +// Using ES6 reflect +Reflect.isExtensible({}); +>Reflect.isExtensible : Symbol(Reflect.isExtensible, Decl(lib.es6.reflect.d.ts, --, --)) +>Reflect : Symbol(Reflect, Decl(lib.es6.reflect.d.ts, --, --), Decl(lib.es6.iterable.d.ts, --, --)) +>isExtensible : Symbol(Reflect.isExtensible, Decl(lib.es6.reflect.d.ts, --, --)) + +// Using Es6 regexp +var reg = new RegExp("/s"); +>reg : Symbol(reg, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 65, 3)) +>RegExp : Symbol(RegExp, Decl(lib.es6.symbol.wellknown.d.ts, --, --), Decl(lib.es6.regexp.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) + +reg.flags; +>reg.flags : Symbol(RegExp.flags, Decl(lib.es6.regexp.d.ts, --, --)) +>reg : Symbol(reg, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 65, 3)) +>flags : Symbol(RegExp.flags, Decl(lib.es6.regexp.d.ts, --, --)) + +// Using ES6 string +var str = "Hello world"; +>str : Symbol(str, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 69, 3)) + +str.includes("hello", 0); +>str.includes : Symbol(String.includes, Decl(lib.es6.string.d.ts, --, --)) +>str : Symbol(str, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 69, 3)) +>includes : Symbol(String.includes, Decl(lib.es6.string.d.ts, --, --)) + +// Using ES6 symbol +var s = Symbol(); +>s : Symbol(s, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 73, 3)) +>Symbol : Symbol(Symbol, Decl(lib.es6.symbol.wellknown.d.ts, --, --), Decl(lib.es6.symbol.d.ts, --, --), Decl(lib.es6.symbol.d.ts, --, --)) + +// Using ES6 wellknown-symbol +const o1 = { +>o1 : Symbol(o1, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 76, 5)) + + [Symbol.hasInstance](value: any) { +>Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es6.symbol.wellknown.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.es6.symbol.wellknown.d.ts, --, --), Decl(lib.es6.symbol.d.ts, --, --), Decl(lib.es6.symbol.d.ts, --, --)) +>hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es6.symbol.wellknown.d.ts, --, --)) +>value : Symbol(value, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 77, 25)) + + return false; + } +} diff --git a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types new file mode 100644 index 00000000000..16051c14b7c --- /dev/null +++ b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types @@ -0,0 +1,231 @@ +=== tests/cases/compiler/modularizeLibrary_NoErrorDuplicateLibOptions1.ts === + +// Using Es6 array +function f(x: number, y: number, z: number) { +>f : (x: number, y: number, z: number) => any[] +>x : number +>y : number +>z : number + + return Array.from(arguments); +>Array.from(arguments) : any[] +>Array.from : { (iterable: Iterable, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; (iterable: Iterable): T[]; (arrayLike: ArrayLike, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; (arrayLike: ArrayLike): T[]; } +>Array : ArrayConstructor +>from : { (iterable: Iterable, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; (iterable: Iterable): T[]; (arrayLike: ArrayLike, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; (arrayLike: ArrayLike): T[]; } +>arguments : IArguments +} + +f(1, 2, 3); // no error +>f(1, 2, 3) : any[] +>f : (x: number, y: number, z: number) => any[] +>1 : number +>2 : number +>3 : number + +// Using ES6 collection +var m = new Map(); +>m : Map +>new Map() : Map +>Map : MapConstructor + +m.clear(); +>m.clear() : void +>m.clear : () => void +>m : Map +>clear : () => void + +// Using ES6 iterable +m.keys(); +>m.keys() : IterableIterator +>m.keys : () => IterableIterator +>m : Map +>keys : () => IterableIterator + +// Using ES6 function +function Baz() { } +>Baz : () => void + +Baz.name; +>Baz.name : string +>Baz : () => void +>name : string + +// Using ES6 generator +function* gen() { +>gen : () => IterableIterator + + let i = 0; +>i : number +>0 : number + + while (i < 10) { +>i < 10 : boolean +>i : number +>10 : number + + yield i; +>yield i : any +>i : number + + i++; +>i++ : number +>i : number + } +} + +function* gen2() { +>gen2 : () => IterableIterator + + let i = 0; +>i : number +>0 : number + + while (i < 10) { +>i < 10 : boolean +>i : number +>10 : number + + yield i; +>yield i : any +>i : number + + i++; +>i++ : number +>i : number + } +} + +// Using ES6 math +Math.sign(1); +>Math.sign(1) : number +>Math.sign : (x: number) => number +>Math : Math +>sign : (x: number) => number +>1 : number + +// Using ES6 object +var o = { +>o : { a: number; [Symbol.hasInstance](value: any): boolean; } +>{ a: 2, [Symbol.hasInstance](value: any) { return false; }} : { a: number; [Symbol.hasInstance](value: any): boolean; } + + a: 2, +>a : number +>2 : number + + [Symbol.hasInstance](value: any) { +>Symbol.hasInstance : symbol +>Symbol : SymbolConstructor +>hasInstance : symbol +>value : any + + return false; +>false : boolean + } +}; +o.hasOwnProperty(Symbol.hasInstance); +>o.hasOwnProperty(Symbol.hasInstance) : boolean +>o.hasOwnProperty : { (v: string | number | symbol): boolean; (v: string): boolean; } +>o : { a: number; [Symbol.hasInstance](value: any): boolean; } +>hasOwnProperty : { (v: string | number | symbol): boolean; (v: string): boolean; } +>Symbol.hasInstance : symbol +>Symbol : SymbolConstructor +>hasInstance : symbol + +// Using ES6 promise +async function out() { +>out : () => Promise<{}> + + return new Promise(function (resolve, reject) {}); +>new Promise(function (resolve, reject) {}) : Promise<{}> +>Promise : PromiseConstructor +>function (resolve, reject) {} : (resolve: (value?: {} | PromiseLike<{}>) => void, reject: (reason?: any) => void) => void +>resolve : (value?: {} | PromiseLike<{}>) => void +>reject : (reason?: any) => void +} + +declare var console: any; +>console : any + +out().then(() => { +>out().then(() => { console.log("Yea!");}) : Promise +>out().then : { (onfulfilled?: (value: {}) => TResult | PromiseLike, onrejected?: (reason: any) => TResult | PromiseLike): Promise; (onfulfilled?: (value: {}) => TResult | PromiseLike, onrejected?: (reason: any) => void): Promise; } +>out() : Promise<{}> +>out : () => Promise<{}> +>then : { (onfulfilled?: (value: {}) => TResult | PromiseLike, onrejected?: (reason: any) => TResult | PromiseLike): Promise; (onfulfilled?: (value: {}) => TResult | PromiseLike, onrejected?: (reason: any) => void): Promise; } +>() => { console.log("Yea!");} : () => void + + console.log("Yea!"); +>console.log("Yea!") : any +>console.log : any +>console : any +>log : any +>"Yea!" : string + +}); + +// Using Es6 proxy +var t = {} +>t : {} +>{} : {} + +var p = new Proxy(t, {}); +>p : {} +>new Proxy(t, {}) : {} +>Proxy : ProxyConstructor +>t : {} +>{} : {} + +// Using ES6 reflect +Reflect.isExtensible({}); +>Reflect.isExtensible({}) : boolean +>Reflect.isExtensible : (target: any) => boolean +>Reflect : typeof Reflect +>isExtensible : (target: any) => boolean +>{} : {} + +// Using Es6 regexp +var reg = new RegExp("/s"); +>reg : RegExp +>new RegExp("/s") : RegExp +>RegExp : RegExpConstructor +>"/s" : string + +reg.flags; +>reg.flags : string +>reg : RegExp +>flags : string + +// Using ES6 string +var str = "Hello world"; +>str : string +>"Hello world" : string + +str.includes("hello", 0); +>str.includes("hello", 0) : boolean +>str.includes : (searchString: string, position?: number) => boolean +>str : string +>includes : (searchString: string, position?: number) => boolean +>"hello" : string +>0 : number + +// Using ES6 symbol +var s = Symbol(); +>s : symbol +>Symbol() : symbol +>Symbol : SymbolConstructor + +// Using ES6 wellknown-symbol +const o1 = { +>o1 : { [Symbol.hasInstance](value: any): boolean; } +>{ [Symbol.hasInstance](value: any) { return false; }} : { [Symbol.hasInstance](value: any): boolean; } + + [Symbol.hasInstance](value: any) { +>Symbol.hasInstance : symbol +>Symbol : SymbolConstructor +>hasInstance : symbol +>value : any + + return false; +>false : boolean + } +} diff --git a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.js b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.js new file mode 100644 index 00000000000..c4c2d6853af --- /dev/null +++ b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.js @@ -0,0 +1,158 @@ +//// [modularizeLibrary_NoErrorDuplicateLibOptions2.ts] + +// Using Es6 array +function f(x: number, y: number, z: number) { + return Array.from(arguments); +} + +f(1, 2, 3); // no error + +// Using ES6 collection +var m = new Map(); +m.clear(); +// Using ES6 iterable +m.keys(); + +// Using ES6 function +function Baz() { } +Baz.name; + +// Using ES6 generator +function* gen() { + let i = 0; + while (i < 10) { + yield i; + i++; + } +} + +function* gen2() { + let i = 0; + while (i < 10) { + yield i; + i++; + } +} + +// Using ES6 math +Math.sign(1); + +// Using ES6 object +var o = { + a: 2, + [Symbol.hasInstance](value: any) { + return false; + } +}; +o.hasOwnProperty(Symbol.hasInstance); + +// Using ES6 promise +async function out() { + return new Promise(function (resolve, reject) {}); +} + +declare var console: any; +out().then(() => { + console.log("Yea!"); +}); + +// Using Es6 proxy +var t = {} +var p = new Proxy(t, {}); + +// Using ES6 reflect +Reflect.isExtensible({}); + +// Using Es6 regexp +var reg = new RegExp("/s"); +reg.flags; + +// Using ES6 string +var str = "Hello world"; +str.includes("hello", 0); + +// Using ES6 symbol +var s = Symbol(); + +// Using ES6 wellknown-symbol +const o1 = { + [Symbol.hasInstance](value: any) { + return false; + } +} + +//// [modularizeLibrary_NoErrorDuplicateLibOptions2.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()); + }); +}; +// Using Es6 array +function f(x, y, z) { + return Array.from(arguments); +} +f(1, 2, 3); // no error +// Using ES6 collection +var m = new Map(); +m.clear(); +// Using ES6 iterable +m.keys(); +// Using ES6 function +function Baz() { } +Baz.name; +// Using ES6 generator +function* gen() { + let i = 0; + while (i < 10) { + yield i; + i++; + } +} +function* gen2() { + let i = 0; + while (i < 10) { + yield i; + i++; + } +} +// Using ES6 math +Math.sign(1); +// Using ES6 object +var o = { + a: 2, + [Symbol.hasInstance](value) { + return false; + } +}; +o.hasOwnProperty(Symbol.hasInstance); +// Using ES6 promise +function out() { + return __awaiter(this, void 0, void 0, function* () { + return new Promise(function (resolve, reject) { }); + }); +} +out().then(() => { + console.log("Yea!"); +}); +// Using Es6 proxy +var t = {}; +var p = new Proxy(t, {}); +// Using ES6 reflect +Reflect.isExtensible({}); +// Using Es6 regexp +var reg = new RegExp("/s"); +reg.flags; +// Using ES6 string +var str = "Hello world"; +str.includes("hello", 0); +// Using ES6 symbol +var s = Symbol(); +// Using ES6 wellknown-symbol +const o1 = { + [Symbol.hasInstance](value) { + return false; + } +}; diff --git a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.symbols b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.symbols new file mode 100644 index 00000000000..3e5448d33c1 --- /dev/null +++ b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.symbols @@ -0,0 +1,184 @@ +=== tests/cases/compiler/modularizeLibrary_NoErrorDuplicateLibOptions2.ts === + +// Using Es6 array +function f(x: number, y: number, z: number) { +>f : Symbol(f, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 0, 0)) +>x : Symbol(x, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 2, 11)) +>y : Symbol(y, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 2, 21)) +>z : Symbol(z, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 2, 32)) + + return Array.from(arguments); +>Array.from : Symbol(ArrayConstructor.from, Decl(lib.es6.iterable.d.ts, --, --), Decl(lib.es6.iterable.d.ts, --, --), Decl(lib.es6.array.d.ts, --, --), Decl(lib.es6.array.d.ts, --, --)) +>Array : Symbol(Array, Decl(lib.es6.symbol.wellknown.d.ts, --, --), Decl(lib.es6.iterable.d.ts, --, --), Decl(lib.es6.array.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>from : Symbol(ArrayConstructor.from, Decl(lib.es6.iterable.d.ts, --, --), Decl(lib.es6.iterable.d.ts, --, --), Decl(lib.es6.array.d.ts, --, --), Decl(lib.es6.array.d.ts, --, --)) +>arguments : Symbol(arguments) +} + +f(1, 2, 3); // no error +>f : Symbol(f, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 0, 0)) + +// Using ES6 collection +var m = new Map(); +>m : Symbol(m, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 9, 3)) +>Map : Symbol(Map, Decl(lib.es6.symbol.wellknown.d.ts, --, --), Decl(lib.es6.iterable.d.ts, --, --), Decl(lib.es6.collection.d.ts, --, --), Decl(lib.es6.collection.d.ts, --, --)) + +m.clear(); +>m.clear : Symbol(Map.clear, Decl(lib.es6.collection.d.ts, --, --)) +>m : Symbol(m, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 9, 3)) +>clear : Symbol(Map.clear, Decl(lib.es6.collection.d.ts, --, --)) + +// Using ES6 iterable +m.keys(); +>m.keys : Symbol(Map.keys, Decl(lib.es6.iterable.d.ts, --, --)) +>m : Symbol(m, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 9, 3)) +>keys : Symbol(Map.keys, Decl(lib.es6.iterable.d.ts, --, --)) + +// Using ES6 function +function Baz() { } +>Baz : Symbol(Baz, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 12, 9)) + +Baz.name; +>Baz.name : Symbol(Function.name, Decl(lib.es6.function.d.ts, --, --)) +>Baz : Symbol(Baz, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 12, 9)) +>name : Symbol(Function.name, Decl(lib.es6.function.d.ts, --, --)) + +// Using ES6 generator +function* gen() { +>gen : Symbol(gen, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 16, 9)) + + let i = 0; +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 20, 7)) + + while (i < 10) { +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 20, 7)) + + yield i; +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 20, 7)) + + i++; +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 20, 7)) + } +} + +function* gen2() { +>gen2 : Symbol(gen2, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 25, 1)) + + let i = 0; +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 28, 7)) + + while (i < 10) { +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 28, 7)) + + yield i; +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 28, 7)) + + i++; +>i : Symbol(i, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 28, 7)) + } +} + +// Using ES6 math +Math.sign(1); +>Math.sign : Symbol(Math.sign, Decl(lib.es6.math.d.ts, --, --)) +>Math : Symbol(Math, Decl(lib.es6.symbol.wellknown.d.ts, --, --), Decl(lib.es6.math.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>sign : Symbol(Math.sign, Decl(lib.es6.math.d.ts, --, --)) + +// Using ES6 object +var o = { +>o : Symbol(o, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 39, 3)) + + a: 2, +>a : Symbol(a, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 39, 9)) + + [Symbol.hasInstance](value: any) { +>Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es6.symbol.wellknown.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.es6.symbol.wellknown.d.ts, --, --), Decl(lib.es6.symbol.d.ts, --, --), Decl(lib.es6.symbol.d.ts, --, --)) +>hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es6.symbol.wellknown.d.ts, --, --)) +>value : Symbol(value, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 41, 25)) + + return false; + } +}; +o.hasOwnProperty(Symbol.hasInstance); +>o.hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.es6.object.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>o : Symbol(o, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 39, 3)) +>hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.es6.object.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es6.symbol.wellknown.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.es6.symbol.wellknown.d.ts, --, --), Decl(lib.es6.symbol.d.ts, --, --), Decl(lib.es6.symbol.d.ts, --, --)) +>hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es6.symbol.wellknown.d.ts, --, --)) + +// Using ES6 promise +async function out() { +>out : Symbol(out, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 45, 37)) + + return new Promise(function (resolve, reject) {}); +>Promise : Symbol(Promise, Decl(lib.es6.symbol.wellknown.d.ts, --, --), Decl(lib.es6.promise.d.ts, --, --), Decl(lib.es6.promise.d.ts, --, --), Decl(lib.es6.iterable.d.ts, --, --)) +>resolve : Symbol(resolve, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 49, 33)) +>reject : Symbol(reject, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 49, 41)) +} + +declare var console: any; +>console : Symbol(console, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 52, 11)) + +out().then(() => { +>out().then : Symbol(Promise.then, Decl(lib.es6.promise.d.ts, --, --), Decl(lib.es6.promise.d.ts, --, --)) +>out : Symbol(out, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 45, 37)) +>then : Symbol(Promise.then, Decl(lib.es6.promise.d.ts, --, --), Decl(lib.es6.promise.d.ts, --, --)) + + console.log("Yea!"); +>console : Symbol(console, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 52, 11)) + +}); + +// Using Es6 proxy +var t = {} +>t : Symbol(t, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 58, 3)) + +var p = new Proxy(t, {}); +>p : Symbol(p, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 59, 3)) +>Proxy : Symbol(Proxy, Decl(lib.es6.proxy.d.ts, --, --)) +>t : Symbol(t, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 58, 3)) + +// Using ES6 reflect +Reflect.isExtensible({}); +>Reflect.isExtensible : Symbol(Reflect.isExtensible, Decl(lib.es6.reflect.d.ts, --, --)) +>Reflect : Symbol(Reflect, Decl(lib.es6.reflect.d.ts, --, --), Decl(lib.es6.iterable.d.ts, --, --)) +>isExtensible : Symbol(Reflect.isExtensible, Decl(lib.es6.reflect.d.ts, --, --)) + +// Using Es6 regexp +var reg = new RegExp("/s"); +>reg : Symbol(reg, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 65, 3)) +>RegExp : Symbol(RegExp, Decl(lib.es6.symbol.wellknown.d.ts, --, --), Decl(lib.es6.regexp.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) + +reg.flags; +>reg.flags : Symbol(RegExp.flags, Decl(lib.es6.regexp.d.ts, --, --)) +>reg : Symbol(reg, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 65, 3)) +>flags : Symbol(RegExp.flags, Decl(lib.es6.regexp.d.ts, --, --)) + +// Using ES6 string +var str = "Hello world"; +>str : Symbol(str, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 69, 3)) + +str.includes("hello", 0); +>str.includes : Symbol(String.includes, Decl(lib.es6.string.d.ts, --, --)) +>str : Symbol(str, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 69, 3)) +>includes : Symbol(String.includes, Decl(lib.es6.string.d.ts, --, --)) + +// Using ES6 symbol +var s = Symbol(); +>s : Symbol(s, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 73, 3)) +>Symbol : Symbol(Symbol, Decl(lib.es6.symbol.wellknown.d.ts, --, --), Decl(lib.es6.symbol.d.ts, --, --), Decl(lib.es6.symbol.d.ts, --, --)) + +// Using ES6 wellknown-symbol +const o1 = { +>o1 : Symbol(o1, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 76, 5)) + + [Symbol.hasInstance](value: any) { +>Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es6.symbol.wellknown.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.es6.symbol.wellknown.d.ts, --, --), Decl(lib.es6.symbol.d.ts, --, --), Decl(lib.es6.symbol.d.ts, --, --)) +>hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es6.symbol.wellknown.d.ts, --, --)) +>value : Symbol(value, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 77, 25)) + + return false; + } +} diff --git a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types new file mode 100644 index 00000000000..a7d8e77e28c --- /dev/null +++ b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types @@ -0,0 +1,231 @@ +=== tests/cases/compiler/modularizeLibrary_NoErrorDuplicateLibOptions2.ts === + +// Using Es6 array +function f(x: number, y: number, z: number) { +>f : (x: number, y: number, z: number) => any[] +>x : number +>y : number +>z : number + + return Array.from(arguments); +>Array.from(arguments) : any[] +>Array.from : { (iterable: Iterable, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; (iterable: Iterable): T[]; (arrayLike: ArrayLike, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; (arrayLike: ArrayLike): T[]; } +>Array : ArrayConstructor +>from : { (iterable: Iterable, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; (iterable: Iterable): T[]; (arrayLike: ArrayLike, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; (arrayLike: ArrayLike): T[]; } +>arguments : IArguments +} + +f(1, 2, 3); // no error +>f(1, 2, 3) : any[] +>f : (x: number, y: number, z: number) => any[] +>1 : number +>2 : number +>3 : number + +// Using ES6 collection +var m = new Map(); +>m : Map +>new Map() : Map +>Map : MapConstructor + +m.clear(); +>m.clear() : void +>m.clear : () => void +>m : Map +>clear : () => void + +// Using ES6 iterable +m.keys(); +>m.keys() : IterableIterator +>m.keys : () => IterableIterator +>m : Map +>keys : () => IterableIterator + +// Using ES6 function +function Baz() { } +>Baz : () => void + +Baz.name; +>Baz.name : string +>Baz : () => void +>name : string + +// Using ES6 generator +function* gen() { +>gen : () => IterableIterator + + let i = 0; +>i : number +>0 : number + + while (i < 10) { +>i < 10 : boolean +>i : number +>10 : number + + yield i; +>yield i : any +>i : number + + i++; +>i++ : number +>i : number + } +} + +function* gen2() { +>gen2 : () => IterableIterator + + let i = 0; +>i : number +>0 : number + + while (i < 10) { +>i < 10 : boolean +>i : number +>10 : number + + yield i; +>yield i : any +>i : number + + i++; +>i++ : number +>i : number + } +} + +// Using ES6 math +Math.sign(1); +>Math.sign(1) : number +>Math.sign : (x: number) => number +>Math : Math +>sign : (x: number) => number +>1 : number + +// Using ES6 object +var o = { +>o : { a: number; [Symbol.hasInstance](value: any): boolean; } +>{ a: 2, [Symbol.hasInstance](value: any) { return false; }} : { a: number; [Symbol.hasInstance](value: any): boolean; } + + a: 2, +>a : number +>2 : number + + [Symbol.hasInstance](value: any) { +>Symbol.hasInstance : symbol +>Symbol : SymbolConstructor +>hasInstance : symbol +>value : any + + return false; +>false : boolean + } +}; +o.hasOwnProperty(Symbol.hasInstance); +>o.hasOwnProperty(Symbol.hasInstance) : boolean +>o.hasOwnProperty : { (v: string | number | symbol): boolean; (v: string): boolean; } +>o : { a: number; [Symbol.hasInstance](value: any): boolean; } +>hasOwnProperty : { (v: string | number | symbol): boolean; (v: string): boolean; } +>Symbol.hasInstance : symbol +>Symbol : SymbolConstructor +>hasInstance : symbol + +// Using ES6 promise +async function out() { +>out : () => Promise<{}> + + return new Promise(function (resolve, reject) {}); +>new Promise(function (resolve, reject) {}) : Promise<{}> +>Promise : PromiseConstructor +>function (resolve, reject) {} : (resolve: (value?: {} | PromiseLike<{}>) => void, reject: (reason?: any) => void) => void +>resolve : (value?: {} | PromiseLike<{}>) => void +>reject : (reason?: any) => void +} + +declare var console: any; +>console : any + +out().then(() => { +>out().then(() => { console.log("Yea!");}) : Promise +>out().then : { (onfulfilled?: (value: {}) => TResult | PromiseLike, onrejected?: (reason: any) => TResult | PromiseLike): Promise; (onfulfilled?: (value: {}) => TResult | PromiseLike, onrejected?: (reason: any) => void): Promise; } +>out() : Promise<{}> +>out : () => Promise<{}> +>then : { (onfulfilled?: (value: {}) => TResult | PromiseLike, onrejected?: (reason: any) => TResult | PromiseLike): Promise; (onfulfilled?: (value: {}) => TResult | PromiseLike, onrejected?: (reason: any) => void): Promise; } +>() => { console.log("Yea!");} : () => void + + console.log("Yea!"); +>console.log("Yea!") : any +>console.log : any +>console : any +>log : any +>"Yea!" : string + +}); + +// Using Es6 proxy +var t = {} +>t : {} +>{} : {} + +var p = new Proxy(t, {}); +>p : {} +>new Proxy(t, {}) : {} +>Proxy : ProxyConstructor +>t : {} +>{} : {} + +// Using ES6 reflect +Reflect.isExtensible({}); +>Reflect.isExtensible({}) : boolean +>Reflect.isExtensible : (target: any) => boolean +>Reflect : typeof Reflect +>isExtensible : (target: any) => boolean +>{} : {} + +// Using Es6 regexp +var reg = new RegExp("/s"); +>reg : RegExp +>new RegExp("/s") : RegExp +>RegExp : RegExpConstructor +>"/s" : string + +reg.flags; +>reg.flags : string +>reg : RegExp +>flags : string + +// Using ES6 string +var str = "Hello world"; +>str : string +>"Hello world" : string + +str.includes("hello", 0); +>str.includes("hello", 0) : boolean +>str.includes : (searchString: string, position?: number) => boolean +>str : string +>includes : (searchString: string, position?: number) => boolean +>"hello" : string +>0 : number + +// Using ES6 symbol +var s = Symbol(); +>s : symbol +>Symbol() : symbol +>Symbol : SymbolConstructor + +// Using ES6 wellknown-symbol +const o1 = { +>o1 : { [Symbol.hasInstance](value: any): boolean; } +>{ [Symbol.hasInstance](value: any) { return false; }} : { [Symbol.hasInstance](value: any): boolean; } + + [Symbol.hasInstance](value: any) { +>Symbol.hasInstance : symbol +>Symbol : SymbolConstructor +>hasInstance : symbol +>value : any + + return false; +>false : boolean + } +} diff --git a/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.js b/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.js new file mode 100644 index 00000000000..8736c51cd16 --- /dev/null +++ b/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.js @@ -0,0 +1,158 @@ +//// [modularizeLibrary_TargetES5UsingES6Lib.ts] + +// Using Es6 array +function f(x: number, y: number, z: number) { + return Array.from(arguments); +} + +f(1, 2, 3); // no error + +// Using ES6 collection +var m = new Map(); +m.clear(); +// Using ES6 iterable +m.keys(); + +// Using ES6 function +function Baz() { } +Baz.name; + +// Using ES6 generator +function* gen() { + let i = 0; + while (i < 10) { + yield i; + i++; + } +} + +function* gen2() { + let i = 0; + while (i < 10) { + yield i; + i++; + } +} + +// Using ES6 math +Math.sign(1); + +// Using ES6 object +var o = { + a: 2, + [Symbol.hasInstance](value: any) { + return false; + } +}; +o.hasOwnProperty(Symbol.hasInstance); + +// Using ES6 promise +async function out() { + return new Promise(function (resolve, reject) {}); +} + +declare var console: any; +out().then(() => { + console.log("Yea!"); +}); + +// Using Es6 proxy +var t = {} +var p = new Proxy(t, {}); + +// Using ES6 reflect +Reflect.isExtensible({}); + +// Using Es6 regexp +var reg = new RegExp("/s"); +reg.flags; + +// Using ES6 string +var str = "Hello world"; +str.includes("hello", 0); + +// Using ES6 symbol +var s = Symbol(); + +// Using ES6 wellknown-symbol +const o1 = { + [Symbol.hasInstance](value: any) { + return false; + } +} + +//// [modularizeLibrary_TargetES5UsingES6Lib.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()); + }); +}; +// Using Es6 array +function f(x, y, z) { + return Array.from(arguments); +} +f(1, 2, 3); // no error +// Using ES6 collection +var m = new Map(); +m.clear(); +// Using ES6 iterable +m.keys(); +// Using ES6 function +function Baz() { } +Baz.name; +// Using ES6 generator +function* gen() { + let i = 0; + while (i < 10) { + yield i; + i++; + } +} +function* gen2() { + let i = 0; + while (i < 10) { + yield i; + i++; + } +} +// Using ES6 math +Math.sign(1); +// Using ES6 object +var o = { + a: 2, + [Symbol.hasInstance](value) { + return false; + } +}; +o.hasOwnProperty(Symbol.hasInstance); +// Using ES6 promise +function out() { + return __awaiter(this, void 0, void 0, function* () { + return new Promise(function (resolve, reject) { }); + }); +} +out().then(() => { + console.log("Yea!"); +}); +// Using Es6 proxy +var t = {}; +var p = new Proxy(t, {}); +// Using ES6 reflect +Reflect.isExtensible({}); +// Using Es6 regexp +var reg = new RegExp("/s"); +reg.flags; +// Using ES6 string +var str = "Hello world"; +str.includes("hello", 0); +// Using ES6 symbol +var s = Symbol(); +// Using ES6 wellknown-symbol +const o1 = { + [Symbol.hasInstance](value) { + return false; + } +}; diff --git a/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.symbols b/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.symbols new file mode 100644 index 00000000000..018826da9b7 --- /dev/null +++ b/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.symbols @@ -0,0 +1,184 @@ +=== tests/cases/compiler/modularizeLibrary_TargetES5UsingES6Lib.ts === + +// Using Es6 array +function f(x: number, y: number, z: number) { +>f : Symbol(f, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 0, 0)) +>x : Symbol(x, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 2, 11)) +>y : Symbol(y, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 2, 21)) +>z : Symbol(z, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 2, 32)) + + return Array.from(arguments); +>Array.from : Symbol(ArrayConstructor.from, Decl(lib.es6.iterable.d.ts, --, --), Decl(lib.es6.iterable.d.ts, --, --), Decl(lib.es6.array.d.ts, --, --), Decl(lib.es6.array.d.ts, --, --)) +>Array : Symbol(Array, Decl(lib.es6.symbol.wellknown.d.ts, --, --), Decl(lib.es6.iterable.d.ts, --, --), Decl(lib.es6.array.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>from : Symbol(ArrayConstructor.from, Decl(lib.es6.iterable.d.ts, --, --), Decl(lib.es6.iterable.d.ts, --, --), Decl(lib.es6.array.d.ts, --, --), Decl(lib.es6.array.d.ts, --, --)) +>arguments : Symbol(arguments) +} + +f(1, 2, 3); // no error +>f : Symbol(f, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 0, 0)) + +// Using ES6 collection +var m = new Map(); +>m : Symbol(m, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 9, 3)) +>Map : Symbol(Map, Decl(lib.es6.symbol.wellknown.d.ts, --, --), Decl(lib.es6.iterable.d.ts, --, --), Decl(lib.es6.collection.d.ts, --, --), Decl(lib.es6.collection.d.ts, --, --)) + +m.clear(); +>m.clear : Symbol(Map.clear, Decl(lib.es6.collection.d.ts, --, --)) +>m : Symbol(m, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 9, 3)) +>clear : Symbol(Map.clear, Decl(lib.es6.collection.d.ts, --, --)) + +// Using ES6 iterable +m.keys(); +>m.keys : Symbol(Map.keys, Decl(lib.es6.iterable.d.ts, --, --)) +>m : Symbol(m, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 9, 3)) +>keys : Symbol(Map.keys, Decl(lib.es6.iterable.d.ts, --, --)) + +// Using ES6 function +function Baz() { } +>Baz : Symbol(Baz, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 12, 9)) + +Baz.name; +>Baz.name : Symbol(Function.name, Decl(lib.es6.function.d.ts, --, --)) +>Baz : Symbol(Baz, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 12, 9)) +>name : Symbol(Function.name, Decl(lib.es6.function.d.ts, --, --)) + +// Using ES6 generator +function* gen() { +>gen : Symbol(gen, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 16, 9)) + + let i = 0; +>i : Symbol(i, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 20, 7)) + + while (i < 10) { +>i : Symbol(i, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 20, 7)) + + yield i; +>i : Symbol(i, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 20, 7)) + + i++; +>i : Symbol(i, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 20, 7)) + } +} + +function* gen2() { +>gen2 : Symbol(gen2, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 25, 1)) + + let i = 0; +>i : Symbol(i, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 28, 7)) + + while (i < 10) { +>i : Symbol(i, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 28, 7)) + + yield i; +>i : Symbol(i, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 28, 7)) + + i++; +>i : Symbol(i, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 28, 7)) + } +} + +// Using ES6 math +Math.sign(1); +>Math.sign : Symbol(Math.sign, Decl(lib.es6.math.d.ts, --, --)) +>Math : Symbol(Math, Decl(lib.es6.symbol.wellknown.d.ts, --, --), Decl(lib.es6.math.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>sign : Symbol(Math.sign, Decl(lib.es6.math.d.ts, --, --)) + +// Using ES6 object +var o = { +>o : Symbol(o, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 39, 3)) + + a: 2, +>a : Symbol(a, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 39, 9)) + + [Symbol.hasInstance](value: any) { +>Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es6.symbol.wellknown.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.es6.symbol.wellknown.d.ts, --, --), Decl(lib.es6.symbol.d.ts, --, --), Decl(lib.es6.symbol.d.ts, --, --)) +>hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es6.symbol.wellknown.d.ts, --, --)) +>value : Symbol(value, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 41, 25)) + + return false; + } +}; +o.hasOwnProperty(Symbol.hasInstance); +>o.hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.es6.object.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>o : Symbol(o, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 39, 3)) +>hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.es6.object.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es6.symbol.wellknown.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.es6.symbol.wellknown.d.ts, --, --), Decl(lib.es6.symbol.d.ts, --, --), Decl(lib.es6.symbol.d.ts, --, --)) +>hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es6.symbol.wellknown.d.ts, --, --)) + +// Using ES6 promise +async function out() { +>out : Symbol(out, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 45, 37)) + + return new Promise(function (resolve, reject) {}); +>Promise : Symbol(Promise, Decl(lib.es6.symbol.wellknown.d.ts, --, --), Decl(lib.es6.promise.d.ts, --, --), Decl(lib.es6.promise.d.ts, --, --), Decl(lib.es6.iterable.d.ts, --, --)) +>resolve : Symbol(resolve, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 49, 33)) +>reject : Symbol(reject, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 49, 41)) +} + +declare var console: any; +>console : Symbol(console, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 52, 11)) + +out().then(() => { +>out().then : Symbol(Promise.then, Decl(lib.es6.promise.d.ts, --, --), Decl(lib.es6.promise.d.ts, --, --)) +>out : Symbol(out, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 45, 37)) +>then : Symbol(Promise.then, Decl(lib.es6.promise.d.ts, --, --), Decl(lib.es6.promise.d.ts, --, --)) + + console.log("Yea!"); +>console : Symbol(console, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 52, 11)) + +}); + +// Using Es6 proxy +var t = {} +>t : Symbol(t, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 58, 3)) + +var p = new Proxy(t, {}); +>p : Symbol(p, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 59, 3)) +>Proxy : Symbol(Proxy, Decl(lib.es6.proxy.d.ts, --, --)) +>t : Symbol(t, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 58, 3)) + +// Using ES6 reflect +Reflect.isExtensible({}); +>Reflect.isExtensible : Symbol(Reflect.isExtensible, Decl(lib.es6.reflect.d.ts, --, --)) +>Reflect : Symbol(Reflect, Decl(lib.es6.reflect.d.ts, --, --), Decl(lib.es6.iterable.d.ts, --, --)) +>isExtensible : Symbol(Reflect.isExtensible, Decl(lib.es6.reflect.d.ts, --, --)) + +// Using Es6 regexp +var reg = new RegExp("/s"); +>reg : Symbol(reg, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 65, 3)) +>RegExp : Symbol(RegExp, Decl(lib.es6.symbol.wellknown.d.ts, --, --), Decl(lib.es6.regexp.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) + +reg.flags; +>reg.flags : Symbol(RegExp.flags, Decl(lib.es6.regexp.d.ts, --, --)) +>reg : Symbol(reg, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 65, 3)) +>flags : Symbol(RegExp.flags, Decl(lib.es6.regexp.d.ts, --, --)) + +// Using ES6 string +var str = "Hello world"; +>str : Symbol(str, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 69, 3)) + +str.includes("hello", 0); +>str.includes : Symbol(String.includes, Decl(lib.es6.string.d.ts, --, --)) +>str : Symbol(str, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 69, 3)) +>includes : Symbol(String.includes, Decl(lib.es6.string.d.ts, --, --)) + +// Using ES6 symbol +var s = Symbol(); +>s : Symbol(s, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 73, 3)) +>Symbol : Symbol(Symbol, Decl(lib.es6.symbol.wellknown.d.ts, --, --), Decl(lib.es6.symbol.d.ts, --, --), Decl(lib.es6.symbol.d.ts, --, --)) + +// Using ES6 wellknown-symbol +const o1 = { +>o1 : Symbol(o1, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 76, 5)) + + [Symbol.hasInstance](value: any) { +>Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es6.symbol.wellknown.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.es6.symbol.wellknown.d.ts, --, --), Decl(lib.es6.symbol.d.ts, --, --), Decl(lib.es6.symbol.d.ts, --, --)) +>hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es6.symbol.wellknown.d.ts, --, --)) +>value : Symbol(value, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 77, 25)) + + return false; + } +} diff --git a/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types b/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types new file mode 100644 index 00000000000..8272465da5e --- /dev/null +++ b/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types @@ -0,0 +1,231 @@ +=== tests/cases/compiler/modularizeLibrary_TargetES5UsingES6Lib.ts === + +// Using Es6 array +function f(x: number, y: number, z: number) { +>f : (x: number, y: number, z: number) => any[] +>x : number +>y : number +>z : number + + return Array.from(arguments); +>Array.from(arguments) : any[] +>Array.from : { (iterable: Iterable, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; (iterable: Iterable): T[]; (arrayLike: ArrayLike, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; (arrayLike: ArrayLike): T[]; } +>Array : ArrayConstructor +>from : { (iterable: Iterable, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; (iterable: Iterable): T[]; (arrayLike: ArrayLike, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; (arrayLike: ArrayLike): T[]; } +>arguments : IArguments +} + +f(1, 2, 3); // no error +>f(1, 2, 3) : any[] +>f : (x: number, y: number, z: number) => any[] +>1 : number +>2 : number +>3 : number + +// Using ES6 collection +var m = new Map(); +>m : Map +>new Map() : Map +>Map : MapConstructor + +m.clear(); +>m.clear() : void +>m.clear : () => void +>m : Map +>clear : () => void + +// Using ES6 iterable +m.keys(); +>m.keys() : IterableIterator +>m.keys : () => IterableIterator +>m : Map +>keys : () => IterableIterator + +// Using ES6 function +function Baz() { } +>Baz : () => void + +Baz.name; +>Baz.name : string +>Baz : () => void +>name : string + +// Using ES6 generator +function* gen() { +>gen : () => IterableIterator + + let i = 0; +>i : number +>0 : number + + while (i < 10) { +>i < 10 : boolean +>i : number +>10 : number + + yield i; +>yield i : any +>i : number + + i++; +>i++ : number +>i : number + } +} + +function* gen2() { +>gen2 : () => IterableIterator + + let i = 0; +>i : number +>0 : number + + while (i < 10) { +>i < 10 : boolean +>i : number +>10 : number + + yield i; +>yield i : any +>i : number + + i++; +>i++ : number +>i : number + } +} + +// Using ES6 math +Math.sign(1); +>Math.sign(1) : number +>Math.sign : (x: number) => number +>Math : Math +>sign : (x: number) => number +>1 : number + +// Using ES6 object +var o = { +>o : { a: number; [Symbol.hasInstance](value: any): boolean; } +>{ a: 2, [Symbol.hasInstance](value: any) { return false; }} : { a: number; [Symbol.hasInstance](value: any): boolean; } + + a: 2, +>a : number +>2 : number + + [Symbol.hasInstance](value: any) { +>Symbol.hasInstance : symbol +>Symbol : SymbolConstructor +>hasInstance : symbol +>value : any + + return false; +>false : boolean + } +}; +o.hasOwnProperty(Symbol.hasInstance); +>o.hasOwnProperty(Symbol.hasInstance) : boolean +>o.hasOwnProperty : { (v: string | number | symbol): boolean; (v: string): boolean; } +>o : { a: number; [Symbol.hasInstance](value: any): boolean; } +>hasOwnProperty : { (v: string | number | symbol): boolean; (v: string): boolean; } +>Symbol.hasInstance : symbol +>Symbol : SymbolConstructor +>hasInstance : symbol + +// Using ES6 promise +async function out() { +>out : () => Promise<{}> + + return new Promise(function (resolve, reject) {}); +>new Promise(function (resolve, reject) {}) : Promise<{}> +>Promise : PromiseConstructor +>function (resolve, reject) {} : (resolve: (value?: {} | PromiseLike<{}>) => void, reject: (reason?: any) => void) => void +>resolve : (value?: {} | PromiseLike<{}>) => void +>reject : (reason?: any) => void +} + +declare var console: any; +>console : any + +out().then(() => { +>out().then(() => { console.log("Yea!");}) : Promise +>out().then : { (onfulfilled?: (value: {}) => TResult | PromiseLike, onrejected?: (reason: any) => TResult | PromiseLike): Promise; (onfulfilled?: (value: {}) => TResult | PromiseLike, onrejected?: (reason: any) => void): Promise; } +>out() : Promise<{}> +>out : () => Promise<{}> +>then : { (onfulfilled?: (value: {}) => TResult | PromiseLike, onrejected?: (reason: any) => TResult | PromiseLike): Promise; (onfulfilled?: (value: {}) => TResult | PromiseLike, onrejected?: (reason: any) => void): Promise; } +>() => { console.log("Yea!");} : () => void + + console.log("Yea!"); +>console.log("Yea!") : any +>console.log : any +>console : any +>log : any +>"Yea!" : string + +}); + +// Using Es6 proxy +var t = {} +>t : {} +>{} : {} + +var p = new Proxy(t, {}); +>p : {} +>new Proxy(t, {}) : {} +>Proxy : ProxyConstructor +>t : {} +>{} : {} + +// Using ES6 reflect +Reflect.isExtensible({}); +>Reflect.isExtensible({}) : boolean +>Reflect.isExtensible : (target: any) => boolean +>Reflect : typeof Reflect +>isExtensible : (target: any) => boolean +>{} : {} + +// Using Es6 regexp +var reg = new RegExp("/s"); +>reg : RegExp +>new RegExp("/s") : RegExp +>RegExp : RegExpConstructor +>"/s" : string + +reg.flags; +>reg.flags : string +>reg : RegExp +>flags : string + +// Using ES6 string +var str = "Hello world"; +>str : string +>"Hello world" : string + +str.includes("hello", 0); +>str.includes("hello", 0) : boolean +>str.includes : (searchString: string, position?: number) => boolean +>str : string +>includes : (searchString: string, position?: number) => boolean +>"hello" : string +>0 : number + +// Using ES6 symbol +var s = Symbol(); +>s : symbol +>Symbol() : symbol +>Symbol : SymbolConstructor + +// Using ES6 wellknown-symbol +const o1 = { +>o1 : { [Symbol.hasInstance](value: any): boolean; } +>{ [Symbol.hasInstance](value: any) { return false; }} : { [Symbol.hasInstance](value: any): boolean; } + + [Symbol.hasInstance](value: any) { +>Symbol.hasInstance : symbol +>Symbol : SymbolConstructor +>hasInstance : symbol +>value : any + + return false; +>false : boolean + } +} diff --git a/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.js b/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.js new file mode 100644 index 00000000000..137bd1063b8 --- /dev/null +++ b/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.js @@ -0,0 +1,99 @@ +//// [modularizeLibrary_TargetES6UsingES6Lib.ts] + +// Using Es6 array +function f(x: number, y: number, z: number) { + return Array.from(arguments); +} + +f(1, 2, 3); // no error + +// Using ES6 collection +var m = new Map(); +m.clear(); +// Using ES6 iterable +m.keys(); + +// Using ES6 function +function Baz() { } +Baz.name; + +// Using ES6 math +Math.sign(1); + +// Using ES6 object +var o = { + a: 2, + [Symbol.hasInstance](value: any) { + return false; + } +}; +o.hasOwnProperty(Symbol.hasInstance); + +// Using Es6 proxy +var t = {} +var p = new Proxy(t, {}); + +// Using ES6 reflect +Reflect.isExtensible({}); + +// Using Es6 regexp +var reg = new RegExp("/s"); +reg.flags; + +// Using ES6 string +var str = "Hello world"; +str.includes("hello", 0); + +// Using ES6 symbol +var s = Symbol(); + +// Using ES6 wellknown-symbol +const o1 = { + [Symbol.hasInstance](value: any) { + return false; + } +} + +//// [modularizeLibrary_TargetES6UsingES6Lib.js] +// Using Es6 array +function f(x, y, z) { + return Array.from(arguments); +} +f(1, 2, 3); // no error +// Using ES6 collection +var m = new Map(); +m.clear(); +// Using ES6 iterable +m.keys(); +// Using ES6 function +function Baz() { } +Baz.name; +// Using ES6 math +Math.sign(1); +// Using ES6 object +var o = { + a: 2, + [Symbol.hasInstance](value) { + return false; + } +}; +o.hasOwnProperty(Symbol.hasInstance); +// Using Es6 proxy +var t = {}; +var p = new Proxy(t, {}); +// Using ES6 reflect +Reflect.isExtensible({}); +// Using Es6 regexp +var reg = new RegExp("/s"); +reg.flags; +// Using ES6 string +var str = "Hello world"; +str.includes("hello", 0); +// Using ES6 symbol +var s = Symbol(); +// Using ES6 wellknown-symbol +const o1 = { + [Symbol.hasInstance](value) { + return false; + } +}; diff --git a/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.symbols b/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.symbols new file mode 100644 index 00000000000..bf4396c82ba --- /dev/null +++ b/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.symbols @@ -0,0 +1,126 @@ +=== tests/cases/compiler/modularizeLibrary_TargetES6UsingES6Lib.ts === + +// Using Es6 array +function f(x: number, y: number, z: number) { +>f : Symbol(f, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 0, 0)) +>x : Symbol(x, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 2, 11)) +>y : Symbol(y, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 2, 21)) +>z : Symbol(z, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 2, 32)) + + return Array.from(arguments); +>Array.from : Symbol(ArrayConstructor.from, Decl(lib.es6.iterable.d.ts, --, --), Decl(lib.es6.iterable.d.ts, --, --), Decl(lib.es6.array.d.ts, --, --), Decl(lib.es6.array.d.ts, --, --)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es6.symbol.wellknown.d.ts, --, --), Decl(lib.es6.iterable.d.ts, --, --), Decl(lib.es6.array.d.ts, --, --)) +>from : Symbol(ArrayConstructor.from, Decl(lib.es6.iterable.d.ts, --, --), Decl(lib.es6.iterable.d.ts, --, --), Decl(lib.es6.array.d.ts, --, --), Decl(lib.es6.array.d.ts, --, --)) +>arguments : Symbol(arguments) +} + +f(1, 2, 3); // no error +>f : Symbol(f, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 0, 0)) + +// Using ES6 collection +var m = new Map(); +>m : Symbol(m, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 9, 3)) +>Map : Symbol(Map, Decl(lib.es6.symbol.wellknown.d.ts, --, --), Decl(lib.es6.iterable.d.ts, --, --), Decl(lib.es6.collection.d.ts, --, --), Decl(lib.es6.collection.d.ts, --, --)) + +m.clear(); +>m.clear : Symbol(Map.clear, Decl(lib.es6.collection.d.ts, --, --)) +>m : Symbol(m, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 9, 3)) +>clear : Symbol(Map.clear, Decl(lib.es6.collection.d.ts, --, --)) + +// Using ES6 iterable +m.keys(); +>m.keys : Symbol(Map.keys, Decl(lib.es6.iterable.d.ts, --, --)) +>m : Symbol(m, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 9, 3)) +>keys : Symbol(Map.keys, Decl(lib.es6.iterable.d.ts, --, --)) + +// Using ES6 function +function Baz() { } +>Baz : Symbol(Baz, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 12, 9)) + +Baz.name; +>Baz.name : Symbol(Function.name, Decl(lib.es6.function.d.ts, --, --)) +>Baz : Symbol(Baz, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 12, 9)) +>name : Symbol(Function.name, Decl(lib.es6.function.d.ts, --, --)) + +// Using ES6 math +Math.sign(1); +>Math.sign : Symbol(Math.sign, Decl(lib.es6.math.d.ts, --, --)) +>Math : Symbol(Math, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es6.symbol.wellknown.d.ts, --, --), Decl(lib.es6.math.d.ts, --, --)) +>sign : Symbol(Math.sign, Decl(lib.es6.math.d.ts, --, --)) + +// Using ES6 object +var o = { +>o : Symbol(o, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 22, 3)) + + a: 2, +>a : Symbol(a, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 22, 9)) + + [Symbol.hasInstance](value: any) { +>Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es6.symbol.wellknown.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.es6.symbol.wellknown.d.ts, --, --), Decl(lib.es6.symbol.d.ts, --, --), Decl(lib.es6.symbol.d.ts, --, --)) +>hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es6.symbol.wellknown.d.ts, --, --)) +>value : Symbol(value, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 24, 25)) + + return false; + } +}; +o.hasOwnProperty(Symbol.hasInstance); +>o.hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.es5.d.ts, --, --), Decl(lib.es6.object.d.ts, --, --)) +>o : Symbol(o, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 22, 3)) +>hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.es5.d.ts, --, --), Decl(lib.es6.object.d.ts, --, --)) +>Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es6.symbol.wellknown.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.es6.symbol.wellknown.d.ts, --, --), Decl(lib.es6.symbol.d.ts, --, --), Decl(lib.es6.symbol.d.ts, --, --)) +>hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es6.symbol.wellknown.d.ts, --, --)) + +// Using Es6 proxy +var t = {} +>t : Symbol(t, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 31, 3)) + +var p = new Proxy(t, {}); +>p : Symbol(p, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 32, 3)) +>Proxy : Symbol(Proxy, Decl(lib.es6.proxy.d.ts, --, --)) +>t : Symbol(t, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 31, 3)) + +// Using ES6 reflect +Reflect.isExtensible({}); +>Reflect.isExtensible : Symbol(Reflect.isExtensible, Decl(lib.es6.reflect.d.ts, --, --)) +>Reflect : Symbol(Reflect, Decl(lib.es6.reflect.d.ts, --, --), Decl(lib.es6.iterable.d.ts, --, --)) +>isExtensible : Symbol(Reflect.isExtensible, Decl(lib.es6.reflect.d.ts, --, --)) + +// Using Es6 regexp +var reg = new RegExp("/s"); +>reg : Symbol(reg, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 38, 3)) +>RegExp : Symbol(RegExp, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es6.symbol.wellknown.d.ts, --, --), Decl(lib.es6.regexp.d.ts, --, --)) + +reg.flags; +>reg.flags : Symbol(RegExp.flags, Decl(lib.es6.regexp.d.ts, --, --)) +>reg : Symbol(reg, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 38, 3)) +>flags : Symbol(RegExp.flags, Decl(lib.es6.regexp.d.ts, --, --)) + +// Using ES6 string +var str = "Hello world"; +>str : Symbol(str, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 42, 3)) + +str.includes("hello", 0); +>str.includes : Symbol(String.includes, Decl(lib.es6.string.d.ts, --, --)) +>str : Symbol(str, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 42, 3)) +>includes : Symbol(String.includes, Decl(lib.es6.string.d.ts, --, --)) + +// Using ES6 symbol +var s = Symbol(); +>s : Symbol(s, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 46, 3)) +>Symbol : Symbol(Symbol, Decl(lib.es6.symbol.wellknown.d.ts, --, --), Decl(lib.es6.symbol.d.ts, --, --), Decl(lib.es6.symbol.d.ts, --, --)) + +// Using ES6 wellknown-symbol +const o1 = { +>o1 : Symbol(o1, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 49, 5)) + + [Symbol.hasInstance](value: any) { +>Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es6.symbol.wellknown.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.es6.symbol.wellknown.d.ts, --, --), Decl(lib.es6.symbol.d.ts, --, --), Decl(lib.es6.symbol.d.ts, --, --)) +>hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.es6.symbol.wellknown.d.ts, --, --)) +>value : Symbol(value, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 50, 25)) + + return false; + } +} diff --git a/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.types b/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.types new file mode 100644 index 00000000000..7af40d3684c --- /dev/null +++ b/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.types @@ -0,0 +1,154 @@ +=== tests/cases/compiler/modularizeLibrary_TargetES6UsingES6Lib.ts === + +// Using Es6 array +function f(x: number, y: number, z: number) { +>f : (x: number, y: number, z: number) => any[] +>x : number +>y : number +>z : number + + return Array.from(arguments); +>Array.from(arguments) : any[] +>Array.from : { (iterable: Iterable, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; (iterable: Iterable): T[]; (arrayLike: ArrayLike, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; (arrayLike: ArrayLike): T[]; } +>Array : ArrayConstructor +>from : { (iterable: Iterable, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; (iterable: Iterable): T[]; (arrayLike: ArrayLike, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; (arrayLike: ArrayLike): T[]; } +>arguments : IArguments +} + +f(1, 2, 3); // no error +>f(1, 2, 3) : any[] +>f : (x: number, y: number, z: number) => any[] +>1 : number +>2 : number +>3 : number + +// Using ES6 collection +var m = new Map(); +>m : Map +>new Map() : Map +>Map : MapConstructor + +m.clear(); +>m.clear() : void +>m.clear : () => void +>m : Map +>clear : () => void + +// Using ES6 iterable +m.keys(); +>m.keys() : IterableIterator +>m.keys : () => IterableIterator +>m : Map +>keys : () => IterableIterator + +// Using ES6 function +function Baz() { } +>Baz : () => void + +Baz.name; +>Baz.name : string +>Baz : () => void +>name : string + +// Using ES6 math +Math.sign(1); +>Math.sign(1) : number +>Math.sign : (x: number) => number +>Math : Math +>sign : (x: number) => number +>1 : number + +// Using ES6 object +var o = { +>o : { a: number; [Symbol.hasInstance](value: any): boolean; } +>{ a: 2, [Symbol.hasInstance](value: any) { return false; }} : { a: number; [Symbol.hasInstance](value: any): boolean; } + + a: 2, +>a : number +>2 : number + + [Symbol.hasInstance](value: any) { +>Symbol.hasInstance : symbol +>Symbol : SymbolConstructor +>hasInstance : symbol +>value : any + + return false; +>false : boolean + } +}; +o.hasOwnProperty(Symbol.hasInstance); +>o.hasOwnProperty(Symbol.hasInstance) : boolean +>o.hasOwnProperty : { (v: string): boolean; (v: string | number | symbol): boolean; } +>o : { a: number; [Symbol.hasInstance](value: any): boolean; } +>hasOwnProperty : { (v: string): boolean; (v: string | number | symbol): boolean; } +>Symbol.hasInstance : symbol +>Symbol : SymbolConstructor +>hasInstance : symbol + +// Using Es6 proxy +var t = {} +>t : {} +>{} : {} + +var p = new Proxy(t, {}); +>p : {} +>new Proxy(t, {}) : {} +>Proxy : ProxyConstructor +>t : {} +>{} : {} + +// Using ES6 reflect +Reflect.isExtensible({}); +>Reflect.isExtensible({}) : boolean +>Reflect.isExtensible : (target: any) => boolean +>Reflect : typeof Reflect +>isExtensible : (target: any) => boolean +>{} : {} + +// Using Es6 regexp +var reg = new RegExp("/s"); +>reg : RegExp +>new RegExp("/s") : RegExp +>RegExp : RegExpConstructor +>"/s" : string + +reg.flags; +>reg.flags : string +>reg : RegExp +>flags : string + +// Using ES6 string +var str = "Hello world"; +>str : string +>"Hello world" : string + +str.includes("hello", 0); +>str.includes("hello", 0) : boolean +>str.includes : (searchString: string, position?: number) => boolean +>str : string +>includes : (searchString: string, position?: number) => boolean +>"hello" : string +>0 : number + +// Using ES6 symbol +var s = Symbol(); +>s : symbol +>Symbol() : symbol +>Symbol : SymbolConstructor + +// Using ES6 wellknown-symbol +const o1 = { +>o1 : { [Symbol.hasInstance](value: any): boolean; } +>{ [Symbol.hasInstance](value: any) { return false; }} : { [Symbol.hasInstance](value: any): boolean; } + + [Symbol.hasInstance](value: any) { +>Symbol.hasInstance : symbol +>Symbol : SymbolConstructor +>hasInstance : symbol +>value : any + + return false; +>false : boolean + } +} diff --git a/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6ArrayLib.js b/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6ArrayLib.js new file mode 100644 index 00000000000..29e0afc711c --- /dev/null +++ b/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6ArrayLib.js @@ -0,0 +1,15 @@ +//// [modularizeLibrary_UsingES5LibAndES6ArrayLib.ts] + +// No error +function f(x: number, y: number, z: number) { + return Array.from(arguments); +} + +f(1, 2, 3); + +//// [modularizeLibrary_UsingES5LibAndES6ArrayLib.js] +// No error +function f(x, y, z) { + return Array.from(arguments); +} +f(1, 2, 3); diff --git a/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6ArrayLib.symbols b/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6ArrayLib.symbols new file mode 100644 index 00000000000..343ff3ffea3 --- /dev/null +++ b/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6ArrayLib.symbols @@ -0,0 +1,19 @@ +=== tests/cases/compiler/modularizeLibrary_UsingES5LibAndES6ArrayLib.ts === + +// No error +function f(x: number, y: number, z: number) { +>f : Symbol(f, Decl(modularizeLibrary_UsingES5LibAndES6ArrayLib.ts, 0, 0)) +>x : Symbol(x, Decl(modularizeLibrary_UsingES5LibAndES6ArrayLib.ts, 2, 11)) +>y : Symbol(y, Decl(modularizeLibrary_UsingES5LibAndES6ArrayLib.ts, 2, 21)) +>z : Symbol(z, Decl(modularizeLibrary_UsingES5LibAndES6ArrayLib.ts, 2, 32)) + + return Array.from(arguments); +>Array.from : Symbol(ArrayConstructor.from, Decl(lib.es6.array.d.ts, --, --), Decl(lib.es6.array.d.ts, --, --)) +>Array : Symbol(Array, Decl(lib.es6.array.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>from : Symbol(ArrayConstructor.from, Decl(lib.es6.array.d.ts, --, --), Decl(lib.es6.array.d.ts, --, --)) +>arguments : Symbol(arguments) +} + +f(1, 2, 3); +>f : Symbol(f, Decl(modularizeLibrary_UsingES5LibAndES6ArrayLib.ts, 0, 0)) + diff --git a/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6ArrayLib.types b/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6ArrayLib.types new file mode 100644 index 00000000000..d17a6fcbcbb --- /dev/null +++ b/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6ArrayLib.types @@ -0,0 +1,24 @@ +=== tests/cases/compiler/modularizeLibrary_UsingES5LibAndES6ArrayLib.ts === + +// No error +function f(x: number, y: number, z: number) { +>f : (x: number, y: number, z: number) => any[] +>x : number +>y : number +>z : number + + return Array.from(arguments); +>Array.from(arguments) : any[] +>Array.from : { (arrayLike: ArrayLike, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; (arrayLike: ArrayLike): T[]; } +>Array : ArrayConstructor +>from : { (arrayLike: ArrayLike, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; (arrayLike: ArrayLike): T[]; } +>arguments : IArguments +} + +f(1, 2, 3); +>f(1, 2, 3) : any[] +>f : (x: number, y: number, z: number) => any[] +>1 : number +>2 : number +>3 : number + diff --git a/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.js b/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.js new file mode 100644 index 00000000000..892bc688524 --- /dev/null +++ b/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.js @@ -0,0 +1,27 @@ +//// [modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts] + +var s = Symbol(); +var t = {}; +var p = new Proxy(t, {}); + +Reflect.ownKeys({}); + +function* idGen() { + let i = 10; + while (i < 20) { + yield i + 2; + } +} + + +//// [modularizeLibrary_UsingES5LibAndES6FeatureLibs.js] +var s = Symbol(); +var t = {}; +var p = new Proxy(t, {}); +Reflect.ownKeys({}); +function* idGen() { + let i = 10; + while (i < 20) { + yield i + 2; + } +} diff --git a/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.symbols b/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.symbols new file mode 100644 index 00000000000..5256f4ae40f --- /dev/null +++ b/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.symbols @@ -0,0 +1,33 @@ +=== tests/cases/compiler/modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts === + +var s = Symbol(); +>s : Symbol(s, Decl(modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts, 1, 3)) +>Symbol : Symbol(Symbol, Decl(lib.es6.symbol.d.ts, --, --), Decl(lib.es6.symbol.d.ts, --, --)) + +var t = {}; +>t : Symbol(t, Decl(modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts, 2, 3)) + +var p = new Proxy(t, {}); +>p : Symbol(p, Decl(modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts, 3, 3)) +>Proxy : Symbol(Proxy, Decl(lib.es6.proxy.d.ts, --, --)) +>t : Symbol(t, Decl(modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts, 2, 3)) + +Reflect.ownKeys({}); +>Reflect.ownKeys : Symbol(Reflect.ownKeys, Decl(lib.es6.reflect.d.ts, --, --)) +>Reflect : Symbol(Reflect, Decl(lib.es6.reflect.d.ts, --, --), Decl(lib.es6.iterable.d.ts, --, --)) +>ownKeys : Symbol(Reflect.ownKeys, Decl(lib.es6.reflect.d.ts, --, --)) + +function* idGen() { +>idGen : Symbol(idGen, Decl(modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts, 5, 20)) + + let i = 10; +>i : Symbol(i, Decl(modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts, 8, 7)) + + while (i < 20) { +>i : Symbol(i, Decl(modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts, 8, 7)) + + yield i + 2; +>i : Symbol(i, Decl(modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts, 8, 7)) + } +} + diff --git a/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.types b/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.types new file mode 100644 index 00000000000..820c2f6dc8a --- /dev/null +++ b/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.types @@ -0,0 +1,45 @@ +=== tests/cases/compiler/modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts === + +var s = Symbol(); +>s : symbol +>Symbol() : symbol +>Symbol : SymbolConstructor + +var t = {}; +>t : {} +>{} : {} + +var p = new Proxy(t, {}); +>p : {} +>new Proxy(t, {}) : {} +>Proxy : ProxyConstructor +>t : {} +>{} : {} + +Reflect.ownKeys({}); +>Reflect.ownKeys({}) : (string | number | symbol)[] +>Reflect.ownKeys : (target: any) => (string | number | symbol)[] +>Reflect : typeof Reflect +>ownKeys : (target: any) => (string | number | symbol)[] +>{} : {} + +function* idGen() { +>idGen : () => IterableIterator + + let i = 10; +>i : number +>10 : number + + while (i < 20) { +>i < 20 : boolean +>i : number +>20 : number + + yield i + 2; +>yield i + 2 : any +>i + 2 : number +>i : number +>2 : number + } +} + diff --git a/tests/baselines/reference/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.js b/tests/baselines/reference/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.js new file mode 100644 index 00000000000..7755fc72ce8 --- /dev/null +++ b/tests/baselines/reference/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.js @@ -0,0 +1,17 @@ +//// [modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.ts] + +function f(x: number, y: number, z: number) { + return Array.from(arguments); +} + +f(1, 2, 3); // no error +let a = ['c', 'd']; +a[Symbol.isConcatSpreadable] = false; + +//// [modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.js] +function f(x, y, z) { + return Array.from(arguments); +} +f(1, 2, 3); // no error +var a = ['c', 'd']; +a[Symbol.isConcatSpreadable] = false; diff --git a/tests/baselines/reference/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.symbols b/tests/baselines/reference/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.symbols new file mode 100644 index 00000000000..0a8d9320dd5 --- /dev/null +++ b/tests/baselines/reference/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.symbols @@ -0,0 +1,27 @@ +=== tests/cases/compiler/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.ts === + +function f(x: number, y: number, z: number) { +>f : Symbol(f, Decl(modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.ts, 0, 0)) +>x : Symbol(x, Decl(modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.ts, 1, 11)) +>y : Symbol(y, Decl(modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.ts, 1, 21)) +>z : Symbol(z, Decl(modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.ts, 1, 32)) + + return Array.from(arguments); +>Array.from : Symbol(ArrayConstructor.from, Decl(lib.es6.array.d.ts, --, --), Decl(lib.es6.array.d.ts, --, --)) +>Array : Symbol(Array, Decl(lib.es6.symbol.wellknown.d.ts, --, --), Decl(lib.es6.array.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>from : Symbol(ArrayConstructor.from, Decl(lib.es6.array.d.ts, --, --), Decl(lib.es6.array.d.ts, --, --)) +>arguments : Symbol(arguments) +} + +f(1, 2, 3); // no error +>f : Symbol(f, Decl(modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.ts, 0, 0)) + +let a = ['c', 'd']; +>a : Symbol(a, Decl(modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.ts, 6, 3)) + +a[Symbol.isConcatSpreadable] = false; +>a : Symbol(a, Decl(modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.ts, 6, 3)) +>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.symbol.wellknown.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.es6.symbol.wellknown.d.ts, --, --), Decl(lib.es6.symbol.d.ts, --, --), Decl(lib.es6.symbol.d.ts, --, --)) +>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.es6.symbol.wellknown.d.ts, --, --)) + diff --git a/tests/baselines/reference/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.types b/tests/baselines/reference/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.types new file mode 100644 index 00000000000..3ae08c79fd4 --- /dev/null +++ b/tests/baselines/reference/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.types @@ -0,0 +1,38 @@ +=== tests/cases/compiler/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.ts === + +function f(x: number, y: number, z: number) { +>f : (x: number, y: number, z: number) => any[] +>x : number +>y : number +>z : number + + return Array.from(arguments); +>Array.from(arguments) : any[] +>Array.from : { (arrayLike: ArrayLike, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; (arrayLike: ArrayLike): T[]; } +>Array : ArrayConstructor +>from : { (arrayLike: ArrayLike, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; (arrayLike: ArrayLike): T[]; } +>arguments : IArguments +} + +f(1, 2, 3); // no error +>f(1, 2, 3) : any[] +>f : (x: number, y: number, z: number) => any[] +>1 : number +>2 : number +>3 : number + +let a = ['c', 'd']; +>a : string[] +>['c', 'd'] : string[] +>'c' : string +>'d' : string + +a[Symbol.isConcatSpreadable] = false; +>a[Symbol.isConcatSpreadable] = false : boolean +>a[Symbol.isConcatSpreadable] : any +>a : string[] +>Symbol.isConcatSpreadable : symbol +>Symbol : SymbolConstructor +>isConcatSpreadable : symbol +>false : boolean + diff --git a/tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6ArrayWithOnlyES6ArrayLib.ts b/tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6ArrayWithOnlyES6ArrayLib.ts new file mode 100644 index 00000000000..d8f9202dbf4 --- /dev/null +++ b/tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6ArrayWithOnlyES6ArrayLib.ts @@ -0,0 +1,9 @@ +// @lib: es2015.array +// @target: es5 + +// Error missing basic JavaScript objects +function f(x: number, y: number, z: number) { + return Array.from(arguments); +} + +f(1, 2, 3); diff --git a/tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts b/tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts new file mode 100644 index 00000000000..290cf0e4211 --- /dev/null +++ b/tests/cases/compiler/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.ts @@ -0,0 +1,57 @@ +// @lib: es5 +// @target: es6 + +// All will be error from using ES6 features but only include ES5 library +// Using Es6 array +function f(x: number, y: number, z: number) { + return Array.from(arguments); +} + +f(1, 2, 3); // no error + +// Using ES6 collection +var m = new Map(); +m.clear(); +// Using ES6 iterable +m.keys(); + +// Using ES6 function +function Baz() { } +Baz.name; + +// Using ES6 math +Math.sign(1); + +// Using ES6 object +var o = { + a: 2, + [Symbol.hasInstance](value: any) { + return false; + } +}; +o.hasOwnProperty(Symbol.hasInstance); + +// Using Es6 proxy +var t = {} +var p = new Proxy(t, {}); + +// Using ES6 reflect +Reflect.isExtensible({}); + +// Using Es6 regexp +var reg = new RegExp("/s"); +reg.flags; + +// Using ES6 string +var str = "Hello world"; +str.includes("hello", 0); + +// Using ES6 symbol +var s = Symbol(); + +// Using ES6 wellknown-symbol +const o1 = { + [Symbol.hasInstance](value: any) { + return false; + } +} \ No newline at end of file diff --git a/tests/cases/compiler/modularizeLibrary_ErrorFromUsingWellknownSymbolWithOutES6WellknownSymbolLib.ts b/tests/cases/compiler/modularizeLibrary_ErrorFromUsingWellknownSymbolWithOutES6WellknownSymbolLib.ts new file mode 100644 index 00000000000..3789e975e14 --- /dev/null +++ b/tests/cases/compiler/modularizeLibrary_ErrorFromUsingWellknownSymbolWithOutES6WellknownSymbolLib.ts @@ -0,0 +1,9 @@ +// @lib: es5,es2015.array + +function f(x: number, y: number, z: number) { + return Array.from(arguments); +} + +f(1, 2, 3); // no error +let a = ['c', 'd']; +a[Symbol.isConcatSpreadable] = false; \ No newline at end of file diff --git a/tests/cases/compiler/modularizeLibrary_NoErrorDuplicateLibOptions1.ts b/tests/cases/compiler/modularizeLibrary_NoErrorDuplicateLibOptions1.ts new file mode 100644 index 00000000000..4b2a88c1320 --- /dev/null +++ b/tests/cases/compiler/modularizeLibrary_NoErrorDuplicateLibOptions1.ts @@ -0,0 +1,83 @@ +// @lib: es5,es6,es6 +// @target: es6 + +// Using Es6 array +function f(x: number, y: number, z: number) { + return Array.from(arguments); +} + +f(1, 2, 3); // no error + +// Using ES6 collection +var m = new Map(); +m.clear(); +// Using ES6 iterable +m.keys(); + +// Using ES6 function +function Baz() { } +Baz.name; + +// Using ES6 generator +function* gen() { + let i = 0; + while (i < 10) { + yield i; + i++; + } +} + +function* gen2() { + let i = 0; + while (i < 10) { + yield i; + i++; + } +} + +// Using ES6 math +Math.sign(1); + +// Using ES6 object +var o = { + a: 2, + [Symbol.hasInstance](value: any) { + return false; + } +}; +o.hasOwnProperty(Symbol.hasInstance); + +// Using ES6 promise +async function out() { + return new Promise(function (resolve, reject) {}); +} + +declare var console: any; +out().then(() => { + console.log("Yea!"); +}); + +// Using Es6 proxy +var t = {} +var p = new Proxy(t, {}); + +// Using ES6 reflect +Reflect.isExtensible({}); + +// Using Es6 regexp +var reg = new RegExp("/s"); +reg.flags; + +// Using ES6 string +var str = "Hello world"; +str.includes("hello", 0); + +// Using ES6 symbol +var s = Symbol(); + +// Using ES6 wellknown-symbol +const o1 = { + [Symbol.hasInstance](value: any) { + return false; + } +} \ No newline at end of file diff --git a/tests/cases/compiler/modularizeLibrary_NoErrorDuplicateLibOptions2.ts b/tests/cases/compiler/modularizeLibrary_NoErrorDuplicateLibOptions2.ts new file mode 100644 index 00000000000..c79b7c3871f --- /dev/null +++ b/tests/cases/compiler/modularizeLibrary_NoErrorDuplicateLibOptions2.ts @@ -0,0 +1,83 @@ +// @lib: es5,es2015,es2015.array,es2015.symbol.wellknown +// @target: es6 + +// Using Es6 array +function f(x: number, y: number, z: number) { + return Array.from(arguments); +} + +f(1, 2, 3); // no error + +// Using ES6 collection +var m = new Map(); +m.clear(); +// Using ES6 iterable +m.keys(); + +// Using ES6 function +function Baz() { } +Baz.name; + +// Using ES6 generator +function* gen() { + let i = 0; + while (i < 10) { + yield i; + i++; + } +} + +function* gen2() { + let i = 0; + while (i < 10) { + yield i; + i++; + } +} + +// Using ES6 math +Math.sign(1); + +// Using ES6 object +var o = { + a: 2, + [Symbol.hasInstance](value: any) { + return false; + } +}; +o.hasOwnProperty(Symbol.hasInstance); + +// Using ES6 promise +async function out() { + return new Promise(function (resolve, reject) {}); +} + +declare var console: any; +out().then(() => { + console.log("Yea!"); +}); + +// Using Es6 proxy +var t = {} +var p = new Proxy(t, {}); + +// Using ES6 reflect +Reflect.isExtensible({}); + +// Using Es6 regexp +var reg = new RegExp("/s"); +reg.flags; + +// Using ES6 string +var str = "Hello world"; +str.includes("hello", 0); + +// Using ES6 symbol +var s = Symbol(); + +// Using ES6 wellknown-symbol +const o1 = { + [Symbol.hasInstance](value: any) { + return false; + } +} \ No newline at end of file diff --git a/tests/cases/compiler/modularizeLibrary_TargetES5UsingES6Lib.ts b/tests/cases/compiler/modularizeLibrary_TargetES5UsingES6Lib.ts new file mode 100644 index 00000000000..e308912757b --- /dev/null +++ b/tests/cases/compiler/modularizeLibrary_TargetES5UsingES6Lib.ts @@ -0,0 +1,83 @@ +// @lib: es5,es6 +// @target: es6 + +// Using Es6 array +function f(x: number, y: number, z: number) { + return Array.from(arguments); +} + +f(1, 2, 3); // no error + +// Using ES6 collection +var m = new Map(); +m.clear(); +// Using ES6 iterable +m.keys(); + +// Using ES6 function +function Baz() { } +Baz.name; + +// Using ES6 generator +function* gen() { + let i = 0; + while (i < 10) { + yield i; + i++; + } +} + +function* gen2() { + let i = 0; + while (i < 10) { + yield i; + i++; + } +} + +// Using ES6 math +Math.sign(1); + +// Using ES6 object +var o = { + a: 2, + [Symbol.hasInstance](value: any) { + return false; + } +}; +o.hasOwnProperty(Symbol.hasInstance); + +// Using ES6 promise +async function out() { + return new Promise(function (resolve, reject) {}); +} + +declare var console: any; +out().then(() => { + console.log("Yea!"); +}); + +// Using Es6 proxy +var t = {} +var p = new Proxy(t, {}); + +// Using ES6 reflect +Reflect.isExtensible({}); + +// Using Es6 regexp +var reg = new RegExp("/s"); +reg.flags; + +// Using ES6 string +var str = "Hello world"; +str.includes("hello", 0); + +// Using ES6 symbol +var s = Symbol(); + +// Using ES6 wellknown-symbol +const o1 = { + [Symbol.hasInstance](value: any) { + return false; + } +} \ No newline at end of file diff --git a/tests/cases/compiler/modularizeLibrary_TargetES6UsingES6Lib.ts b/tests/cases/compiler/modularizeLibrary_TargetES6UsingES6Lib.ts new file mode 100644 index 00000000000..3a938fe1a69 --- /dev/null +++ b/tests/cases/compiler/modularizeLibrary_TargetES6UsingES6Lib.ts @@ -0,0 +1,56 @@ +// @lib: es6 +// @target: es6 + +// Using Es6 array +function f(x: number, y: number, z: number) { + return Array.from(arguments); +} + +f(1, 2, 3); // no error + +// Using ES6 collection +var m = new Map(); +m.clear(); +// Using ES6 iterable +m.keys(); + +// Using ES6 function +function Baz() { } +Baz.name; + +// Using ES6 math +Math.sign(1); + +// Using ES6 object +var o = { + a: 2, + [Symbol.hasInstance](value: any) { + return false; + } +}; +o.hasOwnProperty(Symbol.hasInstance); + +// Using Es6 proxy +var t = {} +var p = new Proxy(t, {}); + +// Using ES6 reflect +Reflect.isExtensible({}); + +// Using Es6 regexp +var reg = new RegExp("/s"); +reg.flags; + +// Using ES6 string +var str = "Hello world"; +str.includes("hello", 0); + +// Using ES6 symbol +var s = Symbol(); + +// Using ES6 wellknown-symbol +const o1 = { + [Symbol.hasInstance](value: any) { + return false; + } +} \ No newline at end of file diff --git a/tests/cases/compiler/modularizeLibrary_UsingES5LibAndES6ArrayLib.ts b/tests/cases/compiler/modularizeLibrary_UsingES5LibAndES6ArrayLib.ts new file mode 100644 index 00000000000..e6902218fc4 --- /dev/null +++ b/tests/cases/compiler/modularizeLibrary_UsingES5LibAndES6ArrayLib.ts @@ -0,0 +1,9 @@ +// @lib: es5,es2015.array +// @target: es5 + +// No error +function f(x: number, y: number, z: number) { + return Array.from(arguments); +} + +f(1, 2, 3); \ No newline at end of file diff --git a/tests/cases/compiler/modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts b/tests/cases/compiler/modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts new file mode 100644 index 00000000000..2e75dc13e95 --- /dev/null +++ b/tests/cases/compiler/modularizeLibrary_UsingES5LibAndES6FeatureLibs.ts @@ -0,0 +1,15 @@ +// @lib: es5,es2015.symbol,es2015.proxy,es2015.generator,es2015.iterable,es2015.reflect +// @target: es6 + +var s = Symbol(); +var t = {}; +var p = new Proxy(t, {}); + +Reflect.ownKeys({}); + +function* idGen() { + let i = 10; + while (i < 20) { + yield i + 2; + } +} diff --git a/tests/cases/compiler/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.ts b/tests/cases/compiler/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.ts new file mode 100644 index 00000000000..9325dfe02ba --- /dev/null +++ b/tests/cases/compiler/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.ts @@ -0,0 +1,9 @@ +// @lib: es5,es2015.array,es2015.symbol.wellknown + +function f(x: number, y: number, z: number) { + return Array.from(arguments); +} + +f(1, 2, 3); // no error +let a = ['c', 'd']; +a[Symbol.isConcatSpreadable] = false; \ No newline at end of file