diff --git a/src/compiler/factory/emitHelpers.ts b/src/compiler/factory/emitHelpers.ts index 255518a2842..d54a8fee68b 100644 --- a/src/compiler/factory/emitHelpers.ts +++ b/src/compiler/factory/emitHelpers.ts @@ -16,7 +16,6 @@ import { FunctionExpression, GeneratedIdentifierFlags, getEmitFlags, - getEmitScriptTarget, getPropertyNameOfBindingOrAssignmentElement, Identifier, InternalEmitFlags, @@ -28,7 +27,6 @@ import { ObjectLiteralElementLike, ParameterDeclaration, PrivateIdentifier, - ScriptTarget, setEmitFlags, setInternalEmitFlags, setTextRange, @@ -400,15 +398,7 @@ export function createEmitHelperFactory(context: TransformationContext): EmitHel // ES2018 Helpers function createAssignHelper(attributesSegments: Expression[]) { - if (getEmitScriptTarget(context.getCompilerOptions()) >= ScriptTarget.ES2015) { - return factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("Object"), "assign"), /*typeArguments*/ undefined, attributesSegments); - } - context.requestEmitHelper(assignHelper); - return factory.createCallExpression( - getUnscopedHelperName("__assign"), - /*typeArguments*/ undefined, - attributesSegments, - ); + return factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("Object"), "assign"), /*typeArguments*/ undefined, attributesSegments); } function createAwaitHelper(expression: Expression) { @@ -816,25 +806,6 @@ const runInitializersHelper: UnscopedEmitHelper = { // ES2018 Helpers -const assignHelper: UnscopedEmitHelper = { - name: "typescript:assign", - importName: "__assign", - scoped: false, - priority: 1, - text: ` - var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); - };`, -}; - const awaitHelper: UnscopedEmitHelper = { name: "typescript:await", importName: "__await", diff --git a/src/compiler/factory/nodeFactory.ts b/src/compiler/factory/nodeFactory.ts index c7286dc33c6..45cd664ccd0 100644 --- a/src/compiler/factory/nodeFactory.ts +++ b/src/compiler/factory/nodeFactory.ts @@ -6665,9 +6665,7 @@ export function createNodeFactory(flags: NodeFactoryFlags, baseFactory: BaseNode } else if (isSuperKeyword(callee)) { thisArg = createThis(); - target = languageVersion !== undefined && languageVersion < ScriptTarget.ES2015 - ? setTextRange(createIdentifier("_super"), callee) - : callee as PrimaryExpression; + target = callee as PrimaryExpression; } else if (getEmitFlags(callee) & EmitFlags.HelperName) { thisArg = createVoidZero(); diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index e1b3cdf7868..3e279535503 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -11655,13 +11655,6 @@ export function createNameResolver({ } } break; - case SyntaxKind.ArrowFunction: - // when targeting ES6 or higher there is no 'arguments' in an arrow function - // for lower compile targets the resolved symbol is used to emit an error - if (getEmitScriptTarget(compilerOptions) >= ScriptTarget.ES2015) { - break; - } - // falls through case SyntaxKind.MethodDeclaration: case SyntaxKind.Constructor: case SyntaxKind.GetAccessor: @@ -11835,14 +11828,12 @@ export function createNameResolver({ // - optional chaining pre-es2020 // - nullish coalesce pre-es2020 // - spread assignment in binding pattern pre-es2017 - if (target >= ScriptTarget.ES2015) { - let declarationRequiresScopeChange = getRequiresScopeChangeCache(functionLocation); - if (declarationRequiresScopeChange === undefined) { - declarationRequiresScopeChange = forEach(functionLocation.parameters, requiresScopeChange) || false; - setRequiresScopeChangeCache(functionLocation, declarationRequiresScopeChange); - } - return !declarationRequiresScopeChange; + let declarationRequiresScopeChange = getRequiresScopeChangeCache(functionLocation); + if (declarationRequiresScopeChange === undefined) { + declarationRequiresScopeChange = forEach(functionLocation.parameters, requiresScopeChange) || false; + setRequiresScopeChangeCache(functionLocation, declarationRequiresScopeChange); } + return !declarationRequiresScopeChange; } return false; diff --git a/src/compiler/visitorPublic.ts b/src/compiler/visitorPublic.ts index d1aee94bc6e..53f5075037f 100644 --- a/src/compiler/visitorPublic.ts +++ b/src/compiler/visitorPublic.ts @@ -6,7 +6,6 @@ import { factory, FunctionBody, getEmitFlags, - getEmitScriptTarget, HasChildren, Identifier, isArray, @@ -93,7 +92,6 @@ import { NodeVisitor, nullTransformationContext, ParameterDeclaration, - ScriptTarget, setEmitFlags, setTextRange, setTextRangePosEnd, @@ -405,10 +403,7 @@ export function visitParameterList(nodes: NodeArray | unde // exists in a different lexical scope. To address this, we move any binding patterns and initializers // in a parameter list to the body if we detect a variable being hoisted while visiting a parameter list // when the emit target is greater than ES2015. - if ( - context.getLexicalEnvironmentFlags() & LexicalEnvironmentFlags.VariablesHoistedInParameters && - getEmitScriptTarget(context.getCompilerOptions()) >= ScriptTarget.ES2015 - ) { + if (context.getLexicalEnvironmentFlags() & LexicalEnvironmentFlags.VariablesHoistedInParameters) { updated = addDefaultValueAssignmentsIfNeeded(updated, context); } context.setLexicalEnvironmentFlags(LexicalEnvironmentFlags.InParameters, false); diff --git a/tests/baselines/reference/anyAndUnknownHaveFalsyComponents.js b/tests/baselines/reference/anyAndUnknownHaveFalsyComponents.js index e793b344ad0..57b21084288 100644 --- a/tests/baselines/reference/anyAndUnknownHaveFalsyComponents.js +++ b/tests/baselines/reference/anyAndUnknownHaveFalsyComponents.js @@ -31,26 +31,15 @@ function foo2() { //// [anyAndUnknownHaveFalsyComponents.js] -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; const y1 = x1 && 3; function foo1() { - return __assign({ display: "block" }, (isTreeHeader1 && { + return Object.assign({ display: "block" }, (isTreeHeader1 && { display: "flex", })); } const y2 = x2 && 3; function foo2() { - return __assign({ display: "block" }, (isTreeHeader1 && { + return Object.assign({ display: "block" }, (isTreeHeader1 && { display: "flex", })); } diff --git a/tests/baselines/reference/capturedParametersInInitializers2.js b/tests/baselines/reference/capturedParametersInInitializers2.js index 4bb279ae1ea..ae2a81645d9 100644 --- a/tests/baselines/reference/capturedParametersInInitializers2.js +++ b/tests/baselines/reference/capturedParametersInInitializers2.js @@ -21,23 +21,28 @@ var __setFunctionName = (this && this.__setFunctionName) || function (f, name, p if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : ""; return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name }); }; -function foo(y = (_a = class { - get [x]() { return x; } - constructor() { x; } - [z]() { return z; } - }, - __setFunctionName(_a, "y"), - _a.c = x, - _a), x = 1, z = 2) { +function foo(y, x, z) { var _a; + if (y === void 0) { y = (_a = class { + get [x]() { return x; } + constructor() { x; } + [z]() { return z; } + }, + __setFunctionName(_a, "y"), + _a.c = x, + _a); } + if (x === void 0) { x = 1; } + if (z === void 0) { z = 2; } y.c; } -function foo2(y = (_a = class { - constructor() { - this[_b] = x; - } - }, - _b = x, - _a), x = 1) { - var _b, _a; +function foo2(y, x) { + var _a, _b; + if (y === void 0) { y = (_b = class { + constructor() { + this[_a] = x; + } + }, + _a = x, + _b); } + if (x === void 0) { x = 1; } } diff --git a/tests/baselines/reference/classWithStaticFieldInParameterBindingPattern(target=es5).js b/tests/baselines/reference/classWithStaticFieldInParameterBindingPattern(target=es5).js index 302b79d1f76..1f5494e202b 100644 --- a/tests/baselines/reference/classWithStaticFieldInParameterBindingPattern(target=es5).js +++ b/tests/baselines/reference/classWithStaticFieldInParameterBindingPattern(target=es5).js @@ -6,7 +6,7 @@ //// [classWithStaticFieldInParameterBindingPattern.js] // https://github.com/microsoft/TypeScript/issues/36295 -(({ [(_a = class { +((_a) => { var _b; var { [(_b = class { }, - _a.x = 1, - _a).x]: b = "" }) => { var _a; })(); + _b.x = 1, + _b).x]: b = "" } = _a; })(); diff --git a/tests/baselines/reference/classWithStaticFieldInParameterInitializer(target=es5).js b/tests/baselines/reference/classWithStaticFieldInParameterInitializer(target=es5).js index 752eafc9f57..e3adc92a100 100644 --- a/tests/baselines/reference/classWithStaticFieldInParameterInitializer(target=es5).js +++ b/tests/baselines/reference/classWithStaticFieldInParameterInitializer(target=es5).js @@ -10,8 +10,8 @@ var __setFunctionName = (this && this.__setFunctionName) || function (f, name, p return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name }); }; // https://github.com/microsoft/TypeScript/issues/36295 -((b = (_a = class { +((b) => { var _a; if (b === void 0) { b = (_a = class { }, __setFunctionName(_a, "b"), _a.x = 1, - _a)) => { var _a; })(); + _a); } })(); diff --git a/tests/baselines/reference/contextualTypeObjectSpreadExpression.js b/tests/baselines/reference/contextualTypeObjectSpreadExpression.js index 032928668ed..dc900493211 100644 --- a/tests/baselines/reference/contextualTypeObjectSpreadExpression.js +++ b/tests/baselines/reference/contextualTypeObjectSpreadExpression.js @@ -9,16 +9,5 @@ i = { ...{ a: "a" } }; //// [contextualTypeObjectSpreadExpression.js] -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; let i; -i = __assign({ a: "a" }); +i = Object.assign({ a: "a" }); diff --git a/tests/baselines/reference/declarationEmitReadonlyComputedProperty.js b/tests/baselines/reference/declarationEmitReadonlyComputedProperty.js index 670c91f5aba..5bbd2be5dea 100644 --- a/tests/baselines/reference/declarationEmitReadonlyComputedProperty.js +++ b/tests/baselines/reference/declarationEmitReadonlyComputedProperty.js @@ -33,21 +33,10 @@ function createInstance() { } //// [index.js] "use strict"; -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; Object.defineProperty(exports, "__esModule", { value: true }); exports.spread = void 0; const bug_1 = require("./bug"); -exports.spread = __assign({}, (0, bug_1.createInstance)()); +exports.spread = Object.assign({}, (0, bug_1.createInstance)()); //// [bug.d.ts] diff --git a/tests/baselines/reference/declarationEmitSpreadStringlyKeyedEnum.js b/tests/baselines/reference/declarationEmitSpreadStringlyKeyedEnum.js index ed33b7fe091..1aaa6b30c48 100644 --- a/tests/baselines/reference/declarationEmitSpreadStringlyKeyedEnum.js +++ b/tests/baselines/reference/declarationEmitSpreadStringlyKeyedEnum.js @@ -6,17 +6,6 @@ export const SpotifyAgeGroupEnum = { ...AgeGroups }; //// [declarationEmitSpreadStringlyKeyedEnum.js] "use strict"; -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; Object.defineProperty(exports, "__esModule", { value: true }); exports.SpotifyAgeGroupEnum = void 0; var AgeGroups; @@ -29,7 +18,7 @@ var AgeGroups; AgeGroups[AgeGroups["45-59"] = 5] = "45-59"; AgeGroups[AgeGroups["60-150"] = 6] = "60-150"; })(AgeGroups || (AgeGroups = {})); -exports.SpotifyAgeGroupEnum = __assign({}, AgeGroups); +exports.SpotifyAgeGroupEnum = Object.assign({}, AgeGroups); //// [declarationEmitSpreadStringlyKeyedEnum.d.ts] diff --git a/tests/baselines/reference/declarationEmitStringEnumUsedInNonlocalSpread.js b/tests/baselines/reference/declarationEmitStringEnumUsedInNonlocalSpread.js index b9e1f3e3e9d..2b76c687bbf 100644 --- a/tests/baselines/reference/declarationEmitStringEnumUsedInNonlocalSpread.js +++ b/tests/baselines/reference/declarationEmitStringEnumUsedInNonlocalSpread.js @@ -46,23 +46,12 @@ class A { exports.A = A; //// [index.js] "use strict"; -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; Object.defineProperty(exports, "__esModule", { value: true }); exports.B = void 0; const class_1 = require("./class"); class B extends class_1.A { getA() { - return __assign(__assign({}, super.getA()), { a: '123' }); + return Object.assign(Object.assign({}, super.getA()), { a: '123' }); } } exports.B = B; diff --git a/tests/baselines/reference/declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.js b/tests/baselines/reference/declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.js index 618990a5f97..eefbdc979e9 100644 --- a/tests/baselines/reference/declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.js +++ b/tests/baselines/reference/declarationsWithRecursiveInternalTypesProduceUniqueTypeParams.js @@ -46,17 +46,6 @@ void p3.result.three; "use strict"; // Note that both of the following have an `any` in their return type from where we bottom out the type printout // for having too many instances of the same symbol nesting. -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; Object.defineProperty(exports, "__esModule", { value: true }); exports.testRecFun = exports.updateIfChanged = void 0; const updateIfChanged = (t) => { @@ -73,7 +62,7 @@ exports.updateIfChanged = updateIfChanged; const testRecFun = (parent) => { return { result: parent, - deeper: (child) => (0, exports.testRecFun)(__assign(__assign({}, parent), child)) + deeper: (child) => (0, exports.testRecFun)(Object.assign(Object.assign({}, parent), child)) }; }; exports.testRecFun = testRecFun; diff --git a/tests/baselines/reference/destructuringFromUnionSpread.js b/tests/baselines/reference/destructuringFromUnionSpread.js index 420a13ded7a..0adf7740fbe 100644 --- a/tests/baselines/reference/destructuringFromUnionSpread.js +++ b/tests/baselines/reference/destructuringFromUnionSpread.js @@ -9,15 +9,4 @@ const { a } = { ...x } // error //// [destructuringFromUnionSpread.js] -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; -const { a } = __assign({}, x); // error +const { a } = Object.assign({}, x); // error diff --git a/tests/baselines/reference/destructuringInitializerContextualTypeFromContext.js b/tests/baselines/reference/destructuringInitializerContextualTypeFromContext.js index dab669996f5..66feadde79d 100644 --- a/tests/baselines/reference/destructuringInitializerContextualTypeFromContext.js +++ b/tests/baselines/reference/destructuringInitializerContextualTypeFromContext.js @@ -29,17 +29,6 @@ f(([_1, _2 = undefined]) => undefined) //// [destructuringInitializerContextualTypeFromContext.js] "use strict"; -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; var __rest = (this && this.__rest) || function (s, e) { var t = {}; for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) @@ -53,7 +42,7 @@ var __rest = (this && this.__rest) || function (s, e) { }; const Parent = (_a) => { var { children, name = "Artemis" } = _a, props = __rest(_a, ["children", "name"]); - return Child(__assign({ name }, props)); + return Child(Object.assign({ name }, props)); }; const Child = (_a) => { var { children, name = "Artemis" } = _a, props = __rest(_a, ["children", "name"]); diff --git a/tests/baselines/reference/destructuringSpread.js b/tests/baselines/reference/destructuringSpread.js index c27b19a2440..709cc971e58 100644 --- a/tests/baselines/reference/destructuringSpread.js +++ b/tests/baselines/reference/destructuringSpread.js @@ -31,20 +31,9 @@ const { c, d, e, f, g } = { //// [destructuringSpread.js] -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; -const { x } = __assign({}, { x: 0 }); -const { y } = __assign({ y: 0 }, {}); -const { z, a, b } = __assign({ z: 0 }, { a: 0, b: 0 }); -const { c, d, e, f, g } = __assign(__assign({}, __assign(__assign({}, __assign({ +const { x } = Object.assign({}, { x: 0 }); +const { y } = Object.assign({ y: 0 }, {}); +const { z, a, b } = Object.assign({ z: 0 }, { a: 0, b: 0 }); +const { c, d, e, f, g } = Object.assign(Object.assign({}, Object.assign(Object.assign({}, Object.assign({ c: 0, }, { d: 0 })), { e: 0 })), { f: 0 }); diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments01.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments01.errors.txt index 4f3fd704723..edf9a3c0844 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments01.errors.txt +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments01.errors.txt @@ -1,14 +1,14 @@ -emitArrowFunctionWhenUsingArguments01.ts(2,15): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES5. Consider using a standard function expression. +emitArrowFunctionWhenUsingArguments01.ts(2,15): error TS2304: Cannot find name 'arguments'. emitArrowFunctionWhenUsingArguments01.ts(7,19): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES5. Consider using a standard function expression. emitArrowFunctionWhenUsingArguments01.ts(13,13): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES5. Consider using a standard function expression. -emitArrowFunctionWhenUsingArguments01.ts(19,15): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES5. Consider using a standard function expression. +emitArrowFunctionWhenUsingArguments01.ts(19,15): error TS2304: Cannot find name 'arguments'. ==== emitArrowFunctionWhenUsingArguments01.ts (4 errors) ==== var a = () => { var arg = arguments[0]; // error ~~~~~~~~~ -!!! error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES5. Consider using a standard function expression. +!!! error TS2304: Cannot find name 'arguments'. } var b = function () { @@ -31,7 +31,7 @@ emitArrowFunctionWhenUsingArguments01.ts(19,15): error TS2496: The 'arguments' o foo(() => { var arg = arguments[0]; // error ~~~~~~~~~ -!!! error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES5. Consider using a standard function expression. +!!! error TS2304: Cannot find name 'arguments'. }); function bar() { diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments01.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments01.symbols index 56b61fc422a..57738e42308 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments01.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments01.symbols @@ -6,7 +6,6 @@ var a = () => { var arg = arguments[0]; // error >arg : Symbol(arg, Decl(emitArrowFunctionWhenUsingArguments01.ts, 1, 7)) ->arguments : Symbol(arguments) } var b = function () { @@ -40,7 +39,6 @@ foo(() => { var arg = arguments[0]; // error >arg : Symbol(arg, Decl(emitArrowFunctionWhenUsingArguments01.ts, 18, 7)) ->arguments : Symbol(arguments) }); diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments01.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments01.types index cc598bbd220..6c3d1858f02 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments01.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments01.types @@ -12,8 +12,8 @@ var a = () => { > : ^^^ >arguments[0] : any > : ^^^ ->arguments : IArguments -> : ^^^^^^^^^^ +>arguments : any +> : ^^^ >0 : 0 > : ^ } @@ -81,8 +81,8 @@ foo(() => { > : ^^^ >arguments[0] : any > : ^^^ ->arguments : IArguments -> : ^^^^^^^^^^ +>arguments : any +> : ^^^ >0 : 0 > : ^ diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02.errors.txt index dd2a76eaddb..cf09790eb8c 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02.errors.txt +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02.errors.txt @@ -1,7 +1,7 @@ -emitArrowFunctionWhenUsingArguments02.ts(1,15): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES5. Consider using a standard function expression. +emitArrowFunctionWhenUsingArguments02.ts(1,15): error TS2304: Cannot find name 'arguments'. ==== emitArrowFunctionWhenUsingArguments02.ts (1 errors) ==== var a = () => arguments; ~~~~~~~~~ -!!! error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES5. Consider using a standard function expression. \ No newline at end of file +!!! error TS2304: Cannot find name 'arguments'. \ No newline at end of file diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02.symbols index bc6ada7030f..525d7f19a9a 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02.symbols @@ -3,5 +3,4 @@ === emitArrowFunctionWhenUsingArguments02.ts === var a = () => arguments; >a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments02.ts, 0, 3)) ->arguments : Symbol(arguments) diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02.types index d944707ad39..50c575b6e48 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments02.types @@ -2,10 +2,10 @@ === emitArrowFunctionWhenUsingArguments02.ts === var a = () => arguments; ->a : () => IArguments -> : ^^^^^^^^^^^^^^^^ ->() => arguments : () => IArguments -> : ^^^^^^^^^^^^^^^^ ->arguments : IArguments -> : ^^^^^^^^^^ +>a : () => any +> : ^^^^^^^^^ +>() => arguments : () => any +> : ^^^^^^^^^ +>arguments : any +> : ^^^ diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03.errors.txt deleted file mode 100644 index c9f5526b14e..00000000000 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03.errors.txt +++ /dev/null @@ -1,8 +0,0 @@ -emitArrowFunctionWhenUsingArguments03.ts(2,15): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES5. Consider using a standard function expression. - - -==== emitArrowFunctionWhenUsingArguments03.ts (1 errors) ==== - var arguments; - var a = () => arguments; - ~~~~~~~~~ -!!! error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES5. Consider using a standard function expression. \ No newline at end of file diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03.symbols index 330ee378981..e54b9ef5bd4 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03.symbols @@ -6,5 +6,5 @@ var arguments; var a = () => arguments; >a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments03.ts, 1, 3)) ->arguments : Symbol(arguments) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments03.ts, 0, 3)) diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03.types index 756142e72f3..bbce51d986f 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments03.types @@ -3,13 +3,11 @@ === emitArrowFunctionWhenUsingArguments03.ts === var arguments; >arguments : any -> : ^^^ var a = () => arguments; ->a : () => IArguments -> : ^^^^^^^^^^^^^^^^ ->() => arguments : () => IArguments -> : ^^^^^^^^^^^^^^^^ ->arguments : IArguments -> : ^^^^^^^^^^ +>a : () => any +> : ^^^^^^^^^ +>() => arguments : () => any +> : ^^^^^^^^^ +>arguments : any diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04.errors.txt deleted file mode 100644 index b962c5453e1..00000000000 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04.errors.txt +++ /dev/null @@ -1,10 +0,0 @@ -emitArrowFunctionWhenUsingArguments04.ts(3,19): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES5. Consider using a standard function expression. - - -==== emitArrowFunctionWhenUsingArguments04.ts (1 errors) ==== - function f() { - var arguments; - var a = () => arguments; - ~~~~~~~~~ -!!! error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES5. Consider using a standard function expression. - } \ No newline at end of file diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04.symbols index ed04a6c54cd..1b2fc7cf3fe 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04.symbols @@ -9,5 +9,5 @@ function f() { var a = () => arguments; >a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments04.ts, 2, 7)) ->arguments : Symbol(arguments) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments04.ts, 1, 7)) } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04.types index 74e000ce61f..f19ab5dbcf9 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments04.types @@ -7,13 +7,11 @@ function f() { var arguments; >arguments : any -> : ^^^ var a = () => arguments; ->a : () => IArguments -> : ^^^^^^^^^^^^^^^^ ->() => arguments : () => IArguments -> : ^^^^^^^^^^^^^^^^ ->arguments : IArguments -> : ^^^^^^^^^^ +>a : () => any +> : ^^^^^^^^^ +>() => arguments : () => any +> : ^^^^^^^^^ +>arguments : any } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05.errors.txt deleted file mode 100644 index 802e88b1467..00000000000 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05.errors.txt +++ /dev/null @@ -1,9 +0,0 @@ -emitArrowFunctionWhenUsingArguments05.ts(2,19): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES5. Consider using a standard function expression. - - -==== emitArrowFunctionWhenUsingArguments05.ts (1 errors) ==== - function f(arguments) { - var a = () => arguments; - ~~~~~~~~~ -!!! error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES5. Consider using a standard function expression. - } \ No newline at end of file diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05.symbols index 1bb2d9b8d32..254d7203b21 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05.symbols @@ -7,5 +7,5 @@ function f(arguments) { var a = () => arguments; >a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments05.ts, 1, 7)) ->arguments : Symbol(arguments) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments05.ts, 0, 11)) } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05.types index 69a46a305c4..6cd5c153831 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments05.types @@ -5,13 +5,11 @@ function f(arguments) { >f : (arguments: any) => void > : ^ ^^^^^^^^^^^^^^ >arguments : any -> : ^^^ var a = () => arguments; ->a : () => IArguments -> : ^^^^^^^^^^^^^^^^ ->() => arguments : () => IArguments -> : ^^^^^^^^^^^^^^^^ ->arguments : IArguments -> : ^^^^^^^^^^ +>a : () => any +> : ^^^^^^^^^ +>() => arguments : () => any +> : ^^^^^^^^^ +>arguments : any } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06.errors.txt deleted file mode 100644 index 1d17c2669a3..00000000000 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06.errors.txt +++ /dev/null @@ -1,9 +0,0 @@ -emitArrowFunctionWhenUsingArguments06.ts(2,25): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES5. Consider using a standard function expression. - - -==== emitArrowFunctionWhenUsingArguments06.ts (1 errors) ==== - function f(arguments) { - var a = () => () => arguments; - ~~~~~~~~~ -!!! error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES5. Consider using a standard function expression. - } \ No newline at end of file diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06.symbols index 9b8370f3f0e..b9bf50b481a 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06.symbols @@ -7,5 +7,5 @@ function f(arguments) { var a = () => () => arguments; >a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments06.ts, 1, 7)) ->arguments : Symbol(arguments) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments06.ts, 0, 11)) } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06.types index ee4e78ccfd4..6fbcc94be2c 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments06.types @@ -5,15 +5,13 @@ function f(arguments) { >f : (arguments: any) => void > : ^ ^^^^^^^^^^^^^^ >arguments : any -> : ^^^ var a = () => () => arguments; ->a : () => () => IArguments -> : ^^^^^^^^^^^^^^^^^^^^^^ ->() => () => arguments : () => () => IArguments -> : ^^^^^^^^^^^^^^^^^^^^^^ ->() => arguments : () => IArguments -> : ^^^^^^^^^^^^^^^^ ->arguments : IArguments -> : ^^^^^^^^^^ +>a : () => () => any +> : ^^^^^^^^^^^^^^^ +>() => () => arguments : () => () => any +> : ^^^^^^^^^^^^^^^ +>() => arguments : () => any +> : ^^^^^^^^^ +>arguments : any } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07.errors.txt deleted file mode 100644 index c3037a6e2b5..00000000000 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07.errors.txt +++ /dev/null @@ -1,9 +0,0 @@ -emitArrowFunctionWhenUsingArguments07.ts(2,34): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES5. Consider using a standard function expression. - - -==== emitArrowFunctionWhenUsingArguments07.ts (1 errors) ==== - function f(arguments) { - var a = (arguments) => () => arguments; - ~~~~~~~~~ -!!! error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES5. Consider using a standard function expression. - } \ No newline at end of file diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07.symbols index 4bccf38d83d..bbfaf7221f8 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07.symbols @@ -8,5 +8,5 @@ function f(arguments) { var a = (arguments) => () => arguments; >a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments07.ts, 1, 7)) >arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments07.ts, 1, 13)) ->arguments : Symbol(arguments) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments07.ts, 1, 13)) } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07.types index 36785c96f6a..3b67ce80024 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments07.types @@ -5,17 +5,14 @@ function f(arguments) { >f : (arguments: any) => void > : ^ ^^^^^^^^^^^^^^ >arguments : any -> : ^^^ var a = (arguments) => () => arguments; ->a : (arguments: any) => () => IArguments -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ->(arguments) => () => arguments : (arguments: any) => () => IArguments -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ +>a : (arguments: any) => () => any +> : ^ ^^^^^^^^^^^^^^^^^^^ +>(arguments) => () => arguments : (arguments: any) => () => any +> : ^ ^^^^^^^^^^^^^^^^^^^ +>arguments : any +>() => arguments : () => any +> : ^^^^^^^^^ >arguments : any -> : ^^^ ->() => arguments : () => IArguments -> : ^^^^^^^^^^^^^^^^ ->arguments : IArguments -> : ^^^^^^^^^^ } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11.errors.txt deleted file mode 100644 index dcce324a922..00000000000 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11.errors.txt +++ /dev/null @@ -1,10 +0,0 @@ -emitArrowFunctionWhenUsingArguments11.ts(3,25): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES5. Consider using a standard function expression. - - -==== emitArrowFunctionWhenUsingArguments11.ts (1 errors) ==== - function f(arguments) { - var _arguments = 10; - var a = () => () => arguments; - ~~~~~~~~~ -!!! error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES5. Consider using a standard function expression. - } \ No newline at end of file diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11.symbols index c554e449a98..96debf73c83 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11.symbols @@ -10,5 +10,5 @@ function f(arguments) { var a = () => () => arguments; >a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments11.ts, 2, 7)) ->arguments : Symbol(arguments) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments11.ts, 0, 11)) } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11.types index 94009bca9e4..e273761aeea 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments11.types @@ -5,7 +5,6 @@ function f(arguments) { >f : (arguments: any) => void > : ^ ^^^^^^^^^^^^^^ >arguments : any -> : ^^^ var _arguments = 10; >_arguments : number @@ -14,12 +13,11 @@ function f(arguments) { > : ^^ var a = () => () => arguments; ->a : () => () => IArguments -> : ^^^^^^^^^^^^^^^^^^^^^^ ->() => () => arguments : () => () => IArguments -> : ^^^^^^^^^^^^^^^^^^^^^^ ->() => arguments : () => IArguments -> : ^^^^^^^^^^^^^^^^ ->arguments : IArguments -> : ^^^^^^^^^^ +>a : () => () => any +> : ^^^^^^^^^^^^^^^ +>() => () => arguments : () => () => any +> : ^^^^^^^^^^^^^^^ +>() => arguments : () => any +> : ^^^^^^^^^ +>arguments : any } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12.errors.txt index 6d2385b2cb7..ac04a75538d 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12.errors.txt +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12.errors.txt @@ -1,14 +1,11 @@ emitArrowFunctionWhenUsingArguments12.ts(2,7): error TS1210: Code contained in a class is evaluated in JavaScript's strict mode which does not allow this use of 'arguments'. For more information, see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode. -emitArrowFunctionWhenUsingArguments12.ts(3,23): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES5. Consider using a standard function expression. -==== emitArrowFunctionWhenUsingArguments12.ts (2 errors) ==== +==== emitArrowFunctionWhenUsingArguments12.ts (1 errors) ==== class C { f(arguments) { ~~~~~~~~~ !!! error TS1210: Code contained in a class is evaluated in JavaScript's strict mode which does not allow this use of 'arguments'. For more information, see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode. var a = () => arguments; - ~~~~~~~~~ -!!! error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES5. Consider using a standard function expression. } } \ No newline at end of file diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12.symbols index f0331238565..69807522f17 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12.symbols @@ -10,6 +10,6 @@ class C { var a = () => arguments; >a : Symbol(a, Decl(emitArrowFunctionWhenUsingArguments12.ts, 2, 11)) ->arguments : Symbol(arguments) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments12.ts, 1, 6)) } } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12.types index 4839104b684..40ce11eb65f 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments12.types @@ -12,11 +12,11 @@ class C { > : ^^^ var a = () => arguments; ->a : () => IArguments -> : ^^^^^^^^^^^^^^^^ ->() => arguments : () => IArguments -> : ^^^^^^^^^^^^^^^^ ->arguments : IArguments -> : ^^^^^^^^^^ +>a : () => any +> : ^^^^^^^^^ +>() => arguments : () => any +> : ^^^^^^^^^ +>arguments : any +> : ^^^ } } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14.errors.txt deleted file mode 100644 index 38491ae7195..00000000000 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14.errors.txt +++ /dev/null @@ -1,12 +0,0 @@ -emitArrowFunctionWhenUsingArguments14.ts(4,22): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES5. Consider using a standard function expression. - - -==== emitArrowFunctionWhenUsingArguments14.ts (1 errors) ==== - function f() { - if (Math.random()) { - const arguments = 100; - return () => arguments; - ~~~~~~~~~ -!!! error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES5. Consider using a standard function expression. - } - } \ No newline at end of file diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14.symbols index b3044325ad7..21a8b2004e8 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14.symbols @@ -13,6 +13,6 @@ function f() { >arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments14.ts, 2, 13)) return () => arguments; ->arguments : Symbol(arguments) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments14.ts, 2, 13)) } } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14.types index 4f265d5bc11..63f66daca2a 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14.types @@ -2,8 +2,8 @@ === emitArrowFunctionWhenUsingArguments14.ts === function f() { ->f : () => () => IArguments -> : ^^^^^^^^^^^^^^^^^^^^^^ +>f : () => () => number +> : ^^^^^^^^^^^^^^^^^^ if (Math.random()) { >Math.random() : number @@ -22,9 +22,9 @@ function f() { > : ^^^ return () => arguments; ->() => arguments : () => IArguments -> : ^^^^^^^^^^^^^^^^ ->arguments : IArguments -> : ^^^^^^^^^^ +>() => arguments : () => number +> : ^^^^^^^^^^^^ +>arguments : 100 +> : ^^^ } } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15.errors.txt deleted file mode 100644 index 08a608ae121..00000000000 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15.errors.txt +++ /dev/null @@ -1,13 +0,0 @@ -emitArrowFunctionWhenUsingArguments15.ts(5,22): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES5. Consider using a standard function expression. - - -==== emitArrowFunctionWhenUsingArguments15.ts (1 errors) ==== - function f() { - var arguments = "hello"; - if (Math.random()) { - const arguments = 100; - return () => arguments; - ~~~~~~~~~ -!!! error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES5. Consider using a standard function expression. - } - } \ No newline at end of file diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15.symbols index 11847717e6a..8b33e698c46 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15.symbols @@ -16,6 +16,6 @@ function f() { >arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments15.ts, 3, 13)) return () => arguments; ->arguments : Symbol(arguments) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments15.ts, 3, 13)) } } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15.types index f8f496216b0..c83d8ca35e8 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15.types @@ -2,8 +2,8 @@ === emitArrowFunctionWhenUsingArguments15.ts === function f() { ->f : () => () => IArguments -> : ^^^^^^^^^^^^^^^^^^^^^^ +>f : () => () => number +> : ^^^^^^^^^^^^^^^^^^ var arguments = "hello"; >arguments : string @@ -28,9 +28,9 @@ function f() { > : ^^^ return () => arguments; ->() => arguments : () => IArguments -> : ^^^^^^^^^^^^^^^^ ->arguments : IArguments -> : ^^^^^^^^^^ +>() => arguments : () => number +> : ^^^^^^^^^^^^ +>arguments : 100 +> : ^^^ } } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16.errors.txt deleted file mode 100644 index f3becb13393..00000000000 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16.errors.txt +++ /dev/null @@ -1,13 +0,0 @@ -emitArrowFunctionWhenUsingArguments16.ts(4,22): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES5. Consider using a standard function expression. - - -==== emitArrowFunctionWhenUsingArguments16.ts (1 errors) ==== - function f() { - var arguments = "hello"; - if (Math.random()) { - return () => arguments[0]; - ~~~~~~~~~ -!!! error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES5. Consider using a standard function expression. - } - var arguments = "world"; - } \ No newline at end of file diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16.symbols index bcca348e03c..539ed97dca8 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16.symbols @@ -13,7 +13,7 @@ function f() { >random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --)) return () => arguments[0]; ->arguments : Symbol(arguments) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments16.ts, 1, 7), Decl(emitArrowFunctionWhenUsingArguments16.ts, 5, 7)) } var arguments = "world"; >arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments16.ts, 1, 7), Decl(emitArrowFunctionWhenUsingArguments16.ts, 5, 7)) diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16.types index e5ffd84d04b..780601d9fc5 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16.types @@ -2,8 +2,8 @@ === emitArrowFunctionWhenUsingArguments16.ts === function f() { ->f : () => () => any -> : ^^^^^^^^^^^^^^^ +>f : () => () => string +> : ^^^^^^^^^^^^^^^^^^ var arguments = "hello"; >arguments : string @@ -22,12 +22,12 @@ function f() { > : ^^^^^^ return () => arguments[0]; ->() => arguments[0] : () => any -> : ^^^^^^^^^ ->arguments[0] : any -> : ^^^ ->arguments : IArguments -> : ^^^^^^^^^^ +>() => arguments[0] : () => string +> : ^^^^^^^^^^^^ +>arguments[0] : string +> : ^^^^^^ +>arguments : string +> : ^^^^^^ >0 : 0 > : ^ } diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17.errors.txt b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17.errors.txt deleted file mode 100644 index 47a19713780..00000000000 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17.errors.txt +++ /dev/null @@ -1,13 +0,0 @@ -emitArrowFunctionWhenUsingArguments17.ts(4,22): error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES5. Consider using a standard function expression. - - -==== emitArrowFunctionWhenUsingArguments17.ts (1 errors) ==== - function f() { - var { arguments } = { arguments: "hello" }; - if (Math.random()) { - return () => arguments[0]; - ~~~~~~~~~ -!!! error TS2496: The 'arguments' object cannot be referenced in an arrow function in ES5. Consider using a standard function expression. - } - var arguments = "world"; - } \ No newline at end of file diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17.symbols index 83602fe1451..5764303b4f9 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17.symbols @@ -14,7 +14,7 @@ function f() { >random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --)) return () => arguments[0]; ->arguments : Symbol(arguments) +>arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments17.ts, 1, 9), Decl(emitArrowFunctionWhenUsingArguments17.ts, 5, 7)) } var arguments = "world"; >arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments17.ts, 1, 9), Decl(emitArrowFunctionWhenUsingArguments17.ts, 5, 7)) diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17.types b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17.types index d9d6a3594c2..08520075773 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17.types +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17.types @@ -2,8 +2,8 @@ === emitArrowFunctionWhenUsingArguments17.ts === function f() { ->f : () => () => any -> : ^^^^^^^^^^^^^^^ +>f : () => () => string +> : ^^^^^^^^^^^^^^^^^^ var { arguments } = { arguments: "hello" }; >arguments : string @@ -26,12 +26,12 @@ function f() { > : ^^^^^^ return () => arguments[0]; ->() => arguments[0] : () => any -> : ^^^^^^^^^ ->arguments[0] : any -> : ^^^ ->arguments : IArguments -> : ^^^^^^^^^^ +>() => arguments[0] : () => string +> : ^^^^^^^^^^^^ +>arguments[0] : string +> : ^^^^^^ +>arguments : string +> : ^^^^^^ >0 : 0 > : ^ } diff --git a/tests/baselines/reference/excessPropertyCheckWithSpread.js b/tests/baselines/reference/excessPropertyCheckWithSpread.js index a05d3423919..a5de2298a1b 100644 --- a/tests/baselines/reference/excessPropertyCheckWithSpread.js +++ b/tests/baselines/reference/excessPropertyCheckWithSpread.js @@ -20,16 +20,5 @@ f({ a: 1, ...l, ...r }); //// [excessPropertyCheckWithSpread.js] -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; -f(__assign({ a: 1 }, i)); -f(__assign(__assign({ a: 1 }, l), r)); +f(Object.assign({ a: 1 }, i)); +f(Object.assign(Object.assign({ a: 1 }, l), r)); diff --git a/tests/baselines/reference/excessPropertyCheckWithUnions.js b/tests/baselines/reference/excessPropertyCheckWithUnions.js index 4e0fffbbaaf..599c84f4b84 100644 --- a/tests/baselines/reference/excessPropertyCheckWithUnions.js +++ b/tests/baselines/reference/excessPropertyCheckWithUnions.js @@ -156,17 +156,6 @@ F2({ //// [excessPropertyCheckWithUnions.js] "use strict"; -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; let wrong = { tag: "T", a1: "extra" }; wrong = { tag: "A", d20: 12 }; wrong = { tag: "D" }; @@ -185,7 +174,7 @@ let over; // these two are still errors despite their doubled up discriminants over = { a: 1, b: 1, first: "ok", second: "error" }; over = { a: 1, b: 1, first: "ok", third: "error" }; -let t2 = __assign({}, t1); +let t2 = Object.assign({}, t1); t0 = t2; const abab = { kind: "A", diff --git a/tests/baselines/reference/explicitAnyAfterSpreadNoImplicitAnyError.js b/tests/baselines/reference/explicitAnyAfterSpreadNoImplicitAnyError.js index 5cd098b2d15..23bc21278ca 100644 --- a/tests/baselines/reference/explicitAnyAfterSpreadNoImplicitAnyError.js +++ b/tests/baselines/reference/explicitAnyAfterSpreadNoImplicitAnyError.js @@ -6,16 +6,5 @@ let x: any; //// [explicitAnyAfterSpreadNoImplicitAnyError.js] -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; -(__assign({ a: [] }, null)); +(Object.assign({ a: [] }, null)); let x; diff --git a/tests/baselines/reference/functionImplementationErrors.errors.txt b/tests/baselines/reference/functionImplementationErrors.errors.txt index 09a5987d82a..4f29d69b857 100644 --- a/tests/baselines/reference/functionImplementationErrors.errors.txt +++ b/tests/baselines/reference/functionImplementationErrors.errors.txt @@ -1,10 +1,9 @@ functionImplementationErrors.ts(25,16): error TS2355: A function whose declared type is neither 'undefined', 'void', nor 'any' must return a value. -functionImplementationErrors.ts(30,17): error TS2373: Parameter 'n' cannot reference identifier 'm' declared after it. functionImplementationErrors.ts(35,17): error TS2373: Parameter 'n' cannot reference identifier 'm' declared after it. functionImplementationErrors.ts(40,1): error TS2839: This condition will always return 'false' since JavaScript compares objects by reference, not value. -==== functionImplementationErrors.ts (4 errors) ==== +==== functionImplementationErrors.ts (3 errors) ==== // FunctionExpression with no return type annotation with multiple return statements with unrelated types var f1 = function () { return ''; @@ -37,8 +36,6 @@ functionImplementationErrors.ts(40,1): error TS2839: This condition will always var m; // Function signature with parameter initializer referencing in scope local variable function f6(n = m) { - ~ -!!! error TS2373: Parameter 'n' cannot reference identifier 'm' declared after it. var m = 4; } diff --git a/tests/baselines/reference/functionImplementationErrors.symbols b/tests/baselines/reference/functionImplementationErrors.symbols index 3c207c5a95d..37c19b405c0 100644 --- a/tests/baselines/reference/functionImplementationErrors.symbols +++ b/tests/baselines/reference/functionImplementationErrors.symbols @@ -45,7 +45,7 @@ var m; function f6(n = m) { >f6 : Symbol(f6, Decl(functionImplementationErrors.ts, 27, 6)) >n : Symbol(n, Decl(functionImplementationErrors.ts, 29, 12)) ->m : Symbol(m, Decl(functionImplementationErrors.ts, 30, 7)) +>m : Symbol(m, Decl(functionImplementationErrors.ts, 27, 3)) var m = 4; >m : Symbol(m, Decl(functionImplementationErrors.ts, 30, 7)) diff --git a/tests/baselines/reference/functionImplementationErrors.types b/tests/baselines/reference/functionImplementationErrors.types index acf714f4f11..2e5d4d2aa75 100644 --- a/tests/baselines/reference/functionImplementationErrors.types +++ b/tests/baselines/reference/functionImplementationErrors.types @@ -88,12 +88,12 @@ var m; // Function signature with parameter initializer referencing in scope local variable function f6(n = m) { ->f6 : (n?: number) => void -> : ^ ^^^^^^^^^^^^^^^^^^ ->n : number -> : ^^^^^^ ->m : number -> : ^^^^^^ +>f6 : (n?: any) => void +> : ^ ^^^^^^^^^^^^^^^ +>n : any +> : ^^^ +>m : any +> : ^^^ var m = 4; >m : number diff --git a/tests/baselines/reference/functionLikeInParameterInitializer.errors.txt b/tests/baselines/reference/functionLikeInParameterInitializer.errors.txt new file mode 100644 index 00000000000..a51f29297d7 --- /dev/null +++ b/tests/baselines/reference/functionLikeInParameterInitializer.errors.txt @@ -0,0 +1,34 @@ +functionLikeInParameterInitializer.ts(2,34): error TS2304: Cannot find name 'foo'. +functionLikeInParameterInitializer.ts(6,44): error TS2304: Cannot find name 'foo'. +functionLikeInParameterInitializer.ts(11,50): error TS2304: Cannot find name 'foo'. +functionLikeInParameterInitializer.ts(16,41): error TS2304: Cannot find name 'foo'. + + +==== functionLikeInParameterInitializer.ts (4 errors) ==== + // error + export function bar(func = () => foo) { + ~~~ +!!! error TS2304: Cannot find name 'foo'. + let foo = "in"; + } + // error + export function baz1(func = { f() { return foo } }) { + ~~~ +!!! error TS2304: Cannot find name 'foo'. + let foo = "in"; + } + + // error + export function baz2(func = function () { return foo }) { + ~~~ +!!! error TS2304: Cannot find name 'foo'. + let foo = "in"; + } + + // error + export function baz3(func = class { x = foo }) { + ~~~ +!!! error TS2304: Cannot find name 'foo'. + let foo = "in"; + } + \ No newline at end of file diff --git a/tests/baselines/reference/functionLikeInParameterInitializer.symbols b/tests/baselines/reference/functionLikeInParameterInitializer.symbols index c2ccb255456..c67e44f4e69 100644 --- a/tests/baselines/reference/functionLikeInParameterInitializer.symbols +++ b/tests/baselines/reference/functionLikeInParameterInitializer.symbols @@ -5,7 +5,6 @@ export function bar(func = () => foo) { >bar : Symbol(bar, Decl(functionLikeInParameterInitializer.ts, 0, 0)) >func : Symbol(func, Decl(functionLikeInParameterInitializer.ts, 1, 20)) ->foo : Symbol(foo, Decl(functionLikeInParameterInitializer.ts, 2, 7)) let foo = "in"; >foo : Symbol(foo, Decl(functionLikeInParameterInitializer.ts, 2, 7)) @@ -15,7 +14,6 @@ export function baz1(func = { f() { return foo } }) { >baz1 : Symbol(baz1, Decl(functionLikeInParameterInitializer.ts, 3, 1)) >func : Symbol(func, Decl(functionLikeInParameterInitializer.ts, 5, 21)) >f : Symbol(f, Decl(functionLikeInParameterInitializer.ts, 5, 29)) ->foo : Symbol(foo, Decl(functionLikeInParameterInitializer.ts, 6, 7)) let foo = "in"; >foo : Symbol(foo, Decl(functionLikeInParameterInitializer.ts, 6, 7)) @@ -25,7 +23,6 @@ export function baz1(func = { f() { return foo } }) { export function baz2(func = function () { return foo }) { >baz2 : Symbol(baz2, Decl(functionLikeInParameterInitializer.ts, 7, 1)) >func : Symbol(func, Decl(functionLikeInParameterInitializer.ts, 10, 21)) ->foo : Symbol(foo, Decl(functionLikeInParameterInitializer.ts, 11, 7)) let foo = "in"; >foo : Symbol(foo, Decl(functionLikeInParameterInitializer.ts, 11, 7)) @@ -36,7 +33,6 @@ export function baz3(func = class { x = foo }) { >baz3 : Symbol(baz3, Decl(functionLikeInParameterInitializer.ts, 12, 1)) >func : Symbol(func, Decl(functionLikeInParameterInitializer.ts, 15, 21)) >x : Symbol((Anonymous class).x, Decl(functionLikeInParameterInitializer.ts, 15, 35)) ->foo : Symbol(foo, Decl(functionLikeInParameterInitializer.ts, 16, 7)) let foo = "in"; >foo : Symbol(foo, Decl(functionLikeInParameterInitializer.ts, 16, 7)) diff --git a/tests/baselines/reference/functionLikeInParameterInitializer.types b/tests/baselines/reference/functionLikeInParameterInitializer.types index 582877c8fb8..a0393006dfd 100644 --- a/tests/baselines/reference/functionLikeInParameterInitializer.types +++ b/tests/baselines/reference/functionLikeInParameterInitializer.types @@ -3,14 +3,14 @@ === functionLikeInParameterInitializer.ts === // error export function bar(func = () => foo) { ->bar : (func?: () => string) => void -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^ ->func : () => string -> : ^^^^^^^^^^^^ ->() => foo : () => string -> : ^^^^^^^^^^^^ ->foo : string -> : ^^^^^^ +>bar : (func?: () => any) => void +> : ^ ^^^^^^^^^^^^^^^^^^^^^ +>func : () => any +> : ^^^^^^^^^ +>() => foo : () => any +> : ^^^^^^^^^ +>foo : any +> : ^^^ let foo = "in"; >foo : string @@ -20,16 +20,16 @@ export function bar(func = () => foo) { } // error export function baz1(func = { f() { return foo } }) { ->baz1 : (func?: { f(): string; }) => void -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->func : { f(): string; } -> : ^^^^^^^^^^^^^^^^ ->{ f() { return foo } } : { f(): string; } -> : ^^^^^^^^^^^^^^^^ ->f : () => string -> : ^^^^^^^^^^^^ ->foo : string -> : ^^^^^^ +>baz1 : (func?: { f(): any; }) => void +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^ +>func : { f(): any; } +> : ^^^^^^^^^^^^^ +>{ f() { return foo } } : { f(): any; } +> : ^^^^^^^^^^^^^ +>f : () => any +> : ^^^^^^^^^ +>foo : any +> : ^^^ let foo = "in"; >foo : string @@ -40,14 +40,14 @@ export function baz1(func = { f() { return foo } }) { // error export function baz2(func = function () { return foo }) { ->baz2 : (func?: () => string) => void -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^ ->func : () => string -> : ^^^^^^^^^^^^ ->function () { return foo } : () => string -> : ^^^^^^^^^^^^ ->foo : string -> : ^^^^^^ +>baz2 : (func?: () => any) => void +> : ^ ^^^^^^^^^^^^^^^^^^^^^ +>func : () => any +> : ^^^^^^^^^ +>function () { return foo } : () => any +> : ^^^^^^^^^ +>foo : any +> : ^^^ let foo = "in"; >foo : string @@ -64,10 +64,10 @@ export function baz3(func = class { x = foo }) { > : ^^^^^^^^^^^^^^^^^^^^^^^^ >class { x = foo } : typeof (Anonymous class) > : ^^^^^^^^^^^^^^^^^^^^^^^^ ->x : string -> : ^^^^^^ ->foo : string -> : ^^^^^^ +>x : any +> : ^^^ +>foo : any +> : ^^^ let foo = "in"; >foo : string diff --git a/tests/baselines/reference/genericIsNeverEmptyObject.js b/tests/baselines/reference/genericIsNeverEmptyObject.js index 169258469c8..4f6c2901ae3 100644 --- a/tests/baselines/reference/genericIsNeverEmptyObject.js +++ b/tests/baselines/reference/genericIsNeverEmptyObject.js @@ -15,17 +15,6 @@ let o2: { b: string, x: number } = test(o1); //// [genericIsNeverEmptyObject.js] "use strict"; // Repro from #29067 -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; var __rest = (this && this.__rest) || function (s, e) { var t = {}; for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) @@ -39,7 +28,7 @@ var __rest = (this && this.__rest) || function (s, e) { }; function test(obj) { let { a } = obj, rest = __rest(obj, ["a"]); - return __assign(__assign({}, rest), { b: a }); + return Object.assign(Object.assign({}, rest), { b: a }); } let o1 = { a: 'hello', x: 42 }; let o2 = test(o1); diff --git a/tests/baselines/reference/importHelpersInTsx.js b/tests/baselines/reference/importHelpersInTsx.js index bb85abcce96..632acb51724 100644 --- a/tests/baselines/reference/importHelpersInTsx.js +++ b/tests/baselines/reference/importHelpersInTsx.js @@ -23,18 +23,6 @@ export declare function __awaiter(thisArg: any, _arguments: any, P: Function, ge "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.x = void 0; -const tslib_1 = require("tslib"); -exports.x = React.createElement("span", tslib_1.__assign({}, o)); +exports.x = React.createElement("span", Object.assign({}, o)); //// [script.js] -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; -const x = React.createElement("span", __assign({}, o)); +const x = React.createElement("span", Object.assign({}, o)); diff --git a/tests/baselines/reference/importHelpersNoHelpers.js b/tests/baselines/reference/importHelpersNoHelpers.js index 3fe6366166b..46e475aaecd 100644 --- a/tests/baselines/reference/importHelpersNoHelpers.js +++ b/tests/baselines/reference/importHelpersNoHelpers.js @@ -67,7 +67,7 @@ C = tslib_1.__decorate([ dec ], C); const o = { a: 1 }; -const y = tslib_1.__assign({}, o); +const y = Object.assign({}, o); const x = tslib_1.__rest(y, []); //// [script.js] var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { diff --git a/tests/baselines/reference/intersectionPropertyCheck.js b/tests/baselines/reference/intersectionPropertyCheck.js index 6c1ad3bd0cf..02a834fc56e 100644 --- a/tests/baselines/reference/intersectionPropertyCheck.js +++ b/tests/baselines/reference/intersectionPropertyCheck.js @@ -23,22 +23,11 @@ function test(value: T): Test { //// [intersectionPropertyCheck.js] "use strict"; -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; let obj = { a: { x: 'hello', y: 2 }, c: 5 }; // Nested excess property let weak = wrong; // Nested weak object type function foo(x, y) { x = y; // Mismatched property in source intersection } function test(value) { - return __assign(__assign({}, value), { hi: true }); + return Object.assign(Object.assign({}, value), { hi: true }); } diff --git a/tests/baselines/reference/intraExpressionInferences.js b/tests/baselines/reference/intraExpressionInferences.js index d8a38d1b8d6..65c41dc3c8c 100644 --- a/tests/baselines/reference/intraExpressionInferences.js +++ b/tests/baselines/reference/intraExpressionInferences.js @@ -336,17 +336,6 @@ const distantRes = distant({ //// [intraExpressionInferences.js] "use strict"; // Repros from #47599 -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; callIt({ produce: () => 0, consume: n => n.toFixed() @@ -458,7 +447,7 @@ branch({ let test1 = u; } }); -Foo(__assign({ +Foo(Object.assign({ a: (x) => 10, b: (arg) => { arg.toString(); diff --git a/tests/baselines/reference/jsxComplexSignatureHasApplicabilityError.js b/tests/baselines/reference/jsxComplexSignatureHasApplicabilityError.js index b425a88ebd5..208423a6651 100644 --- a/tests/baselines/reference/jsxComplexSignatureHasApplicabilityError.js +++ b/tests/baselines/reference/jsxComplexSignatureHasApplicabilityError.js @@ -613,23 +613,12 @@ export interface ReactSelectProps extends React.Props -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; Object.defineProperty(exports, "__esModule", { value: true }); exports.createReactSingleSelect = createReactSingleSelect; const React = require("react"); function createReactSingleSelect(WrappedComponent) { return (props) => { - return (React.createElement(ReactSelectClass, __assign({}, props, { multi: false, autosize: false, value: props.value, onChange: (value) => { + return (React.createElement(ReactSelectClass, Object.assign({}, props, { multi: false, autosize: false, value: props.value, onChange: (value) => { if (props.onChange) { props.onChange(value === null ? undefined : value); } diff --git a/tests/baselines/reference/jsxExcessPropsAndAssignability.js b/tests/baselines/reference/jsxExcessPropsAndAssignability.js index 37a0f7edfd3..59ff4477d36 100644 --- a/tests/baselines/reference/jsxExcessPropsAndAssignability.js +++ b/tests/baselines/reference/jsxExcessPropsAndAssignability.js @@ -21,22 +21,11 @@ const myHoc = ( //// [jsxExcessPropsAndAssignability.js] "use strict"; /// -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; Object.defineProperty(exports, "__esModule", { value: true }); const React = require("react"); const myHoc = (ComposedComponent) => { const WrapperComponent = null; const props = null; - React.createElement(WrapperComponent, __assign({}, props, { myProp: '1000000' })); - React.createElement(WrapperComponent, __assign({}, props, { myProp: 1000000 })); + React.createElement(WrapperComponent, Object.assign({}, props, { myProp: '1000000' })); + React.createElement(WrapperComponent, Object.assign({}, props, { myProp: 1000000 })); }; diff --git a/tests/baselines/reference/jsxJsxsCjsTransformKeyProp(jsx=react-jsx).js b/tests/baselines/reference/jsxJsxsCjsTransformKeyProp(jsx=react-jsx).js index e0f87f52ecd..7f06e65190f 100644 --- a/tests/baselines/reference/jsxJsxsCjsTransformKeyProp(jsx=react-jsx).js +++ b/tests/baselines/reference/jsxJsxsCjsTransformKeyProp(jsx=react-jsx).js @@ -11,21 +11,10 @@ export {}; //// [jsxJsxsCjsTransformKeyProp.js] "use strict"; -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; Object.defineProperty(exports, "__esModule", { value: true }); const react_1 = require("react"); const jsx_runtime_1 = require("react/jsx-runtime"); /// const props = { answer: 42 }; -const a = (0, jsx_runtime_1.jsx)("div", __assign({}, props, { children: "text" }), "foo"); -const b = (0, react_1.createElement)("div", __assign({}, props, { key: "bar" }), "text"); +const a = (0, jsx_runtime_1.jsx)("div", Object.assign({}, props, { children: "text" }), "foo"); +const b = (0, react_1.createElement)("div", Object.assign({}, props, { key: "bar" }), "text"); diff --git a/tests/baselines/reference/jsxJsxsCjsTransformKeyProp(jsx=react-jsxdev).js b/tests/baselines/reference/jsxJsxsCjsTransformKeyProp(jsx=react-jsxdev).js index 672a1d6ece9..00e943c57ed 100644 --- a/tests/baselines/reference/jsxJsxsCjsTransformKeyProp(jsx=react-jsxdev).js +++ b/tests/baselines/reference/jsxJsxsCjsTransformKeyProp(jsx=react-jsxdev).js @@ -11,22 +11,11 @@ export {}; //// [jsxJsxsCjsTransformKeyProp.js] "use strict"; -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; Object.defineProperty(exports, "__esModule", { value: true }); const react_1 = require("react"); const jsx_dev_runtime_1 = require("react/jsx-dev-runtime"); const _jsxFileName = "jsxJsxsCjsTransformKeyProp.tsx"; /// const props = { answer: 42 }; -const a = (0, jsx_dev_runtime_1.jsxDEV)("div", __assign({}, props, { children: "text" }), "foo", false, { fileName: _jsxFileName, lineNumber: 3, columnNumber: 10 }, this); -const b = (0, react_1.createElement)("div", __assign({}, props, { key: "bar" }), "text"); +const a = (0, jsx_dev_runtime_1.jsxDEV)("div", Object.assign({}, props, { children: "text" }), "foo", false, { fileName: _jsxFileName, lineNumber: 3, columnNumber: 10 }, this); +const b = (0, react_1.createElement)("div", Object.assign({}, props, { key: "bar" }), "text"); diff --git a/tests/baselines/reference/jsxJsxsCjsTransformKeyPropCustomImport(jsx=react-jsx).js b/tests/baselines/reference/jsxJsxsCjsTransformKeyPropCustomImport(jsx=react-jsx).js index 7750cb07273..84562093ac9 100644 --- a/tests/baselines/reference/jsxJsxsCjsTransformKeyPropCustomImport(jsx=react-jsx).js +++ b/tests/baselines/reference/jsxJsxsCjsTransformKeyPropCustomImport(jsx=react-jsx).js @@ -11,21 +11,10 @@ export {}; //// [jsxJsxsCjsTransformKeyPropCustomImport.js] "use strict"; -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; Object.defineProperty(exports, "__esModule", { value: true }); const preact_1 = require("preact"); const jsx_runtime_1 = require("preact/jsx-runtime"); /// const props = { answer: 42 }; -const a = (0, jsx_runtime_1.jsx)("div", __assign({}, props, { children: "text" }), "foo"); -const b = (0, preact_1.createElement)("div", __assign({}, props, { key: "bar" }), "text"); +const a = (0, jsx_runtime_1.jsx)("div", Object.assign({}, props, { children: "text" }), "foo"); +const b = (0, preact_1.createElement)("div", Object.assign({}, props, { key: "bar" }), "text"); diff --git a/tests/baselines/reference/jsxJsxsCjsTransformKeyPropCustomImport(jsx=react-jsxdev).js b/tests/baselines/reference/jsxJsxsCjsTransformKeyPropCustomImport(jsx=react-jsxdev).js index e265dc0fe56..99d8c49c946 100644 --- a/tests/baselines/reference/jsxJsxsCjsTransformKeyPropCustomImport(jsx=react-jsxdev).js +++ b/tests/baselines/reference/jsxJsxsCjsTransformKeyPropCustomImport(jsx=react-jsxdev).js @@ -11,22 +11,11 @@ export {}; //// [jsxJsxsCjsTransformKeyPropCustomImport.js] "use strict"; -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; Object.defineProperty(exports, "__esModule", { value: true }); const preact_1 = require("preact"); const jsx_dev_runtime_1 = require("preact/jsx-dev-runtime"); const _jsxFileName = "jsxJsxsCjsTransformKeyPropCustomImport.tsx"; /// const props = { answer: 42 }; -const a = (0, jsx_dev_runtime_1.jsxDEV)("div", __assign({}, props, { children: "text" }), "foo", false, { fileName: _jsxFileName, lineNumber: 3, columnNumber: 10 }, this); -const b = (0, preact_1.createElement)("div", __assign({}, props, { key: "bar" }), "text"); +const a = (0, jsx_dev_runtime_1.jsxDEV)("div", Object.assign({}, props, { children: "text" }), "foo", false, { fileName: _jsxFileName, lineNumber: 3, columnNumber: 10 }, this); +const b = (0, preact_1.createElement)("div", Object.assign({}, props, { key: "bar" }), "text"); diff --git a/tests/baselines/reference/jsxJsxsCjsTransformKeyPropCustomImportPragma(jsx=react-jsx).js b/tests/baselines/reference/jsxJsxsCjsTransformKeyPropCustomImportPragma(jsx=react-jsx).js index bffb9b02d9f..4062f5654a4 100644 --- a/tests/baselines/reference/jsxJsxsCjsTransformKeyPropCustomImportPragma(jsx=react-jsx).js +++ b/tests/baselines/reference/jsxJsxsCjsTransformKeyPropCustomImportPragma(jsx=react-jsx).js @@ -22,38 +22,16 @@ export {}; //// [preact.js] "use strict"; -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; Object.defineProperty(exports, "__esModule", { value: true }); const preact_1 = require("preact"); const jsx_runtime_1 = require("preact/jsx-runtime"); /// /* @jsxImportSource preact */ const props = { answer: 42 }; -const a = (0, jsx_runtime_1.jsx)("div", __assign({}, props, { children: "text" }), "foo"); -const b = (0, preact_1.createElement)("div", __assign({}, props, { key: "bar" }), "text"); +const a = (0, jsx_runtime_1.jsx)("div", Object.assign({}, props, { children: "text" }), "foo"); +const b = (0, preact_1.createElement)("div", Object.assign({}, props, { key: "bar" }), "text"); //// [react.js] "use strict"; -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; Object.defineProperty(exports, "__esModule", { value: true }); const react_1 = require("react"); const jsx_runtime_1 = require("react/jsx-runtime"); @@ -61,5 +39,5 @@ const jsx_runtime_1 = require("react/jsx-runtime"); /* @jsxImportSource react */ require("./preact"); const props2 = { answer: 42 }; -const a2 = (0, jsx_runtime_1.jsx)("div", __assign({}, props2, { children: "text" }), "foo"); -const b2 = (0, react_1.createElement)("div", __assign({}, props2, { key: "bar" }), "text"); +const a2 = (0, jsx_runtime_1.jsx)("div", Object.assign({}, props2, { children: "text" }), "foo"); +const b2 = (0, react_1.createElement)("div", Object.assign({}, props2, { key: "bar" }), "text"); diff --git a/tests/baselines/reference/jsxJsxsCjsTransformKeyPropCustomImportPragma(jsx=react-jsxdev).js b/tests/baselines/reference/jsxJsxsCjsTransformKeyPropCustomImportPragma(jsx=react-jsxdev).js index 4f6f7a85707..06a12373973 100644 --- a/tests/baselines/reference/jsxJsxsCjsTransformKeyPropCustomImportPragma(jsx=react-jsxdev).js +++ b/tests/baselines/reference/jsxJsxsCjsTransformKeyPropCustomImportPragma(jsx=react-jsxdev).js @@ -22,17 +22,6 @@ export {}; //// [preact.js] "use strict"; -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; Object.defineProperty(exports, "__esModule", { value: true }); const preact_1 = require("preact"); const jsx_dev_runtime_1 = require("preact/jsx-dev-runtime"); @@ -40,21 +29,10 @@ const _jsxFileName = "preact.tsx"; /// /* @jsxImportSource preact */ const props = { answer: 42 }; -const a = (0, jsx_dev_runtime_1.jsxDEV)("div", __assign({}, props, { children: "text" }), "foo", false, { fileName: _jsxFileName, lineNumber: 4, columnNumber: 10 }, this); -const b = (0, preact_1.createElement)("div", __assign({}, props, { key: "bar" }), "text"); +const a = (0, jsx_dev_runtime_1.jsxDEV)("div", Object.assign({}, props, { children: "text" }), "foo", false, { fileName: _jsxFileName, lineNumber: 4, columnNumber: 10 }, this); +const b = (0, preact_1.createElement)("div", Object.assign({}, props, { key: "bar" }), "text"); //// [react.js] "use strict"; -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; Object.defineProperty(exports, "__esModule", { value: true }); const react_1 = require("react"); const jsx_dev_runtime_1 = require("react/jsx-dev-runtime"); @@ -63,5 +41,5 @@ const _jsxFileName = "react.tsx"; /* @jsxImportSource react */ require("./preact"); const props2 = { answer: 42 }; -const a2 = (0, jsx_dev_runtime_1.jsxDEV)("div", __assign({}, props2, { children: "text" }), "foo", false, { fileName: _jsxFileName, lineNumber: 5, columnNumber: 11 }, this); -const b2 = (0, react_1.createElement)("div", __assign({}, props2, { key: "bar" }), "text"); +const a2 = (0, jsx_dev_runtime_1.jsxDEV)("div", Object.assign({}, props2, { children: "text" }), "foo", false, { fileName: _jsxFileName, lineNumber: 5, columnNumber: 11 }, this); +const b2 = (0, react_1.createElement)("div", Object.assign({}, props2, { key: "bar" }), "text"); diff --git a/tests/baselines/reference/jsxNamespacePrefixInNameReact.js b/tests/baselines/reference/jsxNamespacePrefixInNameReact.js index 71d7334c9ab..ddf6313cffe 100644 --- a/tests/baselines/reference/jsxNamespacePrefixInNameReact.js +++ b/tests/baselines/reference/jsxNamespacePrefixInNameReact.js @@ -34,17 +34,6 @@ var upcaseComponent2 = ; // Parsed as instrinsic //// [jsxNamespacePrefixInNameReact.js] -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; var justElement1 = React.createElement("a:element", null); var justElement2 = React.createElement("a:element", null); var justElement3 = React.createElement("a:element", { attr: "value" }); @@ -65,9 +54,9 @@ var justAttribute3 = React.createElement("element", { "a:attr": "value" }, "text var both1 = React.createElement("a:element", { "a:attr": "value" }); var both2 = React.createElement("a:element", { "k:attr": "value" }); var both3 = React.createElement("a:element", { "a:attr": "value" }, "text"); -var endOfIdent1 = React.createElement("a:attr", __assign({}, "value")); +var endOfIdent1 = React.createElement("a:attr", Object.assign({}, "value")); var endOfIdent2 = React.createElement("a", { "attr:": "value" }); var beginOfIdent1 = < , a, attr = { "value": } / > ; -var beginOfIdent2 = React.createElement("a:attr", __assign({}, "value")); +var beginOfIdent2 = React.createElement("a:attr", Object.assign({}, "value")); var upcaseComponent1 = React.createElement("ns:Upcase", null); // Parsed as intrinsic var upcaseComponent2 = React.createElement("Upcase:element", null); // Parsed as instrinsic diff --git a/tests/baselines/reference/jsxSpreadFirstUnionNoErrors.js b/tests/baselines/reference/jsxSpreadFirstUnionNoErrors.js index 9097b52c018..aed09ba07f1 100644 --- a/tests/baselines/reference/jsxSpreadFirstUnionNoErrors.js +++ b/tests/baselines/reference/jsxSpreadFirstUnionNoErrors.js @@ -20,17 +20,6 @@ const c = ; //// [jsxSpreadFirstUnionNoErrors.js] "use strict"; -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; Object.defineProperty(exports, "__esModule", { value: true }); const react_1 = require("react"); const Info = (props) => props.status === "hidden" @@ -38,4 +27,4 @@ const Info = (props) => props.status === "hidden" : react_1.default.createElement("div", null, props.content); const a = react_1.default.createElement(Info, { status: "hidden" }); const b = react_1.default.createElement(Info, { status: "visible", content: "hello world" }); -const c = react_1.default.createElement(Info, __assign({}, infoProps)); +const c = react_1.default.createElement(Info, Object.assign({}, infoProps)); diff --git a/tests/baselines/reference/literalTypeWidening.js b/tests/baselines/reference/literalTypeWidening.js index 461b4b0efe4..cf0648a45ea 100644 --- a/tests/baselines/reference/literalTypeWidening.js +++ b/tests/baselines/reference/literalTypeWidening.js @@ -149,17 +149,6 @@ const b: E.A = a; //// [literalTypeWidening.js] "use strict"; // Widening vs. non-widening literal types -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; var __rest = (this && this.__rest) || function (s, e) { var t = {}; for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) @@ -271,7 +260,7 @@ const arr = exports.langCodes.map(code => ({ code })); // Repro from #29081 function test(obj) { let { a } = obj, rest = __rest(obj, ["a"]); - return __assign({ a: 'hello' }, rest); + return Object.assign({ a: 'hello' }, rest); } var E; (function (E) { diff --git a/tests/baselines/reference/metadataOfUnionWithNull.js b/tests/baselines/reference/metadataOfUnionWithNull.js index fb7cf1b8b99..52ef3a46c9a 100644 --- a/tests/baselines/reference/metadataOfUnionWithNull.js +++ b/tests/baselines/reference/metadataOfUnionWithNull.js @@ -89,7 +89,7 @@ __decorate([ ], B.prototype, "d", void 0); __decorate([ PropDeco, - __metadata("design:type", typeof Symbol === "function" ? Symbol : Object) + __metadata("design:type", Symbol) ], B.prototype, "e", void 0); __decorate([ PropDeco, @@ -105,5 +105,5 @@ __decorate([ ], B.prototype, "h", void 0); __decorate([ PropDeco, - __metadata("design:type", typeof Symbol === "function" ? Symbol : Object) + __metadata("design:type", Symbol) ], B.prototype, "j", void 0); diff --git a/tests/baselines/reference/nullishCoalescingOperatorInParameterBindingPattern(target=es5).js b/tests/baselines/reference/nullishCoalescingOperatorInParameterBindingPattern(target=es5).js index 924e1ebd4f0..0b889037b0d 100644 --- a/tests/baselines/reference/nullishCoalescingOperatorInParameterBindingPattern(target=es5).js +++ b/tests/baselines/reference/nullishCoalescingOperatorInParameterBindingPattern(target=es5).js @@ -8,4 +8,4 @@ const a = (): string | undefined => undefined; //// [nullishCoalescingOperatorInParameterBindingPattern.js] // https://github.com/microsoft/TypeScript/issues/36295 const a = () => undefined; -(({ [(_a = a()) !== null && _a !== void 0 ? _a : "d"]: c = "" }) => { var _a; })(); +((_a) => { var _b; var { [(_b = a()) !== null && _b !== void 0 ? _b : "d"]: c = "" } = _a; })(); diff --git a/tests/baselines/reference/nullishCoalescingOperatorInParameterInitializer(target=es5).js b/tests/baselines/reference/nullishCoalescingOperatorInParameterInitializer(target=es5).js index 722c6619597..793f5077431 100644 --- a/tests/baselines/reference/nullishCoalescingOperatorInParameterInitializer(target=es5).js +++ b/tests/baselines/reference/nullishCoalescingOperatorInParameterInitializer(target=es5).js @@ -8,4 +8,4 @@ const a = (): string | undefined => undefined; //// [nullishCoalescingOperatorInParameterInitializer.js] // https://github.com/microsoft/TypeScript/issues/36295 const a = () => undefined; -((b = (_a = a()) !== null && _a !== void 0 ? _a : "d") => { var _a; })(); +((b) => { var _a; if (b === void 0) { b = (_a = a()) !== null && _a !== void 0 ? _a : "d"; } })(); diff --git a/tests/baselines/reference/objectInstantiationFromUnionSpread.js b/tests/baselines/reference/objectInstantiationFromUnionSpread.js index 6f130b2f073..0d5e7bc8718 100644 --- a/tests/baselines/reference/objectInstantiationFromUnionSpread.js +++ b/tests/baselines/reference/objectInstantiationFromUnionSpread.js @@ -24,20 +24,9 @@ function f2(a: Item[]) { //// [objectInstantiationFromUnionSpread.js] // #40995 -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; function f1(a) { - a.map(item => (__assign({}, item))).filter(value => { }); + a.map(item => (Object.assign({}, item))).filter(value => { }); } function f2(a) { - a.map(item => (__assign({}, item))).filter(value => { }); + a.map(item => (Object.assign({}, item))).filter(value => { }); } diff --git a/tests/baselines/reference/objectLiteralFreshnessWithSpread.js b/tests/baselines/reference/objectLiteralFreshnessWithSpread.js index 777f82a56d0..61d8aa65fbd 100644 --- a/tests/baselines/reference/objectLiteralFreshnessWithSpread.js +++ b/tests/baselines/reference/objectLiteralFreshnessWithSpread.js @@ -6,16 +6,5 @@ let xx: { a, b } = { a: 1, ...x, z: 3 } // error for 'z', no error for 'extra' //// [objectLiteralFreshnessWithSpread.js] -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; let x = { b: 1, extra: 2 }; -let xx = __assign(__assign({ a: 1 }, x), { z: 3 }); // error for 'z', no error for 'extra' +let xx = Object.assign(Object.assign({ a: 1 }, x), { z: 3 }); // error for 'z', no error for 'extra' diff --git a/tests/baselines/reference/objectLiteralNormalization.js b/tests/baselines/reference/objectLiteralNormalization.js index 33829cc1f36..b2572f2a31a 100644 --- a/tests/baselines/reference/objectLiteralNormalization.js +++ b/tests/baselines/reference/objectLiteralNormalization.js @@ -54,17 +54,6 @@ let e4 = f({ a: 2 }, data); //// [objectLiteralNormalization.js] "use strict"; -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; // Object literals in unions are normalized upon widening let a1 = [{ a: 0 }, { a: 1, b: "x" }, { a: 2, b: "y", c: true }][0]; a1.a; // number @@ -82,8 +71,8 @@ a2 = { a: "def" }; a2 = {}; a2 = { a: "def", b: 20 }; // Error a2 = { a: 1 }; // Error -let b2 = __assign(__assign({}, b1), { z: 55 }); -let b3 = __assign({}, b2); +let b2 = Object.assign(Object.assign({}, b1), { z: 55 }); +let b3 = Object.assign({}, b2); let c1 = !true ? {} : opts; let c2 = !true ? opts : {}; let c3 = !true ? { a: 0, b: 0 } : {}; diff --git a/tests/baselines/reference/objectSpread.js b/tests/baselines/reference/objectSpread.js index 8f2652b2f46..61742822759 100644 --- a/tests/baselines/reference/objectSpread.js +++ b/tests/baselines/reference/objectSpread.js @@ -146,60 +146,49 @@ function genericSpread(t: T, u: U, v: T | U, w: T | { s: string }, obj: { //// [objectSpread.js] -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; let o = { a: 1, b: 'no' }; let o2 = { b: 'yes', c: true }; let swap = { a: 'yes', b: -1 }; -let addAfter = __assign(__assign({}, o), { c: false }); -let addBefore = __assign({ c: false }, o); -let override = __assign(__assign({}, o), { b: 'override' }); -let nested = __assign(__assign({}, __assign({ a: 3 }, { b: false, c: 'overriden' })), { c: 'whatever' }); -let combined = __assign(__assign({}, o), o2); -let combinedAfter = __assign(__assign(__assign({}, o), o2), { b: 'ok' }); -let combinedNestedChangeType = __assign(__assign({}, __assign({ a: 1 }, { b: false, c: 'overriden' })), { c: -1 }); -let propertyNested = { a: __assign({}, o) }; +let addAfter = Object.assign(Object.assign({}, o), { c: false }); +let addBefore = Object.assign({ c: false }, o); +let override = Object.assign(Object.assign({}, o), { b: 'override' }); +let nested = Object.assign(Object.assign({}, Object.assign({ a: 3 }, { b: false, c: 'overriden' })), { c: 'whatever' }); +let combined = Object.assign(Object.assign({}, o), o2); +let combinedAfter = Object.assign(Object.assign(Object.assign({}, o), o2), { b: 'ok' }); +let combinedNestedChangeType = Object.assign(Object.assign({}, Object.assign({ a: 1 }, { b: false, c: 'overriden' })), { c: -1 }); +let propertyNested = { a: Object.assign({}, o) }; // accessors don't copy the descriptor // (which means that readonly getters become read/write properties) let op = { get a() { return 6; } }; -let getter = __assign(__assign({}, op), { c: 7 }); +let getter = Object.assign(Object.assign({}, op), { c: 7 }); getter.a = 12; // functions result in { } -let spreadFunc = __assign({}, (function () { })); +let spreadFunc = Object.assign({}, (function () { })); function from16326(header, authToken) { - return __assign(__assign(__assign({}, this.header), header), authToken && { authToken }); + return Object.assign(Object.assign(Object.assign({}, this.header), header), authToken && { authToken }); } // boolean && T results in Partial function conditionalSpreadBoolean(b) { let o = { x: 12, y: 13 }; - o = __assign(__assign({}, o), b && { x: 14 }); - let o2 = __assign({}, b && { x: 21 }); + o = Object.assign(Object.assign({}, o), b && { x: 14 }); + let o2 = Object.assign({}, b && { x: 21 }); return o; } function conditionalSpreadNumber(nt) { let o = { x: 15, y: 16 }; - o = __assign(__assign({}, o), nt && { x: nt }); - let o2 = __assign({}, nt && { x: nt }); + o = Object.assign(Object.assign({}, o), nt && { x: nt }); + let o2 = Object.assign({}, nt && { x: nt }); return o; } function conditionalSpreadString(st) { let o = { x: 'hi', y: 17 }; - o = __assign(__assign({}, o), st && { x: st }); - let o2 = __assign({}, st && { x: st }); + o = Object.assign(Object.assign({}, o), st && { x: st }); + let o2 = Object.assign({}, st && { x: st }); return o; } // any results in any let anything; -let spreadAny = __assign({}, anything); +let spreadAny = Object.assign({}, anything); // methods are not enumerable class C { constructor() { @@ -208,51 +197,51 @@ class C { m() { } } let c = new C(); -let spreadC = __assign({}, c); +let spreadC = Object.assign({}, c); // own methods are enumerable -let cplus = __assign(__assign({}, c), { plus() { return this.p + 1; } }); +let cplus = Object.assign(Object.assign({}, c), { plus() { return this.p + 1; } }); cplus.plus(); // new field's type conflicting with existing field is OK -let changeTypeAfter = __assign(__assign({}, o), { a: 'wrong type?' }); -let changeTypeBoth = __assign(__assign({}, o), swap); +let changeTypeAfter = Object.assign(Object.assign({}, o), { a: 'wrong type?' }); +let changeTypeBoth = Object.assign(Object.assign({}, o), swap); // optional function container(definiteBoolean, definiteString, optionalString, optionalNumber) { - let optionalUnionStops = __assign(__assign(__assign({}, definiteBoolean), definiteString), optionalNumber); - let optionalUnionDuplicates = __assign(__assign(__assign(__assign({}, definiteBoolean), definiteString), optionalString), optionalNumber); - let allOptional = __assign(__assign({}, optionalString), optionalNumber); + let optionalUnionStops = Object.assign(Object.assign(Object.assign({}, definiteBoolean), definiteString), optionalNumber); + let optionalUnionDuplicates = Object.assign(Object.assign(Object.assign(Object.assign({}, definiteBoolean), definiteString), optionalString), optionalNumber); + let allOptional = Object.assign(Object.assign({}, optionalString), optionalNumber); // computed property - let computedFirst = __assign(__assign({ ['before everything']: 12 }, o), { b: 'yes' }); - let computedAfter = __assign(__assign({}, o), { b: 'yeah', ['at the end']: 14 }); + let computedFirst = Object.assign(Object.assign({ ['before everything']: 12 }, o), { b: 'yes' }); + let computedAfter = Object.assign(Object.assign({}, o), { b: 'yeah', ['at the end']: 14 }); } // shortcut syntax let a = 12; -let shortCutted = __assign(__assign({}, o), { a }); +let shortCutted = Object.assign(Object.assign({}, o), { a }); // non primitive -let spreadNonPrimitive = __assign({}, {}); +let spreadNonPrimitive = Object.assign({}, {}); // generic spreads function f(t, u) { - return __assign(__assign(__assign({}, t), u), { id: 'id' }); + return Object.assign(Object.assign(Object.assign({}, t), u), { id: 'id' }); } let exclusive = f({ a: 1, b: 'yes' }, { c: 'no', d: false }); let overlap = f({ a: 1 }, { a: 2, b: 'extra' }); let overlapConflict = f({ a: 1 }, { a: 'mismatch' }); let overwriteId = f({ a: 1, id: true }, { c: 1, d: 'no' }); function genericSpread(t, u, v, w, obj) { - let x01 = __assign({}, t); - let x02 = __assign(__assign({}, t), t); - let x03 = __assign(__assign({}, t), u); - let x04 = __assign(__assign({}, u), t); - let x05 = __assign({ a: 5, b: 'hi' }, t); - let x06 = __assign(__assign({}, t), { a: 5, b: 'hi' }); - let x07 = __assign(__assign(__assign({ a: 5, b: 'hi' }, t), { c: true }), obj); - let x09 = __assign(__assign(__assign({ a: 5 }, t), { b: 'hi', c: true }), obj); - let x10 = __assign(__assign(__assign(__assign({ a: 5 }, t), { b: 'hi' }), u), obj); - let x11 = __assign({}, v); - let x12 = __assign(__assign({}, v), obj); - let x13 = __assign({}, w); - let x14 = __assign(__assign({}, w), obj); - let x15 = __assign(__assign({}, t), v); - let x16 = __assign(__assign({}, t), w); - let x17 = __assign(__assign(__assign({}, t), w), obj); - let x18 = __assign(__assign(__assign({}, t), v), w); + let x01 = Object.assign({}, t); + let x02 = Object.assign(Object.assign({}, t), t); + let x03 = Object.assign(Object.assign({}, t), u); + let x04 = Object.assign(Object.assign({}, u), t); + let x05 = Object.assign({ a: 5, b: 'hi' }, t); + let x06 = Object.assign(Object.assign({}, t), { a: 5, b: 'hi' }); + let x07 = Object.assign(Object.assign(Object.assign({ a: 5, b: 'hi' }, t), { c: true }), obj); + let x09 = Object.assign(Object.assign(Object.assign({ a: 5 }, t), { b: 'hi', c: true }), obj); + let x10 = Object.assign(Object.assign(Object.assign(Object.assign({ a: 5 }, t), { b: 'hi' }), u), obj); + let x11 = Object.assign({}, v); + let x12 = Object.assign(Object.assign({}, v), obj); + let x13 = Object.assign({}, w); + let x14 = Object.assign(Object.assign({}, w), obj); + let x15 = Object.assign(Object.assign({}, t), v); + let x16 = Object.assign(Object.assign({}, t), w); + let x17 = Object.assign(Object.assign(Object.assign({}, t), w), obj); + let x18 = Object.assign(Object.assign(Object.assign({}, t), v), w); } diff --git a/tests/baselines/reference/objectSpreadComputedProperty.js b/tests/baselines/reference/objectSpreadComputedProperty.js index 07cbee3e76e..a4daa96af83 100644 --- a/tests/baselines/reference/objectSpreadComputedProperty.js +++ b/tests/baselines/reference/objectSpreadComputedProperty.js @@ -13,23 +13,12 @@ function f() { //// [objectSpreadComputedProperty.js] -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; // fixes #12200 function f() { let n = 12; let m = 13; let a = null; - const o1 = __assign({}, { [n]: n }); - const o2 = __assign({}, { [a]: n }); - const o3 = __assign(__assign(__assign(__assign({ [a]: n }, {}), { [n]: n }), {}), { [m]: m }); + const o1 = Object.assign({}, { [n]: n }); + const o2 = Object.assign({}, { [a]: n }); + const o3 = Object.assign(Object.assign(Object.assign(Object.assign({ [a]: n }, {}), { [n]: n }), {}), { [m]: m }); } diff --git a/tests/baselines/reference/objectSpreadIndexSignature.js b/tests/baselines/reference/objectSpreadIndexSignature.js index 54eae2b42f3..a9d297e60aa 100644 --- a/tests/baselines/reference/objectSpreadIndexSignature.js +++ b/tests/baselines/reference/objectSpreadIndexSignature.js @@ -21,23 +21,12 @@ writable.a = 0; // should be ok. //// [objectSpreadIndexSignature.js] "use strict"; -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; -let i = __assign(__assign({}, indexed1), { b: 11 }); +let i = Object.assign(Object.assign({}, indexed1), { b: 11 }); // only indexed has indexer, so i[101]: any i[101]; -let ii = __assign(__assign({}, indexed1), indexed2); +let ii = Object.assign(Object.assign({}, indexed1), indexed2); // both have indexer, so i[1001]: number | boolean ii[1001]; -indexed3 = __assign({}, b ? indexed3 : undefined); -var writable = __assign({}, roindex); +indexed3 = Object.assign({}, b ? indexed3 : undefined); +var writable = Object.assign({}, roindex); writable.a = 0; // should be ok. diff --git a/tests/baselines/reference/objectSpreadNegative.js b/tests/baselines/reference/objectSpreadNegative.js index 5049fce1dfa..5ef5a972df1 100644 --- a/tests/baselines/reference/objectSpreadNegative.js +++ b/tests/baselines/reference/objectSpreadNegative.js @@ -78,59 +78,48 @@ spreadObj.a; // error 'a' is not in {} //// [objectSpreadNegative.js] -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; let o = { a: 1, b: 'no' }; /// private propagates class PrivateOptionalX { } class PublicX { } -let o2 = __assign(__assign({}, publicX), privateOptionalX); +let o2 = Object.assign(Object.assign({}, publicX), privateOptionalX); let sn = o2.x; // error, x is private -let allOptional = __assign(__assign({}, optionalString), optionalNumber); +let allOptional = Object.assign(Object.assign({}, optionalString), optionalNumber); ; ; -let spread = __assign({ b: true }, { s: "foo" }); +let spread = Object.assign({ b: true }, { s: "foo" }); spread = { s: "foo" }; // error, missing 'b' let b = { b: false }; spread = b; // error, missing 's' // literal repeats are not allowed, but spread repeats are fine -let duplicated = __assign(__assign(__assign(__assign({ b: 'bad' }, o), { b: 'bad' }), o2), { b: 'bad' }); -let duplicatedSpread = __assign(__assign({}, o), o); +let duplicated = Object.assign(Object.assign(Object.assign(Object.assign({ b: 'bad' }, o), { b: 'bad' }), o2), { b: 'bad' }); +let duplicatedSpread = Object.assign(Object.assign({}, o), o); // Note: ignore changes the order that properties are printed -let ignore = __assign({ b: 'ignored' }, o); +let ignore = Object.assign({ b: 'ignored' }, o); let o3 = { a: 1, b: 'no' }; let o4 = { b: 'yes', c: true }; -let combinedBefore = __assign(__assign({ b: 'ok' }, o3), o4); -let combinedMid = __assign(__assign(__assign({}, o3), { b: 'ok' }), o4); -let combinedNested = __assign(__assign(__assign({}, __assign({ a: 4 }, { b: false, c: 'overriden' })), { d: 'actually new' }), { a: 5, d: 'maybe new' }); -let changeTypeBefore = __assign({ a: 'wrong type?' }, o3); -let computedMiddle = __assign(__assign(__assign({}, o3), { ['in the middle']: 13, b: 'maybe?' }), o4); +let combinedBefore = Object.assign(Object.assign({ b: 'ok' }, o3), o4); +let combinedMid = Object.assign(Object.assign(Object.assign({}, o3), { b: 'ok' }), o4); +let combinedNested = Object.assign(Object.assign(Object.assign({}, Object.assign({ a: 4 }, { b: false, c: 'overriden' })), { d: 'actually new' }), { a: 5, d: 'maybe new' }); +let changeTypeBefore = Object.assign({ a: 'wrong type?' }, o3); +let computedMiddle = Object.assign(Object.assign(Object.assign({}, o3), { ['in the middle']: 13, b: 'maybe?' }), o4); // primitives are not allowed, except for falsy ones -let spreadNum = __assign({}, 12); -let spreadSum = __assign({}, 1 + 1); -let spreadZero = __assign({}, 0); +let spreadNum = Object.assign({}, 12); +let spreadSum = Object.assign({}, 1 + 1); +let spreadZero = Object.assign({}, 0); spreadZero.toFixed(); // error, no methods even from a falsy number -let spreadBool = __assign({}, true); +let spreadBool = Object.assign({}, true); spreadBool.valueOf(); -let spreadStr = __assign({}, 'foo'); +let spreadStr = Object.assign({}, 'foo'); spreadStr.length; // error, no 'length' spreadStr.charAt(1); // error, no methods either // functions are skipped -let spreadFunc = __assign({}, function () { }); +let spreadFunc = Object.assign({}, function () { }); spreadFunc(); // error, no call signature // write-only properties get skipped -let setterOnly = __assign({ set b(bad) { } }); +let setterOnly = Object.assign({ set b(bad) { } }); setterOnly.b = 12; // error, 'b' does not exist // methods are skipped because they aren't enumerable class C { @@ -140,9 +129,9 @@ class C { m() { } } let c = new C(); -let spreadC = __assign({}, c); +let spreadC = Object.assign({}, c); spreadC.m(); // error 'm' is not in '{ ... c }' // non primitive let obj = { a: 123 }; -let spreadObj = __assign({}, obj); +let spreadObj = Object.assign({}, obj); spreadObj.a; // error 'a' is not in {} diff --git a/tests/baselines/reference/objectSpreadNegativeParse.js b/tests/baselines/reference/objectSpreadNegativeParse.js index f714a7a92a9..6e26f458fcf 100644 --- a/tests/baselines/reference/objectSpreadNegativeParse.js +++ b/tests/baselines/reference/objectSpreadNegativeParse.js @@ -8,19 +8,8 @@ let o10 = { ...get x() { return 12; }}; //// [objectSpreadNegativeParse.js] -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; -let o7 = __assign({}, o ? : ); -let o8 = __assign({}, * o); -let o9 = __assign({}, matchMedia()), {}; +let o7 = Object.assign({}, o ? : ); +let o8 = Object.assign({}, * o); +let o9 = Object.assign({}, matchMedia()), {}; ; -let o10 = __assign(__assign({}, get), { x() { return 12; } }); +let o10 = Object.assign(Object.assign({}, get), { x() { return 12; } }); diff --git a/tests/baselines/reference/objectSpreadRepeatedComplexity.js b/tests/baselines/reference/objectSpreadRepeatedComplexity.js index cf0c6638c09..c24e89a53a5 100644 --- a/tests/baselines/reference/objectSpreadRepeatedComplexity.js +++ b/tests/baselines/reference/objectSpreadRepeatedComplexity.js @@ -88,20 +88,9 @@ function f(cnd: Record){ //// [objectSpreadRepeatedComplexity.js] "use strict"; -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; function f(cnd) { // Type is a union of 2^(n-1) members, where n is the number of spread objects - return __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({}, (cnd[1] && + return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (cnd[1] && cnd[2] && { prop0: 0, })), (cnd[3] && { diff --git a/tests/baselines/reference/objectSpreadRepeatedNullCheckPerf.js b/tests/baselines/reference/objectSpreadRepeatedNullCheckPerf.js index c5f5e70a656..4cf4463608e 100644 --- a/tests/baselines/reference/objectSpreadRepeatedNullCheckPerf.js +++ b/tests/baselines/reference/objectSpreadRepeatedNullCheckPerf.js @@ -65,18 +65,7 @@ parseWithSpread({ a: 1, b: 2, z: 26 }) //// [objectSpreadRepeatedNullCheckPerf.js] "use strict"; -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; function parseWithSpread(config) { - return __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({}, config.a !== undefined && { a: config.a.toString() }), config.b !== undefined && { b: config.b.toString() }), config.c !== undefined && { c: config.c.toString() }), config.d !== undefined && { d: config.d.toString() }), config.e !== undefined && { e: config.e.toString() }), config.f !== undefined && { f: config.f.toString() }), config.g !== undefined && { g: config.g.toString() }), config.h !== undefined && { h: config.h.toString() }), config.i !== undefined && { i: config.i.toString() }), config.j !== undefined && { j: config.j.toString() }), config.k !== undefined && { k: config.k.toString() }), config.l !== undefined && { l: config.l.toString() }), config.m !== undefined && { m: config.m.toString() }), config.n !== undefined && { n: config.n.toString() }), config.o !== undefined && { o: config.o.toString() }), config.p !== undefined && { p: config.p.toString() }), config.q !== undefined && { q: config.q.toString() }), config.r !== undefined && { r: config.r.toString() }), config.s !== undefined && { s: config.s.toString() }), config.t !== undefined && { t: config.t.toString() }), config.u !== undefined && { u: config.u.toString() }), config.v !== undefined && { v: config.v.toString() }), config.w !== undefined && { w: config.w.toString() }), config.x !== undefined && { x: config.x.toString() }), config.y !== undefined && { y: config.y.toString() }), config.z !== undefined && { z: config.z.toString() }); + return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, config.a !== undefined && { a: config.a.toString() }), config.b !== undefined && { b: config.b.toString() }), config.c !== undefined && { c: config.c.toString() }), config.d !== undefined && { d: config.d.toString() }), config.e !== undefined && { e: config.e.toString() }), config.f !== undefined && { f: config.f.toString() }), config.g !== undefined && { g: config.g.toString() }), config.h !== undefined && { h: config.h.toString() }), config.i !== undefined && { i: config.i.toString() }), config.j !== undefined && { j: config.j.toString() }), config.k !== undefined && { k: config.k.toString() }), config.l !== undefined && { l: config.l.toString() }), config.m !== undefined && { m: config.m.toString() }), config.n !== undefined && { n: config.n.toString() }), config.o !== undefined && { o: config.o.toString() }), config.p !== undefined && { p: config.p.toString() }), config.q !== undefined && { q: config.q.toString() }), config.r !== undefined && { r: config.r.toString() }), config.s !== undefined && { s: config.s.toString() }), config.t !== undefined && { t: config.t.toString() }), config.u !== undefined && { u: config.u.toString() }), config.v !== undefined && { v: config.v.toString() }), config.w !== undefined && { w: config.w.toString() }), config.x !== undefined && { x: config.x.toString() }), config.y !== undefined && { y: config.y.toString() }), config.z !== undefined && { z: config.z.toString() }); } parseWithSpread({ a: 1, b: 2, z: 26 }); diff --git a/tests/baselines/reference/objectSpreadStrictNull.js b/tests/baselines/reference/objectSpreadStrictNull.js index 4264a5a5dac..b4783576d45 100644 --- a/tests/baselines/reference/objectSpreadStrictNull.js +++ b/tests/baselines/reference/objectSpreadStrictNull.js @@ -47,34 +47,23 @@ function g(fields: Fields, partialFields: Partial, nearlyPartialFields: //// [objectSpreadStrictNull.js] -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; function f(definiteBoolean, definiteString, optionalString, optionalNumber, undefinedString, undefinedNumber) { // optional - let optionalUnionStops = __assign(__assign(__assign({}, definiteBoolean), definiteString), optionalNumber); - let optionalUnionDuplicates = __assign(__assign(__assign(__assign({}, definiteBoolean), definiteString), optionalString), optionalNumber); - let allOptional = __assign(__assign({}, optionalString), optionalNumber); + let optionalUnionStops = Object.assign(Object.assign(Object.assign({}, definiteBoolean), definiteString), optionalNumber); + let optionalUnionDuplicates = Object.assign(Object.assign(Object.assign(Object.assign({}, definiteBoolean), definiteString), optionalString), optionalNumber); + let allOptional = Object.assign(Object.assign({}, optionalString), optionalNumber); // undefined - let undefinedUnionStops = __assign(__assign(__assign({}, definiteBoolean), definiteString), undefinedNumber); - let undefinedUnionDuplicates = __assign(__assign(__assign(__assign({}, definiteBoolean), definiteString), undefinedString), undefinedNumber); - let allUndefined = __assign(__assign({}, undefinedString), undefinedNumber); - let undefinedWithOptionalContinues = __assign(__assign(__assign({}, definiteBoolean), undefinedString), optionalNumber); + let undefinedUnionStops = Object.assign(Object.assign(Object.assign({}, definiteBoolean), definiteString), undefinedNumber); + let undefinedUnionDuplicates = Object.assign(Object.assign(Object.assign(Object.assign({}, definiteBoolean), definiteString), undefinedString), undefinedNumber); + let allUndefined = Object.assign(Object.assign({}, undefinedString), undefinedNumber); + let undefinedWithOptionalContinues = Object.assign(Object.assign(Object.assign({}, definiteBoolean), undefinedString), optionalNumber); } const m = { title: "The Matrix", yearReleased: 1999 }; // should error here because title: undefined is not assignable to string -const x = __assign(__assign({}, m), { title: undefined }); +const x = Object.assign(Object.assign({}, m), { title: undefined }); function g(fields, partialFields, nearlyPartialFields) { // ok, undefined is stripped from optional properties when spread - fields = __assign(__assign({}, fields), partialFields); + fields = Object.assign(Object.assign({}, fields), partialFields); // error: not optional, undefined remains - fields = __assign(__assign({}, fields), nearlyPartialFields); + fields = Object.assign(Object.assign({}, fields), nearlyPartialFields); } diff --git a/tests/baselines/reference/objectSpreadWithinMethodWithinObjectWithSpread.js b/tests/baselines/reference/objectSpreadWithinMethodWithinObjectWithSpread.js index b83cb77c430..0c4297a4c92 100644 --- a/tests/baselines/reference/objectSpreadWithinMethodWithinObjectWithSpread.js +++ b/tests/baselines/reference/objectSpreadWithinMethodWithinObjectWithSpread.js @@ -14,18 +14,7 @@ const a = { //// [objectSpreadWithinMethodWithinObjectWithSpread.js] -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; const obj = {}; -const a = __assign(__assign({}, obj), { prop() { - return __assign(__assign({}, obj), { metadata: 213 }); +const a = Object.assign(Object.assign({}, obj), { prop() { + return Object.assign(Object.assign({}, obj), { metadata: 213 }); } }); diff --git a/tests/baselines/reference/optionalChainingInParameterBindingPattern(target=es5).js b/tests/baselines/reference/optionalChainingInParameterBindingPattern(target=es5).js index d3d2d4c6cac..4deb6504419 100644 --- a/tests/baselines/reference/optionalChainingInParameterBindingPattern(target=es5).js +++ b/tests/baselines/reference/optionalChainingInParameterBindingPattern(target=es5).js @@ -8,4 +8,4 @@ const a = (): { d: string } | undefined => undefined; //// [optionalChainingInParameterBindingPattern.js] // https://github.com/microsoft/TypeScript/issues/36295 const a = () => undefined; -(({ [(_a = a()) === null || _a === void 0 ? void 0 : _a.d]: c = "" }) => { var _a; })(); +((_a) => { var _b; var { [(_b = a()) === null || _b === void 0 ? void 0 : _b.d]: c = "" } = _a; })(); diff --git a/tests/baselines/reference/optionalChainingInParameterInitializer(target=es5).js b/tests/baselines/reference/optionalChainingInParameterInitializer(target=es5).js index 36493cf27f7..65f2d016131 100644 --- a/tests/baselines/reference/optionalChainingInParameterInitializer(target=es5).js +++ b/tests/baselines/reference/optionalChainingInParameterInitializer(target=es5).js @@ -8,4 +8,4 @@ const a = (): { d: string } | undefined => undefined; //// [optionalChainingInParameterInitializer.js] // https://github.com/microsoft/TypeScript/issues/36295 const a = () => undefined; -((b = (_a = a()) === null || _a === void 0 ? void 0 : _a.d) => { var _a; })(); +((b) => { var _a; if (b === void 0) { b = (_a = a()) === null || _a === void 0 ? void 0 : _a.d; } })(); diff --git a/tests/baselines/reference/optionalParamReferencingOtherParams2.errors.txt b/tests/baselines/reference/optionalParamReferencingOtherParams2.errors.txt index 9061b457b96..4e6f2c1e6c0 100644 --- a/tests/baselines/reference/optionalParamReferencingOtherParams2.errors.txt +++ b/tests/baselines/reference/optionalParamReferencingOtherParams2.errors.txt @@ -1,11 +1,11 @@ -optionalParamReferencingOtherParams2.ts(2,29): error TS2373: Parameter 'y' cannot reference identifier 'b' declared after it. +optionalParamReferencingOtherParams2.ts(2,29): error TS2304: Cannot find name 'b'. ==== optionalParamReferencingOtherParams2.ts (1 errors) ==== var a = 1; function strange(x = a, y = b) { ~ -!!! error TS2373: Parameter 'y' cannot reference identifier 'b' declared after it. +!!! error TS2304: Cannot find name 'b'. var b = ""; return y; } \ No newline at end of file diff --git a/tests/baselines/reference/optionalParamReferencingOtherParams2.symbols b/tests/baselines/reference/optionalParamReferencingOtherParams2.symbols index 6e157712557..09cbc15ae24 100644 --- a/tests/baselines/reference/optionalParamReferencingOtherParams2.symbols +++ b/tests/baselines/reference/optionalParamReferencingOtherParams2.symbols @@ -9,7 +9,6 @@ function strange(x = a, y = b) { >x : Symbol(x, Decl(optionalParamReferencingOtherParams2.ts, 1, 17)) >a : Symbol(a, Decl(optionalParamReferencingOtherParams2.ts, 0, 3)) >y : Symbol(y, Decl(optionalParamReferencingOtherParams2.ts, 1, 23)) ->b : Symbol(b, Decl(optionalParamReferencingOtherParams2.ts, 2, 7)) var b = ""; >b : Symbol(b, Decl(optionalParamReferencingOtherParams2.ts, 2, 7)) diff --git a/tests/baselines/reference/optionalParamReferencingOtherParams2.types b/tests/baselines/reference/optionalParamReferencingOtherParams2.types index 4c4d1d9aebf..f69088f4739 100644 --- a/tests/baselines/reference/optionalParamReferencingOtherParams2.types +++ b/tests/baselines/reference/optionalParamReferencingOtherParams2.types @@ -8,16 +8,16 @@ var a = 1; > : ^ function strange(x = a, y = b) { ->strange : (x?: number, y?: string) => string -> : ^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ +>strange : (x?: number, y?: any) => any +> : ^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^ >x : number > : ^^^^^^ >a : number > : ^^^^^^ ->y : string -> : ^^^^^^ ->b : string -> : ^^^^^^ +>y : any +> : ^^^ +>b : any +> : ^^^ var b = ""; >b : string @@ -26,6 +26,6 @@ function strange(x = a, y = b) { > : ^^ return y; ->y : string -> : ^^^^^^ +>y : any +> : ^^^ } diff --git a/tests/baselines/reference/parameterInitializersForwardReferencing.errors.txt b/tests/baselines/reference/parameterInitializersForwardReferencing.errors.txt index e9738950e84..cbad689b127 100644 --- a/tests/baselines/reference/parameterInitializersForwardReferencing.errors.txt +++ b/tests/baselines/reference/parameterInitializersForwardReferencing.errors.txt @@ -1,16 +1,15 @@ parameterInitializersForwardReferencing.ts(6,20): error TS2373: Parameter 'a' cannot reference identifier 'b' declared after it. parameterInitializersForwardReferencing.ts(11,21): error TS2373: Parameter 'a' cannot reference identifier 'b' declared after it. parameterInitializersForwardReferencing.ts(11,28): error TS2373: Parameter 'b' cannot reference identifier 'c' declared after it. -parameterInitializersForwardReferencing.ts(17,21): error TS2373: Parameter 'a' cannot reference identifier 'b' declared after it. -parameterInitializersForwardReferencing.ts(23,25): error TS2373: Parameter 'a' cannot reference identifier 'b' declared after it. +parameterInitializersForwardReferencing.ts(17,21): error TS2304: Cannot find name 'b'. parameterInitializersForwardReferencing.ts(32,21): error TS2373: Parameter 'a' cannot reference identifier 'b' declared after it. parameterInitializersForwardReferencing.ts(33,16): error TS2373: Parameter 'a' cannot reference identifier 'b' declared after it. parameterInitializersForwardReferencing.ts(37,14): error TS2373: Parameter 'a' cannot reference identifier 'b' declared after it. parameterInitializersForwardReferencing.ts(37,21): error TS2373: Parameter 'b' cannot reference identifier 'c' declared after it. -parameterInitializersForwardReferencing.ts(37,28): error TS2373: Parameter 'c' cannot reference identifier 'd' declared after it. +parameterInitializersForwardReferencing.ts(37,28): error TS2304: Cannot find name 'd'. -==== parameterInitializersForwardReferencing.ts (10 errors) ==== +==== parameterInitializersForwardReferencing.ts (9 errors) ==== function left(a, b = a, c = b) { a; b; @@ -35,15 +34,13 @@ parameterInitializersForwardReferencing.ts(37,28): error TS2373: Parameter 'c' c function inside(a = b) { ~ -!!! error TS2373: Parameter 'a' cannot reference identifier 'b' declared after it. +!!! error TS2304: Cannot find name 'b'. var b; } function outside() { var b; function inside(a = b) { // Still an error because b is declared inside the function - ~ -!!! error TS2373: Parameter 'a' cannot reference identifier 'b' declared after it. var b; } } @@ -67,7 +64,7 @@ parameterInitializersForwardReferencing.ts(37,28): error TS2373: Parameter 'c' c ~ !!! error TS2373: Parameter 'b' cannot reference identifier 'c' declared after it. ~ -!!! error TS2373: Parameter 'c' cannot reference identifier 'd' declared after it. +!!! error TS2304: Cannot find name 'd'. // Should not produce errors - can reference later parameters if they occur within a function expression initializer. function f(a, b = function () { return c; }, c = b()) { diff --git a/tests/baselines/reference/parameterInitializersForwardReferencing.symbols b/tests/baselines/reference/parameterInitializersForwardReferencing.symbols index cdcb05dc6ba..8c95d445495 100644 --- a/tests/baselines/reference/parameterInitializersForwardReferencing.symbols +++ b/tests/baselines/reference/parameterInitializersForwardReferencing.symbols @@ -52,7 +52,6 @@ function right2(a = b, b = c, c = a) { function inside(a = b) { >inside : Symbol(inside, Decl(parameterInitializersForwardReferencing.ts, 14, 1)) >a : Symbol(a, Decl(parameterInitializersForwardReferencing.ts, 16, 16)) ->b : Symbol(b, Decl(parameterInitializersForwardReferencing.ts, 17, 7)) var b; >b : Symbol(b, Decl(parameterInitializersForwardReferencing.ts, 17, 7)) @@ -67,7 +66,7 @@ function outside() { function inside(a = b) { // Still an error because b is declared inside the function >inside : Symbol(inside, Decl(parameterInitializersForwardReferencing.ts, 21, 10)) >a : Symbol(a, Decl(parameterInitializersForwardReferencing.ts, 22, 20)) ->b : Symbol(b, Decl(parameterInitializersForwardReferencing.ts, 23, 11)) +>b : Symbol(b, Decl(parameterInitializersForwardReferencing.ts, 21, 7)) var b; >b : Symbol(b, Decl(parameterInitializersForwardReferencing.ts, 23, 11)) @@ -110,7 +109,6 @@ var x = (a = b, b = c, c = d) => { var d; }; >c : Symbol(c, Decl(parameterInitializersForwardReferencing.ts, 36, 22)) >c : Symbol(c, Decl(parameterInitializersForwardReferencing.ts, 36, 22)) >d : Symbol(d, Decl(parameterInitializersForwardReferencing.ts, 36, 38)) ->d : Symbol(d, Decl(parameterInitializersForwardReferencing.ts, 36, 38)) // Should not produce errors - can reference later parameters if they occur within a function expression initializer. function f(a, b = function () { return c; }, c = b()) { diff --git a/tests/baselines/reference/parameterInitializersForwardReferencing1.errors.txt b/tests/baselines/reference/parameterInitializersForwardReferencing1.errors.txt index e8b2b856f29..9f393f33488 100644 --- a/tests/baselines/reference/parameterInitializersForwardReferencing1.errors.txt +++ b/tests/baselines/reference/parameterInitializersForwardReferencing1.errors.txt @@ -1,17 +1,13 @@ -parameterInitializersForwardReferencing1.ts(3,20): error TS2373: Parameter 'bar' cannot reference identifier 'foo' declared after it. parameterInitializersForwardReferencing1.ts(13,20): error TS2373: Parameter 'bar' cannot reference identifier 'foo' declared after it. parameterInitializersForwardReferencing1.ts(21,18): error TS2372: Parameter 'a' cannot reference itself. parameterInitializersForwardReferencing1.ts(25,22): error TS2372: Parameter 'async' cannot reference itself. -parameterInitializersForwardReferencing1.ts(29,15): error TS2373: Parameter '{[foo]: bar}' cannot reference identifier 'foo' declared after it. -parameterInitializersForwardReferencing1.ts(29,15): error TS2448: Block-scoped variable 'foo' used before its declaration. +parameterInitializersForwardReferencing1.ts(29,15): error TS2537: Type 'any[]' has no matching index signature for type 'string'. -==== parameterInitializersForwardReferencing1.ts (6 errors) ==== +==== parameterInitializersForwardReferencing1.ts (4 errors) ==== let foo: string = ""; function f1 (bar = foo) { // unexpected compiler error; works at runtime - ~~~ -!!! error TS2373: Parameter 'bar' cannot reference identifier 'foo' declared after it. var foo: number = 2; return bar; // returns 1 } @@ -45,10 +41,7 @@ parameterInitializersForwardReferencing1.ts(29,15): error TS2448: Block-scoped v function f7({[foo]: bar}: any[]) { ~~~ -!!! error TS2373: Parameter '{[foo]: bar}' cannot reference identifier 'foo' declared after it. - ~~~ -!!! error TS2448: Block-scoped variable 'foo' used before its declaration. -!!! related TS2728 parameterInitializersForwardReferencing1.ts:30:9: 'foo' is declared here. +!!! error TS2537: Type 'any[]' has no matching index signature for type 'string'. let foo: number = 2; } diff --git a/tests/baselines/reference/parameterInitializersForwardReferencing1.symbols b/tests/baselines/reference/parameterInitializersForwardReferencing1.symbols index efadc19e5d0..76ef0ee99bc 100644 --- a/tests/baselines/reference/parameterInitializersForwardReferencing1.symbols +++ b/tests/baselines/reference/parameterInitializersForwardReferencing1.symbols @@ -7,7 +7,7 @@ let foo: string = ""; function f1 (bar = foo) { // unexpected compiler error; works at runtime >f1 : Symbol(f1, Decl(parameterInitializersForwardReferencing1.ts, 0, 21)) >bar : Symbol(bar, Decl(parameterInitializersForwardReferencing1.ts, 2, 13)) ->foo : Symbol(foo, Decl(parameterInitializersForwardReferencing1.ts, 3, 7)) +>foo : Symbol(foo, Decl(parameterInitializersForwardReferencing1.ts, 0, 3)) var foo: number = 2; >foo : Symbol(foo, Decl(parameterInitializersForwardReferencing1.ts, 3, 7)) @@ -20,7 +20,7 @@ function f2 (bar = (baz = foo) => baz) { // unexpected compiler error; works at >f2 : Symbol(f2, Decl(parameterInitializersForwardReferencing1.ts, 5, 1)) >bar : Symbol(bar, Decl(parameterInitializersForwardReferencing1.ts, 7, 13)) >baz : Symbol(baz, Decl(parameterInitializersForwardReferencing1.ts, 7, 20)) ->foo : Symbol(foo, Decl(parameterInitializersForwardReferencing1.ts, 8, 7)) +>foo : Symbol(foo, Decl(parameterInitializersForwardReferencing1.ts, 0, 3)) >baz : Symbol(baz, Decl(parameterInitializersForwardReferencing1.ts, 7, 20)) var foo: number = 2; @@ -70,7 +70,7 @@ function f6 (async = async) { function f7({[foo]: bar}: any[]) { >f7 : Symbol(f7, Decl(parameterInitializersForwardReferencing1.ts, 26, 1)) ->foo : Symbol(foo, Decl(parameterInitializersForwardReferencing1.ts, 29, 7)) +>foo : Symbol(foo, Decl(parameterInitializersForwardReferencing1.ts, 0, 3)) >bar : Symbol(bar, Decl(parameterInitializersForwardReferencing1.ts, 28, 13)) let foo: number = 2; diff --git a/tests/baselines/reference/parameterInitializersForwardReferencing1.types b/tests/baselines/reference/parameterInitializersForwardReferencing1.types index f18d9ae0f49..07780a722b1 100644 --- a/tests/baselines/reference/parameterInitializersForwardReferencing1.types +++ b/tests/baselines/reference/parameterInitializersForwardReferencing1.types @@ -8,11 +8,11 @@ let foo: string = ""; > : ^^ function f1 (bar = foo) { // unexpected compiler error; works at runtime ->f1 : (bar?: number) => number +>f1 : (bar?: string) => string > : ^ ^^^^^^^^^^^^^^^^^^^^ ->bar : number +>bar : string > : ^^^^^^ ->foo : number +>foo : string > : ^^^^^^ var foo: number = 2; @@ -22,22 +22,22 @@ function f1 (bar = foo) { // unexpected compiler error; works at runtime > : ^ return bar; // returns 1 ->bar : number +>bar : string > : ^^^^^^ } function f2 (bar = (baz = foo) => baz) { // unexpected compiler error; works at runtime ->f2 : (bar?: (baz?: number) => number) => number +>f2 : (bar?: (baz?: string) => string) => string > : ^ ^^^^ ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->bar : (baz?: number) => number +>bar : (baz?: string) => string > : ^ ^^^^^^^^^^^^^^^^^^^^ ->(baz = foo) => baz : (baz?: number) => number +>(baz = foo) => baz : (baz?: string) => string > : ^ ^^^^^^^^^^^^^^^^^^^^ ->baz : number +>baz : string > : ^^^^^^ ->foo : number +>foo : string > : ^^^^^^ ->baz : number +>baz : string > : ^^^^^^ var foo: number = 2; @@ -47,9 +47,9 @@ function f2 (bar = (baz = foo) => baz) { // unexpected compiler error; works at > : ^ return bar(); // returns 1 ->bar() : number +>bar() : string > : ^^^^^^ ->bar : (baz?: number) => number +>bar : (baz?: string) => string > : ^ ^^^^^^^^^^^^^^^^^^^^ } @@ -114,7 +114,7 @@ function f6 (async = async) { function f7({[foo]: bar}: any[]) { >f7 : ({ [foo]: bar }: any[]) => void > : ^ ^^ ^^^^^^^^^ ->foo : number +>foo : string > : ^^^^^^ >bar : any > : ^^^ diff --git a/tests/baselines/reference/quickIntersectionCheckCorrectlyCachesErrors.js b/tests/baselines/reference/quickIntersectionCheckCorrectlyCachesErrors.js index bf9f9d3a3f2..97135a13474 100644 --- a/tests/baselines/reference/quickIntersectionCheckCorrectlyCachesErrors.js +++ b/tests/baselines/reference/quickIntersectionCheckCorrectlyCachesErrors.js @@ -18,24 +18,13 @@ export function wu(CC: F) { //// [quickIntersectionCheckCorrectlyCachesErrors.js] "use strict"; -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; Object.defineProperty(exports, "__esModule", { value: true }); exports.wu = wu; function wu(CC) { class WU { m() { g(CC); - return React.createElement(CC, __assign({}, null)); + return React.createElement(CC, Object.assign({}, null)); } } } diff --git a/tests/baselines/reference/reactHOCSpreadprops.js b/tests/baselines/reference/reactHOCSpreadprops.js index b9117b47169..e8624e04257 100644 --- a/tests/baselines/reference/reactHOCSpreadprops.js +++ b/tests/baselines/reference/reactHOCSpreadprops.js @@ -14,24 +14,13 @@ function f

(App: React.ComponentClass

| React.StatelessComponent

): void //// [reactHOCSpreadprops.js] "use strict"; -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; Object.defineProperty(exports, "__esModule", { value: true }); /// const React = require("react"); function f(App) { class C extends React.Component { render() { - return React.createElement(App, __assign({}, this.props)); + return React.createElement(App, Object.assign({}, this.props)); } } } diff --git a/tests/baselines/reference/reactNamespaceJSXEmit.js b/tests/baselines/reference/reactNamespaceJSXEmit.js index bbacb893386..ea4baf619b9 100644 --- a/tests/baselines/reference/reactNamespaceJSXEmit.js +++ b/tests/baselines/reference/reactNamespaceJSXEmit.js @@ -16,20 +16,9 @@ declare var x: any; //// [reactNamespaceJSXEmit.js] -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; myReactLib.createElement("foo", { data: true }); myReactLib.createElement(Bar, { x: x }); myReactLib.createElement("x-component", null); -myReactLib.createElement(Bar, __assign({}, x)); -myReactLib.createElement(Bar, __assign({}, x, { y: 2 })); -myReactLib.createElement(_Bar, __assign({}, x)); +myReactLib.createElement(Bar, Object.assign({}, x)); +myReactLib.createElement(Bar, Object.assign({}, x, { y: 2 })); +myReactLib.createElement(_Bar, Object.assign({}, x)); diff --git a/tests/baselines/reference/reactReadonlyHOCAssignabilityReal.js b/tests/baselines/reference/reactReadonlyHOCAssignabilityReal.js index 398c6067ee0..e406aa4de26 100644 --- a/tests/baselines/reference/reactReadonlyHOCAssignabilityReal.js +++ b/tests/baselines/reference/reactReadonlyHOCAssignabilityReal.js @@ -14,24 +14,13 @@ function myHigherOrderComponent

(Inner: React.ComponentClass

const React = require("react"); function myHigherOrderComponent(Inner) { return class OuterComponent extends React.Component { render() { - return React.createElement(Inner, __assign({}, this.props, { name: "Matt" })); + return React.createElement(Inner, Object.assign({}, this.props, { name: "Matt" })); } }; } diff --git a/tests/baselines/reference/reactTagNameComponentWithPropsNoOOM.js b/tests/baselines/reference/reactTagNameComponentWithPropsNoOOM.js index 07eb8f5ce77..5fd35f09b53 100644 --- a/tests/baselines/reference/reactTagNameComponentWithPropsNoOOM.js +++ b/tests/baselines/reference/reactTagNameComponentWithPropsNoOOM.js @@ -16,20 +16,9 @@ const children: any[] = []; //// [reactTagNameComponentWithPropsNoOOM.js] "use strict"; /// -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; Object.defineProperty(exports, "__esModule", { value: true }); const React = require("react"); const classes = ""; const rest = {}; const children = []; -React.createElement(Tag, __assign({ className: classes }, rest), children); +React.createElement(Tag, Object.assign({ className: classes }, rest), children); diff --git a/tests/baselines/reference/reactTagNameComponentWithPropsNoOOM2.js b/tests/baselines/reference/reactTagNameComponentWithPropsNoOOM2.js index f7ab3ffc655..89f465b3de7 100644 --- a/tests/baselines/reference/reactTagNameComponentWithPropsNoOOM2.js +++ b/tests/baselines/reference/reactTagNameComponentWithPropsNoOOM2.js @@ -16,20 +16,9 @@ const children: any[] = []; //// [reactTagNameComponentWithPropsNoOOM2.js] "use strict"; /// -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; Object.defineProperty(exports, "__esModule", { value: true }); const React = require("react"); const classes = ""; const rest = {}; const children = []; -React.createElement(Tag, __assign({ className: classes }, rest), children); +React.createElement(Tag, Object.assign({ className: classes }, rest), children); diff --git a/tests/baselines/reference/reverseMappedTypeIntersectionConstraint.js b/tests/baselines/reference/reverseMappedTypeIntersectionConstraint.js index 2a19678e5f5..e2749d9ea4c 100644 --- a/tests/baselines/reference/reverseMappedTypeIntersectionConstraint.js +++ b/tests/baselines/reference/reverseMappedTypeIntersectionConstraint.js @@ -177,17 +177,6 @@ const config2 = createXMachine({ //// [reverseMappedTypeIntersectionConstraint.js] "use strict"; -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; const inferredParams1 = createMachine({ entry: "foo", states: { @@ -238,7 +227,7 @@ function bar(props) { return foo(props); // no error because lack of excess property check by design } foo({ x: 1, y: 'foo' }); -foo(__assign({ x: 1, y: 'foo' })); // no error because lack of excess property check by design +foo(Object.assign({ x: 1, y: 'foo' })); // no error because lack of excess property check by design baz({ x: 1 }); baz({ x: 1, z: 123 }); baz({ x: 1, y: 'foo' }); diff --git a/tests/baselines/reference/spreadContextualTypedBindingPattern.js b/tests/baselines/reference/spreadContextualTypedBindingPattern.js index fa896d28775..8a4153b22f6 100644 --- a/tests/baselines/reference/spreadContextualTypedBindingPattern.js +++ b/tests/baselines/reference/spreadContextualTypedBindingPattern.js @@ -15,16 +15,5 @@ const { naam, age } = {...bob, ...alice} //// [spreadContextualTypedBindingPattern.js] -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; // [ts] Initializer provides no value for this binding element and the binding element has no default value. -const { naam, age } = __assign(__assign({}, bob), alice); +const { naam, age } = Object.assign(Object.assign({}, bob), alice); diff --git a/tests/baselines/reference/spreadDuplicate.js b/tests/baselines/reference/spreadDuplicate.js index 124cc13306f..76a4788551e 100644 --- a/tests/baselines/reference/spreadDuplicate.js +++ b/tests/baselines/reference/spreadDuplicate.js @@ -24,25 +24,14 @@ let d2 = { a: 123, ...(t ? d : {}) }; // string | number //// [spreadDuplicate.js] "use strict"; // Repro from #44438 -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; -let a1 = __assign({ a: 123 }, a); // string (Error) -let b1 = __assign({ a: 123 }, b); // string | number -let c1 = __assign({ a: 123 }, c); // string | undefined (Error) -let d1 = __assign({ a: 123 }, d); // string | number -let a2 = __assign({ a: 123 }, (t ? a : {})); // string | number -let b2 = __assign({ a: 123 }, (t ? b : {})); // string | number -let c2 = __assign({ a: 123 }, (t ? c : {})); // string | number -let d2 = __assign({ a: 123 }, (t ? d : {})); // string | number +let a1 = Object.assign({ a: 123 }, a); // string (Error) +let b1 = Object.assign({ a: 123 }, b); // string | number +let c1 = Object.assign({ a: 123 }, c); // string | undefined (Error) +let d1 = Object.assign({ a: 123 }, d); // string | number +let a2 = Object.assign({ a: 123 }, (t ? a : {})); // string | number +let b2 = Object.assign({ a: 123 }, (t ? b : {})); // string | number +let c2 = Object.assign({ a: 123 }, (t ? c : {})); // string | number +let d2 = Object.assign({ a: 123 }, (t ? d : {})); // string | number //// [spreadDuplicate.d.ts] diff --git a/tests/baselines/reference/spreadDuplicateExact.js b/tests/baselines/reference/spreadDuplicateExact.js index 6d5fa4d671d..4792617b846 100644 --- a/tests/baselines/reference/spreadDuplicateExact.js +++ b/tests/baselines/reference/spreadDuplicateExact.js @@ -24,25 +24,14 @@ let d2 = { a: 123, ...(t ? d : {}) }; // string | number | undefined //// [spreadDuplicateExact.js] "use strict"; // Repro from #44438 -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; -let a1 = __assign({ a: 123 }, a); // string (Error) -let b1 = __assign({ a: 123 }, b); // string | number -let c1 = __assign({ a: 123 }, c); // string | undefined (Error) -let d1 = __assign({ a: 123 }, d); // string | number | undefined -let a2 = __assign({ a: 123 }, (t ? a : {})); // string | number -let b2 = __assign({ a: 123 }, (t ? b : {})); // string | number -let c2 = __assign({ a: 123 }, (t ? c : {})); // string | number | undefined -let d2 = __assign({ a: 123 }, (t ? d : {})); // string | number | undefined +let a1 = Object.assign({ a: 123 }, a); // string (Error) +let b1 = Object.assign({ a: 123 }, b); // string | number +let c1 = Object.assign({ a: 123 }, c); // string | undefined (Error) +let d1 = Object.assign({ a: 123 }, d); // string | number | undefined +let a2 = Object.assign({ a: 123 }, (t ? a : {})); // string | number +let b2 = Object.assign({ a: 123 }, (t ? b : {})); // string | number +let c2 = Object.assign({ a: 123 }, (t ? c : {})); // string | number | undefined +let d2 = Object.assign({ a: 123 }, (t ? d : {})); // string | number | undefined //// [spreadDuplicateExact.d.ts] diff --git a/tests/baselines/reference/spreadExcessProperty.js b/tests/baselines/reference/spreadExcessProperty.js index 19898b769ee..5c7a3f0b3c0 100644 --- a/tests/baselines/reference/spreadExcessProperty.js +++ b/tests/baselines/reference/spreadExcessProperty.js @@ -7,16 +7,5 @@ const a1: A = { ...extra1 }; // spread should not give excess property errors //// [spreadExcessProperty.js] -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; const extra1 = { a: "a", b: "b", extra: "extra" }; -const a1 = __assign({}, extra1); // spread should not give excess property errors +const a1 = Object.assign({}, extra1); // spread should not give excess property errors diff --git a/tests/baselines/reference/spreadExpressionContextualType.js b/tests/baselines/reference/spreadExpressionContextualType.js index 13cb97cba4e..e14361fa01f 100644 --- a/tests/baselines/reference/spreadExpressionContextualType.js +++ b/tests/baselines/reference/spreadExpressionContextualType.js @@ -24,22 +24,11 @@ function test2(item: T): T { //// [spreadExpressionContextualType.js] "use strict"; // Repro from #43966 -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; function test(item) { - return __assign({}, item); + return Object.assign({}, item); } function test2(item) { - const x = __assign({}, item); + const x = Object.assign({}, item); return x; } diff --git a/tests/baselines/reference/spreadExpressionContextualTypeWithNamespace.js b/tests/baselines/reference/spreadExpressionContextualTypeWithNamespace.js index 58620e049f4..3996f0bb465 100644 --- a/tests/baselines/reference/spreadExpressionContextualTypeWithNamespace.js +++ b/tests/baselines/reference/spreadExpressionContextualTypeWithNamespace.js @@ -50,17 +50,6 @@ exports.obj = obj; function exportedDirectly() { } //// [spreadExpressionContextualTypeWithNamespace_1.js] "use strict"; -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; Object.defineProperty(exports, "__esModule", { value: true }); const stuff = require("./spreadExpressionContextualTypeWithNamespace_0"); stuff.func; @@ -68,7 +57,7 @@ stuff.klass; stuff.obj; stuff.exportedDirectly; function getStuff() { - const thing = __assign({}, stuff); + const thing = Object.assign({}, stuff); thing.func; thing.klass; thing.obj; diff --git a/tests/baselines/reference/spreadIdenticalTypesRemoved.js b/tests/baselines/reference/spreadIdenticalTypesRemoved.js index 7efa77f1afb..d366ff7c558 100644 --- a/tests/baselines/reference/spreadIdenticalTypesRemoved.js +++ b/tests/baselines/reference/spreadIdenticalTypesRemoved.js @@ -31,20 +31,9 @@ function billOwner(pet: Animal2) { //// [spreadIdenticalTypesRemoved.js] "use strict"; -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; function clonePet(pet, fullCopy) { - return __assign({ name: pet.name, kind: pet.kind }, (fullCopy && pet)); + return Object.assign({ name: pet.name, kind: pet.kind }, (fullCopy && pet)); } function billOwner(pet) { - return __assign(__assign({}, (pet.owner && pet)), { paid: false }); + return Object.assign(Object.assign({}, (pet.owner && pet)), { paid: false }); } diff --git a/tests/baselines/reference/spreadIntersection.js b/tests/baselines/reference/spreadIntersection.js index fe2bcebcefd..202b97d9dbf 100644 --- a/tests/baselines/reference/spreadIntersection.js +++ b/tests/baselines/reference/spreadIntersection.js @@ -10,19 +10,8 @@ var o2: { a: number, b: string, c: boolean }; var o2 = { ...intersection, c: false }; //// [spreadIntersection.js] -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; var intersection; var o1; -var o1 = __assign({}, intersection); +var o1 = Object.assign({}, intersection); var o2; -var o2 = __assign(__assign({}, intersection), { c: false }); +var o2 = Object.assign(Object.assign({}, intersection), { c: false }); diff --git a/tests/baselines/reference/spreadIntersectionJsx.js b/tests/baselines/reference/spreadIntersectionJsx.js index eb034023a29..68d5c2662c4 100644 --- a/tests/baselines/reference/spreadIntersectionJsx.js +++ b/tests/baselines/reference/spreadIntersectionJsx.js @@ -9,21 +9,10 @@ let element =

; //// [spreadIntersectionJsx.js] -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; const React = null; class A { } class C { } let intersected; -let element = React.createElement("div", __assign({}, intersected)); +let element = React.createElement("div", Object.assign({}, intersected)); diff --git a/tests/baselines/reference/spreadInvalidArgumentType.js b/tests/baselines/reference/spreadInvalidArgumentType.js index 9bb5ccfb954..f2250b6d0c1 100644 --- a/tests/baselines/reference/spreadInvalidArgumentType.js +++ b/tests/baselines/reference/spreadInvalidArgumentType.js @@ -60,17 +60,6 @@ function f(p1: T, p2: T[]) { //// [spreadInvalidArgumentType.js] -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; var E; (function (E) { E[E["v1"] = 0] = "v1"; @@ -95,23 +84,23 @@ function f(p1, p2) { var n; var a; var e; - var o1 = __assign({}, p1); // OK, generic type paramterre - var o2 = __assign({}, p2); // OK - var o3 = __assign({}, t); // OK, generic type paramter - var o4 = __assign({}, i); // Error, index access - var o5 = __assign({}, k); // Error, index - var o6 = __assign({}, mapped_generic); // OK, generic mapped object type - var o7 = __assign({}, mapped); // OK, non-generic mapped type - var o8 = __assign({}, union_generic); // OK, union with generic type parameter - var o9 = __assign({}, union_primitive); // Error, union with generic type parameter - var o10 = __assign({}, intersection_generic); // OK, intersection with generic type parameter - var o11 = __assign({}, intersection_primitive); // Error, intersection with generic type parameter - var o12 = __assign({}, num); // Error - var o13 = __assign({}, str); // Error - var o14 = __assign({}, u); // error, undefined-only not allowed - var o15 = __assign({}, n); // error, null-only not allowed - var o16 = __assign({}, a); // OK - var o17 = __assign({}, literal_string); // Error - var o18 = __assign({}, literal_number); // Error - var o19 = __assign({}, e); // Error, enum + var o1 = Object.assign({}, p1); // OK, generic type paramterre + var o2 = Object.assign({}, p2); // OK + var o3 = Object.assign({}, t); // OK, generic type paramter + var o4 = Object.assign({}, i); // Error, index access + var o5 = Object.assign({}, k); // Error, index + var o6 = Object.assign({}, mapped_generic); // OK, generic mapped object type + var o7 = Object.assign({}, mapped); // OK, non-generic mapped type + var o8 = Object.assign({}, union_generic); // OK, union with generic type parameter + var o9 = Object.assign({}, union_primitive); // Error, union with generic type parameter + var o10 = Object.assign({}, intersection_generic); // OK, intersection with generic type parameter + var o11 = Object.assign({}, intersection_primitive); // Error, intersection with generic type parameter + var o12 = Object.assign({}, num); // Error + var o13 = Object.assign({}, str); // Error + var o14 = Object.assign({}, u); // error, undefined-only not allowed + var o15 = Object.assign({}, n); // error, null-only not allowed + var o16 = Object.assign({}, a); // OK + var o17 = Object.assign({}, literal_string); // Error + var o18 = Object.assign({}, literal_number); // Error + var o19 = Object.assign({}, e); // Error, enum } diff --git a/tests/baselines/reference/spreadNonPrimitive.js b/tests/baselines/reference/spreadNonPrimitive.js index 8c89051ad77..e361a463481 100644 --- a/tests/baselines/reference/spreadNonPrimitive.js +++ b/tests/baselines/reference/spreadNonPrimitive.js @@ -6,15 +6,4 @@ const x: { a: number, b: number } = { a: 1, ...o, b: 2 }; //// [spreadNonPrimitive.js] -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; -const x = __assign(__assign({ a: 1 }, o), { b: 2 }); +const x = Object.assign(Object.assign({ a: 1 }, o), { b: 2 }); diff --git a/tests/baselines/reference/spreadObjectOrFalsy.js b/tests/baselines/reference/spreadObjectOrFalsy.js index 74c76a287e7..fee6a125063 100644 --- a/tests/baselines/reference/spreadObjectOrFalsy.js +++ b/tests/baselines/reference/spreadObjectOrFalsy.js @@ -55,39 +55,28 @@ class Foo { //// [spreadObjectOrFalsy.js] "use strict"; -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; function f1(a) { - return __assign({}, a); // Error + return Object.assign({}, a); // Error } function f2(a) { - return __assign({}, a); + return Object.assign({}, a); } function f3(a) { - return __assign({}, a); // Error + return Object.assign({}, a); // Error } function f4(a) { - return __assign({}, a); + return Object.assign({}, a); } function f5(a) { - return __assign({}, a); + return Object.assign({}, a); } function f6(a) { - return __assign({}, a); + return Object.assign({}, a); } // Repro from #46976 function g1(a) { const { z } = a; - return __assign({}, z); + return Object.assign({}, z); } class Foo { bar() { diff --git a/tests/baselines/reference/spreadObjectPermutations(exactoptionalpropertytypes=false).js b/tests/baselines/reference/spreadObjectPermutations(exactoptionalpropertytypes=false).js index 81b077c7adf..4f2e773772f 100644 --- a/tests/baselines/reference/spreadObjectPermutations(exactoptionalpropertytypes=false).js +++ b/tests/baselines/reference/spreadObjectPermutations(exactoptionalpropertytypes=false).js @@ -24,29 +24,18 @@ const v_cba = { ...c, ...b, ...a }; //// [spreadObjectPermutations.js] "use strict"; -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; -const v_a = __assign({}, a); -const v_b = __assign({}, b); -const v_c = __assign({}, c); -const v_ab = __assign(__assign({}, a), b); -const v_ac = __assign(__assign({}, a), c); -const v_ba = __assign(__assign({}, b), a); -const v_bc = __assign(__assign({}, b), c); -const v_ca = __assign(__assign({}, c), a); -const v_cb = __assign(__assign({}, c), b); -const v_abc = __assign(__assign(__assign({}, a), b), c); -const v_acb = __assign(__assign(__assign({}, a), c), b); -const v_bac = __assign(__assign(__assign({}, b), a), c); -const v_bca = __assign(__assign(__assign({}, b), c), a); -const v_cab = __assign(__assign(__assign({}, c), a), b); -const v_cba = __assign(__assign(__assign({}, c), b), a); +const v_a = Object.assign({}, a); +const v_b = Object.assign({}, b); +const v_c = Object.assign({}, c); +const v_ab = Object.assign(Object.assign({}, a), b); +const v_ac = Object.assign(Object.assign({}, a), c); +const v_ba = Object.assign(Object.assign({}, b), a); +const v_bc = Object.assign(Object.assign({}, b), c); +const v_ca = Object.assign(Object.assign({}, c), a); +const v_cb = Object.assign(Object.assign({}, c), b); +const v_abc = Object.assign(Object.assign(Object.assign({}, a), b), c); +const v_acb = Object.assign(Object.assign(Object.assign({}, a), c), b); +const v_bac = Object.assign(Object.assign(Object.assign({}, b), a), c); +const v_bca = Object.assign(Object.assign(Object.assign({}, b), c), a); +const v_cab = Object.assign(Object.assign(Object.assign({}, c), a), b); +const v_cba = Object.assign(Object.assign(Object.assign({}, c), b), a); diff --git a/tests/baselines/reference/spreadObjectPermutations(exactoptionalpropertytypes=true).js b/tests/baselines/reference/spreadObjectPermutations(exactoptionalpropertytypes=true).js index 81b077c7adf..4f2e773772f 100644 --- a/tests/baselines/reference/spreadObjectPermutations(exactoptionalpropertytypes=true).js +++ b/tests/baselines/reference/spreadObjectPermutations(exactoptionalpropertytypes=true).js @@ -24,29 +24,18 @@ const v_cba = { ...c, ...b, ...a }; //// [spreadObjectPermutations.js] "use strict"; -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; -const v_a = __assign({}, a); -const v_b = __assign({}, b); -const v_c = __assign({}, c); -const v_ab = __assign(__assign({}, a), b); -const v_ac = __assign(__assign({}, a), c); -const v_ba = __assign(__assign({}, b), a); -const v_bc = __assign(__assign({}, b), c); -const v_ca = __assign(__assign({}, c), a); -const v_cb = __assign(__assign({}, c), b); -const v_abc = __assign(__assign(__assign({}, a), b), c); -const v_acb = __assign(__assign(__assign({}, a), c), b); -const v_bac = __assign(__assign(__assign({}, b), a), c); -const v_bca = __assign(__assign(__assign({}, b), c), a); -const v_cab = __assign(__assign(__assign({}, c), a), b); -const v_cba = __assign(__assign(__assign({}, c), b), a); +const v_a = Object.assign({}, a); +const v_b = Object.assign({}, b); +const v_c = Object.assign({}, c); +const v_ab = Object.assign(Object.assign({}, a), b); +const v_ac = Object.assign(Object.assign({}, a), c); +const v_ba = Object.assign(Object.assign({}, b), a); +const v_bc = Object.assign(Object.assign({}, b), c); +const v_ca = Object.assign(Object.assign({}, c), a); +const v_cb = Object.assign(Object.assign({}, c), b); +const v_abc = Object.assign(Object.assign(Object.assign({}, a), b), c); +const v_acb = Object.assign(Object.assign(Object.assign({}, a), c), b); +const v_bac = Object.assign(Object.assign(Object.assign({}, b), a), c); +const v_bca = Object.assign(Object.assign(Object.assign({}, b), c), a); +const v_cab = Object.assign(Object.assign(Object.assign({}, c), a), b); +const v_cba = Object.assign(Object.assign(Object.assign({}, c), b), a); diff --git a/tests/baselines/reference/spreadObjectWithIndexDoesNotAddUndefinedToLocalIndex.js b/tests/baselines/reference/spreadObjectWithIndexDoesNotAddUndefinedToLocalIndex.js index 18990a04bba..9aba8b291a3 100644 --- a/tests/baselines/reference/spreadObjectWithIndexDoesNotAddUndefinedToLocalIndex.js +++ b/tests/baselines/reference/spreadObjectWithIndexDoesNotAddUndefinedToLocalIndex.js @@ -6,15 +6,4 @@ const x: { [k: string]: string } = { ...m, ["a" + "b"]: "" }; //// [spreadObjectWithIndexDoesNotAddUndefinedToLocalIndex.js] "use strict"; -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; -const x = __assign(__assign({}, m), { ["a" + "b"]: "" }); +const x = Object.assign(Object.assign({}, m), { ["a" + "b"]: "" }); diff --git a/tests/baselines/reference/spreadOfObjectLiteralAssignableToIndexSignature.js b/tests/baselines/reference/spreadOfObjectLiteralAssignableToIndexSignature.js index 41e18b5b651..fd22ce6ddc0 100644 --- a/tests/baselines/reference/spreadOfObjectLiteralAssignableToIndexSignature.js +++ b/tests/baselines/reference/spreadOfObjectLiteralAssignableToIndexSignature.js @@ -17,23 +17,12 @@ recordsOfRecordsOrEmpty.propC = {...(foo !== undefined && {foo})} // OK //// [spreadOfObjectLiteralAssignableToIndexSignature.js] "use strict"; -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; const foo = {}; // OK const recordOfRecords = {}; -recordOfRecords.propA = __assign({}, (foo !== undefined ? { foo } : {})); // OK -recordOfRecords.propB = __assign({}, (foo && { foo })); // OK -recordOfRecords.propC = __assign({}, (foo !== undefined && { foo })); // error'd in 3.7 beta, should be OK +recordOfRecords.propA = Object.assign({}, (foo !== undefined ? { foo } : {})); // OK +recordOfRecords.propB = Object.assign({}, (foo && { foo })); // OK +recordOfRecords.propC = Object.assign({}, (foo !== undefined && { foo })); // error'd in 3.7 beta, should be OK const recordsOfRecordsOrEmpty = {}; -recordsOfRecordsOrEmpty.propA = __assign({}, (foo !== undefined ? { foo } : {})); // OK -recordsOfRecordsOrEmpty.propB = __assign({}, (foo && { foo })); // OK -recordsOfRecordsOrEmpty.propC = __assign({}, (foo !== undefined && { foo })); // OK +recordsOfRecordsOrEmpty.propA = Object.assign({}, (foo !== undefined ? { foo } : {})); // OK +recordsOfRecordsOrEmpty.propB = Object.assign({}, (foo && { foo })); // OK +recordsOfRecordsOrEmpty.propC = Object.assign({}, (foo !== undefined && { foo })); // OK diff --git a/tests/baselines/reference/spreadOverwritesProperty.js b/tests/baselines/reference/spreadOverwritesProperty.js index 8a0545073ad..33dfec4535d 100644 --- a/tests/baselines/reference/spreadOverwritesProperty.js +++ b/tests/baselines/reference/spreadOverwritesProperty.js @@ -17,23 +17,12 @@ function h(obj: { x: number }) { //// [spreadOverwritesProperty.js] -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; -var unused1 = __assign({ b: 1 }, ab); -var unused2 = __assign(__assign({}, ab), ab); -var unused3 = __assign({ b: 1 }, abq); +var unused1 = Object.assign({ b: 1 }, ab); +var unused2 = Object.assign(Object.assign({}, ab), ab); +var unused3 = Object.assign({ b: 1 }, abq); function g(obj) { - return __assign({ x: 1 }, obj); + return Object.assign({ x: 1 }, obj); } function h(obj) { - return __assign({ x: 1 }, obj); + return Object.assign({ x: 1 }, obj); } diff --git a/tests/baselines/reference/spreadOverwritesPropertyStrict.js b/tests/baselines/reference/spreadOverwritesPropertyStrict.js index a19550b90b2..8a61a76dc2b 100644 --- a/tests/baselines/reference/spreadOverwritesPropertyStrict.js +++ b/tests/baselines/reference/spreadOverwritesPropertyStrict.js @@ -38,43 +38,32 @@ function m(anyoptional: { a?: any }) { //// [spreadOverwritesPropertyStrict.js] "use strict"; -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; -var unused1 = __assign({ b: 1 }, ab); // error -var unused2 = __assign(__assign({}, ab), ab); // ok, overwritten error doesn't apply to spreads -var unused3 = __assign({ b: 1 }, abq); // ok, abq might have b: undefined -var unused4 = __assign(__assign({}, ab), { b: 1 }); // ok, we don't care that b in ab is overwritten -var unused5 = __assign(__assign({}, abq), { b: 1 }); // ok +var unused1 = Object.assign({ b: 1 }, ab); // error +var unused2 = Object.assign(Object.assign({}, ab), ab); // ok, overwritten error doesn't apply to spreads +var unused3 = Object.assign({ b: 1 }, abq); // ok, abq might have b: undefined +var unused4 = Object.assign(Object.assign({}, ab), { b: 1 }); // ok, we don't care that b in ab is overwritten +var unused5 = Object.assign(Object.assign({}, abq), { b: 1 }); // ok function g(obj) { - return __assign({ x: 1 }, obj); // ok, obj might have x: undefined + return Object.assign({ x: 1 }, obj); // ok, obj might have x: undefined } function f(obj) { - return __assign({ x: 1 }, obj); // ok, obj might be undefined + return Object.assign({ x: 1 }, obj); // ok, obj might be undefined } function h(obj) { - return __assign({ x: 1 }, obj); // error + return Object.assign({ x: 1 }, obj); // error } function i(b, t) { - return __assign({ command: "hi" }, (b ? t : {})); // ok + return Object.assign({ command: "hi" }, (b ? t : {})); // ok } function j() { - return __assign({ command: "hi" }, { command: "bye" }); // ok + return Object.assign({ command: "hi" }, { command: "bye" }); // ok } function k(t) { - return __assign(__assign(__assign({ command: "hi" }, { spoiler: true }), { spoiler2: true }), t); // error + return Object.assign(Object.assign(Object.assign({ command: "hi" }, { spoiler: true }), { spoiler2: true }), t); // error } function l(anyrequired) { - return __assign({ a: 'zzz' }, anyrequired); // error + return Object.assign({ a: 'zzz' }, anyrequired); // error } function m(anyoptional) { - return __assign({ a: 'zzz' }, anyoptional); // ok + return Object.assign({ a: 'zzz' }, anyoptional); // ok } diff --git a/tests/baselines/reference/spreadTypeRemovesReadonly.js b/tests/baselines/reference/spreadTypeRemovesReadonly.js index 5a78509f614..913b1c6ec31 100644 --- a/tests/baselines/reference/spreadTypeRemovesReadonly.js +++ b/tests/baselines/reference/spreadTypeRemovesReadonly.js @@ -11,17 +11,6 @@ clone.value = 'bar'; //// [spreadTypeRemovesReadonly.js] -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; const data = { value: 'foo' }; -const clone = __assign({}, data); +const clone = Object.assign({}, data); clone.value = 'bar'; diff --git a/tests/baselines/reference/spreadTypeVariable.js b/tests/baselines/reference/spreadTypeVariable.js index d3049f6497a..278ea3bccb4 100644 --- a/tests/baselines/reference/spreadTypeVariable.js +++ b/tests/baselines/reference/spreadTypeVariable.js @@ -28,32 +28,21 @@ function f6(arg: T) { //// [spreadTypeVariable.js] -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; function f1(arg) { - return __assign({}, arg); + return Object.assign({}, arg); } function f2(arg) { - return __assign({}, arg); + return Object.assign({}, arg); } function f3(arg) { - return __assign({}, arg); + return Object.assign({}, arg); } function f4(arg) { - return __assign({}, arg); + return Object.assign({}, arg); } function f5(arg) { - return __assign({}, arg); + return Object.assign({}, arg); } function f6(arg) { - return __assign({}, arg); + return Object.assign({}, arg); } diff --git a/tests/baselines/reference/spreadUnion.js b/tests/baselines/reference/spreadUnion.js index 6d65812e877..60593b340c4 100644 --- a/tests/baselines/reference/spreadUnion.js +++ b/tests/baselines/reference/spreadUnion.js @@ -13,21 +13,10 @@ var o5: { a: number } | { b: string } | { a: number, b: string }; var o5 = { ...union, ...union }; //// [spreadUnion.js] -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; var union; var o3; -var o3 = __assign({}, union); +var o3 = Object.assign({}, union); var o4; -var o4 = __assign(__assign({}, union), { a: false }); +var o4 = Object.assign(Object.assign({}, union), { a: false }); var o5; -var o5 = __assign(__assign({}, union), union); +var o5 = Object.assign(Object.assign({}, union), union); diff --git a/tests/baselines/reference/spreadUnion2.js b/tests/baselines/reference/spreadUnion2.js index 627f615c633..b6d9cce5a07 100644 --- a/tests/baselines/reference/spreadUnion2.js +++ b/tests/baselines/reference/spreadUnion2.js @@ -23,25 +23,14 @@ var o5 = { ...nullUnion, ...nullUnion }; //// [spreadUnion2.js] -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; var o1; -var o1 = __assign({}, undefinedUnion); +var o1 = Object.assign({}, undefinedUnion); var o2; -var o2 = __assign({}, nullUnion); +var o2 = Object.assign({}, nullUnion); var o3; -var o3 = __assign(__assign({}, undefinedUnion), nullUnion); -var o3 = __assign(__assign({}, nullUnion), undefinedUnion); +var o3 = Object.assign(Object.assign({}, undefinedUnion), nullUnion); +var o3 = Object.assign(Object.assign({}, nullUnion), undefinedUnion); var o4; -var o4 = __assign(__assign({}, undefinedUnion), undefinedUnion); +var o4 = Object.assign(Object.assign({}, undefinedUnion), undefinedUnion); var o5; -var o5 = __assign(__assign({}, nullUnion), nullUnion); +var o5 = Object.assign(Object.assign({}, nullUnion), nullUnion); diff --git a/tests/baselines/reference/spreadUnion3.js b/tests/baselines/reference/spreadUnion3.js index b1938ba9648..f3b8af7db86 100644 --- a/tests/baselines/reference/spreadUnion3.js +++ b/tests/baselines/reference/spreadUnion3.js @@ -22,27 +22,16 @@ var y = { ...nullAndUndefinedUnion }; //// [spreadUnion3.js] -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; function f(x) { - return __assign({ y: 123 }, x); // y: string | number + return Object.assign({ y: 123 }, x); // y: string | number } f(undefined); function g(t) { - let b = __assign({}, t); + let b = Object.assign({}, t); let c = b.a; // might not have 'a' } g(); g(undefined); g(null); -var x = __assign(__assign({}, nullAndUndefinedUnion), nullAndUndefinedUnion); -var y = __assign({}, nullAndUndefinedUnion); +var x = Object.assign(Object.assign({}, nullAndUndefinedUnion), nullAndUndefinedUnion); +var y = Object.assign({}, nullAndUndefinedUnion); diff --git a/tests/baselines/reference/spreadUnion4.js b/tests/baselines/reference/spreadUnion4.js index 8315f9908e9..469430b66fb 100644 --- a/tests/baselines/reference/spreadUnion4.js +++ b/tests/baselines/reference/spreadUnion4.js @@ -8,15 +8,4 @@ const c = { ...a, ...b }; //// [spreadUnion4.js] -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; -const c = __assign(__assign({}, a), b); +const c = Object.assign(Object.assign({}, a), b); diff --git a/tests/baselines/reference/staticFieldWithInterfaceContext.js b/tests/baselines/reference/staticFieldWithInterfaceContext.js index ede8d8cbd5c..52e3e9f07be 100644 --- a/tests/baselines/reference/staticFieldWithInterfaceContext.js +++ b/tests/baselines/reference/staticFieldWithInterfaceContext.js @@ -49,11 +49,11 @@ let c2 = (_b = class { _b[_c] = { a: "a" }, _b); c[ex] = { a: "a" }; -function f(c = (_r = class { +function f(c) { var _r; if (c === void 0) { c = (_r = class { }, __setFunctionName(_r, "c"), _r.x = { a: "a" }, - _r)) { var _r; } + _r); } } let { c: c3 } = { c: (_d = class { }, __setFunctionName(_d, "c"), diff --git a/tests/baselines/reference/strictOptionalProperties1.js b/tests/baselines/reference/strictOptionalProperties1.js index 2b4c2c80d89..c88544a128c 100644 --- a/tests/baselines/reference/strictOptionalProperties1.js +++ b/tests/baselines/reference/strictOptionalProperties1.js @@ -239,17 +239,6 @@ type UC = UA & UB; // undefined //// [strictOptionalProperties1.js] "use strict"; -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; function f1(obj) { let a = obj.a; // string | undefined let b = obj.b; // string | undefined @@ -330,7 +319,7 @@ function f6() { } const defaultProps = { foo: 'foo' }; const inputProps = { foo: undefined, bar: 'bar' }; -const completeProps = __assign(__assign({}, defaultProps), inputProps); +const completeProps = Object.assign(Object.assign({}, defaultProps), inputProps); // Example from #13195 const t1 = [1]; const t2 = [1, undefined]; @@ -338,7 +327,7 @@ const t3 = [1, "string", undefined]; const t4 = [1, undefined, undefined]; // Example from #13195 const x = { foo: undefined }; -const y = __assign({ foo: 123 }, x); +const y = Object.assign({ foo: 123 }, x); f11(ox1); // string f11(ox2); // string | undefined f11(ox3); // string diff --git a/tests/baselines/reference/taggedTemplateStringsWithCurriedFunction.js b/tests/baselines/reference/taggedTemplateStringsWithCurriedFunction.js index bd943b8645e..28216ca976a 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithCurriedFunction.js +++ b/tests/baselines/reference/taggedTemplateStringsWithCurriedFunction.js @@ -14,20 +14,9 @@ f({ x: (() => 1)(), ...{ y: 1 } })``; //// [taggedTemplateStringsWithCurriedFunction.js] // Originated from #38558 -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; const f = _ => (..._) => ""; -f(__assign({ x: 0 })) ``; -f(__assign({ x: 0 })) `x`; -f(__assign({ x: 0 })) `x${f}x`; -f(__assign({ x: 0 }, { y: (() => 1)() })) ``; -f(__assign({ x: (() => 1)() }, { y: 1 })) ``; +f(Object.assign({ x: 0 })) ``; +f(Object.assign({ x: 0 })) `x`; +f(Object.assign({ x: 0 })) `x${f}x`; +f(Object.assign({ x: 0 }, { y: (() => 1)() })) ``; +f(Object.assign({ x: (() => 1)() }, { y: 1 })) ``; diff --git a/tests/baselines/reference/trivialSubtypeReductionNoStructuralCheck.js b/tests/baselines/reference/trivialSubtypeReductionNoStructuralCheck.js index 457cca76ea9..d7c8361a423 100644 --- a/tests/baselines/reference/trivialSubtypeReductionNoStructuralCheck.js +++ b/tests/baselines/reference/trivialSubtypeReductionNoStructuralCheck.js @@ -17,22 +17,11 @@ export interface WizardStepProps { //// [trivialSubtypeReductionNoStructuralCheck.js] "use strict"; -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; Object.defineProperty(exports, "__esModule", { value: true }); exports.Wizard = void 0; class Wizard { get steps() { - return __assign({ wizard: this }, props); + return Object.assign({ wizard: this }, props); } } exports.Wizard = Wizard; diff --git a/tests/baselines/reference/trivialSubtypeReductionNoStructuralCheck2.js b/tests/baselines/reference/trivialSubtypeReductionNoStructuralCheck2.js index 39a5951efbc..5faef299d26 100644 --- a/tests/baselines/reference/trivialSubtypeReductionNoStructuralCheck2.js +++ b/tests/baselines/reference/trivialSubtypeReductionNoStructuralCheck2.js @@ -17,22 +17,11 @@ export interface WizardStepProps { //// [trivialSubtypeReductionNoStructuralCheck2.js] "use strict"; -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; Object.defineProperty(exports, "__esModule", { value: true }); exports.Wizard = void 0; class Wizard { get steps() { - return __assign({ wizard: this }, props); + return Object.assign({ wizard: this }, props); } } exports.Wizard = Wizard; diff --git a/tests/baselines/reference/tscWatch/incremental/importHelpers-backing-types-removed-incremental.js b/tests/baselines/reference/tscWatch/incremental/importHelpers-backing-types-removed-incremental.js index af005fcdd2b..e10870067d5 100644 --- a/tests/baselines/reference/tscWatch/incremental/importHelpers-backing-types-removed-incremental.js +++ b/tests/baselines/reference/tscWatch/incremental/importHelpers-backing-types-removed-incremental.js @@ -43,8 +43,7 @@ Output:: "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.x = void 0; -const tslib_1 = require("tslib"); -exports.x = tslib_1.__assign({}); +exports.x = Object.assign({}); //// [/users/username/projects/project/tsconfig.tsbuildinfo] diff --git a/tests/baselines/reference/tscWatch/incremental/importHelpers-backing-types-removed-watch.js b/tests/baselines/reference/tscWatch/incremental/importHelpers-backing-types-removed-watch.js index 21a3cc85c61..fb40e39a10c 100644 --- a/tests/baselines/reference/tscWatch/incremental/importHelpers-backing-types-removed-watch.js +++ b/tests/baselines/reference/tscWatch/incremental/importHelpers-backing-types-removed-watch.js @@ -48,8 +48,7 @@ Output:: "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.x = void 0; -const tslib_1 = require("tslib"); -exports.x = tslib_1.__assign({}); +exports.x = Object.assign({}); diff --git a/tests/baselines/reference/tsxExternalModuleEmit2.js b/tests/baselines/reference/tsxExternalModuleEmit2.js index 13b136d2195..40e3f710a05 100644 --- a/tests/baselines/reference/tsxExternalModuleEmit2.js +++ b/tests/baselines/reference/tsxExternalModuleEmit2.js @@ -18,20 +18,9 @@ declare var Foo, React; //// [app.js] "use strict"; -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; Object.defineProperty(exports, "__esModule", { value: true }); const mod_1 = require("mod"); // Should see mod_1['default'] in emit here React.createElement(Foo, { handler: mod_1.default }); // Should see mod_1['default'] in emit here -React.createElement(Foo, __assign({}, mod_1.default)); +React.createElement(Foo, Object.assign({}, mod_1.default)); diff --git a/tests/baselines/reference/tsxNotUsingApparentTypeOfSFC.js b/tests/baselines/reference/tsxNotUsingApparentTypeOfSFC.js index 86f61ddfe3c..3c95421f452 100644 --- a/tests/baselines/reference/tsxNotUsingApparentTypeOfSFC.js +++ b/tests/baselines/reference/tsxNotUsingApparentTypeOfSFC.js @@ -24,17 +24,6 @@ function test

(wrappedProps: P) { //// [tsxNotUsingApparentTypeOfSFC.js] "use strict"; /// -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; var __importDefault = (this && this.__importDefault) || function (mod) { return (mod && mod.__esModule) ? mod : { "default": mod }; }; @@ -51,6 +40,6 @@ function test(wrappedProps) { } let x = react_1.default.createElement(MySFC, null); // should error let y = react_1.default.createElement(MyComponent, null); // should error - let z = react_1.default.createElement(MySFC, __assign({}, wrappedProps)); // should work - let q = react_1.default.createElement(MyComponent, __assign({}, wrappedProps)); // should work + let z = react_1.default.createElement(MySFC, Object.assign({}, wrappedProps)); // should work + let q = react_1.default.createElement(MyComponent, Object.assign({}, wrappedProps)); // should work } diff --git a/tests/baselines/reference/tsxReactEmit2.js b/tests/baselines/reference/tsxReactEmit2.js index 0c4b927ae73..ce700596a18 100644 --- a/tests/baselines/reference/tsxReactEmit2.js +++ b/tests/baselines/reference/tsxReactEmit2.js @@ -18,20 +18,9 @@ var spreads5 =

{p2}
; //// [file.js] -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; var p1, p2, p3; -var spreads1 = React.createElement("div", __assign({}, p1), p2); -var spreads2 = React.createElement("div", __assign({}, p1), p2); -var spreads3 = React.createElement("div", __assign({ x: p3 }, p1), p2); -var spreads4 = React.createElement("div", __assign({}, p1, { x: p3 }), p2); -var spreads5 = React.createElement("div", __assign({ x: p2 }, p1, { y: p3 }), p2); +var spreads1 = React.createElement("div", Object.assign({}, p1), p2); +var spreads2 = React.createElement("div", Object.assign({}, p1), p2); +var spreads3 = React.createElement("div", Object.assign({ x: p3 }, p1), p2); +var spreads4 = React.createElement("div", Object.assign({}, p1, { x: p3 }), p2); +var spreads5 = React.createElement("div", Object.assign({ x: p2 }, p1, { y: p3 }), p2); diff --git a/tests/baselines/reference/tsxReactEmit4.js b/tests/baselines/reference/tsxReactEmit4.js index b94afbfbf96..c6118e2a5b3 100644 --- a/tests/baselines/reference/tsxReactEmit4.js +++ b/tests/baselines/reference/tsxReactEmit4.js @@ -20,18 +20,7 @@ var openClosed1 =
var spread1 =
; //// [file.js] -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; var p; var openClosed1 = React.createElement("div", null, blah); // Should emit React.__spread({}, p, {x: 0}) -var spread1 = React.createElement("div", __assign({}, p, { x: 0 })); +var spread1 = React.createElement("div", Object.assign({}, p, { x: 0 })); diff --git a/tests/baselines/reference/tsxReactEmit5.js b/tests/baselines/reference/tsxReactEmit5.js index 056c46302b2..aa852e7fcd1 100644 --- a/tests/baselines/reference/tsxReactEmit5.js +++ b/tests/baselines/reference/tsxReactEmit5.js @@ -22,20 +22,9 @@ var spread1 =
; //// [file.js] //// [react-consumer.js] "use strict"; -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; Object.defineProperty(exports, "__esModule", { value: true }); const test_1 = require("./test"); // Should emit test_1.React.createElement // and React.__spread var foo; -var spread1 = test_1.React.createElement("div", __assign({ x: '' }, foo, { y: '' })); +var spread1 = test_1.React.createElement("div", Object.assign({ x: '' }, foo, { y: '' })); diff --git a/tests/baselines/reference/tsxReactEmit6.js b/tests/baselines/reference/tsxReactEmit6.js index 0f0b9a8793d..d3f0647f2bd 100644 --- a/tests/baselines/reference/tsxReactEmit6.js +++ b/tests/baselines/reference/tsxReactEmit6.js @@ -27,17 +27,6 @@ namespace M { //// [file.js] //// [react-consumer.js] -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; var M; (function (M) { })(M || (M = {})); @@ -45,7 +34,7 @@ var M; // Should emit M.React.createElement // and M.React.__spread var foo; - var spread1 = M.React.createElement("div", __assign({ x: '' }, foo, { y: '' })); + var spread1 = M.React.createElement("div", Object.assign({ x: '' }, foo, { y: '' })); // Quotes var x = M.React.createElement("div", null, "This \"quote\" thing"); })(M || (M = {})); diff --git a/tests/baselines/reference/tsxReactPropsInferenceSucceedsOnIntersections.js b/tests/baselines/reference/tsxReactPropsInferenceSucceedsOnIntersections.js index 238668914a4..e075d2dce2f 100644 --- a/tests/baselines/reference/tsxReactPropsInferenceSucceedsOnIntersections.js +++ b/tests/baselines/reference/tsxReactPropsInferenceSucceedsOnIntersections.js @@ -21,20 +21,9 @@ const CustomButton: React.SFC = props =>