diff --git a/src/compat/deprecations.ts b/src/compat/deprecations.ts index a13d76f5859b8..e9a6dc3b9a878 100644 --- a/src/compat/deprecations.ts +++ b/src/compat/deprecations.ts @@ -284,22 +284,22 @@ namespace ts { export const updateBindingElement = Debug.deprecate(factory.updateBindingElement, factoryDeprecation); /** @deprecated Use `factory.createArrayLiteral` or the factory supplied by your transformation context instead. */ - export const createArrayLiteral = Debug.deprecate(factory.createArrayLiteral, factoryDeprecation); + export const createArrayLiteral = Debug.deprecate(factory.createArrayLiteralExpression, factoryDeprecation); /** @deprecated Use `factory.updateArrayLiteral` or the factory supplied by your transformation context instead. */ - export const updateArrayLiteral = Debug.deprecate(factory.updateArrayLiteral, factoryDeprecation); + export const updateArrayLiteral = Debug.deprecate(factory.updateArrayLiteralExpression, factoryDeprecation); /** @deprecated Use `factory.createObjectLiteral` or the factory supplied by your transformation context instead. */ - export const createObjectLiteral = Debug.deprecate(factory.createObjectLiteral, factoryDeprecation); + export const createObjectLiteral = Debug.deprecate(factory.createObjectLiteralExpression, factoryDeprecation); /** @deprecated Use `factory.updateObjectLiteral` or the factory supplied by your transformation context instead. */ - export const updateObjectLiteral = Debug.deprecate(factory.updateObjectLiteral, factoryDeprecation); + export const updateObjectLiteral = Debug.deprecate(factory.updateObjectLiteralExpression, factoryDeprecation); /** @deprecated Use `factory.createPropertyAccess` or the factory supplied by your transformation context instead. */ - export const createPropertyAccess = Debug.deprecate(factory.createPropertyAccess, factoryDeprecation); + export const createPropertyAccess = Debug.deprecate(factory.createPropertyAccessExpression, factoryDeprecation); /** @deprecated Use `factory.updatePropertyAccess` or the factory supplied by your transformation context instead. */ - export const updatePropertyAccess = Debug.deprecate(factory.updatePropertyAccess, factoryDeprecation); + export const updatePropertyAccess = Debug.deprecate(factory.updatePropertyAccessExpression, factoryDeprecation); /** @deprecated Use `factory.createPropertyAccessChain` or the factory supplied by your transformation context instead. */ export const createPropertyAccessChain = Debug.deprecate(factory.createPropertyAccessChain, factoryDeprecation); @@ -308,10 +308,10 @@ namespace ts { export const updatePropertyAccessChain = Debug.deprecate(factory.updatePropertyAccessChain, factoryDeprecation); /** @deprecated Use `factory.createElementAccess` or the factory supplied by your transformation context instead. */ - export const createElementAccess = Debug.deprecate(factory.createElementAccess, factoryDeprecation); + export const createElementAccess = Debug.deprecate(factory.createElementAccessExpression, factoryDeprecation); /** @deprecated Use `factory.updateElementAccess` or the factory supplied by your transformation context instead. */ - export const updateElementAccess = Debug.deprecate(factory.updateElementAccess, factoryDeprecation); + export const updateElementAccess = Debug.deprecate(factory.updateElementAccessExpression, factoryDeprecation); /** @deprecated Use `factory.createElementAccessChain` or the factory supplied by your transformation context instead. */ export const createElementAccessChain = Debug.deprecate(factory.createElementAccessChain, factoryDeprecation); @@ -320,10 +320,10 @@ namespace ts { export const updateElementAccessChain = Debug.deprecate(factory.updateElementAccessChain, factoryDeprecation); /** @deprecated Use `factory.createCall` or the factory supplied by your transformation context instead. */ - export const createCall = Debug.deprecate(factory.createCall, factoryDeprecation); + export const createCall = Debug.deprecate(factory.createCallExpression, factoryDeprecation); /** @deprecated Use `factory.updateCall` or the factory supplied by your transformation context instead. */ - export const updateCall = Debug.deprecate(factory.updateCall, factoryDeprecation); + export const updateCall = Debug.deprecate(factory.updateCallExpression, factoryDeprecation); /** @deprecated Use `factory.createCallChain` or the factory supplied by your transformation context instead. */ export const createCallChain = Debug.deprecate(factory.createCallChain, factoryDeprecation); @@ -332,10 +332,10 @@ namespace ts { export const updateCallChain = Debug.deprecate(factory.updateCallChain, factoryDeprecation); /** @deprecated Use `factory.createNew` or the factory supplied by your transformation context instead. */ - export const createNew = Debug.deprecate(factory.createNew, factoryDeprecation); + export const createNew = Debug.deprecate(factory.createNewExpression, factoryDeprecation); /** @deprecated Use `factory.updateNew` or the factory supplied by your transformation context instead. */ - export const updateNew = Debug.deprecate(factory.updateNew, factoryDeprecation); + export const updateNew = Debug.deprecate(factory.updateNewExpression, factoryDeprecation); /** @deprecated Use `factory.createTypeAssertion` or the factory supplied by your transformation context instead. */ export const createTypeAssertion = Debug.deprecate(factory.createTypeAssertion, factoryDeprecation); @@ -344,10 +344,10 @@ namespace ts { export const updateTypeAssertion = Debug.deprecate(factory.updateTypeAssertion, factoryDeprecation); /** @deprecated Use `factory.createParen` or the factory supplied by your transformation context instead. */ - export const createParen = Debug.deprecate(factory.createParen, factoryDeprecation); + export const createParen = Debug.deprecate(factory.createParenthesizedExpression, factoryDeprecation); /** @deprecated Use `factory.updateParen` or the factory supplied by your transformation context instead. */ - export const updateParen = Debug.deprecate(factory.updateParen, factoryDeprecation); + export const updateParen = Debug.deprecate(factory.updateParenthesizedExpression, factoryDeprecation); /** @deprecated Use `factory.createFunctionExpression` or the factory supplied by your transformation context instead. */ export const createFunctionExpression = Debug.deprecate(factory.createFunctionExpression, factoryDeprecation); @@ -356,46 +356,46 @@ namespace ts { export const updateFunctionExpression = Debug.deprecate(factory.updateFunctionExpression, factoryDeprecation); /** @deprecated Use `factory.createDelete` or the factory supplied by your transformation context instead. */ - export const createDelete = Debug.deprecate(factory.createDelete, factoryDeprecation); + export const createDelete = Debug.deprecate(factory.createDeleteExpression, factoryDeprecation); /** @deprecated Use `factory.updateDelete` or the factory supplied by your transformation context instead. */ - export const updateDelete = Debug.deprecate(factory.updateDelete, factoryDeprecation); + export const updateDelete = Debug.deprecate(factory.updateDeleteExpression, factoryDeprecation); /** @deprecated Use `factory.createTypeOf` or the factory supplied by your transformation context instead. */ - export const createTypeOf = Debug.deprecate(factory.createTypeOf, factoryDeprecation); + export const createTypeOf = Debug.deprecate(factory.createTypeOfExpression, factoryDeprecation); /** @deprecated Use `factory.updateTypeOf` or the factory supplied by your transformation context instead. */ - export const updateTypeOf = Debug.deprecate(factory.updateTypeOf, factoryDeprecation); + export const updateTypeOf = Debug.deprecate(factory.updateTypeOfExpression, factoryDeprecation); /** @deprecated Use `factory.createVoid` or the factory supplied by your transformation context instead. */ - export const createVoid = Debug.deprecate(factory.createVoid, factoryDeprecation); + export const createVoid = Debug.deprecate(factory.createVoidExpression, factoryDeprecation); /** @deprecated Use `factory.updateVoid` or the factory supplied by your transformation context instead. */ - export const updateVoid = Debug.deprecate(factory.updateVoid, factoryDeprecation); + export const updateVoid = Debug.deprecate(factory.updateVoidExpression, factoryDeprecation); /** @deprecated Use `factory.createAwait` or the factory supplied by your transformation context instead. */ - export const createAwait = Debug.deprecate(factory.createAwait, factoryDeprecation); + export const createAwait = Debug.deprecate(factory.createAwaitExpression, factoryDeprecation); /** @deprecated Use `factory.updateAwait` or the factory supplied by your transformation context instead. */ - export const updateAwait = Debug.deprecate(factory.updateAwait, factoryDeprecation); + export const updateAwait = Debug.deprecate(factory.updateAwaitExpression, factoryDeprecation); /** @deprecated Use `factory.createPrefix` or the factory supplied by your transformation context instead. */ - export const createPrefix = Debug.deprecate(factory.createPrefix, factoryDeprecation); + export const createPrefix = Debug.deprecate(factory.createPrefixUnaryExpression, factoryDeprecation); /** @deprecated Use `factory.updatePrefix` or the factory supplied by your transformation context instead. */ - export const updatePrefix = Debug.deprecate(factory.updatePrefix, factoryDeprecation); + export const updatePrefix = Debug.deprecate(factory.updatePrefixUnaryExpression, factoryDeprecation); /** @deprecated Use `factory.createPostfix` or the factory supplied by your transformation context instead. */ - export const createPostfix = Debug.deprecate(factory.createPostfix, factoryDeprecation); + export const createPostfix = Debug.deprecate(factory.createPostfixUnaryExpression, factoryDeprecation); /** @deprecated Use `factory.updatePostfix` or the factory supplied by your transformation context instead. */ - export const updatePostfix = Debug.deprecate(factory.updatePostfix, factoryDeprecation); + export const updatePostfix = Debug.deprecate(factory.updatePostfixUnaryExpression, factoryDeprecation); /** @deprecated Use `factory.createBinary` or the factory supplied by your transformation context instead. */ - export const createBinary = Debug.deprecate(factory.createBinary, factoryDeprecation); + export const createBinary = Debug.deprecate(factory.createBinaryExpression, factoryDeprecation); /** @deprecated Use `factory.updateConditional` or the factory supplied by your transformation context instead. */ - export const updateConditional = Debug.deprecate(factory.updateConditional, factoryDeprecation); + export const updateConditional = Debug.deprecate(factory.updateConditionalExpression, factoryDeprecation); /** @deprecated Use `factory.createTemplateExpression` or the factory supplied by your transformation context instead. */ export const createTemplateExpression = Debug.deprecate(factory.createTemplateExpression, factoryDeprecation); @@ -416,13 +416,13 @@ namespace ts { export const createNoSubstitutionTemplateLiteral = Debug.deprecate(factory.createNoSubstitutionTemplateLiteral, factoryDeprecation); /** @deprecated Use `factory.updateYield` or the factory supplied by your transformation context instead. */ - export const updateYield = Debug.deprecate(factory.updateYield, factoryDeprecation); + export const updateYield = Debug.deprecate(factory.updateYieldExpression, factoryDeprecation); /** @deprecated Use `factory.createSpread` or the factory supplied by your transformation context instead. */ - export const createSpread = Debug.deprecate(factory.createSpread, factoryDeprecation); + export const createSpread = Debug.deprecate(factory.createSpreadElement, factoryDeprecation); /** @deprecated Use `factory.updateSpread` or the factory supplied by your transformation context instead. */ - export const updateSpread = Debug.deprecate(factory.updateSpread, factoryDeprecation); + export const updateSpread = Debug.deprecate(factory.updateSpreadElement, factoryDeprecation); /** @deprecated Use `factory.createOmittedExpression` or the factory supplied by your transformation context instead. */ export const createOmittedExpression = Debug.deprecate(factory.createOmittedExpression, factoryDeprecation); @@ -488,88 +488,88 @@ namespace ts { export const updateStatement = Debug.deprecate(factory.updateExpressionStatement, factoryDeprecation); /** @deprecated Use `factory.createIf` or the factory supplied by your transformation context instead. */ - export const createIf = Debug.deprecate(factory.createIf, factoryDeprecation); + export const createIf = Debug.deprecate(factory.createIfStatement, factoryDeprecation); /** @deprecated Use `factory.updateIf` or the factory supplied by your transformation context instead. */ - export const updateIf = Debug.deprecate(factory.updateIf, factoryDeprecation); + export const updateIf = Debug.deprecate(factory.updateIfStatement, factoryDeprecation); /** @deprecated Use `factory.createDo` or the factory supplied by your transformation context instead. */ - export const createDo = Debug.deprecate(factory.createDo, factoryDeprecation); + export const createDo = Debug.deprecate(factory.createDoStatement, factoryDeprecation); /** @deprecated Use `factory.updateDo` or the factory supplied by your transformation context instead. */ - export const updateDo = Debug.deprecate(factory.updateDo, factoryDeprecation); + export const updateDo = Debug.deprecate(factory.updateDoStatement, factoryDeprecation); /** @deprecated Use `factory.createWhile` or the factory supplied by your transformation context instead. */ - export const createWhile = Debug.deprecate(factory.createWhile, factoryDeprecation); + export const createWhile = Debug.deprecate(factory.createWhileStatement, factoryDeprecation); /** @deprecated Use `factory.updateWhile` or the factory supplied by your transformation context instead. */ - export const updateWhile = Debug.deprecate(factory.updateWhile, factoryDeprecation); + export const updateWhile = Debug.deprecate(factory.updateWhileStatement, factoryDeprecation); /** @deprecated Use `factory.createFor` or the factory supplied by your transformation context instead. */ - export const createFor = Debug.deprecate(factory.createFor, factoryDeprecation); + export const createFor = Debug.deprecate(factory.createForStatement, factoryDeprecation); /** @deprecated Use `factory.updateFor` or the factory supplied by your transformation context instead. */ - export const updateFor = Debug.deprecate(factory.updateFor, factoryDeprecation); + export const updateFor = Debug.deprecate(factory.updateForStatement, factoryDeprecation); /** @deprecated Use `factory.createForIn` or the factory supplied by your transformation context instead. */ - export const createForIn = Debug.deprecate(factory.createForIn, factoryDeprecation); + export const createForIn = Debug.deprecate(factory.createForInStatement, factoryDeprecation); /** @deprecated Use `factory.updateForIn` or the factory supplied by your transformation context instead. */ - export const updateForIn = Debug.deprecate(factory.updateForIn, factoryDeprecation); + export const updateForIn = Debug.deprecate(factory.updateForInStatement, factoryDeprecation); /** @deprecated Use `factory.createForOf` or the factory supplied by your transformation context instead. */ - export const createForOf = Debug.deprecate(factory.createForOf, factoryDeprecation); + export const createForOf = Debug.deprecate(factory.createForOfStatement, factoryDeprecation); /** @deprecated Use `factory.updateForOf` or the factory supplied by your transformation context instead. */ - export const updateForOf = Debug.deprecate(factory.updateForOf, factoryDeprecation); + export const updateForOf = Debug.deprecate(factory.updateForOfStatement, factoryDeprecation); /** @deprecated Use `factory.createContinue` or the factory supplied by your transformation context instead. */ - export const createContinue = Debug.deprecate(factory.createContinue, factoryDeprecation); + export const createContinue = Debug.deprecate(factory.createContinueStatement, factoryDeprecation); /** @deprecated Use `factory.updateContinue` or the factory supplied by your transformation context instead. */ - export const updateContinue = Debug.deprecate(factory.updateContinue, factoryDeprecation); + export const updateContinue = Debug.deprecate(factory.updateContinueStatement, factoryDeprecation); /** @deprecated Use `factory.createBreak` or the factory supplied by your transformation context instead. */ - export const createBreak = Debug.deprecate(factory.createBreak, factoryDeprecation); + export const createBreak = Debug.deprecate(factory.createBreakStatement, factoryDeprecation); /** @deprecated Use `factory.updateBreak` or the factory supplied by your transformation context instead. */ - export const updateBreak = Debug.deprecate(factory.updateBreak, factoryDeprecation); + export const updateBreak = Debug.deprecate(factory.updateBreakStatement, factoryDeprecation); /** @deprecated Use `factory.createReturn` or the factory supplied by your transformation context instead. */ - export const createReturn = Debug.deprecate(factory.createReturn, factoryDeprecation); + export const createReturn = Debug.deprecate(factory.createReturnStatement, factoryDeprecation); /** @deprecated Use `factory.updateReturn` or the factory supplied by your transformation context instead. */ - export const updateReturn = Debug.deprecate(factory.updateReturn, factoryDeprecation); + export const updateReturn = Debug.deprecate(factory.updateReturnStatement, factoryDeprecation); /** @deprecated Use `factory.createWith` or the factory supplied by your transformation context instead. */ - export const createWith = Debug.deprecate(factory.createWith, factoryDeprecation); + export const createWith = Debug.deprecate(factory.createWithStatement, factoryDeprecation); /** @deprecated Use `factory.updateWith` or the factory supplied by your transformation context instead. */ - export const updateWith = Debug.deprecate(factory.updateWith, factoryDeprecation); + export const updateWith = Debug.deprecate(factory.updateWithStatement, factoryDeprecation); /** @deprecated Use `factory.createSwitch` or the factory supplied by your transformation context instead. */ - export const createSwitch = Debug.deprecate(factory.createSwitch, factoryDeprecation); + export const createSwitch = Debug.deprecate(factory.createSwitchStatement, factoryDeprecation); /** @deprecated Use `factory.updateSwitch` or the factory supplied by your transformation context instead. */ - export const updateSwitch = Debug.deprecate(factory.updateSwitch, factoryDeprecation); + export const updateSwitch = Debug.deprecate(factory.updateSwitchStatement, factoryDeprecation); /** @deprecated Use `factory.createLabel` or the factory supplied by your transformation context instead. */ - export const createLabel = Debug.deprecate(factory.createLabel, factoryDeprecation); + export const createLabel = Debug.deprecate(factory.createLabeledStatement, factoryDeprecation); /** @deprecated Use `factory.updateLabel` or the factory supplied by your transformation context instead. */ - export const updateLabel = Debug.deprecate(factory.updateLabel, factoryDeprecation); + export const updateLabel = Debug.deprecate(factory.updateLabeledStatement, factoryDeprecation); /** @deprecated Use `factory.createThrow` or the factory supplied by your transformation context instead. */ - export const createThrow = Debug.deprecate(factory.createThrow, factoryDeprecation); + export const createThrow = Debug.deprecate(factory.createThrowStatement, factoryDeprecation); /** @deprecated Use `factory.updateThrow` or the factory supplied by your transformation context instead. */ - export const updateThrow = Debug.deprecate(factory.updateThrow, factoryDeprecation); + export const updateThrow = Debug.deprecate(factory.updateThrowStatement, factoryDeprecation); /** @deprecated Use `factory.createTry` or the factory supplied by your transformation context instead. */ - export const createTry = Debug.deprecate(factory.createTry, factoryDeprecation); + export const createTry = Debug.deprecate(factory.createTryStatement, factoryDeprecation); /** @deprecated Use `factory.updateTry` or the factory supplied by your transformation context instead. */ - export const updateTry = Debug.deprecate(factory.updateTry, factoryDeprecation); + export const updateTry = Debug.deprecate(factory.updateTryStatement, factoryDeprecation); /** @deprecated Use `factory.createDebuggerStatement` or the factory supplied by your transformation context instead. */ export const createDebuggerStatement = Debug.deprecate(factory.createDebuggerStatement, factoryDeprecation); @@ -881,10 +881,10 @@ namespace ts { export const updatePartiallyEmittedExpression = Debug.deprecate(factory.updatePartiallyEmittedExpression, factoryDeprecation); /** @deprecated Use `factory.createCommaList` or the factory supplied by your transformation context instead. */ - export const createCommaList = Debug.deprecate(factory.createCommaList, factoryDeprecation); + export const createCommaList = Debug.deprecate(factory.createCommaListExpression, factoryDeprecation); /** @deprecated Use `factory.updateCommaList` or the factory supplied by your transformation context instead. */ - export const updateCommaList = Debug.deprecate(factory.updateCommaList, factoryDeprecation); + export const updateCommaList = Debug.deprecate(factory.updateCommaListExpression, factoryDeprecation); /** @deprecated Use `factory.createBundle` or the factory supplied by your transformation context instead. */ export const createBundle = Debug.deprecate(factory.createBundle, factoryDeprecation); @@ -1029,7 +1029,7 @@ namespace ts { else { template = typeArgumentsOrTemplate as TemplateLiteral; } - return factory.createTaggedTemplate(tag, typeArguments, template); + return factory.createTaggedTemplateExpression(tag, typeArguments, template); } as { (tag: Expression, template: TemplateLiteral): TaggedTemplateExpression; (tag: Expression, typeArguments: readonly TypeNode[] | undefined, template: TemplateLiteral): TaggedTemplateExpression; @@ -1044,7 +1044,7 @@ namespace ts { else { template = typeArgumentsOrTemplate as TemplateLiteral; } - return factory.updateTaggedTemplate(node, tag, typeArguments, template); + return factory.updateTaggedTemplateExpression(node, tag, typeArguments, template); } as { (node: TaggedTemplateExpression, tag: Expression, template: TemplateLiteral): TaggedTemplateExpression; (node: TaggedTemplateExpression, tag: Expression, typeArguments: readonly TypeNode[] | undefined, template: TemplateLiteral): TaggedTemplateExpression; @@ -1055,13 +1055,13 @@ namespace ts { if (typeof operator === "number") { operator = operator === node.operatorToken.kind ? node.operatorToken : factory.createToken(operator); } - return factory.updateBinary(node, left, operator, right); + return factory.updateBinaryExpression(node, left, operator, right); }, factoryDeprecation); /** @deprecated Use `factory.createConditional` or the factory supplied by your transformation context instead. */ export const createConditional = Debug.deprecate(function createConditional(condition: Expression, questionTokenOrWhenTrue: QuestionToken | Expression, whenTrueOrWhenFalse: Expression, colonToken?: ColonToken, whenFalse?: Expression) { - return arguments.length === 5 ? factory.createConditional(condition, questionTokenOrWhenTrue as QuestionToken, whenTrueOrWhenFalse, colonToken, whenFalse!) : - arguments.length === 3 ? factory.createConditional(condition, factory.createToken(SyntaxKind.QuestionToken), questionTokenOrWhenTrue as Expression, factory.createToken(SyntaxKind.ColonToken), whenTrueOrWhenFalse) : + return arguments.length === 5 ? factory.createConditionalExpression(condition, questionTokenOrWhenTrue as QuestionToken, whenTrueOrWhenFalse, colonToken, whenFalse!) : + arguments.length === 3 ? factory.createConditionalExpression(condition, factory.createToken(SyntaxKind.QuestionToken), questionTokenOrWhenTrue as Expression, factory.createToken(SyntaxKind.ColonToken), whenTrueOrWhenFalse) : Debug.fail("Argument count mismatch"); } as { (condition: Expression, whenTrue: Expression, whenFalse: Expression): ConditionalExpression; @@ -1077,7 +1077,7 @@ namespace ts { else { expression = asteriskTokenOrExpression as Expression; } - return factory.createYield(asteriskToken, expression); + return factory.createYieldExpression(asteriskToken, expression); } as { (expression?: Expression): YieldExpression; (asteriskToken: AsteriskToken | undefined, expression: Expression): YieldExpression; diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index f3ddc03b06948..192398a72520b 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -4292,7 +4292,7 @@ namespace ts { if (type.flags & TypeFlags.NumberLiteral) { const value = (type).value; context.approximateLength += ("" + value).length; - return factory.createLiteralTypeNode(value < 0 ? factory.createPrefix(SyntaxKind.MinusToken, factory.createNumericLiteral(-value)) : factory.createNumericLiteral(value)); + return factory.createLiteralTypeNode(value < 0 ? factory.createPrefixUnaryExpression(SyntaxKind.MinusToken, factory.createNumericLiteral(-value)) : factory.createNumericLiteral(value)); } if (type.flags & TypeFlags.BigIntLiteral) { context.approximateLength += (pseudoBigIntToString((type).value).length) + 1; @@ -5517,7 +5517,7 @@ namespace ts { const identifier = setEmitFlags(factory.createIdentifier(symbolName, typeParameterNodes), EmitFlags.NoAsciiEscaping); identifier.symbol = symbol; - return index > 0 ? factory.createPropertyAccess(createExpressionFromSymbolChain(chain, index - 1), identifier) : identifier; + return index > 0 ? factory.createPropertyAccessExpression(createExpressionFromSymbolChain(chain, index - 1), identifier) : identifier; } else { if (firstChar === CharacterCodes.openBracket) { @@ -5539,7 +5539,7 @@ namespace ts { expression = setEmitFlags(factory.createIdentifier(symbolName, typeParameterNodes), EmitFlags.NoAsciiEscaping); expression.symbol = symbol; } - return factory.createElementAccess(createExpressionFromSymbolChain(chain, index - 1), expression); + return factory.createElementAccessExpression(createExpressionFromSymbolChain(chain, index - 1), expression); } } } @@ -5562,7 +5562,7 @@ namespace ts { return fromNameType; } if (isKnownSymbol(symbol)) { - return factory.createComputedPropertyName(factory.createPropertyAccess(factory.createIdentifier("Symbol"), (symbol.escapedName as string).substr(3))); + return factory.createComputedPropertyName(factory.createPropertyAccessExpression(factory.createIdentifier("Symbol"), (symbol.escapedName as string).substr(3))); } const rawName = unescapeLeadingUnderscores(symbol.escapedName); return createPropertyNameNodeForIdentifierOrLiteral(rawName, singleQuote); @@ -7577,7 +7577,7 @@ namespace ts { const propName = getDestructuringPropertyName(node); if (propName) { const literal = setTextRange(parseNodeFactory.createStringLiteral(propName), node); - const result = setTextRange(parseNodeFactory.createElementAccess(parentAccess, literal), node); + const result = setTextRange(parseNodeFactory.createElementAccessExpression(parentAccess, literal), node); setParent(literal, result); setParent(result, node); result.flowNode = parentAccess.flowNode; @@ -7869,7 +7869,7 @@ namespace ts { } function getFlowTypeInConstructor(symbol: Symbol, constructor: ConstructorDeclaration) { - const reference = factory.createPropertyAccess(factory.createThis(), unescapeLeadingUnderscores(symbol.escapedName)); + const reference = factory.createPropertyAccessExpression(factory.createThis(), unescapeLeadingUnderscores(symbol.escapedName)); setParent(reference.expression, reference); setParent(reference, constructor); reference.flowNode = constructor.returnFlowNode; @@ -34238,7 +34238,7 @@ namespace ts { } function isPropertyInitializedInConstructor(propName: Identifier | PrivateIdentifier, propType: Type, constructor: ConstructorDeclaration) { - const reference = factory.createPropertyAccess(factory.createThis(), propName); + const reference = factory.createPropertyAccessExpression(factory.createThis(), propName); setParent(reference.expression, reference); setParent(reference, constructor); reference.flowNode = constructor.returnFlowNode; diff --git a/src/compiler/factory/emitHelpers.ts b/src/compiler/factory/emitHelpers.ts index b9c4a388185fe..9a76e759a2671 100644 --- a/src/compiler/factory/emitHelpers.ts +++ b/src/compiler/factory/emitHelpers.ts @@ -87,7 +87,7 @@ namespace ts { context.requestEmitHelper(decorateHelper); const argumentsArray: Expression[] = []; - argumentsArray.push(factory.createArrayLiteral(decoratorExpressions, /*multiLine*/ true)); + argumentsArray.push(factory.createArrayLiteralExpression(decoratorExpressions, /*multiLine*/ true)); argumentsArray.push(target); if (memberName) { argumentsArray.push(memberName); @@ -96,7 +96,7 @@ namespace ts { } } - return factory.createCall( + return factory.createCallExpression( getUnscopedHelperName("__decorate"), /*typeArguments*/ undefined, argumentsArray @@ -105,7 +105,7 @@ namespace ts { function createMetadataHelper(metadataKey: string, metadataValue: Expression) { context.requestEmitHelper(metadataHelper); - return factory.createCall( + return factory.createCallExpression( getUnscopedHelperName("__metadata"), /*typeArguments*/ undefined, [ @@ -118,7 +118,7 @@ namespace ts { function createParamHelper(expression: Expression, parameterOffset: number, location?: TextRange) { context.requestEmitHelper(paramHelper); return setTextRange( - factory.createCall( + factory.createCallExpression( getUnscopedHelperName("__param"), /*typeArguments*/ undefined, [ @@ -134,12 +134,12 @@ namespace ts { function createAssignHelper(attributesSegments: Expression[]) { if (context.getCompilerOptions().target! >= ScriptTarget.ES2015) { - return factory.createCall(factory.createPropertyAccess(factory.createIdentifier("Object"), "assign"), + return factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("Object"), "assign"), /*typeArguments*/ undefined, attributesSegments); } context.requestEmitHelper(assignHelper); - return factory.createCall( + return factory.createCallExpression( getUnscopedHelperName("__assign"), /*typeArguments*/ undefined, attributesSegments @@ -148,7 +148,7 @@ namespace ts { function createAwaitHelper(expression: Expression) { context.requestEmitHelper(awaitHelper); - return factory.createCall(getUnscopedHelperName("__await"), /*typeArguments*/ undefined, [expression]); + return factory.createCallExpression(getUnscopedHelperName("__await"), /*typeArguments*/ undefined, [expression]); } function createAsyncGeneratorHelper(generatorFunc: FunctionExpression, hasLexicalThis: boolean) { @@ -158,7 +158,7 @@ namespace ts { // Mark this node as originally an async function (generatorFunc.emitNode || (generatorFunc.emitNode = {} as EmitNode)).flags |= EmitFlags.AsyncFunctionBody | EmitFlags.ReuseTempVariableScope; - return factory.createCall( + return factory.createCallExpression( getUnscopedHelperName("__asyncGenerator"), /*typeArguments*/ undefined, [ @@ -172,7 +172,7 @@ namespace ts { function createAsyncDelegatorHelper(expression: Expression) { context.requestEmitHelper(awaitHelper); context.requestEmitHelper(asyncDelegator); - return factory.createCall( + return factory.createCallExpression( getUnscopedHelperName("__asyncDelegator"), /*typeArguments*/ undefined, [expression] @@ -181,7 +181,7 @@ namespace ts { function createAsyncValuesHelper(expression: Expression) { context.requestEmitHelper(asyncValues); - return factory.createCall( + return factory.createCallExpression( getUnscopedHelperName("__asyncValues"), /*typeArguments*/ undefined, [expression] @@ -206,7 +206,7 @@ namespace ts { computedTempVariableOffset++; // typeof _tmp === "symbol" ? _tmp : _tmp + "" propertyNames.push( - factory.createConditional( + factory.createConditionalExpression( factory.createTypeCheck(temp, "symbol"), /*questionToken*/ undefined, temp, @@ -220,13 +220,13 @@ namespace ts { } } } - return factory.createCall( + return factory.createCallExpression( getUnscopedHelperName("__rest"), /*typeArguments*/ undefined, [ value, setTextRange( - factory.createArrayLiteral(propertyNames), + factory.createArrayLiteralExpression(propertyNames), location )] ); @@ -250,7 +250,7 @@ namespace ts { // Mark this node as originally an async function (generatorFunc.emitNode || (generatorFunc.emitNode = {} as EmitNode)).flags |= EmitFlags.AsyncFunctionBody | EmitFlags.ReuseTempVariableScope; - return factory.createCall( + return factory.createCallExpression( getUnscopedHelperName("__awaiter"), /*typeArguments*/ undefined, [ @@ -266,7 +266,7 @@ namespace ts { function createExtendsHelper(name: Identifier) { context.requestEmitHelper(extendsHelper); - return factory.createCall( + return factory.createCallExpression( getUnscopedHelperName("__extends"), /*typeArguments*/ undefined, [name, factory.createUniqueName("_super", GeneratedIdentifierFlags.Optimistic | GeneratedIdentifierFlags.FileLevel)] @@ -275,7 +275,7 @@ namespace ts { function createTemplateObjectHelper(cooked: ArrayLiteralExpression, raw: ArrayLiteralExpression) { context.requestEmitHelper(templateObjectHelper); - return factory.createCall( + return factory.createCallExpression( getUnscopedHelperName("__makeTemplateObject"), /*typeArguments*/ undefined, [cooked, raw] @@ -285,7 +285,7 @@ namespace ts { function createSpreadHelper(argumentList: readonly Expression[]) { context.requestEmitHelper(readHelper); context.requestEmitHelper(spreadHelper); - return factory.createCall( + return factory.createCallExpression( getUnscopedHelperName("__spread"), /*typeArguments*/ undefined, argumentList @@ -294,7 +294,7 @@ namespace ts { function createSpreadArraysHelper(argumentList: readonly Expression[]) { context.requestEmitHelper(spreadArraysHelper); - return factory.createCall( + return factory.createCallExpression( getUnscopedHelperName("__spreadArrays"), /*typeArguments*/ undefined, argumentList @@ -305,7 +305,7 @@ namespace ts { function createValuesHelper(expression: Expression) { context.requestEmitHelper(valuesHelper); - return factory.createCall( + return factory.createCallExpression( getUnscopedHelperName("__values"), /*typeArguments*/ undefined, [expression] @@ -314,7 +314,7 @@ namespace ts { function createReadHelper(iteratorRecord: Expression, count: number | undefined) { context.requestEmitHelper(readHelper); - return factory.createCall( + return factory.createCallExpression( getUnscopedHelperName("__read"), /*typeArguments*/ undefined, count !== undefined @@ -327,7 +327,7 @@ namespace ts { function createGeneratorHelper(body: FunctionExpression) { context.requestEmitHelper(generatorHelper); - return factory.createCall( + return factory.createCallExpression( getUnscopedHelperName("__generator"), /*typeArguments*/ undefined, [factory.createThis(), body]); @@ -337,7 +337,7 @@ namespace ts { function createCreateBindingHelper(module: Expression, inputName: Expression, outputName: Expression | undefined) { context.requestEmitHelper(createBindingHelper); - return factory.createCall( + return factory.createCallExpression( getUnscopedHelperName("__createBinding"), /*typeArguments*/ undefined, [factory.createIdentifier("exports"), module, inputName, ...(outputName ? [outputName] : [])]); @@ -345,7 +345,7 @@ namespace ts { function createImportStarHelper(expression: Expression) { context.requestEmitHelper(importStarHelper); - return factory.createCall( + return factory.createCallExpression( getUnscopedHelperName("__importStar"), /*typeArguments*/ undefined, [expression] @@ -359,7 +359,7 @@ namespace ts { function createImportDefaultHelper(expression: Expression) { context.requestEmitHelper(importDefaultHelper); - return factory.createCall( + return factory.createCallExpression( getUnscopedHelperName("__importDefault"), /*typeArguments*/ undefined, [expression] @@ -370,12 +370,12 @@ namespace ts { function createClassPrivateFieldGetHelper(receiver: Expression, privateField: Identifier) { context.requestEmitHelper(classPrivateFieldGetHelper); - return factory.createCall(getUnscopedHelperName("__classPrivateFieldGet"), /*typeArguments*/ undefined, [receiver, privateField]); + return factory.createCallExpression(getUnscopedHelperName("__classPrivateFieldGet"), /*typeArguments*/ undefined, [receiver, privateField]); } function createClassPrivateFieldSetHelper(receiver: Expression, privateField: Identifier, value: Expression) { context.requestEmitHelper(classPrivateFieldSetHelper); - return factory.createCall(getUnscopedHelperName("__classPrivateFieldSet"), /*typeArguments*/ undefined, [receiver, privateField, value]); + return factory.createCallExpression(getUnscopedHelperName("__classPrivateFieldSet"), /*typeArguments*/ undefined, [receiver, privateField, value]); } } diff --git a/src/compiler/factory/nodeConverters.ts b/src/compiler/factory/nodeConverters.ts index bd7fd28bf45f0..08aff2a91cd87 100644 --- a/src/compiler/factory/nodeConverters.ts +++ b/src/compiler/factory/nodeConverters.ts @@ -14,7 +14,7 @@ namespace ts { function convertToFunctionBlock(node: ConciseBody, multiLine?: boolean): Block { if (isBlock(node)) return node; - const returnStatement = factory.createReturn(node); + const returnStatement = factory.createReturnStatement(node); setTextRange(returnStatement, node); const body = factory.createBlock([returnStatement], multiLine); setTextRange(body, node); @@ -44,7 +44,7 @@ namespace ts { if (isBindingElement(element)) { if (element.dotDotDotToken) { Debug.assertNode(element.name, isIdentifier); - return setOriginalNode(setTextRange(factory.createSpread(element.name), element), element); + return setOriginalNode(setTextRange(factory.createSpreadElement(element.name), element), element); } const expression = convertToAssignmentElementTarget(element.name); return element.initializer @@ -93,7 +93,7 @@ namespace ts { if (isObjectBindingPattern(node)) { return setOriginalNode( setTextRange( - factory.createObjectLiteral(map(node.elements, convertToObjectAssignmentElement)), + factory.createObjectLiteralExpression(map(node.elements, convertToObjectAssignmentElement)), node ), node @@ -106,7 +106,7 @@ namespace ts { if (isArrayBindingPattern(node)) { return setOriginalNode( setTextRange( - factory.createArrayLiteral(map(node.elements, convertToArrayAssignmentElement)), + factory.createArrayLiteralExpression(map(node.elements, convertToArrayAssignmentElement)), node ), node diff --git a/src/compiler/factory/nodeFactory.ts b/src/compiler/factory/nodeFactory.ts index cc5080af689df..4814bf679e074 100644 --- a/src/compiler/factory/nodeFactory.ts +++ b/src/compiler/factory/nodeFactory.ts @@ -144,54 +144,54 @@ namespace ts { updateArrayBindingPattern, createBindingElement, updateBindingElement, - createArrayLiteral: createArrayLiteralExpression, - updateArrayLiteral: updateArrayLiteralExpression, - createObjectLiteral: createObjectLiteralExpression, - updateObjectLiteral: updateObjectLiteralExpression, - createPropertyAccess: flags & NodeFactoryFlags.NoIndentationOnFreshPropertyAccess ? + createArrayLiteralExpression, + updateArrayLiteralExpression, + createObjectLiteralExpression, + updateObjectLiteralExpression, + createPropertyAccessExpression: flags & NodeFactoryFlags.NoIndentationOnFreshPropertyAccess ? (expression, name) => setEmitFlags(createPropertyAccessExpression(expression, name), EmitFlags.NoIndentation) : createPropertyAccessExpression, - updatePropertyAccess: updatePropertyAccessExpression, + updatePropertyAccessExpression, createPropertyAccessChain: flags & NodeFactoryFlags.NoIndentationOnFreshPropertyAccess ? (expression, questionDotToken, name) => setEmitFlags(createPropertyAccessChain(expression, questionDotToken, name), EmitFlags.NoIndentation) : createPropertyAccessChain, updatePropertyAccessChain, - createElementAccess: createElementAccessExpression, - updateElementAccess: updateElementAccessExpression, + createElementAccessExpression, + updateElementAccessExpression, createElementAccessChain, updateElementAccessChain, - createCall: createCallExpression, - updateCall: updateCallExpression, + createCallExpression, + updateCallExpression, createCallChain, updateCallChain, - createNew: createNewExpression, - updateNew: updateNewExpression, - createTaggedTemplate: createTaggedTemplateExpression, - updateTaggedTemplate: updateTaggedTemplateExpression, + createNewExpression, + updateNewExpression, + createTaggedTemplateExpression, + updateTaggedTemplateExpression, createTypeAssertion, updateTypeAssertion, - createParen: createParenthesizedExpression, - updateParen: updateParenthesizedExpression, + createParenthesizedExpression, + updateParenthesizedExpression, createFunctionExpression, updateFunctionExpression, createArrowFunction, updateArrowFunction, - createDelete: createDeleteExpression, - updateDelete: updateDeleteExpression, - createTypeOf: createTypeOfExpression, - updateTypeOf: updateTypeOfExpression, - createVoid: createVoidExpression, - updateVoid: updateVoidExpression, - createAwait: createAwaitExpression, - updateAwait: updateAwaitExpression, - createPrefix: createPrefixUnaryExpression, - updatePrefix: updatePrefixUnaryExpression, - createPostfix: createPostfixUnaryExpression, - updatePostfix: updatePostfixUnaryExpression, - createBinary: createBinaryExpression, - updateBinary: updateBinaryExpression, - createConditional: createConditionalExpression, - updateConditional: updateConditionalExpression, + createDeleteExpression, + updateDeleteExpression, + createTypeOfExpression, + updateTypeOfExpression, + createVoidExpression, + updateVoidExpression, + createAwaitExpression, + updateAwaitExpression, + createPrefixUnaryExpression, + updatePrefixUnaryExpression, + createPostfixUnaryExpression, + updatePostfixUnaryExpression, + createBinaryExpression, + updateBinaryExpression, + createConditionalExpression, + updateConditionalExpression, createTemplateExpression, updateTemplateExpression, createTemplateHead, @@ -199,10 +199,10 @@ namespace ts { createTemplateTail, createNoSubstitutionTemplateLiteral, createTemplateLiteralLikeNode, - createYield: createYieldExpression, - updateYield: updateYieldExpression, - createSpread: createSpreadElement, - updateSpread: updateSpreadElement, + createYieldExpression, + updateYieldExpression, + createSpreadElement, + updateSpreadElement, createClassExpression, updateClassExpression, createOmittedExpression, @@ -226,34 +226,34 @@ namespace ts { createEmptyStatement, createExpressionStatement, updateExpressionStatement, - createIf: createIfStatement, - updateIf: updateIfStatement, - createDo: createDoStatement, - updateDo: updateDoStatement, - createWhile: createWhileStatement, - updateWhile: updateWhileStatement, - createFor: createForStatement, - updateFor: updateForStatement, - createForIn: createForInStatement, - updateForIn: updateForInStatement, - createForOf: createForOfStatement, - updateForOf: updateForOfStatement, - createContinue: createContinueStatement, - updateContinue: updateContinueStatement, - createBreak: createBreakStatement, - updateBreak: updateBreakStatement, - createReturn: createReturnStatement, - updateReturn: updateReturnStatement, - createWith: createWithStatement, - updateWith: updateWithStatement, - createSwitch: createSwitchStatement, - updateSwitch: updateSwitchStatement, - createLabel: createLabeledStatement, - updateLabel: updateLabeledStatement, - createThrow: createThrowStatement, - updateThrow: updateThrowStatement, - createTry: createTryStatement, - updateTry: updateTryStatement, + createIfStatement, + updateIfStatement, + createDoStatement, + updateDoStatement, + createWhileStatement, + updateWhileStatement, + createForStatement, + updateForStatement, + createForInStatement, + updateForInStatement, + createForOfStatement, + updateForOfStatement, + createContinueStatement, + updateContinueStatement, + createBreakStatement, + updateBreakStatement, + createReturnStatement, + updateReturnStatement, + createWithStatement, + updateWithStatement, + createSwitchStatement, + updateSwitchStatement, + createLabeledStatement, + updateLabeledStatement, + createThrowStatement, + updateThrowStatement, + createTryStatement, + updateTryStatement, createDebuggerStatement, createVariableDeclaration, updateVariableDeclaration, @@ -415,13 +415,14 @@ namespace ts { createNotEmittedStatement, createPartiallyEmittedExpression, updatePartiallyEmittedExpression, - createCommaList: createCommaListExpression, - updateCommaList: updateCommaListExpression, + createCommaListExpression, + updateCommaListExpression, createEndOfDeclarationMarker, createMergeDeclarationMarker, createSyntheticReferenceExpression, updateSyntheticReferenceExpression, cloneNode, + // Lazily load factory methods for common operator factories and utilities get createComma() { return getBinaryCreateFunction(SyntaxKind.CommaToken); }, get createAssignment() { return getBinaryCreateFunction(SyntaxKind.EqualsToken) as NodeFactory["createAssignment"]; }, diff --git a/src/compiler/factory/parenthesizerRules.ts b/src/compiler/factory/parenthesizerRules.ts index 7a62c11385bcd..069df2d60c9ae 100644 --- a/src/compiler/factory/parenthesizerRules.ts +++ b/src/compiler/factory/parenthesizerRules.ts @@ -201,7 +201,7 @@ namespace ts { } return binaryOperandNeedsParentheses(binaryOperator, operand, isLeftSideOfBinary, leftOperand) - ? factory.createParen(operand) + ? factory.createParenthesizedExpression(operand) : operand; } @@ -215,7 +215,7 @@ namespace ts { } function parenthesizeExpressionOfComputedPropertyName(expression: Expression): Expression { - return isCommaSequence(expression) ? factory.createParen(expression) : expression; + return isCommaSequence(expression) ? factory.createParenthesizedExpression(expression) : expression; } function parenthesizeConditionOfConditionalExpression(condition: Expression): Expression { @@ -223,7 +223,7 @@ namespace ts { const emittedCondition = skipPartiallyEmittedExpressions(condition); const conditionPrecedence = getExpressionPrecedence(emittedCondition); if (compareValues(conditionPrecedence, conditionalPrecedence) !== Comparison.GreaterThan) { - return factory.createParen(condition); + return factory.createParenthesizedExpression(condition); } return condition; } @@ -234,7 +234,7 @@ namespace ts { // if should be wrapped in parens since comma operator has the lowest precedence const emittedExpression = skipPartiallyEmittedExpressions(branch); return isCommaSequence(emittedExpression) - ? factory.createParen(branch) + ? factory.createParenthesizedExpression(branch) : branch; } @@ -259,7 +259,7 @@ namespace ts { needsParens = true; } } - return needsParens ? factory.createParen(expression) : expression; + return needsParens ? factory.createParenthesizedExpression(expression) : expression; } /** @@ -270,11 +270,11 @@ namespace ts { const leftmostExpr = getLeftmostExpression(expression, /*stopAtCallExpressions*/ true); switch (leftmostExpr.kind) { case SyntaxKind.CallExpression: - return factory.createParen(expression); + return factory.createParenthesizedExpression(expression); case SyntaxKind.NewExpression: return !(leftmostExpr as NewExpression).arguments - ? factory.createParen(expression) + ? factory.createParenthesizedExpression(expression) : expression as LeftHandSideExpression; // TODO(rbuckton): Verify this assertion holds } @@ -300,17 +300,17 @@ namespace ts { } // TODO(rbuckton): Verifiy whether `setTextRange` is needed. - return setTextRange(factory.createParen(expression), expression); + return setTextRange(factory.createParenthesizedExpression(expression), expression); } function parenthesizeOperandOfPostfixUnary(operand: Expression): LeftHandSideExpression { // TODO(rbuckton): Verifiy whether `setTextRange` is needed. - return isLeftHandSideExpression(operand) ? operand : setTextRange(factory.createParen(operand), operand); + return isLeftHandSideExpression(operand) ? operand : setTextRange(factory.createParenthesizedExpression(operand), operand); } function parenthesizeOperandOfPrefixUnary(operand: Expression): UnaryExpression { // TODO(rbuckton): Verifiy whether `setTextRange` is needed. - return isUnaryExpression(operand) ? operand : setTextRange(factory.createParen(operand), operand); + return isUnaryExpression(operand) ? operand : setTextRange(factory.createParenthesizedExpression(operand), operand); } function parenthesizeExpressionsOfCommaDelimitedList(elements: NodeArray): NodeArray { @@ -323,7 +323,7 @@ namespace ts { const expressionPrecedence = getExpressionPrecedence(emittedExpression); const commaPrecedence = getOperatorPrecedence(SyntaxKind.BinaryExpression, SyntaxKind.CommaToken); // TODO(rbuckton): Verifiy whether `setTextRange` is needed. - return expressionPrecedence > commaPrecedence ? expression : setTextRange(factory.createParen(expression), expression); + return expressionPrecedence > commaPrecedence ? expression : setTextRange(factory.createParenthesizedExpression(expression), expression); } function parenthesizeExpressionOfExpressionStatement(expression: Expression): Expression { @@ -333,9 +333,9 @@ namespace ts { const kind = skipPartiallyEmittedExpressions(callee).kind; if (kind === SyntaxKind.FunctionExpression || kind === SyntaxKind.ArrowFunction) { // TODO(rbuckton): Verifiy whether `setTextRange` is needed. - const updated = factory.updateCall( + const updated = factory.updateCallExpression( emittedExpression, - setTextRange(factory.createParen(callee), callee), + setTextRange(factory.createParenthesizedExpression(callee), callee), emittedExpression.typeArguments, emittedExpression.arguments ); @@ -346,7 +346,7 @@ namespace ts { const leftmostExpressionKind = getLeftmostExpression(emittedExpression, /*stopAtCallExpressions*/ false).kind; if (leftmostExpressionKind === SyntaxKind.ObjectLiteralExpression || leftmostExpressionKind === SyntaxKind.FunctionExpression) { // TODO(rbuckton): Verifiy whether `setTextRange` is needed. - return setTextRange(factory.createParen(expression), expression); + return setTextRange(factory.createParenthesizedExpression(expression), expression); } return expression; @@ -355,7 +355,7 @@ namespace ts { function parenthesizeConciseBodyOfArrowFunction(body: ConciseBody): ConciseBody { if (!isBlock(body) && (isCommaSequence(body) || getLeftmostExpression(body, /*stopAtCallExpressions*/ false).kind === SyntaxKind.ObjectLiteralExpression)) { // TODO(rbuckton): Verifiy whether `setTextRange` is needed. - return setTextRange(factory.createParen(body), body); + return setTextRange(factory.createParenthesizedExpression(body), body); } return body; diff --git a/src/compiler/factory/utilities.ts b/src/compiler/factory/utilities.ts index df952b7d97b1d..459b578936901 100644 --- a/src/compiler/factory/utilities.ts +++ b/src/compiler/factory/utilities.ts @@ -9,13 +9,13 @@ namespace ts { export function createMemberAccessForPropertyName(factory: NodeFactory, target: Expression, memberName: PropertyName, location?: TextRange): MemberExpression { if (isComputedPropertyName(memberName)) { - return setTextRange(factory.createElementAccess(target, memberName.expression), location); + return setTextRange(factory.createElementAccessExpression(target, memberName.expression), location); } else { const expression = setTextRange( isIdentifierOrPrivateIdentifier(memberName) - ? factory.createPropertyAccess(target, memberName) - : factory.createElementAccess(target, memberName), + ? factory.createPropertyAccessExpression(target, memberName) + : factory.createElementAccessExpression(target, memberName), memberName ); getOrCreateEmitNode(expression).flags |= EmitFlags.NoNestedSourceMaps; @@ -39,7 +39,7 @@ namespace ts { const left = createJsxFactoryExpressionFromEntityName(factory, jsxFactory.left, parent); const right = factory.createIdentifier(idText(jsxFactory.right)) as Mutable; right.escapedText = jsxFactory.right.escapedText; - return factory.createPropertyAccess(left, right); + return factory.createPropertyAccessExpression(left, right); } else { return createReactNamespace(idText(jsxFactory), parent); @@ -49,7 +49,7 @@ namespace ts { function createJsxFactoryExpression(factory: NodeFactory, jsxFactoryEntity: EntityName | undefined, reactNamespace: string, parent: JsxOpeningLikeElement | JsxOpeningFragment): Expression { return jsxFactoryEntity ? createJsxFactoryExpressionFromEntityName(factory, jsxFactoryEntity, parent) : - factory.createPropertyAccess( + factory.createPropertyAccessExpression( createReactNamespace(reactNamespace, parent), "createElement" ); @@ -78,7 +78,7 @@ namespace ts { } return setTextRange( - factory.createCall( + factory.createCallExpression( createJsxFactoryExpression(factory, jsxFactoryEntity, reactNamespace, parentElement), /*typeArguments*/ undefined, argumentsList @@ -88,7 +88,7 @@ namespace ts { } export function createExpressionForJsxFragment(factory: NodeFactory, jsxFactoryEntity: EntityName | undefined, reactNamespace: string, children: readonly Expression[], parentElement: JsxOpeningFragment, location: TextRange): LeftHandSideExpression { - const tagName = factory.createPropertyAccess( + const tagName = factory.createPropertyAccessExpression( createReactNamespace(reactNamespace, parentElement), "Fragment" ); @@ -109,7 +109,7 @@ namespace ts { } return setTextRange( - factory.createCall( + factory.createCallExpression( createJsxFactoryExpression(factory, jsxFactoryEntity, reactNamespace, parentElement), /*typeArguments*/ undefined, argumentsList @@ -158,7 +158,7 @@ namespace ts { const left = createExpressionFromEntityName(factory, node.left); // TODO(rbuckton): Does this need to be parented? const right = setParent(setTextRange(factory.cloneNode(node.right), node.right), node.right.parent); - return setTextRange(factory.createPropertyAccess(left, right), node); + return setTextRange(factory.createPropertyAccessExpression(left, right), node); } else { // TODO(rbuckton): Does this need to be parented? diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 86d7200005882..85c0402f663fb 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -3196,7 +3196,7 @@ namespace ts { parseTokenNode() : parseLiteralLikeNode(token()) as LiteralExpression; if (negative) { - expression = finishNode(factory.createPrefix(SyntaxKind.MinusToken, expression), pos); + expression = finishNode(factory.createPrefixUnaryExpression(SyntaxKind.MinusToken, expression), pos); } return finishNode(factory.createLiteralTypeNode(expression), pos); } @@ -3768,7 +3768,7 @@ namespace ts { if (!scanner.hasPrecedingLineBreak() && (token() === SyntaxKind.AsteriskToken || isStartOfExpression())) { return finishNode( - factory.createYield( + factory.createYieldExpression( parseOptionalToken(SyntaxKind.AsteriskToken), parseAssignmentExpressionOrHigher() ), @@ -3778,7 +3778,7 @@ namespace ts { else { // if the next token is not on the same line as yield. or we don't have an '*' or // the start of an expression, then this is just a simple "yield" expression. - return finishNode(factory.createYield(/*asteriskToken*/ undefined, /*expression*/ undefined), pos); + return finishNode(factory.createYieldExpression(/*asteriskToken*/ undefined, /*expression*/ undefined), pos); } } @@ -4114,7 +4114,7 @@ namespace ts { // we do not that for the 'whenFalse' part. let colonToken; return finishNode( - factory.createConditional( + factory.createConditionalExpression( leftOperand, questionToken, doOutsideOfContext(disallowInAndDecoratorContext, parseAssignmentExpressionOrHigher), @@ -4209,7 +4209,7 @@ namespace ts { } function makeBinaryExpression(left: Expression, operatorToken: BinaryOperatorToken, right: Expression, pos: number): BinaryExpression { - return finishNode(factory.createBinary(left, operatorToken, right), pos); + return finishNode(factory.createBinaryExpression(left, operatorToken, right), pos); } function makeAsExpression(left: Expression, right: TypeNode): AsExpression { @@ -4218,22 +4218,22 @@ namespace ts { function parsePrefixUnaryExpression() { const pos = getNodePos(); - return finishNode(factory.createPrefix(token(), nextTokenAnd(parseSimpleUnaryExpression)), pos); + return finishNode(factory.createPrefixUnaryExpression(token(), nextTokenAnd(parseSimpleUnaryExpression)), pos); } function parseDeleteExpression() { const pos = getNodePos(); - return finishNode(factory.createDelete(nextTokenAnd(parseSimpleUnaryExpression)), pos); + return finishNode(factory.createDeleteExpression(nextTokenAnd(parseSimpleUnaryExpression)), pos); } function parseTypeOfExpression() { const pos = getNodePos(); - return finishNode(factory.createTypeOf(nextTokenAnd(parseSimpleUnaryExpression)), pos); + return finishNode(factory.createTypeOfExpression(nextTokenAnd(parseSimpleUnaryExpression)), pos); } function parseVoidExpression() { const pos = getNodePos(); - return finishNode(factory.createVoid(nextTokenAnd(parseSimpleUnaryExpression)), pos); + return finishNode(factory.createVoidExpression(nextTokenAnd(parseSimpleUnaryExpression)), pos); } function isAwaitExpression(): boolean { @@ -4251,7 +4251,7 @@ namespace ts { function parseAwaitExpression() { const pos = getNodePos(); - return finishNode(factory.createAwait(nextTokenAnd(parseSimpleUnaryExpression)), pos); + return finishNode(factory.createAwaitExpression(nextTokenAnd(parseSimpleUnaryExpression)), pos); } /** @@ -4396,7 +4396,7 @@ namespace ts { function parseUpdateExpression(): UpdateExpression { if (token() === SyntaxKind.PlusPlusToken || token() === SyntaxKind.MinusMinusToken) { const pos = getNodePos(); - return finishNode(factory.createPrefix(token(), nextTokenAnd(parseLeftHandSideExpressionOrHigher)), pos); + return finishNode(factory.createPrefixUnaryExpression(token(), nextTokenAnd(parseLeftHandSideExpressionOrHigher)), pos); } else if (languageVariant === LanguageVariant.JSX && token() === SyntaxKind.LessThanToken && lookAhead(nextTokenIsIdentifierOrKeywordOrGreaterThan)) { // JSXElement is part of primaryExpression @@ -4409,7 +4409,7 @@ namespace ts { if ((token() === SyntaxKind.PlusPlusToken || token() === SyntaxKind.MinusMinusToken) && !scanner.hasPrecedingLineBreak()) { const operator = token(); nextToken(); - return finishNode(factory.createPostfix(expression, operator), expression.pos); + return finishNode(factory.createPostfixUnaryExpression(expression, operator), expression.pos); } return expression; @@ -4552,7 +4552,7 @@ namespace ts { // If it wasn't then just try to parse out a '.' and report an error. parseExpectedToken(SyntaxKind.DotToken, Diagnostics.super_must_be_followed_by_an_argument_list_or_member_access); // private names will never work with `super` (`super.#foo`), but that's a semantic error, not syntactic - return finishNode(factory.createPropertyAccess(expression, parseRightSideOfDot(/*allowIdentifierNames*/ true, /*allowPrivateIdentifiers*/ true)), pos); + return finishNode(factory.createPropertyAccessExpression(expression, parseRightSideOfDot(/*allowIdentifierNames*/ true, /*allowPrivateIdentifiers*/ true)), pos); } function parseJsxElementOrSelfClosingElementOrFragment(inExpressionContext: boolean, topInvalidNodePosition?: number): JsxElement | JsxSelfClosingElement | JsxFragment { @@ -4592,7 +4592,7 @@ namespace ts { const operatorToken = createMissingNode(SyntaxKind.CommaToken, /*reportAtCurrentPosition*/ false); setTextRangePosWidth(operatorToken, invalidElement.pos, 0); parseErrorAt(skipTrivia(sourceText, topBadPos), invalidElement.end, Diagnostics.JSX_expressions_must_have_one_parent_element); - return finishNode(factory.createBinary(result, operatorToken as Token, invalidElement), pos); + return finishNode(factory.createBinaryExpression(result, operatorToken as Token, invalidElement), pos); } } @@ -4708,7 +4708,7 @@ namespace ts { let expression: JsxTagNameExpression = token() === SyntaxKind.ThisKeyword ? parseTokenNode() : parseIdentifierName(); while (parseOptional(SyntaxKind.DotToken)) { - expression = finishNode(factory.createPropertyAccess(expression, parseRightSideOfDot(/*allowIdentifierNames*/ true, /*allowPrivateIdentifiers*/ false)), pos) as JsxTagNamePropertyAccess; + expression = finishNode(factory.createPropertyAccessExpression(expression, parseRightSideOfDot(/*allowIdentifierNames*/ true, /*allowPrivateIdentifiers*/ false)), pos) as JsxTagNamePropertyAccess; } return expression; } @@ -4845,7 +4845,7 @@ namespace ts { const isOptionalChain = questionDotToken || tryReparseOptionalChain(expression); const propertyAccess = isOptionalChain ? factory.createPropertyAccessChain(expression, questionDotToken, name) : - factory.createPropertyAccess(expression, name); + factory.createPropertyAccessExpression(expression, name); if (isOptionalChain && isPrivateIdentifier(propertyAccess.name)) { parseErrorAtRange(propertyAccess.name, Diagnostics.An_optional_chain_cannot_contain_private_identifiers); } @@ -4869,7 +4869,7 @@ namespace ts { const indexedAccess = questionDotToken || tryReparseOptionalChain(expression) ? factory.createElementAccessChain(expression, questionDotToken, argumentExpression) : - factory.createElementAccess(expression, argumentExpression); + factory.createElementAccessExpression(expression, argumentExpression); return finishNode(indexedAccess, pos); } @@ -4916,7 +4916,7 @@ namespace ts { } function parseTaggedTemplateRest(pos: number, tag: LeftHandSideExpression, questionDotToken: QuestionDotToken | undefined, typeArguments: NodeArray | undefined) { - const tagExpression = factory.createTaggedTemplate( + const tagExpression = factory.createTaggedTemplateExpression( tag, typeArguments, token() === SyntaxKind.NoSubstitutionTemplateLiteral ? @@ -4950,7 +4950,7 @@ namespace ts { const argumentList = parseArgumentList(); const callExpr = questionDotToken || tryReparseOptionalChain(expression) ? factory.createCallChain(expression, questionDotToken, typeArguments, argumentList) : - factory.createCall(expression, typeArguments, argumentList); + factory.createCallExpression(expression, typeArguments, argumentList); expression = finishNode(callExpr, pos); continue; } @@ -4959,7 +4959,7 @@ namespace ts { const argumentList = parseArgumentList(); const callExpr = questionDotToken || tryReparseOptionalChain(expression) ? factory.createCallChain(expression, questionDotToken, /*typeArguments*/ undefined, argumentList) : - factory.createCall(expression, /*typeArguments*/ undefined, argumentList); + factory.createCallExpression(expression, /*typeArguments*/ undefined, argumentList); expression = finishNode(callExpr, pos); continue; } @@ -5095,14 +5095,14 @@ namespace ts { parseExpected(SyntaxKind.OpenParenToken); const expression = allowInAnd(parseExpression); parseExpected(SyntaxKind.CloseParenToken); - return withJSDoc(finishNode(factory.createParen(expression), pos), hasJSDoc); + return withJSDoc(finishNode(factory.createParenthesizedExpression(expression), pos), hasJSDoc); } function parseSpreadElement(): Expression { const pos = getNodePos(); parseExpected(SyntaxKind.DotDotDotToken); const expression = parseAssignmentExpressionOrHigher(); - return finishNode(factory.createSpread(expression), pos); + return finishNode(factory.createSpreadElement(expression), pos); } function parseArgumentOrArrayLiteralElement(): Expression { @@ -5121,7 +5121,7 @@ namespace ts { const multiLine = scanner.hasPrecedingLineBreak(); const elements = parseDelimitedList(ParsingContext.ArrayLiteralMembers, parseArgumentOrArrayLiteralElement); parseExpected(SyntaxKind.CloseBracketToken); - return finishNode(factory.createArrayLiteral(elements, multiLine), pos); + return finishNode(factory.createArrayLiteralExpression(elements, multiLine), pos); } function parseObjectLiteralElement(): ObjectLiteralElementLike { @@ -5198,7 +5198,7 @@ namespace ts { ); } } - return finishNode(factory.createObjectLiteral(properties, multiLine), pos); + return finishNode(factory.createObjectLiteralExpression(properties, multiLine), pos); } function parseFunctionExpression(): FunctionExpression { @@ -5272,7 +5272,7 @@ namespace ts { else if (typeArguments) { parseErrorAt(pos, scanner.getStartPos(), Diagnostics.A_new_expression_with_type_arguments_must_always_be_followed_by_a_parenthesized_argument_list); } - return finishNode(factory.createNew(expression, typeArguments, argumentsArray), pos); + return finishNode(factory.createNewExpression(expression, typeArguments, argumentsArray), pos); } // STATEMENTS @@ -5339,7 +5339,7 @@ namespace ts { parseExpected(SyntaxKind.CloseParenToken); const thenStatement = parseStatement(); const elseStatement = parseOptional(SyntaxKind.ElseKeyword) ? parseStatement() : undefined; - return finishNode(factory.createIf(expression, thenStatement, elseStatement), pos); + return finishNode(factory.createIfStatement(expression, thenStatement, elseStatement), pos); } function parseDoStatement(): DoStatement { @@ -5356,7 +5356,7 @@ namespace ts { // spec but allowed in consensus reality. Approved -- this is the de-facto standard whereby // do;while(0)x will have a semicolon inserted before x. parseOptional(SyntaxKind.SemicolonToken); - return finishNode(factory.createDo(statement, expression), pos); + return finishNode(factory.createDoStatement(statement, expression), pos); } function parseWhileStatement(): WhileStatement { @@ -5366,7 +5366,7 @@ namespace ts { const expression = allowInAnd(parseExpression); parseExpected(SyntaxKind.CloseParenToken); const statement = parseStatement(); - return finishNode(factory.createWhile(expression, statement), pos); + return finishNode(factory.createWhileStatement(expression, statement), pos); } function parseForOrForInOrForOfStatement(): Statement { @@ -5389,12 +5389,12 @@ namespace ts { if (awaitToken ? parseExpected(SyntaxKind.OfKeyword) : parseOptional(SyntaxKind.OfKeyword)) { const expression = allowInAnd(parseAssignmentExpressionOrHigher); parseExpected(SyntaxKind.CloseParenToken); - node = factory.createForOf(awaitToken, initializer, expression, parseStatement()); + node = factory.createForOfStatement(awaitToken, initializer, expression, parseStatement()); } else if (parseOptional(SyntaxKind.InKeyword)) { const expression = allowInAnd(parseExpression); parseExpected(SyntaxKind.CloseParenToken); - node = factory.createForIn(initializer, expression, parseStatement()); + node = factory.createForInStatement(initializer, expression, parseStatement()); } else { parseExpected(SyntaxKind.SemicolonToken); @@ -5406,7 +5406,7 @@ namespace ts { ? allowInAnd(parseExpression) : undefined; parseExpected(SyntaxKind.CloseParenToken); - node = factory.createFor(initializer, condition, incrementor, parseStatement()); + node = factory.createForStatement(initializer, condition, incrementor, parseStatement()); } return finishNode(node, pos); @@ -5420,8 +5420,8 @@ namespace ts { parseSemicolon(); const node = kind === SyntaxKind.BreakStatement - ? factory.createBreak(label) - : factory.createContinue(label); + ? factory.createBreakStatement(label) + : factory.createContinueStatement(label); return finishNode(node, pos); } @@ -5430,7 +5430,7 @@ namespace ts { parseExpected(SyntaxKind.ReturnKeyword); const expression = canParseSemicolon() ? undefined : allowInAnd(parseExpression); parseSemicolon(); - return finishNode(factory.createReturn(expression), pos); + return finishNode(factory.createReturnStatement(expression), pos); } function parseWithStatement(): WithStatement { @@ -5440,7 +5440,7 @@ namespace ts { const expression = allowInAnd(parseExpression); parseExpected(SyntaxKind.CloseParenToken); const statement = doInsideOfContext(NodeFlags.InWithStatement, parseStatement); - return finishNode(factory.createWith(expression, statement), pos); + return finishNode(factory.createWithStatement(expression, statement), pos); } function parseCaseClause(): CaseClause { @@ -5479,7 +5479,7 @@ namespace ts { const expression = allowInAnd(parseExpression); parseExpected(SyntaxKind.CloseParenToken); const caseBlock = parseCaseBlock(); - return finishNode(factory.createSwitch(expression, caseBlock), pos); + return finishNode(factory.createSwitchStatement(expression, caseBlock), pos); } function parseThrowStatement(): ThrowStatement { @@ -5497,7 +5497,7 @@ namespace ts { // TODO(rbuckton): Should we use `createMissingNode` here instead? const expression = scanner.hasPrecedingLineBreak() ? undefined : allowInAnd(parseExpression); parseSemicolon(); - return finishNode(factory.createThrow(expression!), pos); + return finishNode(factory.createThrowStatement(expression!), pos); } // TODO: Review for error recovery @@ -5516,7 +5516,7 @@ namespace ts { finallyBlock = parseBlock(/*ignoreMissingOpenBrace*/ false); } - return finishNode(factory.createTry(tryBlock, catchClause, finallyBlock), pos); + return finishNode(factory.createTryStatement(tryBlock, catchClause, finallyBlock), pos); } function parseCatchClause(): CatchClause { @@ -5554,7 +5554,7 @@ namespace ts { const hasParen = token() === SyntaxKind.OpenParenToken; const expression = allowInAnd(parseExpression); if (ts.isIdentifier(expression) && parseOptional(SyntaxKind.ColonToken)) { - node = factory.createLabel(expression, parseStatement()); + node = factory.createLabeledStatement(expression, parseStatement()); } else { parseSemicolon(); @@ -7526,7 +7526,7 @@ namespace ts { let node: Identifier | PropertyAccessEntityNameExpression = parseJSDocIdentifierName(); while (parseOptional(SyntaxKind.DotToken)) { const name = parseJSDocIdentifierName(); - node = finishNode(factory.createPropertyAccess(node, name), pos) as PropertyAccessEntityNameExpression; + node = finishNode(factory.createPropertyAccessExpression(node, name), pos) as PropertyAccessEntityNameExpression; } return node; } diff --git a/src/compiler/transformers/classFields.ts b/src/compiler/transformers/classFields.ts index fd9a4bb2f751f..774ded70dfef4 100644 --- a/src/compiler/transformers/classFields.ts +++ b/src/compiler/transformers/classFields.ts @@ -253,13 +253,13 @@ namespace ts { const receiver = visitNode(node.operand.expression, visitor, isExpression); const { readExpression, initializeExpression } = createCopiableReceiverExpr(receiver); - const existingValue = factory.createPrefix(SyntaxKind.PlusToken, createPrivateIdentifierAccess(info, readExpression)); + const existingValue = factory.createPrefixUnaryExpression(SyntaxKind.PlusToken, createPrivateIdentifierAccess(info, readExpression)); return setOriginalNode( createPrivateIdentifierAssignment( info, initializeExpression || readExpression, - factory.createBinary(existingValue, operator, factory.createNumericLiteral(1)), + factory.createBinaryExpression(existingValue, operator, factory.createNumericLiteral(1)), SyntaxKind.EqualsToken ), node @@ -279,7 +279,7 @@ namespace ts { const receiver = visitNode(node.operand.expression, visitor, isExpression); const { readExpression, initializeExpression } = createCopiableReceiverExpr(receiver); - const existingValue = factory.createPrefix(SyntaxKind.PlusToken, createPrivateIdentifierAccess(info, readExpression)); + const existingValue = factory.createPrefixUnaryExpression(SyntaxKind.PlusToken, createPrivateIdentifierAccess(info, readExpression)); // Create a temporary variable to store the value returned by the expression. const returnValue = valueIsDiscarded ? undefined : factory.createTempVariable(hoistVariableDeclaration); @@ -289,7 +289,7 @@ namespace ts { createPrivateIdentifierAssignment( info, initializeExpression || readExpression, - factory.createBinary( + factory.createBinaryExpression( returnValue ? factory.createAssignment(returnValue, existingValue) : existingValue, operator, factory.createNumericLiteral(1) @@ -307,7 +307,7 @@ namespace ts { function visitForStatement(node: ForStatement) { if (node.incrementor && isPostfixUnaryExpression(node.incrementor)) { - return factory.updateFor( + return factory.updateForStatement( node, visitNode(node.initializer, visitor, isForInitializer), visitNode(node.condition, visitor, isExpression), @@ -339,9 +339,9 @@ namespace ts { if (shouldTransformPrivateFields && isPrivateIdentifierPropertyAccessExpression(node.expression)) { // Transform call expressions of private names to properly bind the `this` parameter. const { thisArg, target } = factory.createCallBinding(node.expression, hoistVariableDeclaration, languageVersion); - return factory.updateCall( + return factory.updateCallExpression( node, - factory.createPropertyAccess(visitNode(target, visitor), "call"), + factory.createPropertyAccessExpression(visitNode(target, visitor), "call"), /*typeArguments*/ undefined, [visitNode(thisArg, visitor, isExpression), ...visitNodes(node.arguments, visitor, isExpression)] ); @@ -353,10 +353,10 @@ namespace ts { if (shouldTransformPrivateFields && isPrivateIdentifierPropertyAccessExpression(node.tag)) { // Bind the `this` correctly for tagged template literals when the tag is a private identifier property access. const { thisArg, target } = factory.createCallBinding(node.tag, hoistVariableDeclaration, languageVersion); - return factory.updateTaggedTemplate( + return factory.updateTaggedTemplateExpression( node, - factory.createCall( - factory.createPropertyAccess(visitNode(target, visitor), "bind"), + factory.createCallExpression( + factory.createPropertyAccessExpression(visitNode(target, visitor), "bind"), /*typeArguments*/ undefined, [visitNode(thisArg, visitor, isExpression)] ), @@ -372,7 +372,7 @@ namespace ts { if (isDestructuringAssignment(node)) { const savedPendingExpressions = pendingExpressions; pendingExpressions = undefined!; - node = factory.updateBinary( + node = factory.updateBinaryExpression( node, visitNode(node.left, visitorDestructuringTarget), node.operatorToken, @@ -414,7 +414,7 @@ namespace ts { return context.getEmitHelperFactory().createClassPrivateFieldSetHelper( initializeExpression || readExpression, info.weakMapName, - factory.createBinary( + factory.createBinaryExpression( context.getEmitHelperFactory().createClassPrivateFieldGetHelper(readExpression, info.weakMapName), getNonAssignmentOperatorForCompoundAssignment(operator), right @@ -642,10 +642,10 @@ namespace ts { // statements.push( factory.createExpressionStatement( - factory.createCall( + factory.createCallExpression( factory.createSuper(), /*typeArguments*/ undefined, - [factory.createSpread(factory.createIdentifier("arguments"))] + [factory.createSpreadElement(factory.createIdentifier("arguments"))] ) ) ); @@ -905,7 +905,7 @@ namespace ts { getPendingExpressions().push( factory.createAssignment( weakMapName, - factory.createNew( + factory.createNewExpression( factory.createIdentifier("WeakMap"), /*typeArguments*/ undefined, [] @@ -946,12 +946,12 @@ namespace ts { // differently inside the function. if (isThisProperty(node) || isSuperProperty(node) || !isSimpleCopiableExpression(node.expression)) { receiver = factory.createTempVariable(hoistVariableDeclaration, /*reservedInNestedScopes*/ true); - getPendingExpressions().push(factory.createBinary(receiver, SyntaxKind.EqualsToken, node.expression)); + getPendingExpressions().push(factory.createBinaryExpression(receiver, SyntaxKind.EqualsToken, node.expression)); } - return factory.createPropertyAccess( + return factory.createPropertyAccessExpression( // Explicit parens required because of v8 regression (https://bugs.chromium.org/p/v8/issues/detail?id=9560) - factory.createParen( - factory.createObjectLiteral([ + factory.createParenthesizedExpression( + factory.createObjectLiteralExpression([ factory.createSetAccessorDeclaration( /*decorators*/ undefined, /*modifiers*/ undefined, @@ -987,7 +987,7 @@ namespace ts { if (target && isPrivateIdentifierPropertyAccessExpression(target)) { const wrapped = wrapPrivateIdentifierForDestructuringTarget(target); if (isAssignmentExpression(node)) { - return factory.updateBinary( + return factory.updateBinaryExpression( node, wrapped, node.operatorToken, @@ -995,7 +995,7 @@ namespace ts { ); } else if (isSpreadElement(node)) { - return factory.updateSpread(node, wrapped); + return factory.updateSpreadElement(node, wrapped); } else { return wrapped; @@ -1035,7 +1035,7 @@ namespace ts { // // Transformation: // [ { set value(x) { this.#myProp = x; } }.value ] = [ "hello" ]; - return factory.updateArrayLiteral( + return factory.updateArrayLiteralExpression( node, visitNodes(node.elements, visitArrayAssignmentTarget, isExpression) ); @@ -1048,7 +1048,7 @@ namespace ts { // // Transformation: // ({ stringProperty: { set value(x) { this.#myProp = x; } }.value }) = { stringProperty: "hello" }; - return factory.updateObjectLiteral( + return factory.updateObjectLiteralExpression( node, visitNodes(node.properties, visitObjectAssignmentTarget, isObjectLiteralElementLike) ); @@ -1057,8 +1057,8 @@ namespace ts { } function createPrivateInstanceFieldInitializer(receiver: LeftHandSideExpression, initializer: Expression | undefined, weakMapName: Identifier) { - return factory.createCall( - factory.createPropertyAccess(weakMapName, "set"), + return factory.createCallExpression( + factory.createPropertyAccessExpression(weakMapName, "set"), /*typeArguments*/ undefined, [receiver, initializer || factory.createVoidZero()] ); diff --git a/src/compiler/transformers/destructuring.ts b/src/compiler/transformers/destructuring.ts index 22df01488e831..1dcbc0814750d 100644 --- a/src/compiler/transformers/destructuring.ts +++ b/src/compiler/transformers/destructuring.ts @@ -410,7 +410,7 @@ namespace ts { continue; } else if (!getRestIndicatorOfBindingOrAssignmentElement(element)) { - const rhsValue = flattenContext.context.factory.createElementAccess(value, i); + const rhsValue = flattenContext.context.factory.createElementAccessExpression(value, i); flattenBindingOrAssignmentElement(flattenContext, element, rhsValue, /*location*/ element); } else if (i === numElements - 1) { @@ -438,7 +438,7 @@ namespace ts { */ function createDefaultValueCheck(flattenContext: FlattenContext, value: Expression, defaultValue: Expression, location: TextRange): Expression { value = ensureIdentifier(flattenContext, value, /*reuseIdentifierExpressions*/ true, location); - return flattenContext.context.factory.createConditional(flattenContext.context.factory.createTypeCheck(value, "undefined"), /*questionToken*/ undefined, defaultValue, /*colonToken*/ undefined, value); + return flattenContext.context.factory.createConditionalExpression(flattenContext.context.factory.createTypeCheck(value, "undefined"), /*questionToken*/ undefined, defaultValue, /*colonToken*/ undefined, value); } /** @@ -454,15 +454,15 @@ namespace ts { function createDestructuringPropertyAccess(flattenContext: FlattenContext, value: Expression, propertyName: PropertyName): LeftHandSideExpression { if (isComputedPropertyName(propertyName)) { const argumentExpression = ensureIdentifier(flattenContext, visitNode(propertyName.expression, flattenContext.visitor), /*reuseIdentifierExpressions*/ false, /*location*/ propertyName); - return flattenContext.context.factory.createElementAccess(value, argumentExpression); + return flattenContext.context.factory.createElementAccessExpression(value, argumentExpression); } else if (isStringOrNumericLiteralLike(propertyName)) { const argumentExpression = factory.cloneNode(propertyName); - return flattenContext.context.factory.createElementAccess(value, argumentExpression); + return flattenContext.context.factory.createElementAccessExpression(value, argumentExpression); } else { const name = flattenContext.context.factory.createIdentifier(idText(propertyName)); - return flattenContext.context.factory.createPropertyAccess(value, name); + return flattenContext.context.factory.createPropertyAccessExpression(value, name); } } @@ -500,7 +500,7 @@ namespace ts { } function makeArrayAssignmentPattern(factory: NodeFactory, elements: BindingOrAssignmentElement[]) { - return factory.createArrayLiteral(map(elements, factory.converters.convertToArrayAssignmentElement)); + return factory.createArrayLiteralExpression(map(elements, factory.converters.convertToArrayAssignmentElement)); } function makeObjectBindingPattern(factory: NodeFactory, elements: BindingOrAssignmentElement[]) { @@ -509,7 +509,7 @@ namespace ts { } function makeObjectAssignmentPattern(factory: NodeFactory, elements: BindingOrAssignmentElement[]) { - return factory.createObjectLiteral(map(elements, factory.converters.convertToObjectAssignmentElement)); + return factory.createObjectLiteralExpression(map(elements, factory.converters.convertToObjectAssignmentElement)); } function makeBindingElement(factory: NodeFactory, name: Identifier) { diff --git a/src/compiler/transformers/es2015.ts b/src/compiler/transformers/es2015.ts index 5ffebb2f16f7e..dc4078caa2433 100644 --- a/src/compiler/transformers/es2015.ts +++ b/src/compiler/transformers/es2015.ts @@ -553,7 +553,7 @@ namespace ts { } function returnCapturedThis(node: Node): ReturnStatement { - return setOriginalNode(factory.createReturn(factory.createUniqueName("_this", GeneratedIdentifierFlags.Optimistic | GeneratedIdentifierFlags.FileLevel)), node); + return setOriginalNode(factory.createReturnStatement(factory.createUniqueName("_this", GeneratedIdentifierFlags.Optimistic | GeneratedIdentifierFlags.FileLevel)), node); } function visitReturnStatement(node: ReturnStatement): Statement { @@ -562,8 +562,8 @@ namespace ts { if (isReturnVoidStatementInConstructorWithCapturedSuper(node)) { node = returnCapturedThis(node); } - return factory.createReturn( - factory.createObjectLiteral( + return factory.createReturnStatement( + factory.createObjectLiteralExpression( [ factory.createPropertyAssignment( factory.createIdentifier("value"), @@ -651,12 +651,12 @@ namespace ts { expr = copyExpr; } else { - expr = factory.createBinary(expr!, SyntaxKind.CommaToken, copyExpr); + expr = factory.createBinaryExpression(expr!, SyntaxKind.CommaToken, copyExpr); } } - returnExpression = factory.createBinary(expr!, SyntaxKind.CommaToken, returnExpression); + returnExpression = factory.createBinaryExpression(expr!, SyntaxKind.CommaToken, returnExpression); } - return factory.createReturn(returnExpression); + return factory.createReturnStatement(returnExpression); } } return visitEachChild(node, visitor, context); @@ -793,8 +793,8 @@ namespace ts { setTextRangeEnd(outer, skipTrivia(currentText, node.pos)); setEmitFlags(outer, EmitFlags.NoComments); - const result = factory.createParen( - factory.createCall( + const result = factory.createParenthesizedExpression( + factory.createCallExpression( outer, /*typeArguments*/ undefined, extendsClauseElement @@ -829,7 +829,7 @@ namespace ts { setTextRangeEnd(outer, closingBraceLocation.end); setEmitFlags(outer, EmitFlags.NoComments); - const statement = factory.createReturn(outer); + const statement = factory.createReturnStatement(outer); setTextRangePos(statement, closingBraceLocation.pos); setEmitFlags(statement, EmitFlags.NoComments | EmitFlags.NoTokenSourceMaps); statements.push(statement); @@ -922,7 +922,7 @@ namespace ts { if (isDerivedClass) { // return _super !== null && _super.apply(this, arguments) || this; - statements.push(factory.createReturn(createDefaultSuperCallOrThis())); + statements.push(factory.createReturnStatement(createDefaultSuperCallOrThis())); } const statementsArray = factory.createNodeArray(statements); @@ -1024,7 +1024,7 @@ namespace ts { // })(Base); // ``` const superCall = cast(cast(superCallExpression, isBinaryExpression).left, isCallExpression); - const returnStatement = factory.createReturn(superCallExpression); + const returnStatement = factory.createReturnStatement(superCallExpression); setCommentRange(returnStatement, getCommentRange(superCall)); setEmitFlags(superCall, EmitFlags.NoComments); statements.push(returnStatement); @@ -1057,7 +1057,7 @@ namespace ts { insertCaptureThisForNode(statements, constructor, superCallExpression || createActualThis()); if (!isSufficientlyCoveredByReturnStatements(constructor.body)) { - statements.push(factory.createReturn(factory.createUniqueName("_this", GeneratedIdentifierFlags.Optimistic | GeneratedIdentifierFlags.FileLevel))); + statements.push(factory.createReturnStatement(factory.createUniqueName("_this", GeneratedIdentifierFlags.Optimistic | GeneratedIdentifierFlags.FileLevel))); } } } @@ -1295,7 +1295,7 @@ namespace ts { */ function insertDefaultValueAssignmentForInitializer(statements: Statement[], parameter: ParameterDeclaration, name: Identifier, initializer: Expression): void { initializer = visitNode(initializer, visitor, isExpression); - const statement = factory.createIf( + const statement = factory.createIfStatement( factory.createTypeCheck(factory.cloneNode(name), "undefined"), setEmitFlags( setTextRange( @@ -1375,7 +1375,7 @@ namespace ts { declarationName, /*exclamationToken*/ undefined, /*type*/ undefined, - factory.createArrayLiteral([]) + factory.createArrayLiteralExpression([]) ) ]) ), @@ -1388,7 +1388,7 @@ namespace ts { // for (var _i = restIndex; _i < arguments.length; _i++) { // param[_i - restIndex] = arguments[_i]; // } - const forStatement = factory.createFor( + const forStatement = factory.createForStatement( setTextRange( factory.createVariableDeclarationList([ factory.createVariableDeclaration(temp, /*exclamationToken*/ undefined, /*type*/ undefined, factory.createNumericLiteral(restIndex)) @@ -1398,7 +1398,7 @@ namespace ts { setTextRange( factory.createLessThan( temp, - factory.createPropertyAccess(factory.createIdentifier("arguments"), "length") + factory.createPropertyAccessExpression(factory.createIdentifier("arguments"), "length") ), parameter ), @@ -1408,13 +1408,13 @@ namespace ts { setTextRange( factory.createExpressionStatement( factory.createAssignment( - factory.createElementAccess( + factory.createElementAccessExpression( expressionName, restIndex === 0 ? temp : factory.createSubtract(temp, factory.createNumericLiteral(restIndex)) ), - factory.createElementAccess(factory.createIdentifier("arguments"), temp) + factory.createElementAccessExpression(factory.createIdentifier("arguments"), temp) ) ), /*location*/ parameter @@ -1500,7 +1500,7 @@ namespace ts { case SyntaxKind.Constructor: // Class constructors can only be called with `new`, so `this.constructor` // should be relatively safe to use. - newTarget = factory.createPropertyAccess( + newTarget = factory.createPropertyAccessExpression( setEmitFlags(factory.createThis(), EmitFlags.NoSubstitution), "constructor" ); @@ -1510,17 +1510,17 @@ namespace ts { case SyntaxKind.FunctionExpression: // Functions can be called or constructed, and may have a `this` due to // being a member or when calling an imported function via `other_1.f()`. - newTarget = factory.createConditional( + newTarget = factory.createConditionalExpression( factory.createLogicalAnd( setEmitFlags(factory.createThis(), EmitFlags.NoSubstitution), - factory.createBinary( + factory.createBinaryExpression( setEmitFlags(factory.createThis(), EmitFlags.NoSubstitution), SyntaxKind.InstanceOfKeyword, factory.getLocalName(node) ) ), /*questionToken*/ undefined, - factory.createPropertyAccess( + factory.createPropertyAccessExpression( setEmitFlags(factory.createThis(), EmitFlags.NoSubstitution), "constructor" ), @@ -1702,13 +1702,13 @@ namespace ts { factory.createPropertyAssignment("configurable", factory.createTrue()) ); - const call = factory.createCall( - factory.createPropertyAccess(factory.createIdentifier("Object"), "defineProperty"), + const call = factory.createCallExpression( + factory.createPropertyAccessExpression(factory.createIdentifier("Object"), "defineProperty"), /*typeArguments*/ undefined, [ target, propertyName, - factory.createObjectLiteral(properties, /*multiLine*/ true) + factory.createObjectLiteralExpression(properties, /*multiLine*/ true) ] ); if (startsOnNewLine) { @@ -1915,7 +1915,7 @@ namespace ts { } const expression = visitNode(body, visitor, isExpression); - const returnStatement = factory.createReturn(expression); + const returnStatement = factory.createReturnStatement(expression); setTextRange(returnStatement, body); moveSyntheticComments(returnStatement, body); setEmitFlags(returnStatement, EmitFlags.NoTokenSourceMaps | EmitFlags.NoTrailingSourceMap | EmitFlags.NoTrailingComments); @@ -1999,9 +1999,9 @@ namespace ts { // we pass that information along to the children that care about it. switch (node.expression.kind) { case SyntaxKind.ParenthesizedExpression: - return factory.updateParen(node, visitParenthesizedExpression(node.expression, /*needsDestructuringValue*/ false)); + return factory.updateParenthesizedExpression(node, visitParenthesizedExpression(node.expression, /*needsDestructuringValue*/ false)); case SyntaxKind.BinaryExpression: - return factory.updateParen(node, visitBinaryExpression(node.expression, /*needsDestructuringValue*/ false)); + return factory.updateParenthesizedExpression(node, visitBinaryExpression(node.expression, /*needsDestructuringValue*/ false)); } } return visitEachChild(node, visitor, context); @@ -2052,7 +2052,7 @@ namespace ts { ); } else { - assignment = factory.createBinary(decl.name, SyntaxKind.EqualsToken, visitNode(decl.initializer, visitor, isExpression)); + assignment = factory.createBinaryExpression(decl.name, SyntaxKind.EqualsToken, visitNode(decl.initializer, visitor, isExpression)); setTextRange(assignment, decl); } @@ -2439,7 +2439,7 @@ namespace ts { setEmitFlags(expression, EmitFlags.NoSourceMap | getEmitFlags(expression)); const forStatement = setTextRange( - factory.createFor( + factory.createForStatement( /*initializer*/ setEmitFlags( setTextRange( factory.createVariableDeclarationList([ @@ -2453,14 +2453,14 @@ namespace ts { /*condition*/ setTextRange( factory.createLessThan( counter, - factory.createPropertyAccess(rhsReference, "length") + factory.createPropertyAccessExpression(rhsReference, "length") ), node.expression ), /*incrementor*/ setTextRange(factory.createPostfixIncrement(counter), node.expression), /*statement*/ convertForOfStatementHead( node, - factory.createElementAccess(rhsReference, counter), + factory.createElementAccessExpression(rhsReference, counter), convertedLoopBodyStatements ) ), @@ -2481,7 +2481,7 @@ namespace ts { const catchVariable = factory.getGeneratedNameForNode(errorRecord); const returnMethod = factory.createTempVariable(/*recordTempVariable*/ undefined); const values = setTextRange(emitHelpers().createValuesHelper(expression), node.expression); - const next = factory.createCall(factory.createPropertyAccess(iterator, "next"), /*typeArguments*/ undefined, []); + const next = factory.createCallExpression(factory.createPropertyAccessExpression(iterator, "next"), /*typeArguments*/ undefined, []); hoistVariableDeclaration(errorRecord); hoistVariableDeclaration(returnMethod); @@ -2493,7 +2493,7 @@ namespace ts { const forStatement = setEmitFlags( setTextRange( - factory.createFor( + factory.createForStatement( /*initializer*/ setEmitFlags( setTextRange( factory.createVariableDeclarationList([ @@ -2504,11 +2504,11 @@ namespace ts { ), EmitFlags.NoHoisting ), - /*condition*/ factory.createLogicalNot(factory.createPropertyAccess(result, "done")), + /*condition*/ factory.createLogicalNot(factory.createPropertyAccessExpression(result, "done")), /*incrementor*/ factory.createAssignment(result, next), /*statement*/ convertForOfStatementHead( node, - factory.createPropertyAccess(result, "value"), + factory.createPropertyAccessExpression(result, "value"), convertedLoopBodyStatements ) ), @@ -2517,7 +2517,7 @@ namespace ts { EmitFlags.NoTokenTrailingSourceMaps ); - return factory.createTry( + return factory.createTryStatement( factory.createBlock([ factory.restoreEnclosingLabel( forStatement, @@ -2531,7 +2531,7 @@ namespace ts { factory.createExpressionStatement( factory.createAssignment( errorRecord, - factory.createObjectLiteral([ + factory.createObjectLiteralExpression([ factory.createPropertyAssignment("error", catchVariable) ]) ) @@ -2541,20 +2541,20 @@ namespace ts { ) ), factory.createBlock([ - factory.createTry( + factory.createTryStatement( /*tryBlock*/ factory.createBlock([ setEmitFlags( - factory.createIf( + factory.createIfStatement( factory.createLogicalAnd( factory.createLogicalAnd( result, factory.createLogicalNot( - factory.createPropertyAccess(result, "done") + factory.createPropertyAccessExpression(result, "done") ) ), factory.createAssignment( returnMethod, - factory.createPropertyAccess(iterator, "return") + factory.createPropertyAccessExpression(iterator, "return") ) ), factory.createExpressionStatement( @@ -2568,10 +2568,10 @@ namespace ts { /*finallyBlock*/ setEmitFlags( factory.createBlock([ setEmitFlags( - factory.createIf( + factory.createIfStatement( errorRecord, - factory.createThrow( - factory.createPropertyAccess(errorRecord, "error") + factory.createThrowStatement( + factory.createPropertyAccessExpression(errorRecord, "error") ) ), EmitFlags.SingleLine @@ -2618,7 +2618,7 @@ namespace ts { const assignment = factory.createAssignment( temp, setEmitFlags( - factory.createObjectLiteral( + factory.createObjectLiteralExpression( visitNodes(properties, visitor, isObjectLiteralElementLike, 0, numInitialProperties), node.multiLine ), @@ -2774,7 +2774,7 @@ namespace ts { function convertForStatement(node: ForStatement, initializerFunction: IterationStatementPartFunction | undefined, convertedLoopBody: Statement) { const shouldConvertCondition = node.condition && shouldConvertPartOfIterationStatement(node.condition); const shouldConvertIncrementor = shouldConvertCondition || node.incrementor && shouldConvertPartOfIterationStatement(node.incrementor); - return factory.updateFor( + return factory.updateForStatement( node, visitNode(initializerFunction ? initializerFunction.part : node.initializer, visitor, isForInitializer), visitNode(shouldConvertCondition ? undefined : node.condition, visitor, isExpression), @@ -2784,7 +2784,7 @@ namespace ts { } function convertForOfStatement(node: ForOfStatement, convertedLoopBody: Statement) { - return factory.updateForOf( + return factory.updateForOfStatement( node, /*awaitModifier*/ undefined, visitNode(node.initializer, visitor, isForInitializer), @@ -2793,7 +2793,7 @@ namespace ts { } function convertForInStatement(node: ForInStatement, convertedLoopBody: Statement) { - return factory.updateForIn( + return factory.updateForInStatement( node, visitNode(node.initializer, visitor, isForInitializer), visitNode(node.expression, visitor, isExpression), @@ -2801,14 +2801,14 @@ namespace ts { } function convertDoStatement(node: DoStatement, convertedLoopBody: Statement) { - return factory.updateDo( + return factory.updateDoStatement( node, convertedLoopBody, visitNode(node.expression, visitor, isExpression)); } function convertWhileStatement(node: WhileStatement, convertedLoopBody: Statement) { - return factory.updateWhile( + return factory.updateWhileStatement( node, visitNode(node.expression, visitor, isExpression), convertedLoopBody); @@ -3086,23 +3086,23 @@ namespace ts { currentState.conditionVariable = factory.createUniqueName("inc"); if (node.incrementor) { - statements.push(factory.createIf( + statements.push(factory.createIfStatement( currentState.conditionVariable, factory.createExpressionStatement(visitNode(node.incrementor, visitor, isExpression)), factory.createExpressionStatement(factory.createAssignment(currentState.conditionVariable, factory.createTrue())) )); } else { - statements.push(factory.createIf( + statements.push(factory.createIfStatement( factory.createLogicalNot(currentState.conditionVariable), factory.createExpressionStatement(factory.createAssignment(currentState.conditionVariable, factory.createTrue())) )); } if (shouldConvertConditionOfForStatement(node)) { - statements.push(factory.createIf( - factory.createPrefix(SyntaxKind.ExclamationToken, visitNode(node.condition, visitor, isExpression)), - visitNode(factory.createBreak(), visitor, isStatement) + statements.push(factory.createIfStatement( + factory.createPrefixUnaryExpression(SyntaxKind.ExclamationToken, visitNode(node.condition, visitor, isExpression)), + visitNode(factory.createBreakStatement(), visitor, isStatement) )); } } @@ -3177,7 +3177,7 @@ namespace ts { function copyOutParameter(outParam: LoopOutParameter, copyDirection: CopyDirection): BinaryExpression { const source = copyDirection === CopyDirection.ToOriginal ? outParam.outParamName : outParam.originalName; const target = copyDirection === CopyDirection.ToOriginal ? outParam.originalName : outParam.outParamName; - return factory.createBinary(target, SyntaxKind.EqualsToken, source); + return factory.createBinaryExpression(target, SyntaxKind.EqualsToken, source); } function copyOutParameters(outParams: LoopOutParameter[], partFlags: LoopOutParameterFlags, copyDirection: CopyDirection, statements: Statement[]): void { @@ -3189,9 +3189,9 @@ namespace ts { } function generateCallToConvertedLoopInitializer(initFunctionExpressionName: Identifier, containsYield: boolean): Statement { - const call = factory.createCall(initFunctionExpressionName, /*typeArguments*/ undefined, []); + const call = factory.createCallExpression(initFunctionExpressionName, /*typeArguments*/ undefined, []); const callResult = containsYield - ? factory.createYield( + ? factory.createYieldExpression( factory.createToken(SyntaxKind.AsteriskToken), setEmitFlags(call, EmitFlags.Iterator) ) @@ -3210,9 +3210,9 @@ namespace ts { !state.labeledNonLocalBreaks && !state.labeledNonLocalContinues; - const call = factory.createCall(loopFunctionExpressionName, /*typeArguments*/ undefined, map(state.loopParameters, p => p.name)); + const call = factory.createCallExpression(loopFunctionExpressionName, /*typeArguments*/ undefined, map(state.loopParameters, p => p.name)); const callResult = containsYield - ? factory.createYield( + ? factory.createYieldExpression( factory.createToken(SyntaxKind.AsteriskToken), setEmitFlags(call, EmitFlags.Iterator) ) @@ -3236,13 +3236,13 @@ namespace ts { let returnStatement: ReturnStatement; if (outerState) { outerState.nonLocalJumps! |= Jump.Return; - returnStatement = factory.createReturn(loopResultName); + returnStatement = factory.createReturnStatement(loopResultName); } else { - returnStatement = factory.createReturn(factory.createPropertyAccess(loopResultName, "value")); + returnStatement = factory.createReturnStatement(factory.createPropertyAccessExpression(loopResultName, "value")); } statements.push( - factory.createIf( + factory.createIfStatement( factory.createTypeCheck(loopResultName, "object"), returnStatement ) @@ -3251,12 +3251,12 @@ namespace ts { if (state.nonLocalJumps! & Jump.Break) { statements.push( - factory.createIf( + factory.createIfStatement( factory.createStrictEquality( loopResultName, factory.createStringLiteral("break") ), - factory.createBreak() + factory.createBreakStatement() ) ); } @@ -3266,7 +3266,7 @@ namespace ts { processLabeledJumps(state.labeledNonLocalBreaks!, /*isBreak*/ true, loopResultName, outerState, caseClauses); processLabeledJumps(state.labeledNonLocalContinues!, /*isBreak*/ false, loopResultName, outerState, caseClauses); statements.push( - factory.createSwitch( + factory.createSwitchStatement( loopResultName, factory.createCaseBlock(caseClauses) ) @@ -3302,11 +3302,11 @@ namespace ts { // otherwise propagate pair 'label -> marker' to outer converted loop and emit 'return labelMarker' so outer loop can later decide what to do if (!outerLoop || (outerLoop.labels && outerLoop.labels.get(labelText))) { const label = factory.createIdentifier(labelText); - statements.push(isBreak ? factory.createBreak(label) : factory.createContinue(label)); + statements.push(isBreak ? factory.createBreakStatement(label) : factory.createContinueStatement(label)); } else { setLabeledJump(outerLoop, isBreak, labelText, labelMarker); - statements.push(factory.createReturn(loopResultName)); + statements.push(factory.createReturnStatement(loopResultName)); } caseClauses.push(factory.createCaseClause(factory.createStringLiteral(labelMarker), statements)); }); @@ -3588,7 +3588,7 @@ namespace ts { return visitCallExpressionWithPotentialCapturedThisAssignment(node, /*assignToCapturedThis*/ true); } - return factory.updateCall( + return factory.updateCallExpression( node, visitNode(node.expression, callExpressionVisitor, isExpression), /*typeArguments*/ undefined, @@ -3728,7 +3728,7 @@ namespace ts { return factory.restoreOuterExpressions(node.expression, factory.restoreOuterExpressions(variable.initializer, factory.restoreOuterExpressions(aliasAssignment && aliasAssignment.right, - factory.updateCall(call, + factory.updateCallExpression(call, factory.restoreOuterExpressions(call.expression, factory.updateFunctionExpression( func, @@ -3840,8 +3840,8 @@ namespace ts { // [output] // new ((_a = C).bind.apply(_a, [void 0].concat(a)))() - const { target, thisArg } = factory.createCallBinding(factory.createPropertyAccess(node.expression, "bind"), hoistVariableDeclaration); - return factory.createNew( + const { target, thisArg } = factory.createCallBinding(factory.createPropertyAccessExpression(node.expression, "bind"), hoistVariableDeclaration); + return factory.createNewExpression( factory.createFunctionApplyCall( visitNode(target, visitor, isExpression), thisArg, @@ -3930,7 +3930,7 @@ namespace ts { } function visitSpanOfNonSpreads(chunk: Expression[], multiLine: boolean, hasTrailingComma: boolean): VisitResult { - return factory.createArrayLiteral( + return factory.createArrayLiteralExpression( visitNodes(factory.createNodeArray(chunk, hasTrailingComma), visitor, isExpression), multiLine ); @@ -4092,7 +4092,7 @@ namespace ts { function visitSuperKeyword(isExpressionOfCall: boolean): LeftHandSideExpression { return hierarchyFacts & HierarchyFacts.NonStaticClassElement && !isExpressionOfCall - ? factory.createPropertyAccess(factory.createUniqueName("_super", GeneratedIdentifierFlags.Optimistic | GeneratedIdentifierFlags.FileLevel), "prototype") + ? factory.createPropertyAccessExpression(factory.createUniqueName("_super", GeneratedIdentifierFlags.Optimistic | GeneratedIdentifierFlags.FileLevel), "prototype") : factory.createUniqueName("_super", GeneratedIdentifierFlags.Optimistic | GeneratedIdentifierFlags.FileLevel); } @@ -4283,7 +4283,7 @@ namespace ts { function getClassMemberPrefix(node: ClassExpression | ClassDeclaration, member: ClassElement) { return hasSyntacticModifier(member, ModifierFlags.Static) ? factory.getInternalName(node) - : factory.createPropertyAccess(factory.getInternalName(node), "prototype"); + : factory.createPropertyAccessExpression(factory.getInternalName(node), "prototype"); } function hasSynthesizedDefaultSuperCall(constructor: ConstructorDeclaration | undefined, hasExtendsClause: boolean) { diff --git a/src/compiler/transformers/es2016.ts b/src/compiler/transformers/es2016.ts index 4a3996c87d5d3..653c66174d4ff 100644 --- a/src/compiler/transformers/es2016.ts +++ b/src/compiler/transformers/es2016.ts @@ -49,14 +49,14 @@ namespace ts { const expressionTemp = factory.createTempVariable(hoistVariableDeclaration); const argumentExpressionTemp = factory.createTempVariable(hoistVariableDeclaration); target = setTextRange( - factory.createElementAccess( + factory.createElementAccessExpression( setTextRange(factory.createAssignment(expressionTemp, left.expression), left.expression), setTextRange(factory.createAssignment(argumentExpressionTemp, left.argumentExpression), left.argumentExpression) ), left ); value = setTextRange( - factory.createElementAccess( + factory.createElementAccessExpression( expressionTemp, argumentExpressionTemp ), @@ -67,14 +67,14 @@ namespace ts { // Transforms `a.x **= b` into `(_a = a).x = Math.pow(_a.x, b)` const expressionTemp = factory.createTempVariable(hoistVariableDeclaration); target = setTextRange( - factory.createPropertyAccess( + factory.createPropertyAccessExpression( setTextRange(factory.createAssignment(expressionTemp, left.expression), left.expression), left.name ), left ); value = setTextRange( - factory.createPropertyAccess( + factory.createPropertyAccessExpression( expressionTemp, left.name ), diff --git a/src/compiler/transformers/es2017.ts b/src/compiler/transformers/es2017.ts index fb5fb2347fc39..64971fffe6369 100644 --- a/src/compiler/transformers/es2017.ts +++ b/src/compiler/transformers/es2017.ts @@ -219,7 +219,7 @@ namespace ts { } function visitForInStatementInAsyncBody(node: ForInStatement) { - return factory.updateForIn( + return factory.updateForInStatement( node, isVariableDeclarationListWithCollidingName(node.initializer) ? visitVariableDeclarationListWithCollidingNames(node.initializer, /*hasReceiver*/ true)! @@ -230,7 +230,7 @@ namespace ts { } function visitForOfStatementInAsyncBody(node: ForOfStatement) { - return factory.updateForOf( + return factory.updateForOfStatement( node, visitNode(node.awaitModifier, visitor, isToken), isVariableDeclarationListWithCollidingName(node.initializer) @@ -243,7 +243,7 @@ namespace ts { function visitForStatementInAsyncBody(node: ForStatement) { const initializer = node.initializer!; // TODO: GH#18217 - return factory.updateFor( + return factory.updateForStatement( node, isVariableDeclarationListWithCollidingName(initializer) ? visitVariableDeclarationListWithCollidingNames(initializer, /*hasReceiver*/ false) @@ -268,7 +268,7 @@ namespace ts { } return setOriginalNode( setTextRange( - factory.createYield( + factory.createYieldExpression( /*asteriskToken*/ undefined, visitNode(node.expression, visitor, isExpression) ), @@ -483,7 +483,7 @@ namespace ts { const statements: Statement[] = []; const statementOffset = factory.copyPrologue((node.body).statements, statements, /*ensureUseStrict*/ false, visitor); statements.push( - factory.createReturn( + factory.createReturnStatement( emitHelpers().createAwaiterHelper( inHasLexicalThisContext(), hasLexicalArguments, @@ -653,7 +653,7 @@ namespace ts { function substitutePropertyAccessExpression(node: PropertyAccessExpression) { if (node.expression.kind === SyntaxKind.SuperKeyword) { return setTextRange( - factory.createPropertyAccess( + factory.createPropertyAccessExpression( factory.createUniqueName("_super", GeneratedIdentifierFlags.Optimistic | GeneratedIdentifierFlags.FileLevel), node.name), node @@ -678,8 +678,8 @@ namespace ts { const argumentExpression = isPropertyAccessExpression(expression) ? substitutePropertyAccessExpression(expression) : substituteElementAccessExpression(expression); - return factory.createCall( - factory.createPropertyAccess(argumentExpression, "call"), + return factory.createCallExpression( + factory.createPropertyAccessExpression(argumentExpression, "call"), /*typeArguments*/ undefined, [ factory.createThis(), @@ -702,8 +702,8 @@ namespace ts { function createSuperElementAccessInAsyncMethod(argumentExpression: Expression, location: TextRange): LeftHandSideExpression { if (enclosingSuperContainerFlags & NodeCheckFlags.AsyncMethodWithSuperBinding) { return setTextRange( - factory.createPropertyAccess( - factory.createCall( + factory.createPropertyAccessExpression( + factory.createCallExpression( factory.createUniqueName("_superIndex", GeneratedIdentifierFlags.Optimistic | GeneratedIdentifierFlags.FileLevel), /*typeArguments*/ undefined, [argumentExpression] @@ -715,7 +715,7 @@ namespace ts { } else { return setTextRange( - factory.createCall( + factory.createCallExpression( factory.createUniqueName("_superIndex", GeneratedIdentifierFlags.Optimistic | GeneratedIdentifierFlags.FileLevel), /*typeArguments*/ undefined, [argumentExpression] @@ -744,7 +744,7 @@ namespace ts { /* type */ undefined, /* equalsGreaterThanToken */ undefined, setEmitFlags( - factory.createPropertyAccess( + factory.createPropertyAccessExpression( setEmitFlags( factory.createSuper(), EmitFlags.NoSubstitution @@ -777,7 +777,7 @@ namespace ts { /* equalsGreaterThanToken */ undefined, factory.createAssignment( setEmitFlags( - factory.createPropertyAccess( + factory.createPropertyAccessExpression( setEmitFlags( factory.createSuper(), EmitFlags.NoSubstitution @@ -795,7 +795,7 @@ namespace ts { accessors.push( factory.createPropertyAssignment( name, - factory.createObjectLiteral(getterAndSetter), + factory.createObjectLiteralExpression(getterAndSetter), ) ); }); @@ -807,15 +807,15 @@ namespace ts { factory.createUniqueName("_super", GeneratedIdentifierFlags.Optimistic | GeneratedIdentifierFlags.FileLevel), /*exclamationToken*/ undefined, /* type */ undefined, - factory.createCall( - factory.createPropertyAccess( + factory.createCallExpression( + factory.createPropertyAccessExpression( factory.createIdentifier("Object"), "create" ), /* typeArguments */ undefined, [ factory.createNull(), - factory.createObjectLiteral(accessors, /* multiline */ true) + factory.createObjectLiteralExpression(accessors, /* multiline */ true) ] ) ) diff --git a/src/compiler/transformers/es2018.ts b/src/compiler/transformers/es2018.ts index 3e3c213151fb7..143a864edb40b 100644 --- a/src/compiler/transformers/es2018.ts +++ b/src/compiler/transformers/es2018.ts @@ -264,7 +264,7 @@ namespace ts { if (enclosingFunctionFlags & FunctionFlags.Async && enclosingFunctionFlags & FunctionFlags.Generator) { return setOriginalNode( setTextRange( - factory.createYield(/*asteriskToken*/ undefined, emitHelpers().createAwaitHelper(visitNode(node.expression, visitor, isExpression))), + factory.createYieldExpression(/*asteriskToken*/ undefined, emitHelpers().createAwaitHelper(visitNode(node.expression, visitor, isExpression))), /*location*/ node ), node @@ -280,10 +280,10 @@ namespace ts { return setOriginalNode( setTextRange( - factory.createYield( + factory.createYieldExpression( /*asteriskToken*/ undefined, emitHelpers().createAwaitHelper( - factory.updateYield( + factory.updateYieldExpression( node, node.asteriskToken, setTextRange( @@ -306,7 +306,7 @@ namespace ts { return setOriginalNode( setTextRange( - factory.createYield( + factory.createYieldExpression( /*asteriskToken*/ undefined, createDownlevelAwait( node.expression @@ -325,7 +325,7 @@ namespace ts { function visitReturnStatement(node: ReturnStatement) { if (enclosingFunctionFlags & FunctionFlags.Async && enclosingFunctionFlags & FunctionFlags.Generator) { - return factory.updateReturn(node, createDownlevelAwait( + return factory.updateReturnStatement(node, createDownlevelAwait( node.expression ? visitNode(node.expression, visitor, isExpression) : factory.createVoidZero() )); } @@ -350,7 +350,7 @@ namespace ts { for (const e of elements) { if (e.kind === SyntaxKind.SpreadAssignment) { if (chunkObject) { - objects.push(factory.createObjectLiteral(chunkObject)); + objects.push(factory.createObjectLiteralExpression(chunkObject)); chunkObject = undefined; } const target = e.expression; @@ -363,7 +363,7 @@ namespace ts { } } if (chunkObject) { - objects.push(factory.createObjectLiteral(chunkObject)); + objects.push(factory.createObjectLiteralExpression(chunkObject)); } return objects; @@ -394,7 +394,7 @@ namespace ts { // end up with `{ a: 1, b: 2, c: 3 }` const objects = chunkObjectLiteralElements(node.properties); if (objects.length && objects[0].kind !== SyntaxKind.ObjectLiteralExpression) { - objects.unshift(factory.createObjectLiteral()); + objects.unshift(factory.createObjectLiteralExpression()); } let expression: Expression = objects[0]; if (objects.length > 1) { @@ -462,7 +462,7 @@ namespace ts { ); } else if (node.operatorToken.kind === SyntaxKind.CommaToken) { - return factory.updateBinary( + return factory.updateBinaryExpression( node, visitNode(node.left, visitorNoDestructuringValue, isExpression), node.operatorToken, @@ -537,7 +537,7 @@ namespace ts { } function visitForStatement(node: ForStatement): VisitResult { - return factory.updateFor( + return factory.updateForStatement( node, visitNode(node.initializer, visitorNoDestructuringValue, isForInitializer), visitNode(node.condition, visitor, isExpression), @@ -584,7 +584,7 @@ namespace ts { bodyLocation = node.statement; statementsLocation = node.statement; } - return factory.updateForOf( + return factory.updateForOfStatement( node, node.awaitModifier, setTextRange( @@ -639,8 +639,8 @@ namespace ts { function createDownlevelAwait(expression: Expression) { return enclosingFunctionFlags & FunctionFlags.Generator - ? factory.createYield(/*asteriskToken*/ undefined, emitHelpers().createAwaitHelper(expression)) - : factory.createAwait(expression); + ? factory.createYieldExpression(/*asteriskToken*/ undefined, emitHelpers().createAwaitHelper(expression)) + : factory.createAwaitExpression(expression); } function transformForAwaitOfStatement(node: ForOfStatement, outermostLabeledStatement: LabeledStatement | undefined, ancestorFacts: HierarchyFacts) { @@ -651,9 +651,9 @@ namespace ts { const catchVariable = factory.getGeneratedNameForNode(errorRecord); const returnMethod = factory.createTempVariable(/*recordTempVariable*/ undefined); const callValues = setTextRange(emitHelpers().createAsyncValuesHelper(expression), node.expression); - const callNext = factory.createCall(factory.createPropertyAccess(iterator, "next"), /*typeArguments*/ undefined, []); - const getDone = factory.createPropertyAccess(result, "done"); - const getValue = factory.createPropertyAccess(result, "value"); + const callNext = factory.createCallExpression(factory.createPropertyAccessExpression(iterator, "next"), /*typeArguments*/ undefined, []); + const getDone = factory.createPropertyAccessExpression(result, "done"); + const getValue = factory.createPropertyAccessExpression(result, "value"); const callReturn = factory.createFunctionCallCall(returnMethod, iterator, []); hoistVariableDeclaration(errorRecord); @@ -666,7 +666,7 @@ namespace ts { const forStatement = setEmitFlags( setTextRange( - factory.createFor( + factory.createForStatement( /*initializer*/ setEmitFlags( setTextRange( factory.createVariableDeclarationList([ @@ -689,7 +689,7 @@ namespace ts { EmitFlags.NoTokenTrailingSourceMaps ); - return factory.createTry( + return factory.createTryStatement( factory.createBlock([ factory.restoreEnclosingLabel( forStatement, @@ -703,7 +703,7 @@ namespace ts { factory.createExpressionStatement( factory.createAssignment( errorRecord, - factory.createObjectLiteral([ + factory.createObjectLiteralExpression([ factory.createPropertyAssignment("error", catchVariable) ]) ) @@ -713,10 +713,10 @@ namespace ts { ) ), factory.createBlock([ - factory.createTry( + factory.createTryStatement( /*tryBlock*/ factory.createBlock([ setEmitFlags( - factory.createIf( + factory.createIfStatement( factory.createLogicalAnd( factory.createLogicalAnd( result, @@ -724,7 +724,7 @@ namespace ts { ), factory.createAssignment( returnMethod, - factory.createPropertyAccess(iterator, "return") + factory.createPropertyAccessExpression(iterator, "return") ) ), factory.createExpressionStatement(createDownlevelAwait(callReturn)) @@ -736,10 +736,10 @@ namespace ts { /*finallyBlock*/ setEmitFlags( factory.createBlock([ setEmitFlags( - factory.createIf( + factory.createIfStatement( errorRecord, - factory.createThrow( - factory.createPropertyAccess(errorRecord, "error") + factory.createThrowStatement( + factory.createPropertyAccessExpression(errorRecord, "error") ) ), EmitFlags.SingleLine @@ -914,7 +914,7 @@ namespace ts { capturedSuperProperties = createUnderscoreEscapedMap(); hasSuperElementAccess = false; - const returnStatement = factory.createReturn( + const returnStatement = factory.createReturnStatement( emitHelpers().createAsyncGeneratorHelper( factory.createFunctionExpression( /*modifiers*/ undefined, @@ -1094,7 +1094,7 @@ namespace ts { function substitutePropertyAccessExpression(node: PropertyAccessExpression) { if (node.expression.kind === SyntaxKind.SuperKeyword) { return setTextRange( - factory.createPropertyAccess( + factory.createPropertyAccessExpression( factory.createUniqueName("_super", GeneratedIdentifierFlags.Optimistic | GeneratedIdentifierFlags.FileLevel), node.name), node @@ -1119,8 +1119,8 @@ namespace ts { const argumentExpression = isPropertyAccessExpression(expression) ? substitutePropertyAccessExpression(expression) : substituteElementAccessExpression(expression); - return factory.createCall( - factory.createPropertyAccess(argumentExpression, "call"), + return factory.createCallExpression( + factory.createPropertyAccessExpression(argumentExpression, "call"), /*typeArguments*/ undefined, [ factory.createThis(), @@ -1143,8 +1143,8 @@ namespace ts { function createSuperElementAccessInAsyncMethod(argumentExpression: Expression, location: TextRange): LeftHandSideExpression { if (enclosingSuperContainerFlags & NodeCheckFlags.AsyncMethodWithSuperBinding) { return setTextRange( - factory.createPropertyAccess( - factory.createCall( + factory.createPropertyAccessExpression( + factory.createCallExpression( factory.createIdentifier("_superIndex"), /*typeArguments*/ undefined, [argumentExpression] @@ -1156,7 +1156,7 @@ namespace ts { } else { return setTextRange( - factory.createCall( + factory.createCallExpression( factory.createIdentifier("_superIndex"), /*typeArguments*/ undefined, [argumentExpression] diff --git a/src/compiler/transformers/es2020.ts b/src/compiler/transformers/es2020.ts index 784fdfce4ea1e..a3a87df91ed33 100644 --- a/src/compiler/transformers/es2020.ts +++ b/src/compiler/transformers/es2020.ts @@ -58,9 +58,9 @@ namespace ts { if (isSyntheticReference(expression)) { // `(a.b)` -> { expression `((_a = a).b)`, thisArg: `_a` } // `(a[b])` -> { expression `((_a = a)[b])`, thisArg: `_a` } - return factory.createSyntheticReferenceExpression(factory.updateParen(node, expression.expression), expression.thisArg); + return factory.createSyntheticReferenceExpression(factory.updateParenthesizedExpression(node, expression.expression), expression.thisArg); } - return factory.updateParen(node, expression); + return factory.updateParenthesizedExpression(node, expression); } function visitNonOptionalPropertyOrElementAccessExpression(node: AccessExpression, captureThisArg: boolean, isDelete: boolean): Expression { @@ -85,8 +85,8 @@ namespace ts { } expression = node.kind === SyntaxKind.PropertyAccessExpression - ? factory.updatePropertyAccess(node, expression, visitNode(node.name, visitor, isIdentifier)) - : factory.updateElementAccess(node, expression, visitNode(node.argumentExpression, visitor, isExpression)); + ? factory.updatePropertyAccessExpression(node, expression, visitNode(node.name, visitor, isIdentifier)) + : factory.updateElementAccessExpression(node, expression, visitNode(node.argumentExpression, visitor, isExpression)); return thisArg ? factory.createSyntheticReferenceExpression(expression, thisArg) : expression; } @@ -137,8 +137,8 @@ namespace ts { } } rightExpression = segment.kind === SyntaxKind.PropertyAccessExpression - ? factory.createPropertyAccess(rightExpression, visitNode(segment.name, visitor, isIdentifier)) - : factory.createElementAccess(rightExpression, visitNode(segment.argumentExpression, visitor, isExpression)); + ? factory.createPropertyAccessExpression(rightExpression, visitNode(segment.name, visitor, isIdentifier)) + : factory.createElementAccessExpression(rightExpression, visitNode(segment.argumentExpression, visitor, isExpression)); break; case SyntaxKind.CallExpression: if (i === 0 && leftThisArg) { @@ -149,7 +149,7 @@ namespace ts { ); } else { - rightExpression = factory.createCall( + rightExpression = factory.createCallExpression( rightExpression, /*typeArguments*/ undefined, visitNodes(segment.arguments, visitor, isExpression) @@ -161,20 +161,20 @@ namespace ts { } const target = isDelete - ? factory.createConditional(createNotNullCondition(leftExpression, capturedLeft, /*invert*/ true), /*questionToken*/ undefined, factory.createTrue(), /*colonToken*/ undefined, factory.createDelete(rightExpression)) - : factory.createConditional(createNotNullCondition(leftExpression, capturedLeft, /*invert*/ true), /*questionToken*/ undefined, factory.createVoidZero(), /*colonToken*/ undefined, rightExpression); + ? factory.createConditionalExpression(createNotNullCondition(leftExpression, capturedLeft, /*invert*/ true), /*questionToken*/ undefined, factory.createTrue(), /*colonToken*/ undefined, factory.createDeleteExpression(rightExpression)) + : factory.createConditionalExpression(createNotNullCondition(leftExpression, capturedLeft, /*invert*/ true), /*questionToken*/ undefined, factory.createVoidZero(), /*colonToken*/ undefined, rightExpression); return thisArg ? factory.createSyntheticReferenceExpression(target, thisArg) : target; } function createNotNullCondition(left: Expression, right: Expression, invert?: boolean) { - return factory.createBinary( - factory.createBinary( + return factory.createBinaryExpression( + factory.createBinaryExpression( left, factory.createToken(invert ? SyntaxKind.EqualsEqualsEqualsToken : SyntaxKind.ExclamationEqualsEqualsToken), factory.createNull() ), factory.createToken(invert ? SyntaxKind.BarBarToken : SyntaxKind.AmpersandAmpersandToken), - factory.createBinary( + factory.createBinaryExpression( right, factory.createToken(invert ? SyntaxKind.EqualsEqualsEqualsToken : SyntaxKind.ExclamationEqualsEqualsToken), factory.createVoidZero() @@ -190,7 +190,7 @@ namespace ts { left = factory.createAssignment(right, left); // if (inParameterInitializer) tempVariableInParameter = true; } - return factory.createConditional( + return factory.createConditionalExpression( createNotNullCondition(left, right), /*questionToken*/ undefined, right, @@ -202,7 +202,7 @@ namespace ts { function visitDeleteExpression(node: DeleteExpression) { return isOptionalChain(skipParentheses(node.expression)) ? setOriginalNode(visitNonOptionalExpression(node.expression, /*captureThisArg*/ false, /*isDelete*/ true), node) - : factory.updateDelete(node, visitNode(node.expression, visitor, isExpression)); + : factory.updateDeleteExpression(node, visitNode(node.expression, visitor, isExpression)); } } } diff --git a/src/compiler/transformers/es5.ts b/src/compiler/transformers/es5.ts index 4fe09b2f16792..74fff32a2644e 100644 --- a/src/compiler/transformers/es5.ts +++ b/src/compiler/transformers/es5.ts @@ -88,7 +88,7 @@ namespace ts { } const literalName = trySubstituteReservedName(node.name); if (literalName) { - return setTextRange(factory.createElementAccess(node.expression, literalName), node); + return setTextRange(factory.createElementAccessExpression(node.expression, literalName), node); } return node; } diff --git a/src/compiler/transformers/esnext.ts b/src/compiler/transformers/esnext.ts index a7b8210ece478..f38d0b7262d60 100644 --- a/src/compiler/transformers/esnext.ts +++ b/src/compiler/transformers/esnext.ts @@ -40,11 +40,11 @@ namespace ts { if (isAccessExpression(left)) { const tempVariable = factory.createTempVariable(hoistVariableDeclaration); if (isPropertyAccessExpression(left)) { - assignmentTarget = factory.createPropertyAccess( + assignmentTarget = factory.createPropertyAccessExpression( tempVariable, left.name ); - left = factory.createPropertyAccess( + left = factory.createPropertyAccessExpression( factory.createAssignment( tempVariable, left.expression @@ -53,11 +53,11 @@ namespace ts { ); } else { - assignmentTarget = factory.createElementAccess( + assignmentTarget = factory.createElementAccessExpression( tempVariable, left.argumentExpression ); - left = factory.createElementAccess( + left = factory.createElementAccessExpression( factory.createAssignment( tempVariable, left.expression @@ -67,10 +67,10 @@ namespace ts { } } - return factory.createBinary( + return factory.createBinaryExpression( left, nonAssignmentOperator, - factory.createParen( + factory.createParenthesizedExpression( factory.createAssignment( assignmentTarget, right diff --git a/src/compiler/transformers/generators.ts b/src/compiler/transformers/generators.ts index 2303acbec51da..c73037656a77c 100644 --- a/src/compiler/transformers/generators.ts +++ b/src/compiler/transformers/generators.ts @@ -590,7 +590,7 @@ namespace ts { const buildResult = build(); insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment()); - statements.push(factory.createReturn(buildResult)); + statements.push(factory.createReturnStatement(buildResult)); // Restore previous generator state inGeneratorFunctionBody = savedInGeneratorFunctionBody; @@ -690,7 +690,7 @@ namespace ts { // .mark resumeLabel // _a.b = %sent%; - target = factory.updatePropertyAccess( + target = factory.updatePropertyAccessExpression( left, cacheExpression(visitNode((left).expression, visitor, isLeftHandSideExpression)), (left).name @@ -709,7 +709,7 @@ namespace ts { // .mark resumeLabel // _a[_b] = %sent%; - target = factory.updateElementAccess(left, + target = factory.updateElementAccessExpression(left, cacheExpression(visitNode((left).expression, visitor, isLeftHandSideExpression)), cacheExpression(visitNode((left).argumentExpression, visitor, isExpression)) ); @@ -726,7 +726,7 @@ namespace ts { factory.createAssignment( target, setTextRange( - factory.createBinary( + factory.createBinaryExpression( cacheExpression(target), getNonAssignmentOperatorForCompoundAssignment(operator), visitNode(right, visitor, isExpression) @@ -738,7 +738,7 @@ namespace ts { ); } else { - return factory.updateBinary(node, target, node.operatorToken, visitNode(right, visitor, isExpression)); + return factory.updateBinaryExpression(node, target, node.operatorToken, visitNode(right, visitor, isExpression)); } } @@ -763,7 +763,7 @@ namespace ts { // .yield resumeLabel // _a + %sent% + c() - return factory.updateBinary(node, + return factory.updateBinaryExpression(node, cacheExpression(visitNode(node.left, visitor, isExpression)), node.operatorToken, visitNode(node.right, visitor, isExpression)); @@ -966,7 +966,7 @@ namespace ts { temp = declareLocal(); const initialElements = visitNodes(elements, visitor, isExpression, 0, numInitialElements); emitAssignment(temp, - factory.createArrayLiteral( + factory.createArrayLiteralExpression( leadingElement ? [leadingElement, ...initialElements] : initialElements @@ -977,9 +977,9 @@ namespace ts { const expressions = reduceLeft(elements, reduceElement, [], numInitialElements); return temp - ? factory.createArrayConcatCall(temp, [factory.createArrayLiteral(expressions, multiLine)]) + ? factory.createArrayConcatCall(temp, [factory.createArrayLiteralExpression(expressions, multiLine)]) : setTextRange( - factory.createArrayLiteral(leadingElement ? [leadingElement, ...expressions] : expressions, multiLine), + factory.createArrayLiteralExpression(leadingElement ? [leadingElement, ...expressions] : expressions, multiLine), location ); @@ -995,9 +995,9 @@ namespace ts { hasAssignedTemp ? factory.createArrayConcatCall( temp, - [factory.createArrayLiteral(expressions, multiLine)] + [factory.createArrayLiteralExpression(expressions, multiLine)] ) - : factory.createArrayLiteral( + : factory.createArrayLiteralExpression( leadingElement ? [leadingElement, ...expressions] : expressions, multiLine ) @@ -1036,7 +1036,7 @@ namespace ts { const temp = declareLocal(); emitAssignment(temp, - factory.createObjectLiteral( + factory.createObjectLiteralExpression( visitNodes(properties, visitor, isObjectLiteralElementLike, 0, numInitialProperties), multiLine ) @@ -1082,7 +1082,7 @@ namespace ts { // .mark resumeLabel // a = _a[%sent%] - return factory.updateElementAccess(node, + return factory.updateElementAccessExpression(node, cacheExpression(visitNode(node.expression, visitor, isLeftHandSideExpression)), visitNode(node.argumentExpression, visitor, isExpression)); } @@ -1132,10 +1132,10 @@ namespace ts { // .mark resumeLabel // new (_b.apply(_a, _c.concat([%sent%, 2]))); - const { target, thisArg } = factory.createCallBinding(factory.createPropertyAccess(node.expression, "bind"), hoistVariableDeclaration); + const { target, thisArg } = factory.createCallBinding(factory.createPropertyAccessExpression(node.expression, "bind"), hoistVariableDeclaration); return setOriginalNode( setTextRange( - factory.createNew( + factory.createNewExpression( factory.createFunctionApplyCall( cacheExpression(visitNode(target, visitor, isExpression)), thisArg, @@ -1471,7 +1471,7 @@ namespace ts { } const variables = getInitializedVariables(initializer); - node = factory.updateFor(node, + node = factory.updateForStatement(node, variables.length > 0 ? factory.inlineExpressions(map(variables, transformInitializedVariable)) : undefined, @@ -1520,15 +1520,15 @@ namespace ts { const keysIndex = factory.createLoopVariable(); // _i const initializer = node.initializer; hoistVariableDeclaration(keysIndex); - emitAssignment(keysArray, factory.createArrayLiteral()); + emitAssignment(keysArray, factory.createArrayLiteralExpression()); emitStatement( - factory.createForIn( + factory.createForInStatement( key, visitNode(node.expression, visitor, isExpression), factory.createExpressionStatement( - factory.createCall( - factory.createPropertyAccess(keysArray, "push"), + factory.createCallExpression( + factory.createPropertyAccessExpression(keysArray, "push"), /*typeArguments*/ undefined, [key] ) @@ -1543,7 +1543,7 @@ namespace ts { const endLabel = beginLoopBlock(incrementLabel); markLabel(conditionLabel); - emitBreakWhenFalse(endLabel, factory.createLessThan(keysIndex, factory.createPropertyAccess(keysArray, "length"))); + emitBreakWhenFalse(endLabel, factory.createLessThan(keysIndex, factory.createPropertyAccessExpression(keysArray, "length"))); let variable: Expression; if (isVariableDeclarationList(initializer)) { @@ -1558,7 +1558,7 @@ namespace ts { Debug.assert(isLeftHandSideExpression(variable)); } - emitAssignment(variable, factory.createElementAccess(keysArray, keysIndex)); + emitAssignment(variable, factory.createElementAccessExpression(keysArray, keysIndex)); transformAndEmitEmbeddedStatement(node.statement); markLabel(incrementLabel); @@ -1596,7 +1596,7 @@ namespace ts { hoistVariableDeclaration(variable.name); } - node = factory.updateForIn(node, + node = factory.updateForInStatement(node, initializer.declarations[0].name, visitNode(node.expression, visitor, isExpression), visitNode(node.statement, visitor, isStatement, factory.liftToBlock) @@ -1771,7 +1771,7 @@ namespace ts { } if (pendingClauses.length) { - emitStatement(factory.createSwitch(expression, factory.createCaseBlock(pendingClauses))); + emitStatement(factory.createSwitchStatement(expression, factory.createCaseBlock(pendingClauses))); clausesWritten += pendingClauses.length; pendingClauses = []; } @@ -2132,7 +2132,7 @@ namespace ts { exception.catchVariable = name; exception.catchLabel = catchLabel; - emitAssignment(name, factory.createCall(factory.createPropertyAccess(state, "sent"), /*typeArguments*/ undefined, [])); + emitAssignment(name, factory.createCallExpression(factory.createPropertyAccessExpression(state, "sent"), /*typeArguments*/ undefined, [])); emitNop(); } @@ -2431,8 +2431,8 @@ namespace ts { function createInlineBreak(label: Label, location?: TextRange): ReturnStatement { Debug.assertLessThan(0, label, "Invalid label"); return setTextRange( - factory.createReturn( - factory.createArrayLiteral([ + factory.createReturnStatement( + factory.createArrayLiteralExpression([ createInstruction(Instruction.Break), createLabel(label) ]) @@ -2449,8 +2449,8 @@ namespace ts { */ function createInlineReturn(expression?: Expression, location?: TextRange): ReturnStatement { return setTextRange( - factory.createReturn( - factory.createArrayLiteral(expression + factory.createReturnStatement( + factory.createArrayLiteralExpression(expression ? [createInstruction(Instruction.Return), expression] : [createInstruction(Instruction.Return)] ) @@ -2464,8 +2464,8 @@ namespace ts { */ function createGeneratorResume(location?: TextRange): LeftHandSideExpression { return setTextRange( - factory.createCall( - factory.createPropertyAccess(state, "sent"), + factory.createCallExpression( + factory.createPropertyAccessExpression(state, "sent"), /*typeArguments*/ undefined, [] ), @@ -2661,8 +2661,8 @@ namespace ts { } if (clauses) { - const labelExpression = factory.createPropertyAccess(state, "label"); - const switchStatement = factory.createSwitch(labelExpression, factory.createCaseBlock(clauses)); + const labelExpression = factory.createPropertyAccessExpression(state, "label"); + const switchStatement = factory.createSwitchStatement(labelExpression, factory.createCaseBlock(clauses)); return [startOnNewLine(switchStatement)]; } @@ -2751,7 +2751,7 @@ namespace ts { // surround the statements in generated `with` blocks to create the same environment. for (let i = withBlockStack.length - 1; i >= 0; i--) { const withBlock = withBlockStack[i]; - statements = [factory.createWith(withBlock.expression, factory.createBlock(statements))]; + statements = [factory.createWithStatement(withBlock.expression, factory.createBlock(statements))]; } } @@ -2762,11 +2762,11 @@ namespace ts { const { startLabel, catchLabel, finallyLabel, endLabel } = currentExceptionBlock; statements.unshift( factory.createExpressionStatement( - factory.createCall( - factory.createPropertyAccess(factory.createPropertyAccess(state, "trys"), "push"), + factory.createCallExpression( + factory.createPropertyAccessExpression(factory.createPropertyAccessExpression(state, "trys"), "push"), /*typeArguments*/ undefined, [ - factory.createArrayLiteral([ + factory.createArrayLiteralExpression([ createLabel(startLabel), createLabel(catchLabel), createLabel(finallyLabel), @@ -2786,7 +2786,7 @@ namespace ts { statements.push( factory.createExpressionStatement( factory.createAssignment( - factory.createPropertyAccess(state, "label"), + factory.createPropertyAccessExpression(state, "label"), factory.createNumericLiteral(labelNumber + 1) ) ) @@ -2980,7 +2980,7 @@ namespace ts { function writeThrow(expression: Expression, operationLocation: TextRange | undefined): void { lastOperationWasAbrupt = true; lastOperationWasCompletion = true; - writeStatement(setTextRange(factory.createThrow(expression), operationLocation)); + writeStatement(setTextRange(factory.createThrowStatement(expression), operationLocation)); } /** @@ -2995,8 +2995,8 @@ namespace ts { writeStatement( setEmitFlags( setTextRange( - factory.createReturn( - factory.createArrayLiteral(expression + factory.createReturnStatement( + factory.createArrayLiteralExpression(expression ? [createInstruction(Instruction.Return), expression] : [createInstruction(Instruction.Return)] ) @@ -3019,8 +3019,8 @@ namespace ts { writeStatement( setEmitFlags( setTextRange( - factory.createReturn( - factory.createArrayLiteral([ + factory.createReturnStatement( + factory.createArrayLiteralExpression([ createInstruction(Instruction.Break), createLabel(label) ]) @@ -3042,12 +3042,12 @@ namespace ts { function writeBreakWhenTrue(label: Label, condition: Expression, operationLocation: TextRange | undefined): void { writeStatement( setEmitFlags( - factory.createIf( + factory.createIfStatement( condition, setEmitFlags( setTextRange( - factory.createReturn( - factory.createArrayLiteral([ + factory.createReturnStatement( + factory.createArrayLiteralExpression([ createInstruction(Instruction.Break), createLabel(label) ]) @@ -3072,12 +3072,12 @@ namespace ts { function writeBreakWhenFalse(label: Label, condition: Expression, operationLocation: TextRange | undefined): void { writeStatement( setEmitFlags( - factory.createIf( + factory.createIfStatement( factory.createLogicalNot(condition), setEmitFlags( setTextRange( - factory.createReturn( - factory.createArrayLiteral([ + factory.createReturnStatement( + factory.createArrayLiteralExpression([ createInstruction(Instruction.Break), createLabel(label) ]) @@ -3103,8 +3103,8 @@ namespace ts { writeStatement( setEmitFlags( setTextRange( - factory.createReturn( - factory.createArrayLiteral( + factory.createReturnStatement( + factory.createArrayLiteralExpression( expression ? [createInstruction(Instruction.Yield), expression] : [createInstruction(Instruction.Yield)] @@ -3128,8 +3128,8 @@ namespace ts { writeStatement( setEmitFlags( setTextRange( - factory.createReturn( - factory.createArrayLiteral([ + factory.createReturnStatement( + factory.createArrayLiteralExpression([ createInstruction(Instruction.YieldStar), expression ]) @@ -3147,8 +3147,8 @@ namespace ts { function writeEndfinally(): void { lastOperationWasAbrupt = true; writeStatement( - factory.createReturn( - factory.createArrayLiteral([ + factory.createReturnStatement( + factory.createArrayLiteralExpression([ createInstruction(Instruction.Endfinally) ]) ) diff --git a/src/compiler/transformers/jsx.ts b/src/compiler/transformers/jsx.ts index a207251b6d2a8..37ed4eb901fa5 100644 --- a/src/compiler/transformers/jsx.ts +++ b/src/compiler/transformers/jsx.ts @@ -102,14 +102,14 @@ namespace ts { const segments = flatten( spanMap(attrs, isJsxSpreadAttribute, (attrs, isSpread) => isSpread ? map(attrs, transformJsxSpreadAttributeToExpression) - : factory.createObjectLiteral(map(attrs, transformJsxAttributeToObjectLiteralElement)) + : factory.createObjectLiteralExpression(map(attrs, transformJsxAttributeToObjectLiteralElement)) ) ); if (isJsxSpreadAttribute(attrs[0])) { // We must always emit at least one object literal before a spread // argument.factory.createObjectLiteral - segments.unshift(factory.createObjectLiteral()); + segments.unshift(factory.createObjectLiteralExpression()); } // Either emit one big object literal (no spread attribs), or diff --git a/src/compiler/transformers/module/module.ts b/src/compiler/transformers/module/module.ts index d699a8211f14a..90422838e5739 100644 --- a/src/compiler/transformers/module/module.ts +++ b/src/compiler/transformers/module/module.ts @@ -99,7 +99,7 @@ namespace ts { append(statements, createUnderscoreUnderscoreESModule()); } if (length(currentModuleInfo.exportedNames)) { - append(statements, factory.createExpressionStatement(reduceLeft(currentModuleInfo.exportedNames, (prev, nextId) => factory.createAssignment(factory.createPropertyAccess(factory.createIdentifier("exports"), factory.createIdentifier(idText(nextId))), prev), factory.createVoidZero() as Expression))); + append(statements, factory.createExpressionStatement(reduceLeft(currentModuleInfo.exportedNames, (prev, nextId) => factory.createAssignment(factory.createPropertyAccessExpression(factory.createIdentifier("exports"), factory.createIdentifier(idText(nextId))), prev), factory.createVoidZero() as Expression))); } append(statements, visitNode(currentModuleInfo.externalHelpersImportDeclaration, sourceElementVisitor, isStatement)); @@ -152,7 +152,7 @@ namespace ts { setTextRange( factory.createNodeArray([ factory.createExpressionStatement( - factory.createCall( + factory.createCallExpression( define, /*typeArguments*/ undefined, [ @@ -162,7 +162,7 @@ namespace ts { // Add the dependency array argument: // // ["require", "exports", module1", "module2", ...] - factory.createArrayLiteral(jsonSourceFile ? emptyArray : [ + factory.createArrayLiteralExpression(jsonSourceFile ? emptyArray : [ factory.createStringLiteral("require"), factory.createStringLiteral("exports"), ...aliasedModuleNames, @@ -173,7 +173,7 @@ namespace ts { // // function (require, exports, module1, module2) ... jsonSourceFile ? - jsonSourceFile.statements.length ? jsonSourceFile.statements[0].expression : factory.createObjectLiteral() : + jsonSourceFile.statements.length ? jsonSourceFile.statements[0].expression : factory.createObjectLiteralExpression() : factory.createFunctionExpression( /*modifiers*/ undefined, /*asteriskToken*/ undefined, @@ -217,10 +217,10 @@ namespace ts { setTextRange( factory.createBlock( [ - factory.createIf( + factory.createIfStatement( factory.createLogicalAnd( factory.createTypeCheck(factory.createIdentifier("module"), "object"), - factory.createTypeCheck(factory.createPropertyAccess(factory.createIdentifier("module"), "exports"), "object") + factory.createTypeCheck(factory.createPropertyAccessExpression(factory.createIdentifier("module"), "exports"), "object") ), factory.createBlock([ factory.createVariableStatement( @@ -230,7 +230,7 @@ namespace ts { "v", /*exclamationToken*/ undefined, /*type*/ undefined, - factory.createCall( + factory.createCallExpression( factory.createIdentifier("factory"), /*typeArguments*/ undefined, [ @@ -242,14 +242,14 @@ namespace ts { ] ), setEmitFlags( - factory.createIf( + factory.createIfStatement( factory.createStrictInequality( factory.createIdentifier("v"), factory.createIdentifier("undefined") ), factory.createExpressionStatement( factory.createAssignment( - factory.createPropertyAccess(factory.createIdentifier("module"), "exports"), + factory.createPropertyAccessExpression(factory.createIdentifier("module"), "exports"), factory.createIdentifier("v") ) ) @@ -257,20 +257,20 @@ namespace ts { EmitFlags.SingleLine ) ]), - factory.createIf( + factory.createIfStatement( factory.createLogicalAnd( factory.createTypeCheck(factory.createIdentifier("define"), "function"), - factory.createPropertyAccess(factory.createIdentifier("define"), "amd") + factory.createPropertyAccessExpression(factory.createIdentifier("define"), "amd") ), factory.createBlock([ factory.createExpressionStatement( - factory.createCall( + factory.createCallExpression( factory.createIdentifier("define"), /*typeArguments*/ undefined, [ // Add the module name (if provided). ...(moduleName ? [moduleName] : []), - factory.createArrayLiteral([ + factory.createArrayLiteralExpression([ factory.createStringLiteral("require"), factory.createStringLiteral("exports"), ...aliasedModuleNames, @@ -307,7 +307,7 @@ namespace ts { setTextRange( factory.createNodeArray([ factory.createExpressionStatement( - factory.createCall( + factory.createCallExpression( umdHeader, /*typeArguments*/ undefined, [ @@ -421,7 +421,7 @@ namespace ts { append(statements, createUnderscoreUnderscoreESModule()); } if (length(currentModuleInfo.exportedNames)) { - append(statements, factory.createExpressionStatement(reduceLeft(currentModuleInfo.exportedNames, (prev, nextId) => factory.createAssignment(factory.createPropertyAccess(factory.createIdentifier("exports"), factory.createIdentifier(idText(nextId))), prev), factory.createVoidZero() as Expression))); + append(statements, factory.createExpressionStatement(reduceLeft(currentModuleInfo.exportedNames, (prev, nextId) => factory.createAssignment(factory.createPropertyAccessExpression(factory.createIdentifier("exports"), factory.createIdentifier(idText(nextId))), prev), factory.createVoidZero() as Expression))); } // Visit each statement of the module body. @@ -459,7 +459,7 @@ namespace ts { const expressionResult = visitNode(currentModuleInfo.exportEquals.expression, moduleExpressionElementVisitor); if (expressionResult) { if (emitAsReturn) { - const statement = factory.createReturn(expressionResult); + const statement = factory.createReturnStatement(expressionResult); setTextRange(statement, currentModuleInfo.exportEquals); setEmitFlags(statement, EmitFlags.NoTokenSourceMaps | EmitFlags.NoComments); statements.push(statement); @@ -467,7 +467,7 @@ namespace ts { else { const statement = factory.createExpressionStatement( factory.createAssignment( - factory.createPropertyAccess( + factory.createPropertyAccessExpression( factory.createIdentifier("module"), "exports" ), @@ -627,7 +627,7 @@ namespace ts { needUMDDynamicImportHelper = true; if (isSimpleCopiableExpression(arg)) { const argClone = isGeneratedIdentifier(arg) ? arg : isStringLiteral(arg) ? factory.createStringLiteralFromNode(arg) : setEmitFlags(setTextRange(factory.cloneNode(arg), arg), EmitFlags.NoComments); - return factory.createConditional( + return factory.createConditionalExpression( /*condition*/ factory.createIdentifier("__syncRequire"), /*questionToken*/ undefined, /*whenTrue*/ createImportCallExpressionCommonJS(arg, containsLexicalThis), @@ -637,7 +637,7 @@ namespace ts { } else { const temp = factory.createTempVariable(hoistVariableDeclaration); - return factory.createComma(factory.createAssignment(temp, arg), factory.createConditional( + return factory.createComma(factory.createAssignment(temp, arg), factory.createConditionalExpression( /*condition*/ factory.createIdentifier("__syncRequire"), /*questionToken*/ undefined, /*whenTrue*/ createImportCallExpressionCommonJS(temp, containsLexicalThis), @@ -662,10 +662,10 @@ namespace ts { ]; const body = factory.createBlock([ factory.createExpressionStatement( - factory.createCall( + factory.createCallExpression( factory.createIdentifier("require"), /*typeArguments*/ undefined, - [factory.createArrayLiteral([arg || factory.createOmittedExpression()]), resolve, reject] + [factory.createArrayLiteralExpression([arg || factory.createOmittedExpression()]), resolve, reject] ) ) ]); @@ -698,10 +698,10 @@ namespace ts { } } - const promise = factory.createNew(factory.createIdentifier("Promise"), /*typeArguments*/ undefined, [func]); + const promise = factory.createNewExpression(factory.createIdentifier("Promise"), /*typeArguments*/ undefined, [func]); if (compilerOptions.esModuleInterop) { context.requestEmitHelper(importStarHelper); - return factory.createCall(factory.createPropertyAccess(promise, factory.createIdentifier("then")), /*typeArguments*/ undefined, [emitHelpers().createImportStarCallbackHelper()]); + return factory.createCallExpression(factory.createPropertyAccessExpression(promise, factory.createIdentifier("then")), /*typeArguments*/ undefined, [emitHelpers().createImportStarCallbackHelper()]); } return promise; } @@ -712,8 +712,8 @@ namespace ts { // Promise.resolve().then(function () { return require(x); }) /*CommonJs Require*/ // We have to wrap require in then callback so that require is done in asynchronously // if we simply do require in resolve callback in Promise constructor. We will execute the loading immediately - const promiseResolveCall = factory.createCall(factory.createPropertyAccess(factory.createIdentifier("Promise"), "resolve"), /*typeArguments*/ undefined, /*argumentsArray*/ []); - let requireCall: Expression = factory.createCall(factory.createIdentifier("require"), /*typeArguments*/ undefined, arg ? [arg] : []); + const promiseResolveCall = factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("Promise"), "resolve"), /*typeArguments*/ undefined, /*argumentsArray*/ []); + let requireCall: Expression = factory.createCallExpression(factory.createIdentifier("require"), /*typeArguments*/ undefined, arg ? [arg] : []); if (compilerOptions.esModuleInterop) { context.requestEmitHelper(importStarHelper); requireCall = emitHelpers().createImportStarHelper(requireCall); @@ -737,7 +737,7 @@ namespace ts { /*typeParameters*/ undefined, /*parameters*/ [], /*type*/ undefined, - factory.createBlock([factory.createReturn(requireCall)])); + factory.createBlock([factory.createReturnStatement(requireCall)])); // if there is a lexical 'this' in the import call arguments, ensure we indicate // that this new function expression indicates it captures 'this' so that the @@ -747,7 +747,7 @@ namespace ts { } } - return factory.createCall(factory.createPropertyAccess(promiseResolveCall, "then"), /*typeArguments*/ undefined, [func]); + return factory.createCallExpression(factory.createPropertyAccessExpression(promiseResolveCall, "then"), /*typeArguments*/ undefined, [func]); } function getHelperExpressionForExport(node: ExportDeclaration, innerExpr: Expression) { @@ -756,7 +756,7 @@ namespace ts { } if (getExportNeedsImportStarHelper(node)) { context.requestEmitHelper(importStarHelper); - return factory.createCall(context.getEmitHelperFactory().getUnscopedHelperName("__importStar"), /*typeArguments*/ undefined, [innerExpr]); + return factory.createCallExpression(context.getEmitHelperFactory().getUnscopedHelperName("__importStar"), /*typeArguments*/ undefined, [innerExpr]); } return innerExpr; } @@ -893,7 +893,7 @@ namespace ts { args.push(moduleName); } - return factory.createCall(factory.createIdentifier("require"), /*typeArguments*/ undefined, args); + return factory.createCallExpression(factory.createIdentifier("require"), /*typeArguments*/ undefined, args); } /** @@ -1023,7 +1023,7 @@ namespace ts { ); } else { - const exportedValue = factory.createPropertyAccess( + const exportedValue = factory.createPropertyAccessExpression( generatedName, specifier.propertyName || specifier.name ); @@ -1271,7 +1271,7 @@ namespace ts { else { return factory.createAssignment( setTextRange( - factory.createPropertyAccess( + factory.createPropertyAccessExpression( factory.createIdentifier("exports"), node.name ), @@ -1515,13 +1515,13 @@ namespace ts { } else { statement = factory.createExpressionStatement( - factory.createCall( - factory.createPropertyAccess(factory.createIdentifier("Object"), "defineProperty"), + factory.createCallExpression( + factory.createPropertyAccessExpression(factory.createIdentifier("Object"), "defineProperty"), /*typeArguments*/ undefined, [ factory.createIdentifier("exports"), factory.createStringLiteral("__esModule"), - factory.createObjectLiteral([ + factory.createObjectLiteralExpression([ factory.createPropertyAssignment("value", factory.createTrue()) ]) ] @@ -1559,8 +1559,8 @@ namespace ts { */ function createExportExpression(name: Identifier, value: Expression, location?: TextRange, liveBinding?: boolean) { return setTextRange( - liveBinding && languageVersion !== ScriptTarget.ES3 ? factory.createCall( - factory.createPropertyAccess( + liveBinding && languageVersion !== ScriptTarget.ES3 ? factory.createCallExpression( + factory.createPropertyAccessExpression( factory.createIdentifier("Object"), "defineProperty" ), @@ -1568,7 +1568,7 @@ namespace ts { [ factory.createIdentifier("exports"), factory.createStringLiteralFromNode(name), - factory.createObjectLiteral([ + factory.createObjectLiteralExpression([ factory.createPropertyAssignment("enumerable", factory.createTrue()), factory.createPropertyAssignment("get", factory.createFunctionExpression( /*modifiers*/ undefined, @@ -1577,12 +1577,12 @@ namespace ts { /*typeParameters*/ undefined, /*parameters*/ [], /*type*/ undefined, - factory.createBlock([factory.createReturn(value)]) + factory.createBlock([factory.createReturnStatement(value)]) )) ]) ] ) : factory.createAssignment( - factory.createPropertyAccess( + factory.createPropertyAccessExpression( factory.createIdentifier("exports"), factory.cloneNode(name) ), @@ -1716,7 +1716,7 @@ namespace ts { if (getEmitFlags(node) & EmitFlags.HelperName) { const externalHelpersModuleName = getExternalHelpersModuleName(currentSourceFile); if (externalHelpersModuleName) { - return factory.createPropertyAccess(externalHelpersModuleName, node); + return factory.createPropertyAccessExpression(externalHelpersModuleName, node); } return node; @@ -1726,7 +1726,7 @@ namespace ts { const exportContainer = resolver.getReferencedExportContainer(node, isExportName(node)); if (exportContainer && exportContainer.kind === SyntaxKind.SourceFile) { return setTextRange( - factory.createPropertyAccess( + factory.createPropertyAccessExpression( factory.createIdentifier("exports"), factory.cloneNode(node) ), @@ -1738,7 +1738,7 @@ namespace ts { if (importDeclaration) { if (isImportClause(importDeclaration)) { return setTextRange( - factory.createPropertyAccess( + factory.createPropertyAccessExpression( factory.getGeneratedNameForNode(importDeclaration.parent), factory.createIdentifier("default") ), @@ -1748,7 +1748,7 @@ namespace ts { else if (isImportSpecifier(importDeclaration)) { const name = importDeclaration.propertyName || importDeclaration.name; return setTextRange( - factory.createPropertyAccess( + factory.createPropertyAccessExpression( factory.getGeneratedNameForNode(importDeclaration.parent.parent.parent), factory.cloneNode(name) ), @@ -1820,7 +1820,7 @@ namespace ts { if (exportedNames) { let expression: Expression = node.kind === SyntaxKind.PostfixUnaryExpression ? setTextRange( - factory.createBinary( + factory.createBinaryExpression( node.operand, factory.createToken(node.operator === SyntaxKind.PlusPlusToken ? SyntaxKind.PlusEqualsToken : SyntaxKind.MinusEqualsToken), factory.createNumericLiteral(1) @@ -1872,7 +1872,7 @@ namespace ts { function createExportStarHelper(context: TransformationContext, module: Expression) { context.requestEmitHelper(exportStarHelper); - return context.factory.createCall(context.getEmitHelperFactory().getUnscopedHelperName("__exportStar"), /*typeArguments*/ undefined, [module, context.factory.createIdentifier("exports")]); + return context.factory.createCallExpression(context.getEmitHelperFactory().getUnscopedHelperName("__exportStar"), /*typeArguments*/ undefined, [module, context.factory.createIdentifier("exports")]); } // emit helper for dynamic import diff --git a/src/compiler/transformers/module/system.ts b/src/compiler/transformers/module/system.ts index ca8d567e51d1b..26590fbb5d9d1 100644 --- a/src/compiler/transformers/module/system.ts +++ b/src/compiler/transformers/module/system.ts @@ -100,15 +100,15 @@ namespace ts { // Clear the emit-helpers flag for later passes since we'll have already used it in the module body // So the helper will be emit at the correct position instead of at the top of the source-file const moduleName = tryGetModuleNameFromFile(factory, node, host, compilerOptions); - const dependencies = factory.createArrayLiteral(map(dependencyGroups, dependencyGroup => dependencyGroup.name)); + const dependencies = factory.createArrayLiteralExpression(map(dependencyGroups, dependencyGroup => dependencyGroup.name)); const updated = setEmitFlags( factory.updateSourceFile( node, setTextRange( factory.createNodeArray([ factory.createExpressionStatement( - factory.createCall( - factory.createPropertyAccess(factory.createIdentifier("System"), "register"), + factory.createCallExpression( + factory.createPropertyAccessExpression(factory.createIdentifier("System"), "register"), /*typeArguments*/ undefined, moduleName ? [moduleName, dependencies, moduleBodyFunction] @@ -238,7 +238,7 @@ namespace ts { /*type*/ undefined, factory.createLogicalAnd( contextObject, - factory.createPropertyAccess(contextObject, "id") + factory.createPropertyAccessExpression(contextObject, "id") ) ) ]) @@ -267,7 +267,7 @@ namespace ts { const modifiers = node.transformFlags & TransformFlags.ContainsAwait ? factory.createModifiersFromModifierFlags(ModifierFlags.Async) : undefined; - const moduleObject = factory.createObjectLiteral([ + const moduleObject = factory.createObjectLiteralExpression([ factory.createPropertyAssignment("setters", createSettersArray(exportStarFunction, dependencyGroups) ), @@ -284,7 +284,7 @@ namespace ts { ) ], /*multiLine*/ true); - statements.push(factory.createReturn(moduleObject)); + statements.push(factory.createReturnStatement(moduleObject)); return factory.createBlock(statements, /*multiLine*/ true); } @@ -349,7 +349,7 @@ namespace ts { exportedNamesStorageRef, /*exclamationToken*/ undefined, /*type*/ undefined, - factory.createObjectLiteral(exportedNames, /*multiline*/ true) + factory.createObjectLiteralExpression(exportedNames, /*multiline*/ true) ) ]) ) @@ -377,8 +377,8 @@ namespace ts { condition = factory.createLogicalAnd( condition, factory.createLogicalNot( - factory.createCall( - factory.createPropertyAccess(localNames, "hasOwnProperty"), + factory.createCallExpression( + factory.createPropertyAccessExpression(localNames, "hasOwnProperty"), /*typeArguments*/ undefined, [n] ) @@ -402,23 +402,23 @@ namespace ts { exports, /*exclamationToken*/ undefined, /*type*/ undefined, - factory.createObjectLiteral([]) + factory.createObjectLiteralExpression([]) ) ]) ), - factory.createForIn( + factory.createForInStatement( factory.createVariableDeclarationList([ factory.createVariableDeclaration(n) ]), m, factory.createBlock([ setEmitFlags( - factory.createIf( + factory.createIfStatement( condition, factory.createExpressionStatement( factory.createAssignment( - factory.createElementAccess(exports, n), - factory.createElementAccess(m, n) + factory.createElementAccessExpression(exports, n), + factory.createElementAccessExpression(m, n) ) ) ), @@ -427,7 +427,7 @@ namespace ts { ]) ), factory.createExpressionStatement( - factory.createCall( + factory.createCallExpression( exportFunction, /*typeArguments*/ undefined, [exports] @@ -488,7 +488,7 @@ namespace ts { properties.push( factory.createPropertyAssignment( factory.createStringLiteral(idText(e.name)), - factory.createElementAccess( + factory.createElementAccessExpression( parameterName, factory.createStringLiteral(idText(e.propertyName || e.name)) ) @@ -498,10 +498,10 @@ namespace ts { statements.push( factory.createExpressionStatement( - factory.createCall( + factory.createCallExpression( exportFunction, /*typeArguments*/ undefined, - [factory.createObjectLiteral(properties, /*multiline*/ true)] + [factory.createObjectLiteralExpression(properties, /*multiline*/ true)] ) ) ); @@ -509,7 +509,7 @@ namespace ts { else { statements.push( factory.createExpressionStatement( - factory.createCall( + factory.createCallExpression( exportFunction, /*typeArguments*/ undefined, [ @@ -529,7 +529,7 @@ namespace ts { // exportStar(foo_1_1); statements.push( factory.createExpressionStatement( - factory.createCall( + factory.createCallExpression( exportStarFunction, /*typeArguments*/ undefined, [parameterName] @@ -554,7 +554,7 @@ namespace ts { ); } - return factory.createArrayLiteral(setters, /*multiLine*/ true); + return factory.createArrayLiteralExpression(setters, /*multiLine*/ true); } // @@ -1141,7 +1141,7 @@ namespace ts { function createExportExpression(name: Identifier | StringLiteral, value: Expression) { const exportName = isIdentifier(name) ? factory.createStringLiteralFromNode(name) : name; setEmitFlags(value, getEmitFlags(value) | EmitFlags.NoComments); - return setCommentRange(factory.createCall(exportFunction, /*typeArguments*/ undefined, [exportName, value]), value); + return setCommentRange(factory.createCallExpression(exportFunction, /*typeArguments*/ undefined, [exportName, value]), value); } // @@ -1226,7 +1226,7 @@ namespace ts { const savedEnclosingBlockScopedContainer = enclosingBlockScopedContainer; enclosingBlockScopedContainer = node; - node = factory.updateFor( + node = factory.updateForStatement( node, node.initializer && visitForInitializer(node.initializer), visitNode(node.condition, destructuringAndImportCallVisitor, isExpression), @@ -1247,7 +1247,7 @@ namespace ts { const savedEnclosingBlockScopedContainer = enclosingBlockScopedContainer; enclosingBlockScopedContainer = node; - node = factory.updateForIn( + node = factory.updateForInStatement( node, visitForInitializer(node.initializer), visitNode(node.expression, destructuringAndImportCallVisitor, isExpression), @@ -1267,7 +1267,7 @@ namespace ts { const savedEnclosingBlockScopedContainer = enclosingBlockScopedContainer; enclosingBlockScopedContainer = node; - node = factory.updateForOf( + node = factory.updateForOfStatement( node, node.awaitModifier, visitForInitializer(node.initializer), @@ -1318,7 +1318,7 @@ namespace ts { * @param node The node to visit. */ function visitDoStatement(node: DoStatement): VisitResult { - return factory.updateDo( + return factory.updateDoStatement( node, visitNode(node.statement, nestedElementVisitor, isStatement, factory.liftToBlock), visitNode(node.expression, destructuringAndImportCallVisitor, isExpression) @@ -1331,7 +1331,7 @@ namespace ts { * @param node The node to visit. */ function visitWhileStatement(node: WhileStatement): VisitResult { - return factory.updateWhile( + return factory.updateWhileStatement( node, visitNode(node.expression, destructuringAndImportCallVisitor, isExpression), visitNode(node.statement, nestedElementVisitor, isStatement, factory.liftToBlock) @@ -1344,7 +1344,7 @@ namespace ts { * @param node The node to visit. */ function visitLabeledStatement(node: LabeledStatement): VisitResult { - return factory.updateLabel( + return factory.updateLabeledStatement( node, node.label, visitNode(node.statement, nestedElementVisitor, isStatement, factory.liftToBlock) @@ -1357,7 +1357,7 @@ namespace ts { * @param node The node to visit. */ function visitWithStatement(node: WithStatement): VisitResult { - return factory.updateWith( + return factory.updateWithStatement( node, visitNode(node.expression, destructuringAndImportCallVisitor, isExpression), visitNode(node.statement, nestedElementVisitor, isStatement, factory.liftToBlock) @@ -1370,7 +1370,7 @@ namespace ts { * @param node The node to visit. */ function visitSwitchStatement(node: SwitchStatement): VisitResult { - return factory.updateSwitch( + return factory.updateSwitchStatement( node, visitNode(node.expression, destructuringAndImportCallVisitor, isExpression), visitNode(node.caseBlock, nestedElementVisitor, isCaseBlock) @@ -1495,8 +1495,8 @@ namespace ts { // } // }; // }); - return factory.createCall( - factory.createPropertyAccess( + return factory.createCallExpression( + factory.createPropertyAccessExpression( contextObject, factory.createIdentifier("import") ), @@ -1665,7 +1665,7 @@ namespace ts { return setTextRange( factory.createPropertyAssignment( factory.cloneNode(name), - factory.createPropertyAccess( + factory.createPropertyAccessExpression( factory.getGeneratedNameForNode(importDeclaration.parent), factory.createIdentifier("default") ) @@ -1677,7 +1677,7 @@ namespace ts { return setTextRange( factory.createPropertyAssignment( factory.cloneNode(name), - factory.createPropertyAccess( + factory.createPropertyAccessExpression( factory.getGeneratedNameForNode(importDeclaration.parent.parent.parent), factory.cloneNode(importDeclaration.propertyName || importDeclaration.name) ), @@ -1720,7 +1720,7 @@ namespace ts { if (getEmitFlags(node) & EmitFlags.HelperName) { const externalHelpersModuleName = getExternalHelpersModuleName(currentSourceFile); if (externalHelpersModuleName) { - return factory.createPropertyAccess(externalHelpersModuleName, node); + return factory.createPropertyAccessExpression(externalHelpersModuleName, node); } return node; @@ -1737,7 +1737,7 @@ namespace ts { if (importDeclaration) { if (isImportClause(importDeclaration)) { return setTextRange( - factory.createPropertyAccess( + factory.createPropertyAccessExpression( factory.getGeneratedNameForNode(importDeclaration.parent), factory.createIdentifier("default") ), @@ -1746,7 +1746,7 @@ namespace ts { } else if (isImportSpecifier(importDeclaration)) { return setTextRange( - factory.createPropertyAccess( + factory.createPropertyAccessExpression( factory.getGeneratedNameForNode(importDeclaration.parent.parent.parent), factory.cloneNode(importDeclaration.propertyName || importDeclaration.name) ), @@ -1817,7 +1817,7 @@ namespace ts { if (exportedNames) { let expression: Expression = node.kind === SyntaxKind.PostfixUnaryExpression ? setTextRange( - factory.createPrefix( + factory.createPrefixUnaryExpression( node.operator, node.operand ), @@ -1844,7 +1844,7 @@ namespace ts { function substituteMetaProperty(node: MetaProperty) { if (isImportMeta(node)) { - return factory.createPropertyAccess(contextObject, factory.createIdentifier("meta")); + return factory.createPropertyAccessExpression(contextObject, factory.createIdentifier("meta")); } return node; } diff --git a/src/compiler/transformers/taggedTemplate.ts b/src/compiler/transformers/taggedTemplate.ts index 3582001f075d0..c3b3231916ab1 100644 --- a/src/compiler/transformers/taggedTemplate.ts +++ b/src/compiler/transformers/taggedTemplate.ts @@ -43,8 +43,8 @@ namespace ts { } const helperCall = context.getEmitHelperFactory().createTemplateObjectHelper( - factory.createArrayLiteral(cookedStrings), - factory.createArrayLiteral(rawStrings)); + factory.createArrayLiteralExpression(cookedStrings), + factory.createArrayLiteralExpression(rawStrings)); // Create a variable to cache the template object if we're in a module. // Do not do this in the global scope, as any variable we currently generate could conflict with @@ -63,7 +63,7 @@ namespace ts { templateArguments[0] = helperCall; } - return factory.createCall(tag, /*typeArguments*/ undefined, templateArguments); + return factory.createCallExpression(tag, /*typeArguments*/ undefined, templateArguments); } function createTemplateCooked(template: TemplateHead | TemplateMiddle | TemplateTail | NoSubstitutionTemplateLiteral) { diff --git a/src/compiler/transformers/ts.ts b/src/compiler/transformers/ts.ts index 2eedcd0ed3fc7..1eb4ddb777928 100644 --- a/src/compiler/transformers/ts.ts +++ b/src/compiler/transformers/ts.ts @@ -659,7 +659,7 @@ namespace ts { setTextRangeEnd(outer, closingBraceLocation.end); setEmitFlags(outer, EmitFlags.NoComments); - const statement = factory.createReturn(outer); + const statement = factory.createReturnStatement(outer); setTextRangePos(statement, closingBraceLocation.pos); setEmitFlags(statement, EmitFlags.NoComments | EmitFlags.NoTokenSourceMaps); statements.push(statement); @@ -1336,7 +1336,7 @@ namespace ts { (properties || (properties = [])).push(factory.createPropertyAssignment("returnType", factory.createArrowFunction(/*modifiers*/ undefined, /*typeParameters*/ undefined, [], /*type*/ undefined, factory.createToken(SyntaxKind.EqualsGreaterThanToken), serializeReturnTypeOfNode(node)))); } if (properties) { - decoratorExpressions.push(emitHelpers().createMetadataHelper("design:typeinfo", factory.createObjectLiteral(properties, /*multiLine*/ true))); + decoratorExpressions.push(emitHelpers().createMetadataHelper("design:typeinfo", factory.createObjectLiteralExpression(properties, /*multiLine*/ true))); } } } @@ -1449,7 +1449,7 @@ namespace ts { } } - return factory.createArrayLiteral(expressions); + return factory.createArrayLiteralExpression(expressions); } function getParametersOfDecoratedDeclaration(node: SignatureDeclaration, container: ClassLikeDeclaration) { @@ -1664,7 +1664,7 @@ namespace ts { const serialized = serializeEntityNameAsExpressionFallback(node.typeName); const temp = factory.createTempVariable(hoistVariableDeclaration); - return factory.createConditional( + return factory.createConditionalExpression( factory.createTypeCheck(factory.createAssignment(temp, serialized), "function"), /*questionToken*/ undefined, temp, @@ -1713,7 +1713,7 @@ namespace ts { function createCheckedValue(left: Expression, right: Expression) { return factory.createLogicalAnd( - factory.createStrictInequality(factory.createTypeOf(left), factory.createStringLiteral("undefined")), + factory.createStrictInequality(factory.createTypeOfExpression(left), factory.createStringLiteral("undefined")), right ); } @@ -1741,7 +1741,7 @@ namespace ts { left.left, factory.createStrictInequality(factory.createAssignment(temp, left.right), factory.createVoidZero()) ), - factory.createPropertyAccess(temp, node.right) + factory.createPropertyAccessExpression(temp, node.right) ); } @@ -1773,7 +1773,7 @@ namespace ts { * qualified name at runtime. */ function serializeQualifiedNameAsExpression(node: QualifiedName): SerializedEntityNameAsExpression { - return factory.createPropertyAccess(serializeEntityNameAsExpression(node.left), node.right); + return factory.createPropertyAccessExpression(serializeEntityNameAsExpression(node.left), node.right); } /** @@ -1781,7 +1781,7 @@ namespace ts { * available. */ function getGlobalSymbolNameWithFallback(): ConditionalExpression { - return factory.createConditional( + return factory.createConditionalExpression( factory.createTypeCheck(factory.createIdentifier("Symbol"), "function"), /*questionToken*/ undefined, factory.createIdentifier("Symbol"), @@ -1796,7 +1796,7 @@ namespace ts { */ function getGlobalBigIntNameWithFallback(): SerializedTypeNode { return languageVersion < ScriptTarget.ESNext - ? factory.createConditional( + ? factory.createConditionalExpression( factory.createTypeCheck(factory.createIdentifier("BigInt"), "function"), /*questionToken*/ undefined, factory.createIdentifier("BigInt"), @@ -1999,7 +1999,7 @@ namespace ts { factory.createExpressionStatement( factory.createAssignment( setTextRange( - factory.createPropertyAccess( + factory.createPropertyAccessExpression( factory.createThis(), propertyName ), @@ -2250,7 +2250,7 @@ namespace ts { // HOWEVER - if there are leading comments on the expression itself, to handle ASI // correctly for return and throw, we must keep the parenthesis if (length(getLeadingCommentRangesOfNode(expression, currentSourceFile))) { - return factory.updateParen(node, expression); + return factory.updateParenthesizedExpression(node, expression); } return factory.createPartiallyEmittedExpression(expression, node); } @@ -2269,7 +2269,7 @@ namespace ts { } function visitCallExpression(node: CallExpression) { - return factory.updateCall( + return factory.updateCallExpression( node, visitNode(node.expression, visitor, isExpression), /*typeArguments*/ undefined, @@ -2277,7 +2277,7 @@ namespace ts { } function visitNewExpression(node: NewExpression) { - return factory.updateNew( + return factory.updateNewExpression( node, visitNode(node.expression, visitor, isExpression), /*typeArguments*/ undefined, @@ -2285,7 +2285,7 @@ namespace ts { } function visitTaggedTemplateExpression(node: TaggedTemplateExpression) { - return factory.updateTaggedTemplate( + return factory.updateTaggedTemplateExpression( node, visitNode(node.tag, visitor, isExpression), /*typeArguments*/ undefined, @@ -2366,7 +2366,7 @@ namespace ts { exportName, factory.createAssignment( exportName, - factory.createObjectLiteral() + factory.createObjectLiteralExpression() ) ); @@ -2383,7 +2383,7 @@ namespace ts { // ... // })(x || (x = {})); const enumStatement = factory.createExpressionStatement( - factory.createCall( + factory.createCallExpression( factory.createFunctionExpression( /*modifiers*/ undefined, /*asteriskToken*/ undefined, @@ -2448,7 +2448,7 @@ namespace ts { const name = getExpressionForPropertyName(member, /*generateNameForComputedPropertyName*/ false); const valueExpression = transformEnumMemberDeclarationValue(member); const innerAssignment = factory.createAssignment( - factory.createElementAccess( + factory.createElementAccessExpression( currentNamespaceContainerName, name ), @@ -2457,7 +2457,7 @@ namespace ts { const outerAssignment = valueExpression.kind === SyntaxKind.StringLiteral ? innerAssignment : factory.createAssignment( - factory.createElementAccess( + factory.createElementAccessExpression( currentNamespaceContainerName, innerAssignment ), @@ -2667,7 +2667,7 @@ namespace ts { exportName, factory.createAssignment( exportName, - factory.createObjectLiteral() + factory.createObjectLiteralExpression() ) ); @@ -2683,7 +2683,7 @@ namespace ts { // x_1.y = ...; // })(x || (x = {})); const moduleStatement = factory.createExpressionStatement( - factory.createCall( + factory.createCallExpression( factory.createFunctionExpression( /*modifiers*/ undefined, /*asteriskToken*/ undefined, @@ -3147,7 +3147,7 @@ namespace ts { } function getClassPrototype(node: ClassExpression | ClassDeclaration) { - return factory.createPropertyAccess(factory.getDeclarationName(node), "prototype"); + return factory.createPropertyAccessExpression(factory.getDeclarationName(node), "prototype"); } function getClassMemberPrefix(node: ClassExpression | ClassDeclaration, member: ClassElement) { @@ -3317,7 +3317,7 @@ namespace ts { (applicableSubstitutions & TypeScriptSubstitutionFlags.NonQualifiedEnumMembers && container.kind === SyntaxKind.EnumDeclaration); if (substitute) { return setTextRange( - factory.createPropertyAccess(factory.getGeneratedNameForNode(container), node), + factory.createPropertyAccessExpression(factory.getGeneratedNameForNode(container), node), /*location*/ node ); } diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 5eaca783a9e37..5c4e6f0c1592b 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -6714,50 +6714,50 @@ namespace ts { // Expression // - createArrayLiteral(elements?: readonly Expression[], multiLine?: boolean): ArrayLiteralExpression; - updateArrayLiteral(node: ArrayLiteralExpression, elements: readonly Expression[]): ArrayLiteralExpression; - createObjectLiteral(properties?: readonly ObjectLiteralElementLike[], multiLine?: boolean): ObjectLiteralExpression; - updateObjectLiteral(node: ObjectLiteralExpression, properties: readonly ObjectLiteralElementLike[]): ObjectLiteralExpression; - createPropertyAccess(expression: Expression, name: string | Identifier | PrivateIdentifier): PropertyAccessExpression; - updatePropertyAccess(node: PropertyAccessExpression, expression: Expression, name: Identifier | PrivateIdentifier): PropertyAccessExpression; + createArrayLiteralExpression(elements?: readonly Expression[], multiLine?: boolean): ArrayLiteralExpression; + updateArrayLiteralExpression(node: ArrayLiteralExpression, elements: readonly Expression[]): ArrayLiteralExpression; + createObjectLiteralExpression(properties?: readonly ObjectLiteralElementLike[], multiLine?: boolean): ObjectLiteralExpression; + updateObjectLiteralExpression(node: ObjectLiteralExpression, properties: readonly ObjectLiteralElementLike[]): ObjectLiteralExpression; + createPropertyAccessExpression(expression: Expression, name: string | Identifier | PrivateIdentifier): PropertyAccessExpression; + updatePropertyAccessExpression(node: PropertyAccessExpression, expression: Expression, name: Identifier | PrivateIdentifier): PropertyAccessExpression; createPropertyAccessChain(expression: Expression, questionDotToken: QuestionDotToken | undefined, name: string | Identifier | PrivateIdentifier): PropertyAccessChain; updatePropertyAccessChain(node: PropertyAccessChain, expression: Expression, questionDotToken: QuestionDotToken | undefined, name: Identifier | PrivateIdentifier): PropertyAccessChain; - createElementAccess(expression: Expression, index: number | Expression): ElementAccessExpression; - updateElementAccess(node: ElementAccessExpression, expression: Expression, argumentExpression: Expression): ElementAccessExpression; + createElementAccessExpression(expression: Expression, index: number | Expression): ElementAccessExpression; + updateElementAccessExpression(node: ElementAccessExpression, expression: Expression, argumentExpression: Expression): ElementAccessExpression; createElementAccessChain(expression: Expression, questionDotToken: QuestionDotToken | undefined, index: number | Expression): ElementAccessChain; updateElementAccessChain(node: ElementAccessChain, expression: Expression, questionDotToken: QuestionDotToken | undefined, argumentExpression: Expression): ElementAccessChain; - createCall(expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined): CallExpression; - updateCall(node: CallExpression, expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[]): CallExpression; + createCallExpression(expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined): CallExpression; + updateCallExpression(node: CallExpression, expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[]): CallExpression; createCallChain(expression: Expression, questionDotToken: QuestionDotToken | undefined, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined): CallChain; updateCallChain(node: CallChain, expression: Expression, questionDotToken: QuestionDotToken | undefined, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[]): CallChain; - createNew(expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined): NewExpression; - updateNew(node: NewExpression, expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined): NewExpression; - createTaggedTemplate(tag: Expression, typeArguments: readonly TypeNode[] | undefined, template: TemplateLiteral): TaggedTemplateExpression; - updateTaggedTemplate(node: TaggedTemplateExpression, tag: Expression, typeArguments: readonly TypeNode[] | undefined, template: TemplateLiteral): TaggedTemplateExpression; + createNewExpression(expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined): NewExpression; + updateNewExpression(node: NewExpression, expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined): NewExpression; + createTaggedTemplateExpression(tag: Expression, typeArguments: readonly TypeNode[] | undefined, template: TemplateLiteral): TaggedTemplateExpression; + updateTaggedTemplateExpression(node: TaggedTemplateExpression, tag: Expression, typeArguments: readonly TypeNode[] | undefined, template: TemplateLiteral): TaggedTemplateExpression; createTypeAssertion(type: TypeNode, expression: Expression): TypeAssertion; updateTypeAssertion(node: TypeAssertion, type: TypeNode, expression: Expression): TypeAssertion; - createParen(expression: Expression): ParenthesizedExpression; - updateParen(node: ParenthesizedExpression, expression: Expression): ParenthesizedExpression; + createParenthesizedExpression(expression: Expression): ParenthesizedExpression; + updateParenthesizedExpression(node: ParenthesizedExpression, expression: Expression): ParenthesizedExpression; createFunctionExpression(modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[] | undefined, type: TypeNode | undefined, body: Block): FunctionExpression; updateFunctionExpression(node: FunctionExpression, modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block): FunctionExpression; createArrowFunction(modifiers: readonly Modifier[] | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, equalsGreaterThanToken: EqualsGreaterThanToken | undefined, body: ConciseBody): ArrowFunction; updateArrowFunction(node: ArrowFunction, modifiers: readonly Modifier[] | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, equalsGreaterThanToken: EqualsGreaterThanToken, body: ConciseBody): ArrowFunction; - createDelete(expression: Expression): DeleteExpression; - updateDelete(node: DeleteExpression, expression: Expression): DeleteExpression; - createTypeOf(expression: Expression): TypeOfExpression; - updateTypeOf(node: TypeOfExpression, expression: Expression): TypeOfExpression; - createVoid(expression: Expression): VoidExpression; - updateVoid(node: VoidExpression, expression: Expression): VoidExpression; - createAwait(expression: Expression): AwaitExpression; - updateAwait(node: AwaitExpression, expression: Expression): AwaitExpression; - createPrefix(operator: PrefixUnaryOperator, operand: Expression): PrefixUnaryExpression; - updatePrefix(node: PrefixUnaryExpression, operand: Expression): PrefixUnaryExpression; - createPostfix(operand: Expression, operator: PostfixUnaryOperator): PostfixUnaryExpression; - updatePostfix(node: PostfixUnaryExpression, operand: Expression): PostfixUnaryExpression; - createBinary(left: Expression, operator: BinaryOperator | BinaryOperatorToken, right: Expression): BinaryExpression; - updateBinary(node: BinaryExpression, left: Expression, operator: BinaryOperator | BinaryOperatorToken, right: Expression): BinaryExpression; - createConditional(condition: Expression, questionToken: QuestionToken | undefined, whenTrue: Expression, colonToken: ColonToken | undefined, whenFalse: Expression): ConditionalExpression; - updateConditional(node: ConditionalExpression, condition: Expression, questionToken: QuestionToken, whenTrue: Expression, colonToken: ColonToken, whenFalse: Expression): ConditionalExpression; + createDeleteExpression(expression: Expression): DeleteExpression; + updateDeleteExpression(node: DeleteExpression, expression: Expression): DeleteExpression; + createTypeOfExpression(expression: Expression): TypeOfExpression; + updateTypeOfExpression(node: TypeOfExpression, expression: Expression): TypeOfExpression; + createVoidExpression(expression: Expression): VoidExpression; + updateVoidExpression(node: VoidExpression, expression: Expression): VoidExpression; + createAwaitExpression(expression: Expression): AwaitExpression; + updateAwaitExpression(node: AwaitExpression, expression: Expression): AwaitExpression; + createPrefixUnaryExpression(operator: PrefixUnaryOperator, operand: Expression): PrefixUnaryExpression; + updatePrefixUnaryExpression(node: PrefixUnaryExpression, operand: Expression): PrefixUnaryExpression; + createPostfixUnaryExpression(operand: Expression, operator: PostfixUnaryOperator): PostfixUnaryExpression; + updatePostfixUnaryExpression(node: PostfixUnaryExpression, operand: Expression): PostfixUnaryExpression; + createBinaryExpression(left: Expression, operator: BinaryOperator | BinaryOperatorToken, right: Expression): BinaryExpression; + updateBinaryExpression(node: BinaryExpression, left: Expression, operator: BinaryOperator | BinaryOperatorToken, right: Expression): BinaryExpression; + createConditionalExpression(condition: Expression, questionToken: QuestionToken | undefined, whenTrue: Expression, colonToken: ColonToken | undefined, whenFalse: Expression): ConditionalExpression; + updateConditionalExpression(node: ConditionalExpression, condition: Expression, questionToken: QuestionToken, whenTrue: Expression, colonToken: ColonToken, whenFalse: Expression): ConditionalExpression; createTemplateExpression(head: TemplateHead, templateSpans: readonly TemplateSpan[]): TemplateExpression; updateTemplateExpression(node: TemplateExpression, head: TemplateHead, templateSpans: readonly TemplateSpan[]): TemplateExpression; createTemplateHead(text: string, rawText?: string, templateFlags?: TokenFlags): TemplateHead; @@ -6770,12 +6770,12 @@ namespace ts { createNoSubstitutionTemplateLiteral(text: string | undefined, rawText: string): NoSubstitutionTemplateLiteral; /* @internal */ createLiteralLikeNode(kind: LiteralToken["kind"] | SyntaxKind.JsxTextAllWhiteSpaces, text: string): LiteralToken; /* @internal */ createTemplateLiteralLikeNode(kind: TemplateLiteralToken["kind"], text: string, rawText: string, templateFlags: TokenFlags | undefined): TemplateLiteralLikeNode; - createYield(asteriskToken: AsteriskToken, expression: Expression): YieldExpression; - createYield(asteriskToken: undefined, expression: Expression | undefined): YieldExpression; - /* @internal */ createYield(asteriskToken: AsteriskToken | undefined, expression: Expression | undefined): YieldExpression; // eslint-disable-line @typescript-eslint/unified-signatures - updateYield(node: YieldExpression, asteriskToken: AsteriskToken | undefined, expression: Expression | undefined): YieldExpression; - createSpread(expression: Expression): SpreadElement; - updateSpread(node: SpreadElement, expression: Expression): SpreadElement; + createYieldExpression(asteriskToken: AsteriskToken, expression: Expression): YieldExpression; + createYieldExpression(asteriskToken: undefined, expression: Expression | undefined): YieldExpression; + /* @internal */ createYieldExpression(asteriskToken: AsteriskToken | undefined, expression: Expression | undefined): YieldExpression; // eslint-disable-line @typescript-eslint/unified-signatures + updateYieldExpression(node: YieldExpression, asteriskToken: AsteriskToken | undefined, expression: Expression | undefined): YieldExpression; + createSpreadElement(expression: Expression): SpreadElement; + updateSpreadElement(node: SpreadElement, expression: Expression): SpreadElement; createClassExpression(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassExpression; updateClassExpression(node: ClassExpression, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassExpression; createOmittedExpression(): OmittedExpression; @@ -6809,34 +6809,34 @@ namespace ts { createEmptyStatement(): EmptyStatement; createExpressionStatement(expression: Expression): ExpressionStatement; updateExpressionStatement(node: ExpressionStatement, expression: Expression): ExpressionStatement; - createIf(expression: Expression, thenStatement: Statement, elseStatement?: Statement): IfStatement; - updateIf(node: IfStatement, expression: Expression, thenStatement: Statement, elseStatement: Statement | undefined): IfStatement; - createDo(statement: Statement, expression: Expression): DoStatement; - updateDo(node: DoStatement, statement: Statement, expression: Expression): DoStatement; - createWhile(expression: Expression, statement: Statement): WhileStatement; - updateWhile(node: WhileStatement, expression: Expression, statement: Statement): WhileStatement; - createFor(initializer: ForInitializer | undefined, condition: Expression | undefined, incrementor: Expression | undefined, statement: Statement): ForStatement; - updateFor(node: ForStatement, initializer: ForInitializer | undefined, condition: Expression | undefined, incrementor: Expression | undefined, statement: Statement): ForStatement; - createForIn(initializer: ForInitializer, expression: Expression, statement: Statement): ForInStatement; - updateForIn(node: ForInStatement, initializer: ForInitializer, expression: Expression, statement: Statement): ForInStatement; - createForOf(awaitModifier: AwaitKeyword | undefined, initializer: ForInitializer, expression: Expression, statement: Statement): ForOfStatement; - updateForOf(node: ForOfStatement, awaitModifier: AwaitKeyword | undefined, initializer: ForInitializer, expression: Expression, statement: Statement): ForOfStatement; - createContinue(label?: string | Identifier): ContinueStatement; - updateContinue(node: ContinueStatement, label: Identifier | undefined): ContinueStatement; - createBreak(label?: string | Identifier): BreakStatement; - updateBreak(node: BreakStatement, label: Identifier | undefined): BreakStatement; - createReturn(expression?: Expression): ReturnStatement; - updateReturn(node: ReturnStatement, expression: Expression | undefined): ReturnStatement; - createWith(expression: Expression, statement: Statement): WithStatement; - updateWith(node: WithStatement, expression: Expression, statement: Statement): WithStatement; - createSwitch(expression: Expression, caseBlock: CaseBlock): SwitchStatement; - updateSwitch(node: SwitchStatement, expression: Expression, caseBlock: CaseBlock): SwitchStatement; - createLabel(label: string | Identifier, statement: Statement): LabeledStatement; - updateLabel(node: LabeledStatement, label: Identifier, statement: Statement): LabeledStatement; - createThrow(expression: Expression): ThrowStatement; - updateThrow(node: ThrowStatement, expression: Expression): ThrowStatement; - createTry(tryBlock: Block, catchClause: CatchClause | undefined, finallyBlock: Block | undefined): TryStatement; - updateTry(node: TryStatement, tryBlock: Block, catchClause: CatchClause | undefined, finallyBlock: Block | undefined): TryStatement; + createIfStatement(expression: Expression, thenStatement: Statement, elseStatement?: Statement): IfStatement; + updateIfStatement(node: IfStatement, expression: Expression, thenStatement: Statement, elseStatement: Statement | undefined): IfStatement; + createDoStatement(statement: Statement, expression: Expression): DoStatement; + updateDoStatement(node: DoStatement, statement: Statement, expression: Expression): DoStatement; + createWhileStatement(expression: Expression, statement: Statement): WhileStatement; + updateWhileStatement(node: WhileStatement, expression: Expression, statement: Statement): WhileStatement; + createForStatement(initializer: ForInitializer | undefined, condition: Expression | undefined, incrementor: Expression | undefined, statement: Statement): ForStatement; + updateForStatement(node: ForStatement, initializer: ForInitializer | undefined, condition: Expression | undefined, incrementor: Expression | undefined, statement: Statement): ForStatement; + createForInStatement(initializer: ForInitializer, expression: Expression, statement: Statement): ForInStatement; + updateForInStatement(node: ForInStatement, initializer: ForInitializer, expression: Expression, statement: Statement): ForInStatement; + createForOfStatement(awaitModifier: AwaitKeyword | undefined, initializer: ForInitializer, expression: Expression, statement: Statement): ForOfStatement; + updateForOfStatement(node: ForOfStatement, awaitModifier: AwaitKeyword | undefined, initializer: ForInitializer, expression: Expression, statement: Statement): ForOfStatement; + createContinueStatement(label?: string | Identifier): ContinueStatement; + updateContinueStatement(node: ContinueStatement, label: Identifier | undefined): ContinueStatement; + createBreakStatement(label?: string | Identifier): BreakStatement; + updateBreakStatement(node: BreakStatement, label: Identifier | undefined): BreakStatement; + createReturnStatement(expression?: Expression): ReturnStatement; + updateReturnStatement(node: ReturnStatement, expression: Expression | undefined): ReturnStatement; + createWithStatement(expression: Expression, statement: Statement): WithStatement; + updateWithStatement(node: WithStatement, expression: Expression, statement: Statement): WithStatement; + createSwitchStatement(expression: Expression, caseBlock: CaseBlock): SwitchStatement; + updateSwitchStatement(node: SwitchStatement, expression: Expression, caseBlock: CaseBlock): SwitchStatement; + createLabeledStatement(label: string | Identifier, statement: Statement): LabeledStatement; + updateLabeledStatement(node: LabeledStatement, label: Identifier, statement: Statement): LabeledStatement; + createThrowStatement(expression: Expression): ThrowStatement; + updateThrowStatement(node: ThrowStatement, expression: Expression): ThrowStatement; + createTryStatement(tryBlock: Block, catchClause: CatchClause | undefined, finallyBlock: Block | undefined): TryStatement; + updateTryStatement(node: TryStatement, tryBlock: Block, catchClause: CatchClause | undefined, finallyBlock: Block | undefined): TryStatement; createDebuggerStatement(): DebuggerStatement; createVariableDeclaration(name: string | BindingName, exclamationToken?: ExclamationToken, type?: TypeNode, initializer?: Expression): VariableDeclaration; updateVariableDeclaration(node: VariableDeclaration, name: BindingName, exclamationToken: ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): VariableDeclaration; @@ -7043,8 +7043,8 @@ namespace ts { updatePartiallyEmittedExpression(node: PartiallyEmittedExpression, expression: Expression): PartiallyEmittedExpression; /* @internal */ createSyntheticReferenceExpression(expression: Expression, thisArg: Expression): SyntheticReferenceExpression; /* @internal */ updateSyntheticReferenceExpression(node: SyntheticReferenceExpression, expression: Expression, thisArg: Expression): SyntheticReferenceExpression; - createCommaList(elements: readonly Expression[]): CommaListExpression; - updateCommaList(node: CommaListExpression, elements: readonly Expression[]): CommaListExpression; + createCommaListExpression(elements: readonly Expression[]): CommaListExpression; + updateCommaListExpression(node: CommaListExpression, elements: readonly Expression[]): CommaListExpression; createBundle(sourceFiles: readonly SourceFile[], prepends?: readonly (UnparsedSource | InputFiles)[]): Bundle; updateBundle(node: Bundle, sourceFiles: readonly SourceFile[], prepends?: readonly (UnparsedSource | InputFiles)[]): Bundle; diff --git a/src/compiler/visitorPublic.ts b/src/compiler/visitorPublic.ts index 2f8bd36213459..86651c8e433d0 100644 --- a/src/compiler/visitorPublic.ts +++ b/src/compiler/visitorPublic.ts @@ -218,7 +218,7 @@ namespace ts { /*exclamationToken*/ undefined, parameter.type, parameter.initializer ? - factory.createConditional( + factory.createConditionalExpression( factory.createStrictEquality( factory.getGeneratedNameForNode(parameter), factory.createVoidZero() @@ -246,7 +246,7 @@ namespace ts { function addDefaultValueAssignmentForInitializer(parameter: ParameterDeclaration, name: Identifier, initializer: Expression, context: TransformationContext) { const factory = context.factory; context.addInitializationStatement( - factory.createIf( + factory.createIfStatement( factory.createTypeCheck(factory.cloneNode(name), "undefined"), setEmitFlags( setTextRange( @@ -588,11 +588,11 @@ namespace ts { // Expression case SyntaxKind.ArrayLiteralExpression: - return factory.updateArrayLiteral(node, + return factory.updateArrayLiteralExpression(node, nodesVisitor((node).elements, visitor, isExpression)); case SyntaxKind.ObjectLiteralExpression: - return factory.updateObjectLiteral(node, + return factory.updateObjectLiteralExpression(node, nodesVisitor((node).properties, visitor, isObjectLiteralElementLike)); case SyntaxKind.PropertyAccessExpression: @@ -602,7 +602,7 @@ namespace ts { nodeVisitor((node).questionDotToken, tokenVisitor, isToken), nodeVisitor((node).name, visitor, isIdentifier)); } - return factory.updatePropertyAccess(node, + return factory.updatePropertyAccessExpression(node, nodeVisitor((node).expression, visitor, isExpression), nodeVisitor((node).name, visitor, isIdentifierOrPrivateIdentifier)); @@ -613,7 +613,7 @@ namespace ts { nodeVisitor((node).questionDotToken, tokenVisitor, isToken), nodeVisitor((node).argumentExpression, visitor, isExpression)); } - return factory.updateElementAccess(node, + return factory.updateElementAccessExpression(node, nodeVisitor((node).expression, visitor, isExpression), nodeVisitor((node).argumentExpression, visitor, isExpression)); @@ -625,19 +625,19 @@ namespace ts { nodesVisitor((node).typeArguments, visitor, isTypeNode), nodesVisitor((node).arguments, visitor, isExpression)); } - return factory.updateCall(node, + return factory.updateCallExpression(node, nodeVisitor((node).expression, visitor, isExpression), nodesVisitor((node).typeArguments, visitor, isTypeNode), nodesVisitor((node).arguments, visitor, isExpression)); case SyntaxKind.NewExpression: - return factory.updateNew(node, + return factory.updateNewExpression(node, nodeVisitor((node).expression, visitor, isExpression), nodesVisitor((node).typeArguments, visitor, isTypeNode), nodesVisitor((node).arguments, visitor, isExpression)); case SyntaxKind.TaggedTemplateExpression: - return factory.updateTaggedTemplate(node, + return factory.updateTaggedTemplateExpression(node, nodeVisitor((node).tag, visitor, isExpression), visitNodes((node).typeArguments, visitor, isExpression), nodeVisitor((node).template, visitor, isTemplateLiteral)); @@ -648,7 +648,7 @@ namespace ts { nodeVisitor((node).expression, visitor, isExpression)); case SyntaxKind.ParenthesizedExpression: - return factory.updateParen(node, + return factory.updateParenthesizedExpression(node, nodeVisitor((node).expression, visitor, isExpression)); case SyntaxKind.FunctionExpression: @@ -671,37 +671,37 @@ namespace ts { visitFunctionBody((node).body, visitor, context, nodeVisitor)); case SyntaxKind.DeleteExpression: - return factory.updateDelete(node, + return factory.updateDeleteExpression(node, nodeVisitor((node).expression, visitor, isExpression)); case SyntaxKind.TypeOfExpression: - return factory.updateTypeOf(node, + return factory.updateTypeOfExpression(node, nodeVisitor((node).expression, visitor, isExpression)); case SyntaxKind.VoidExpression: - return factory.updateVoid(node, + return factory.updateVoidExpression(node, nodeVisitor((node).expression, visitor, isExpression)); case SyntaxKind.AwaitExpression: - return factory.updateAwait(node, + return factory.updateAwaitExpression(node, nodeVisitor((node).expression, visitor, isExpression)); case SyntaxKind.PrefixUnaryExpression: - return factory.updatePrefix(node, + return factory.updatePrefixUnaryExpression(node, nodeVisitor((node).operand, visitor, isExpression)); case SyntaxKind.PostfixUnaryExpression: - return factory.updatePostfix(node, + return factory.updatePostfixUnaryExpression(node, nodeVisitor((node).operand, visitor, isExpression)); case SyntaxKind.BinaryExpression: - return factory.updateBinary(node, + return factory.updateBinaryExpression(node, nodeVisitor((node).left, visitor, isExpression), nodeVisitor((node).operatorToken, tokenVisitor, isToken), nodeVisitor((node).right, visitor, isExpression)); case SyntaxKind.ConditionalExpression: - return factory.updateConditional(node, + return factory.updateConditionalExpression(node, nodeVisitor((node).condition, visitor, isExpression), nodeVisitor((node).questionToken, tokenVisitor, isToken), nodeVisitor((node).whenTrue, visitor, isExpression), @@ -714,12 +714,12 @@ namespace ts { nodesVisitor((node).templateSpans, visitor, isTemplateSpan)); case SyntaxKind.YieldExpression: - return factory.updateYield(node, + return factory.updateYieldExpression(node, nodeVisitor((node).asteriskToken, tokenVisitor, isToken), nodeVisitor((node).expression, visitor, isExpression)); case SyntaxKind.SpreadElement: - return factory.updateSpread(node, + return factory.updateSpreadElement(node, nodeVisitor((node).expression, visitor, isExpression)); case SyntaxKind.ClassExpression: @@ -774,74 +774,74 @@ namespace ts { nodeVisitor((node).expression, visitor, isExpression)); case SyntaxKind.IfStatement: - return factory.updateIf(node, + return factory.updateIfStatement(node, nodeVisitor((node).expression, visitor, isExpression), nodeVisitor((node).thenStatement, visitor, isStatement, factory.liftToBlock), nodeVisitor((node).elseStatement, visitor, isStatement, factory.liftToBlock)); case SyntaxKind.DoStatement: - return factory.updateDo(node, + return factory.updateDoStatement(node, nodeVisitor((node).statement, visitor, isStatement, factory.liftToBlock), nodeVisitor((node).expression, visitor, isExpression)); case SyntaxKind.WhileStatement: - return factory.updateWhile(node, + return factory.updateWhileStatement(node, nodeVisitor((node).expression, visitor, isExpression), nodeVisitor((node).statement, visitor, isStatement, factory.liftToBlock)); case SyntaxKind.ForStatement: - return factory.updateFor(node, + return factory.updateForStatement(node, nodeVisitor((node).initializer, visitor, isForInitializer), nodeVisitor((node).condition, visitor, isExpression), nodeVisitor((node).incrementor, visitor, isExpression), nodeVisitor((node).statement, visitor, isStatement, factory.liftToBlock)); case SyntaxKind.ForInStatement: - return factory.updateForIn(node, + return factory.updateForInStatement(node, nodeVisitor((node).initializer, visitor, isForInitializer), nodeVisitor((node).expression, visitor, isExpression), nodeVisitor((node).statement, visitor, isStatement, factory.liftToBlock)); case SyntaxKind.ForOfStatement: - return factory.updateForOf(node, + return factory.updateForOfStatement(node, nodeVisitor((node).awaitModifier, tokenVisitor, isToken), nodeVisitor((node).initializer, visitor, isForInitializer), nodeVisitor((node).expression, visitor, isExpression), nodeVisitor((node).statement, visitor, isStatement, factory.liftToBlock)); case SyntaxKind.ContinueStatement: - return factory.updateContinue(node, + return factory.updateContinueStatement(node, nodeVisitor((node).label, visitor, isIdentifier)); case SyntaxKind.BreakStatement: - return factory.updateBreak(node, + return factory.updateBreakStatement(node, nodeVisitor((node).label, visitor, isIdentifier)); case SyntaxKind.ReturnStatement: - return factory.updateReturn(node, + return factory.updateReturnStatement(node, nodeVisitor((node).expression, visitor, isExpression)); case SyntaxKind.WithStatement: - return factory.updateWith(node, + return factory.updateWithStatement(node, nodeVisitor((node).expression, visitor, isExpression), nodeVisitor((node).statement, visitor, isStatement, factory.liftToBlock)); case SyntaxKind.SwitchStatement: - return factory.updateSwitch(node, + return factory.updateSwitchStatement(node, nodeVisitor((node).expression, visitor, isExpression), nodeVisitor((node).caseBlock, visitor, isCaseBlock)); case SyntaxKind.LabeledStatement: - return factory.updateLabel(node, + return factory.updateLabeledStatement(node, nodeVisitor((node).label, visitor, isIdentifier), nodeVisitor((node).statement, visitor, isStatement, factory.liftToBlock)); case SyntaxKind.ThrowStatement: - return factory.updateThrow(node, + return factory.updateThrowStatement(node, nodeVisitor((node).expression!, visitor, isExpression)); // expression could be `undefined` due to invalid parse. case SyntaxKind.TryStatement: - return factory.updateTry(node, + return factory.updateTryStatement(node, nodeVisitor((node).tryBlock, visitor, isBlock), nodeVisitor((node).catchClause, visitor, isCatchClause), nodeVisitor((node).finallyBlock, visitor, isBlock)); @@ -1082,7 +1082,7 @@ namespace ts { nodeVisitor((node).expression, visitor, isExpression)); case SyntaxKind.CommaListExpression: - return factory.updateCommaList(node, + return factory.updateCommaListExpression(node, nodesVisitor((node).elements, visitor, isExpression)); default: diff --git a/src/services/codefixes/addMissingAwait.ts b/src/services/codefixes/addMissingAwait.ts index 600bbc0791a0f..fc7c25d3f7db9 100644 --- a/src/services/codefixes/addMissingAwait.ts +++ b/src/services/codefixes/addMissingAwait.ts @@ -244,7 +244,7 @@ namespace ts.codefix { } } const type = checker.getTypeAtLocation(side); - const newNode = checker.getPromisedTypeOfPromise(type) ? factory.createAwait(side) : side; + const newNode = checker.getPromisedTypeOfPromise(type) ? factory.createAwaitExpression(side) : side; changeTracker.replaceNode(sourceFile, side, newNode); } } @@ -258,7 +258,7 @@ namespace ts.codefix { changeTracker.replaceNode( sourceFile, insertionSite.parent.expression, - factory.createParen(factory.createAwait(insertionSite.parent.expression))); + factory.createParenthesizedExpression(factory.createAwaitExpression(insertionSite.parent.expression))); insertLeadingSemicolonIfNeeded(changeTracker, insertionSite.parent.expression, sourceFile); } else if (contains(callableConstructableErrorCodes, errorCode) && isCallOrNewExpression(insertionSite.parent)) { @@ -268,7 +268,7 @@ namespace ts.codefix { return; } } - changeTracker.replaceNode(sourceFile, insertionSite, factory.createParen(factory.createAwait(insertionSite))); + changeTracker.replaceNode(sourceFile, insertionSite, factory.createParenthesizedExpression(factory.createAwaitExpression(insertionSite))); insertLeadingSemicolonIfNeeded(changeTracker, insertionSite, sourceFile); } else { @@ -278,7 +278,7 @@ namespace ts.codefix { return; } } - changeTracker.replaceNode(sourceFile, insertionSite, factory.createAwait(insertionSite)); + changeTracker.replaceNode(sourceFile, insertionSite, factory.createAwaitExpression(insertionSite)); } } diff --git a/src/services/codefixes/addMissingInvocationForDecorator.ts b/src/services/codefixes/addMissingInvocationForDecorator.ts index 4e5190ba571a9..e772b4a82f267 100644 --- a/src/services/codefixes/addMissingInvocationForDecorator.ts +++ b/src/services/codefixes/addMissingInvocationForDecorator.ts @@ -16,7 +16,7 @@ namespace ts.codefix { const token = getTokenAtPosition(sourceFile, pos); const decorator = findAncestor(token, isDecorator)!; Debug.assert(!!decorator, "Expected position to be owned by a decorator."); - const replacement = factory.createCall(decorator.expression, /*typeArguments*/ undefined, /*argumentsArray*/ undefined); + const replacement = factory.createCallExpression(decorator.expression, /*typeArguments*/ undefined, /*argumentsArray*/ undefined); changeTracker.replaceNode(sourceFile, decorator.expression, replacement); } } diff --git a/src/services/codefixes/convertFunctionToEs6Class.ts b/src/services/codefixes/convertFunctionToEs6Class.ts index 81292b64b2bfc..0ca2135307f95 100644 --- a/src/services/codefixes/convertFunctionToEs6Class.ts +++ b/src/services/codefixes/convertFunctionToEs6Class.ts @@ -208,7 +208,7 @@ namespace ts.codefix { } // case 2: () => [1,2,3] else { - bodyBlock = factory.createBlock([factory.createReturn(arrowFunctionBody)]); + bodyBlock = factory.createBlock([factory.createReturnStatement(arrowFunctionBody)]); } const fullModifiers = concatenate(modifiers, getModifierKindFromSource(arrowFunction, SyntaxKind.AsyncKeyword)); const method = factory.createMethodDeclaration(/*decorators*/ undefined, fullModifiers, /*asteriskToken*/ undefined, name, /*questionToken*/ undefined, diff --git a/src/services/codefixes/convertToAsyncFunction.ts b/src/services/codefixes/convertToAsyncFunction.ts index bb79beca86dc5..72bc3cb2a956a 100644 --- a/src/services/codefixes/convertToAsyncFunction.ts +++ b/src/services/codefixes/convertToAsyncFunction.ts @@ -287,7 +287,7 @@ namespace ts.codefix { varDeclList = factory.createVariableStatement(/*modifiers*/ undefined, factory.createVariableDeclarationList(varDecl, NodeFlags.Let)); } - const tryStatement = factory.createTry(tryBlock, catchClause, /*finallyBlock*/ undefined); + const tryStatement = factory.createTryStatement(tryBlock, catchClause, /*finallyBlock*/ undefined); const destructuredResult = prevArgName && varDeclIdentifier && isSynthBindingPattern(prevArgName) && factory.createVariableStatement(/*modifiers*/ undefined, factory.createVariableDeclarationList([factory.createVariableDeclaration(getSynthesizedDeepCloneWithRenames(prevArgName.bindingPattern), /*exclamationToken*/ undefined, /*type*/ undefined, varDeclIdentifier)], NodeFlags.Const)); return compact([varDeclList, tryStatement, destructuredResult]); @@ -311,7 +311,7 @@ namespace ts.codefix { const catchVariableDeclaration = factory.createVariableDeclaration(catchArg); const catchClause = factory.createCatchClause(catchVariableDeclaration, factory.createBlock(transformationBody2)); - return [factory.createTry(tryBlock, catchClause, /* finallyBlock */ undefined)]; + return [factory.createTryStatement(tryBlock, catchClause, /* finallyBlock */ undefined)]; } return transformExpression(node.expression, transformer, onFulfilledArgumentName).concat(transformationBody); @@ -322,10 +322,10 @@ namespace ts.codefix { */ function transformPromiseExpressionOfPropertyAccess(node: Expression, transformer: Transformer, prevArgName?: SynthBindingName): readonly Statement[] { if (shouldReturn(node, transformer)) { - return [factory.createReturn(getSynthesizedDeepClone(node))]; + return [factory.createReturnStatement(getSynthesizedDeepClone(node))]; } - return createVariableOrAssignmentOrExpressionStatement(prevArgName, factory.createAwait(node), /*typeAnnotation*/ undefined); + return createVariableOrAssignmentOrExpressionStatement(prevArgName, factory.createAwaitExpression(node), /*typeAnnotation*/ undefined); } function createVariableOrAssignmentOrExpressionStatement(variableName: SynthBindingName | undefined, rightHandSide: Expression, typeAnnotation: TypeNode | undefined): readonly Statement[] { @@ -356,10 +356,10 @@ namespace ts.codefix { const name = factory.createUniqueName("result", GeneratedIdentifierFlags.Optimistic); return [ ...createVariableOrAssignmentOrExpressionStatement(createSynthIdentifier(name), expressionToReturn, typeAnnotation), - factory.createReturn(name) + factory.createReturnStatement(name) ]; } - return [factory.createReturn(expressionToReturn)]; + return [factory.createReturnStatement(expressionToReturn)]; } // should be kept up to date with isFixablePromiseArgument in suggestionDiagnostics.ts @@ -374,7 +374,7 @@ namespace ts.codefix { break; } - const synthCall = factory.createCall(getSynthesizedDeepClone(func as Identifier), /*typeArguments*/ undefined, isSynthIdentifier(argName) ? [argName.identifier] : []); + const synthCall = factory.createCallExpression(getSynthesizedDeepClone(func as Identifier), /*typeArguments*/ undefined, isSynthIdentifier(argName) ? [argName.identifier] : []); if (shouldReturn(parent, transformer)) { return maybeAnnotateAndReturn(synthCall, parent.typeArguments?.[0]); } @@ -386,7 +386,7 @@ namespace ts.codefix { return silentFail(); } const returnType = callSignatures[0].getReturnType(); - const varDeclOrAssignment = createVariableOrAssignmentOrExpressionStatement(prevArgName, factory.createAwait(synthCall), parent.typeArguments?.[0]); + const varDeclOrAssignment = createVariableOrAssignmentOrExpressionStatement(prevArgName, factory.createAwaitExpression(synthCall), parent.typeArguments?.[0]); if (prevArgName) { prevArgName.types.push(returnType); } @@ -424,7 +424,7 @@ namespace ts.codefix { seenReturnStatement); } else { - const innerRetStmts = isFixablePromiseHandler(funcBody) ? [factory.createReturn(funcBody)] : emptyArray; + const innerRetStmts = isFixablePromiseHandler(funcBody) ? [factory.createReturnStatement(funcBody)] : emptyArray; const innerCbBody = getInnerTransformationBody(transformer, innerRetStmts, prevArgName); if (innerCbBody.length > 0) { @@ -434,7 +434,7 @@ namespace ts.codefix { const type = transformer.checker.getTypeAtLocation(func); const returnType = getLastCallSignature(type, transformer.checker)!.getReturnType(); const rightHandSide = getSynthesizedDeepClone(funcBody); - const possiblyAwaitedRightHandSide = !!transformer.checker.getPromisedTypeOfPromise(returnType) ? factory.createAwait(rightHandSide) : rightHandSide; + const possiblyAwaitedRightHandSide = !!transformer.checker.getPromisedTypeOfPromise(returnType) ? factory.createAwaitExpression(rightHandSide) : rightHandSide; if (!shouldReturn(parent, transformer)) { const transformedStatement = createVariableOrAssignmentOrExpressionStatement(prevArgName, possiblyAwaitedRightHandSide, /*typeAnnotation*/ undefined); if (prevArgName) { @@ -465,7 +465,7 @@ namespace ts.codefix { for (const stmt of stmts) { if (isReturnStatement(stmt)) { if (stmt.expression) { - const possiblyAwaitedExpression = isPromiseTypedExpression(stmt.expression, transformer.checker) ? factory.createAwait(stmt.expression) : stmt.expression; + const possiblyAwaitedExpression = isPromiseTypedExpression(stmt.expression, transformer.checker) ? factory.createAwaitExpression(stmt.expression) : stmt.expression; if (prevArgName === undefined) { ret.push(factory.createExpressionStatement(possiblyAwaitedExpression)); } diff --git a/src/services/codefixes/convertToEs6Module.ts b/src/services/codefixes/convertToEs6Module.ts index 5fc2850d71c07..56648e7434856 100644 --- a/src/services/codefixes/convertToEs6Module.ts +++ b/src/services/codefixes/convertToEs6Module.ts @@ -31,7 +31,7 @@ namespace ts.codefix { break; case SyntaxKind.CallExpression: if (isRequireCall(importNode, /*checkArgumentIsStringLiteralLike*/ false)) { - changes.replaceNode(importingFile, importNode, factory.createPropertyAccess(getSynthesizedDeepClone(importNode), "default")); + changes.replaceNode(importingFile, importNode, factory.createPropertyAccessExpression(getSynthesizedDeepClone(importNode), "default")); } break; } diff --git a/src/services/codefixes/fixAddMissingMember.ts b/src/services/codefixes/fixAddMissingMember.ts index 21f4f5e5b1930..9d48f054226b9 100644 --- a/src/services/codefixes/fixAddMissingMember.ts +++ b/src/services/codefixes/fixAddMissingMember.ts @@ -198,7 +198,7 @@ namespace ts.codefix { } function initializePropertyToUndefined(obj: Expression, propertyName: string) { - return factory.createExpressionStatement(factory.createAssignment(factory.createPropertyAccess(obj, propertyName), factory.createIdentifier("undefined"))); + return factory.createExpressionStatement(factory.createAssignment(factory.createPropertyAccessExpression(obj, propertyName), factory.createIdentifier("undefined"))); } function createActionsForAddMissingMemberInTypeScriptFile(context: CodeFixContext, { parentDeclaration, declSourceFile, modifierFlags, token }: ClassOrInterfaceInfo): CodeFixAction[] | undefined { diff --git a/src/services/codefixes/fixAddMissingNewOperator.ts b/src/services/codefixes/fixAddMissingNewOperator.ts index f4dd821500782..cd8eb9c8c212c 100644 --- a/src/services/codefixes/fixAddMissingNewOperator.ts +++ b/src/services/codefixes/fixAddMissingNewOperator.ts @@ -16,7 +16,7 @@ namespace ts.codefix { function addMissingNewOperator(changes: textChanges.ChangeTracker, sourceFile: SourceFile, span: TextSpan): void { const call = cast(findAncestorMatchingSpan(sourceFile, span), isCallExpression); - const newExpression = factory.createNew(call.expression, call.typeArguments, call.arguments); + const newExpression = factory.createNewExpression(call.expression, call.typeArguments, call.arguments); changes.replaceNode(sourceFile, call, newExpression); } diff --git a/src/services/codefixes/fixConstructorForDerivedNeedSuperCall.ts b/src/services/codefixes/fixConstructorForDerivedNeedSuperCall.ts index 2a7724879ef4f..b7941259ede90 100644 --- a/src/services/codefixes/fixConstructorForDerivedNeedSuperCall.ts +++ b/src/services/codefixes/fixConstructorForDerivedNeedSuperCall.ts @@ -22,7 +22,7 @@ namespace ts.codefix { } function doChange(changes: textChanges.ChangeTracker, sourceFile: SourceFile, ctr: ConstructorDeclaration) { - const superCall = factory.createExpressionStatement(factory.createCall(factory.createSuper(), /*typeArguments*/ undefined, /*argumentsArray*/ emptyArray)); + const superCall = factory.createExpressionStatement(factory.createCallExpression(factory.createSuper(), /*typeArguments*/ undefined, /*argumentsArray*/ emptyArray)); changes.insertNodeAtConstructorStart(sourceFile, ctr, superCall); } } diff --git a/src/services/codefixes/fixForgottenThisPropertyAccess.ts b/src/services/codefixes/fixForgottenThisPropertyAccess.ts index 8b619d007c54e..067ce4b0b9e26 100644 --- a/src/services/codefixes/fixForgottenThisPropertyAccess.ts +++ b/src/services/codefixes/fixForgottenThisPropertyAccess.ts @@ -40,6 +40,6 @@ namespace ts.codefix { function doChange(changes: textChanges.ChangeTracker, sourceFile: SourceFile, { node, className }: Info): void { // TODO (https://github.com/Microsoft/TypeScript/issues/21246): use shared helper suppressLeadingAndTrailingTrivia(node); - changes.replaceNode(sourceFile, node, factory.createPropertyAccess(className ? factory.createIdentifier(className) : factory.createThis(), node)); + changes.replaceNode(sourceFile, node, factory.createPropertyAccessExpression(className ? factory.createIdentifier(className) : factory.createThis(), node)); } } diff --git a/src/services/codefixes/fixInvalidImportSyntax.ts b/src/services/codefixes/fixInvalidImportSyntax.ts index 600544652b277..acc033df36fc7 100644 --- a/src/services/codefixes/fixInvalidImportSyntax.ts +++ b/src/services/codefixes/fixInvalidImportSyntax.ts @@ -88,7 +88,7 @@ namespace ts.codefix { } if (isExpression(expr) && !(isNamedDeclaration(expr.parent) && expr.parent.name === expr)) { const sourceFile = context.sourceFile; - const changes = textChanges.ChangeTracker.with(context, t => t.replaceNode(sourceFile, expr, factory.createPropertyAccess(expr, "default"), {})); + const changes = textChanges.ChangeTracker.with(context, t => t.replaceNode(sourceFile, expr, factory.createPropertyAccessExpression(expr, "default"), {})); fixes.push(createCodeFixActionWithoutFixAll(fixName, changes, Diagnostics.Use_synthetic_default_member)); } return fixes; diff --git a/src/services/codefixes/fixSpelling.ts b/src/services/codefixes/fixSpelling.ts index a1f32eab255bf..b90c16c390826 100644 --- a/src/services/codefixes/fixSpelling.ts +++ b/src/services/codefixes/fixSpelling.ts @@ -70,7 +70,7 @@ namespace ts.codefix { changes.replaceNode(sourceFile, node, factory.createIdentifier(suggestion)); } else { - changes.replaceNode(sourceFile, node.parent, factory.createElementAccess(node.parent.expression, factory.createStringLiteral(suggestion))); + changes.replaceNode(sourceFile, node.parent, factory.createElementAccessExpression(node.parent.expression, factory.createStringLiteral(suggestion))); } } else { diff --git a/src/services/codefixes/fixStrictClassInitialization.ts b/src/services/codefixes/fixStrictClassInitialization.ts index 7424df1fdf905..37cb7ffa74224 100644 --- a/src/services/codefixes/fixStrictClassInitialization.ts +++ b/src/services/codefixes/fixStrictClassInitialization.ts @@ -131,10 +131,10 @@ namespace ts.codefix { const constructorDeclaration = getFirstConstructorWithBody(classDeclaration); if (constructorDeclaration && constructorDeclaration.parameters.length) return undefined; - return factory.createNew(factory.createIdentifier(type.symbol.name), /*typeArguments*/ undefined, /*argumentsArray*/ undefined); + return factory.createNewExpression(factory.createIdentifier(type.symbol.name), /*typeArguments*/ undefined, /*argumentsArray*/ undefined); } else if (checker.isArrayLikeType(type)) { - return factory.createArrayLiteral(); + return factory.createArrayLiteralExpression(); } return undefined; } diff --git a/src/services/codefixes/generateAccessors.ts b/src/services/codefixes/generateAccessors.ts index a9a77ba08134e..75e3c9b9d24b2 100644 --- a/src/services/codefixes/generateAccessors.ts +++ b/src/services/codefixes/generateAccessors.ts @@ -79,7 +79,7 @@ namespace ts.codefix { function createAccessorAccessExpression(fieldName: AcceptedNameType, isStatic: boolean, container: ContainerDeclaration) { const leftHead = isStatic ? (container).name! : factory.createThis(); // TODO: GH#18217 - return isIdentifier(fieldName) ? factory.createPropertyAccess(leftHead, fieldName) : factory.createElementAccess(leftHead, factory.createStringLiteralFromNode(fieldName)); + return isIdentifier(fieldName) ? factory.createPropertyAccessExpression(leftHead, fieldName) : factory.createElementAccessExpression(leftHead, factory.createStringLiteralFromNode(fieldName)); } function createModifiers(modifierFlags: ModifierFlags): ModifiersArray | undefined { @@ -138,7 +138,7 @@ namespace ts.codefix { /*parameters*/ undefined!, // TODO: GH#18217 type, factory.createBlock([ - factory.createReturn( + factory.createReturnStatement( createAccessorAccessExpression(fieldName, isStatic, container) ) ], /*multiLine*/ true) diff --git a/src/services/codefixes/helpers.ts b/src/services/codefixes/helpers.ts index 7ee8f2ce3060d..405a5db924bd6 100644 --- a/src/services/codefixes/helpers.ts +++ b/src/services/codefixes/helpers.ts @@ -381,8 +381,8 @@ namespace ts.codefix { function createStubbedMethodBody(preferences: UserPreferences): Block { return factory.createBlock( - [factory.createThrow( - factory.createNew( + [factory.createThrowStatement( + factory.createNewExpression( factory.createIdentifier("Error"), /*typeArguments*/ undefined, // TODO Handle auto quote preference. @@ -412,7 +412,7 @@ namespace ts.codefix { if (compilerOptionsProperty === undefined) { changeTracker.insertNodeAtObjectStart(configFile, tsconfigObjectLiteral, createJsonPropertyAssignment( "compilerOptions", - factory.createObjectLiteral(options.map(([optionName, optionValue]) => createJsonPropertyAssignment(optionName, optionValue)), /*multiLine*/ true))); + factory.createObjectLiteralExpression(options.map(([optionName, optionValue]) => createJsonPropertyAssignment(optionName, optionValue)), /*multiLine*/ true))); return; } diff --git a/src/services/codefixes/importFixes.ts b/src/services/codefixes/importFixes.ts index 3911b1c801c11..4de3035f09f8b 100644 --- a/src/services/codefixes/importFixes.ts +++ b/src/services/codefixes/importFixes.ts @@ -777,7 +777,7 @@ namespace ts.codefix { typeof name === "string" ? factory.createIdentifier(name) : name, /*exclamationToken*/ undefined, /*type*/ undefined, - factory.createCall(factory.createIdentifier("require"), /*typeArguments*/ undefined, [quotedModuleSpecifier]))], + factory.createCallExpression(factory.createIdentifier("require"), /*typeArguments*/ undefined, [quotedModuleSpecifier]))], NodeFlags.Const)); } diff --git a/src/services/codefixes/returnValueCorrect.ts b/src/services/codefixes/returnValueCorrect.ts index 39bcbe35a71db..54b782417af2c 100644 --- a/src/services/codefixes/returnValueCorrect.ts +++ b/src/services/codefixes/returnValueCorrect.ts @@ -93,7 +93,7 @@ namespace ts.codefix { }; } else if (isLabeledStatement(firstStatement) && isExpressionStatement(firstStatement.statement)) { - const node = factory.createObjectLiteral([factory.createPropertyAssignment(firstStatement.label, firstStatement.statement.expression)]); + const node = factory.createObjectLiteralExpression([factory.createPropertyAssignment(firstStatement.label, firstStatement.statement.expression)]); const nodeType = createObjectTypeFromLabeledExpression(checker, firstStatement.label, firstStatement.statement.expression); if (checkFixedAssignableTo(checker, declaration, nodeType, expectType, isFunctionType)) { return isArrowFunction(declaration) ? { @@ -114,7 +114,7 @@ namespace ts.codefix { else if (isBlock(firstStatement) && length(firstStatement.statements) === 1) { const firstBlockStatement = first(firstStatement.statements); if (isLabeledStatement(firstBlockStatement) && isExpressionStatement(firstBlockStatement.statement)) { - const node = factory.createObjectLiteral([factory.createPropertyAssignment(firstBlockStatement.label, firstBlockStatement.statement.expression)]); + const node = factory.createObjectLiteralExpression([factory.createPropertyAssignment(firstBlockStatement.label, firstBlockStatement.statement.expression)]); const nodeType = createObjectTypeFromLabeledExpression(checker, firstBlockStatement.label, firstBlockStatement.statement.expression); if (checkFixedAssignableTo(checker, declaration, nodeType, expectType, isFunctionType)) { return { @@ -208,7 +208,7 @@ namespace ts.codefix { function addReturnStatement(changes: textChanges.ChangeTracker, sourceFile: SourceFile, expression: Expression, statement: Statement) { suppressLeadingAndTrailingTrivia(expression); const probablyNeedSemi = probablyUsesSemicolons(sourceFile); - changes.replaceNode(sourceFile, statement, factory.createReturn(expression), { + changes.replaceNode(sourceFile, statement, factory.createReturnStatement(expression), { leadingTriviaOption: textChanges.LeadingTriviaOption.Exclude, trailingTriviaOption: textChanges.TrailingTriviaOption.Exclude, suffix: probablyNeedSemi ? ";" : undefined @@ -216,7 +216,7 @@ namespace ts.codefix { } function removeBlockBodyBrace(changes: textChanges.ChangeTracker, sourceFile: SourceFile, declaration: ArrowFunction, expression: Expression, commentSource: Node, withParen: boolean) { - const newBody = (withParen || needsParentheses(expression)) ? factory.createParen(expression) : expression; + const newBody = (withParen || needsParentheses(expression)) ? factory.createParenthesizedExpression(expression) : expression; suppressLeadingAndTrailingTrivia(commentSource); copyComments(commentSource, newBody); @@ -224,7 +224,7 @@ namespace ts.codefix { } function wrapBlockWithParen(changes: textChanges.ChangeTracker, sourceFile: SourceFile, declaration: ArrowFunction, expression: Expression) { - changes.replaceNode(sourceFile, declaration.body, factory.createParen(expression)); + changes.replaceNode(sourceFile, declaration.body, factory.createParenthesizedExpression(expression)); } function getActionForfixAddReturnStatement(context: CodeFixContext, expression: Expression, statement: Statement) { diff --git a/src/services/refactors/addOrRemoveBracesToArrowFunction.ts b/src/services/refactors/addOrRemoveBracesToArrowFunction.ts index 11a246c0c70f9..d451a10e2fdab 100644 --- a/src/services/refactors/addOrRemoveBracesToArrowFunction.ts +++ b/src/services/refactors/addOrRemoveBracesToArrowFunction.ts @@ -46,14 +46,14 @@ namespace ts.refactor.addOrRemoveBracesToArrowFunction { let body: ConciseBody; if (actionName === addBracesActionName) { - const returnStatement = factory.createReturn(expression); + const returnStatement = factory.createReturnStatement(expression); body = factory.createBlock([returnStatement], /* multiLine */ true); suppressLeadingAndTrailingTrivia(body); copyLeadingComments(expression!, returnStatement, file, SyntaxKind.MultiLineCommentTrivia, /* hasTrailingNewLine */ true); } else if (actionName === removeBracesActionName && returnStatement) { const actualExpression = expression || factory.createVoidZero(); - body = needsParentheses(actualExpression) ? factory.createParen(actualExpression) : actualExpression; + body = needsParentheses(actualExpression) ? factory.createParenthesizedExpression(actualExpression) : actualExpression; suppressLeadingAndTrailingTrivia(body); copyTrailingAsLeadingComments(returnStatement, body, file, SyntaxKind.MultiLineCommentTrivia, /* hasTrailingNewLine */ false); copyLeadingComments(returnStatement, body, file, SyntaxKind.MultiLineCommentTrivia, /* hasTrailingNewLine */ false); diff --git a/src/services/refactors/convertArrowFunctionOrFunctionExpression.ts b/src/services/refactors/convertArrowFunctionOrFunctionExpression.ts index 0de97fe30ac2a..6982d67f0d452 100644 --- a/src/services/refactors/convertArrowFunctionOrFunctionExpression.ts +++ b/src/services/refactors/convertArrowFunctionOrFunctionExpression.ts @@ -147,7 +147,7 @@ namespace ts.refactor.convertArrowFunctionOrFunctionExpression { function convertToBlock(body: ConciseBody): Block { if (isExpression(body)) { - return factory.createBlock([factory.createReturn(body)], /* multiLine */ true); + return factory.createBlock([factory.createReturnStatement(body)], /* multiLine */ true); } else { return body; diff --git a/src/services/refactors/convertImport.ts b/src/services/refactors/convertImport.ts index 49820bd84b5f5..9d33f086aa844 100644 --- a/src/services/refactors/convertImport.ts +++ b/src/services/refactors/convertImport.ts @@ -102,7 +102,7 @@ namespace ts.refactor { for (const element of toConvert.elements) { const propertyName = (element.propertyName || element.name).text; FindAllReferences.Core.eachSymbolReferenceInFile(element.name, checker, sourceFile, id => { - const access = factory.createPropertyAccess(factory.createIdentifier(namespaceImportName), propertyName); + const access = factory.createPropertyAccessExpression(factory.createIdentifier(namespaceImportName), propertyName); if (isShorthandPropertyAssignment(id.parent)) { changes.replaceNode(sourceFile, id.parent, factory.createPropertyAssignment(id.text, access)); } diff --git a/src/services/refactors/convertParamsToDestructuredObject.ts b/src/services/refactors/convertParamsToDestructuredObject.ts index 3f63c8c3a671d..ec2277b5da8a7 100644 --- a/src/services/refactors/convertParamsToDestructuredObject.ts +++ b/src/services/refactors/convertParamsToDestructuredObject.ts @@ -384,11 +384,11 @@ namespace ts.refactor.convertParamsToDestructuredObject { if (hasRestParameter && functionArguments.length >= parameters.length) { const restArguments = functionArguments.slice(parameters.length - 1); - const restProperty = factory.createPropertyAssignment(getParameterName(last(parameters)), factory.createArrayLiteral(restArguments)); + const restProperty = factory.createPropertyAssignment(getParameterName(last(parameters)), factory.createArrayLiteralExpression(restArguments)); properties.push(restProperty); } - const objectLiteral = factory.createObjectLiteral(properties, /*multiLine*/ false); + const objectLiteral = factory.createObjectLiteralExpression(properties, /*multiLine*/ false); return objectLiteral; } @@ -402,7 +402,7 @@ namespace ts.refactor.convertParamsToDestructuredObject { let objectInitializer: Expression | undefined; // If every parameter in the original function was optional, add an empty object initializer to the new object parameter if (every(refactorableParameters, isOptionalParameter)) { - objectInitializer = factory.createObjectLiteral(); + objectInitializer = factory.createObjectLiteralExpression(); } const objectParameter = factory.createParameterDeclaration( @@ -440,7 +440,7 @@ namespace ts.refactor.convertParamsToDestructuredObject { /*dotDotDotToken*/ undefined, /*propertyName*/ undefined, getParameterName(parameterDeclaration), - isRestParameter(parameterDeclaration) && isOptionalParameter(parameterDeclaration) ? factory.createArrayLiteral() : parameterDeclaration.initializer); + isRestParameter(parameterDeclaration) && isOptionalParameter(parameterDeclaration) ? factory.createArrayLiteralExpression() : parameterDeclaration.initializer); suppressLeadingAndTrailingTrivia(element); if (parameterDeclaration.initializer && element.initializer) { diff --git a/src/services/refactors/extractSymbol.ts b/src/services/refactors/extractSymbol.ts index 01341d42b0187..fcccf5a72a382 100644 --- a/src/services/refactors/extractSymbol.ts +++ b/src/services/refactors/extractSymbol.ts @@ -847,15 +847,15 @@ namespace ts.refactor.extractSymbol { // replace range with function call const called = getCalledExpression(scope, range, functionNameText); - let call: Expression = factory.createCall( + let call: Expression = factory.createCallExpression( called, callTypeArguments, // Note that no attempt is made to take advantage of type argument inference callArguments); if (range.facts & RangeFacts.IsGenerator) { - call = factory.createYield(factory.createToken(SyntaxKind.AsteriskToken), call); + call = factory.createYieldExpression(factory.createToken(SyntaxKind.AsteriskToken), call); } if (range.facts & RangeFacts.IsAsyncFunction) { - call = factory.createAwait(call); + call = factory.createAwaitExpression(call); } if (exposedVariableDeclarations.length && !writes) { @@ -958,22 +958,22 @@ namespace ts.refactor.extractSymbol { newNodes.push(factory.createExpressionStatement(factory.createAssignment(assignments[0].name, call))); if (range.facts & RangeFacts.HasReturn) { - newNodes.push(factory.createReturn()); + newNodes.push(factory.createReturnStatement()); } } else { // emit e.g. // { a, b, __return } = newFunction(a, b); // return __return; - newNodes.push(factory.createExpressionStatement(factory.createAssignment(factory.createObjectLiteral(assignments), call))); + newNodes.push(factory.createExpressionStatement(factory.createAssignment(factory.createObjectLiteralExpression(assignments), call))); if (returnValueProperty) { - newNodes.push(factory.createReturn(factory.createIdentifier(returnValueProperty))); + newNodes.push(factory.createReturnStatement(factory.createIdentifier(returnValueProperty))); } } } else { if (range.facts & RangeFacts.HasReturn) { - newNodes.push(factory.createReturn(call)); + newNodes.push(factory.createReturnStatement(call)); } else if (isReadonlyArray(range.range)) { newNodes.push(factory.createExpressionStatement(call)); @@ -1060,7 +1060,7 @@ namespace ts.refactor.extractSymbol { variableType, initializer); - const localReference = factory.createPropertyAccess( + const localReference = factory.createPropertyAccessExpression( rangeFacts & RangeFacts.InStaticRegion ? factory.createIdentifier(scope.name!.getText()) // TODO: GH#18217 : factory.createThis(), @@ -1256,7 +1256,7 @@ namespace ts.refactor.extractSymbol { const functionReference = factory.createIdentifier(functionNameText); if (isClassLike(scope)) { const lhs = range.facts & RangeFacts.InStaticRegion ? factory.createIdentifier(scope.name!.text) : factory.createThis(); // TODO: GH#18217 - return factory.createPropertyAccess(lhs, functionReference); + return factory.createPropertyAccessExpression(lhs, functionReference); } else { return functionReference; @@ -1271,7 +1271,7 @@ namespace ts.refactor.extractSymbol { } let returnValueProperty: string | undefined; let ignoreReturns = false; - const statements = factory.createNodeArray(isBlock(body) ? body.statements.slice(0) : [isStatement(body) ? body : factory.createReturn(body)]); + const statements = factory.createNodeArray(isBlock(body) ? body.statements.slice(0) : [isStatement(body) ? body : factory.createReturnStatement(body)]); // rewrite body if either there are writes that should be propagated back via return statements or there are substitutions if (hasWritesOrVariableDeclarations || substitutions.size) { const rewrittenStatements = visitNodes(statements, visitor).slice(); @@ -1280,10 +1280,10 @@ namespace ts.refactor.extractSymbol { // it is ok to know that range has at least one return since it we only allow unconditional returns const assignments = getPropertyAssignmentsForWritesAndVariableDeclarations(exposedVariableDeclarations, writes); if (assignments.length === 1) { - rewrittenStatements.push(factory.createReturn(assignments[0].name)); + rewrittenStatements.push(factory.createReturnStatement(assignments[0].name)); } else { - rewrittenStatements.push(factory.createReturn(factory.createObjectLiteral(assignments))); + rewrittenStatements.push(factory.createReturnStatement(factory.createObjectLiteralExpression(assignments))); } } return { body: factory.createBlock(rewrittenStatements, /*multiLine*/ true), returnValueProperty }; @@ -1302,10 +1302,10 @@ namespace ts.refactor.extractSymbol { assignments.unshift(factory.createPropertyAssignment(returnValueProperty, visitNode(node.expression, visitor))); } if (assignments.length === 1) { - return factory.createReturn(assignments[0].name as Expression); + return factory.createReturnStatement(assignments[0].name as Expression); } else { - return factory.createReturn(factory.createObjectLiteral(assignments)); + return factory.createReturnStatement(factory.createObjectLiteralExpression(assignments)); } } else { @@ -1844,7 +1844,7 @@ namespace ts.refactor.extractSymbol { } return isTypeNode ? factory.createQualifiedName(prefix, factory.createIdentifier(symbol.name)) - : factory.createPropertyAccess(prefix, symbol.name); + : factory.createPropertyAccessExpression(prefix, symbol.name); } } diff --git a/src/services/refactors/moveToNewFile.ts b/src/services/refactors/moveToNewFile.ts index 8930c4f2fa6d8..f4984fe18bde9 100644 --- a/src/services/refactors/moveToNewFile.ts +++ b/src/services/refactors/moveToNewFile.ts @@ -303,7 +303,7 @@ namespace ts.refactor { } function createRequireCall(moduleSpecifier: StringLiteralLike): CallExpression { - return factory.createCall(factory.createIdentifier("require"), /*typeArguments*/ undefined, [moduleSpecifier]); + return factory.createCallExpression(factory.createIdentifier("require"), /*typeArguments*/ undefined, [moduleSpecifier]); } function addExports(sourceFile: SourceFile, toMove: readonly Statement[], needExport: ReadonlySymbolSet, useEs6Exports: boolean): readonly Statement[] { @@ -798,8 +798,8 @@ namespace ts.refactor { /** Creates `exports.x = x;` */ function createExportAssignment(name: string): Statement { return factory.createExpressionStatement( - factory.createBinary( - factory.createPropertyAccess(factory.createIdentifier("exports"), factory.createIdentifier(name)), + factory.createBinaryExpression( + factory.createPropertyAccessExpression(factory.createIdentifier("exports"), factory.createIdentifier(name)), SyntaxKind.EqualsToken, factory.createIdentifier(name))); } diff --git a/src/services/textChanges.ts b/src/services/textChanges.ts index 9515a53ab50f1..1acce25574bfb 100644 --- a/src/services/textChanges.ts +++ b/src/services/textChanges.ts @@ -803,7 +803,7 @@ namespace ts.textChanges { } public parenthesizeExpression(sourceFile: SourceFile, expression: Expression) { - this.replaceRange(sourceFile, rangeOfNode(expression), factory.createParen(expression)); + this.replaceRange(sourceFile, rangeOfNode(expression), factory.createParenthesizedExpression(expression)); } private finishClassesWithNodesInsertedAtStart(): void { @@ -1415,7 +1415,7 @@ namespace ts.textChanges { switch (gp.kind) { case SyntaxKind.ForOfStatement: case SyntaxKind.ForInStatement: - changes.replaceNode(sourceFile, node, factory.createObjectLiteral()); + changes.replaceNode(sourceFile, node, factory.createObjectLiteralExpression()); break; case SyntaxKind.ForStatement: diff --git a/src/testRunner/unittests/factory.ts b/src/testRunner/unittests/factory.ts index 3de018dcd17b7..a413881c07d3e 100644 --- a/src/testRunner/unittests/factory.ts +++ b/src/testRunner/unittests/factory.ts @@ -19,15 +19,15 @@ namespace ts { factory.createPropertyDeclaration(/*decorators*/ undefined, [factory.createToken(SyntaxKind.StaticKeyword)], "prop", /*questionOrExclamationToken*/ undefined, /*type*/ undefined, factory.createStringLiteral("1")), ]); checkExpression(clazz); - checkExpression(factory.createPropertyAccess(clazz, "prop")); + checkExpression(factory.createPropertyAccessExpression(clazz, "prop")); const func = factory.createFunctionExpression(/*modifiers*/ undefined, /*asteriskToken*/ undefined, "fn", /*typeParameters*/ undefined, /*parameters*/ undefined, /*type*/ undefined, factory.createBlock([])); checkExpression(func); - checkExpression(factory.createCall(func, /*typeArguments*/ undefined, /*argumentsArray*/ undefined)); - checkExpression(factory.createTaggedTemplate(func, /*typeArguments*/ undefined, factory.createNoSubstitutionTemplateLiteral(""))); + checkExpression(factory.createCallExpression(func, /*typeArguments*/ undefined, /*argumentsArray*/ undefined)); + checkExpression(factory.createTaggedTemplateExpression(func, /*typeArguments*/ undefined, factory.createNoSubstitutionTemplateLiteral(""))); - checkExpression(factory.createBinary(factory.createStringLiteral("a"), SyntaxKind.CommaToken, factory.createStringLiteral("b"))); - checkExpression(factory.createCommaList([factory.createStringLiteral("a"), factory.createStringLiteral("b")])); + checkExpression(factory.createBinaryExpression(factory.createStringLiteral("a"), SyntaxKind.CommaToken, factory.createStringLiteral("b"))); + checkExpression(factory.createCommaListExpression([factory.createStringLiteral("a"), factory.createStringLiteral("b")])); }); }); @@ -45,12 +45,12 @@ namespace ts { assertSyntaxKind(node.body, SyntaxKind.ParenthesizedExpression); } - checkBody(factory.createObjectLiteral()); - checkBody(factory.createPropertyAccess(factory.createObjectLiteral(), "prop")); - checkBody(factory.createAsExpression(factory.createPropertyAccess(factory.createObjectLiteral(), "prop"), factory.createTypeReferenceNode("T", /*typeArguments*/ undefined))); - checkBody(factory.createNonNullExpression(factory.createPropertyAccess(factory.createObjectLiteral(), "prop"))); - checkBody(factory.createCommaList([factory.createStringLiteral("a"), factory.createStringLiteral("b")])); - checkBody(factory.createBinary(factory.createStringLiteral("a"), SyntaxKind.CommaToken, factory.createStringLiteral("b"))); + checkBody(factory.createObjectLiteralExpression()); + checkBody(factory.createPropertyAccessExpression(factory.createObjectLiteralExpression(), "prop")); + checkBody(factory.createAsExpression(factory.createPropertyAccessExpression(factory.createObjectLiteralExpression(), "prop"), factory.createTypeReferenceNode("T", /*typeArguments*/ undefined))); + checkBody(factory.createNonNullExpression(factory.createPropertyAccessExpression(factory.createObjectLiteralExpression(), "prop"))); + checkBody(factory.createCommaListExpression([factory.createStringLiteral("a"), factory.createStringLiteral("b")])); + checkBody(factory.createBinaryExpression(factory.createStringLiteral("a"), SyntaxKind.CommaToken, factory.createStringLiteral("b"))); }); }); @@ -66,7 +66,7 @@ namespace ts { factory.createBlock([]), ); function checkRhs(operator: BinaryOperator, expectParens: boolean) { - const node = factory.createBinary(lhs, operator, rhs); + const node = factory.createBinaryExpression(lhs, operator, rhs); assertSyntaxKind(node.right, expectParens ? SyntaxKind.ParenthesizedExpression : SyntaxKind.ArrowFunction); } diff --git a/src/testRunner/unittests/printer.ts b/src/testRunner/unittests/printer.ts index 53489fbb709ee..59ffa8f0ed24f 100644 --- a/src/testRunner/unittests/printer.ts +++ b/src/testRunner/unittests/printer.ts @@ -146,9 +146,9 @@ namespace ts { printsCorrectly("newExpressionWithPropertyAccessOnCallExpression", {}, printer => printer.printNode( EmitHint.Unspecified, - factory.createNew( - factory.createPropertyAccess( - factory.createCall(factory.createIdentifier("f"), /*typeArguments*/ undefined, /*argumentsArray*/ undefined), + factory.createNewExpression( + factory.createPropertyAccessExpression( + factory.createCallExpression(factory.createIdentifier("f"), /*typeArguments*/ undefined, /*argumentsArray*/ undefined), "x"), /*typeArguments*/ undefined, /*argumentsArray*/ undefined @@ -158,8 +158,8 @@ namespace ts { printsCorrectly("newExpressionOnConditionalExpression", {}, printer => printer.printNode( EmitHint.Unspecified, - factory.createNew( - factory.createConditional( + factory.createNewExpression( + factory.createConditionalExpression( factory.createIdentifier("x"), factory.createToken(SyntaxKind.QuestionToken), factory.createIdentifier("y"), factory.createToken(SyntaxKind.ColonToken), factory.createIdentifier("z")), diff --git a/src/testRunner/unittests/services/textChanges.ts b/src/testRunner/unittests/services/textChanges.ts index 0c59f4dc0a512..7a5c9af03ff56 100644 --- a/src/testRunner/unittests/services/textChanges.ts +++ b/src/testRunner/unittests/services/textChanges.ts @@ -96,8 +96,8 @@ namespace M changeTracker.insertNodeBefore(sourceFile, /*before*/findChild("M2", sourceFile), newFunction); // replace statements with return statement - const newStatement = factory.createReturn( - factory.createCall( + const newStatement = factory.createReturnStatement( + factory.createCallExpression( /*expression*/ newFunction.name!, /*typeArguments*/ undefined, /*argumentsArray*/ emptyArray @@ -178,7 +178,7 @@ var a = 4; // comment 7 }); } function createTestVariableDeclaration(name: string) { - return factory.createVariableDeclaration(name, /*exclamationToken*/ undefined, /*type*/ undefined, factory.createObjectLiteral([factory.createPropertyAssignment("p1", factory.createNumericLiteral(1))], /*multiline*/ true)); + return factory.createVariableDeclaration(name, /*exclamationToken*/ undefined, /*type*/ undefined, factory.createObjectLiteralExpression([factory.createPropertyAssignment("p1", factory.createNumericLiteral(1))], /*multiline*/ true)); } function createTestClass() { return factory.createClassDeclaration( @@ -333,7 +333,7 @@ namespace M { return find(classDecl.members, (m): m is ConstructorDeclaration => isConstructorDeclaration(m) && !!m.body)!; } function createTestSuperCall() { - const superCall = factory.createCall( + const superCall = factory.createCallExpression( factory.createSuper(), /*typeArguments*/ undefined, /*argumentsArray*/ emptyArray @@ -755,7 +755,7 @@ interface A { let x = foo `; runSingleFileTest("insertNodeInStatementListAfterNodeWithoutSeparator1", /*placeOpenBraceOnNewLineForFunctions*/ false, text, /*validateNodes*/ false, (sourceFile, changeTracker) => { - const newNode = factory.createExpressionStatement(factory.createParen(factory.createNumericLiteral(1))); + const newNode = factory.createExpressionStatement(factory.createParenthesizedExpression(factory.createNumericLiteral(1))); changeTracker.insertNodeAfter(sourceFile, findVariableStatementContaining("x", sourceFile), newNode); }); } diff --git a/src/testRunner/unittests/transform.ts b/src/testRunner/unittests/transform.ts index ded2c6a775609..e18dd33c92c3c 100644 --- a/src/testRunner/unittests/transform.ts +++ b/src/testRunner/unittests/transform.ts @@ -53,7 +53,7 @@ namespace ts { function createTaggedTemplateLiteral(): Transformer { return sourceFile => factory.updateSourceFile(sourceFile, [ factory.createExpressionStatement( - factory.createTaggedTemplate( + factory.createTaggedTemplateExpression( factory.createIdentifier("$tpl"), /*typeArguments*/ undefined, factory.createNoSubstitutionTemplateLiteral("foo", "foo"))) diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts index cde4c1ddd54c1..012164ed997b3 100644 --- a/tests/baselines/reference/api/tsserverlibrary.d.ts +++ b/tests/baselines/reference/api/tsserverlibrary.d.ts @@ -3190,50 +3190,50 @@ declare namespace ts { updateArrayBindingPattern(node: ArrayBindingPattern, elements: readonly ArrayBindingElement[]): ArrayBindingPattern; createBindingElement(dotDotDotToken: DotDotDotToken | undefined, propertyName: string | PropertyName | undefined, name: string | BindingName, initializer?: Expression): BindingElement; updateBindingElement(node: BindingElement, dotDotDotToken: DotDotDotToken | undefined, propertyName: PropertyName | undefined, name: BindingName, initializer: Expression | undefined): BindingElement; - createArrayLiteral(elements?: readonly Expression[], multiLine?: boolean): ArrayLiteralExpression; - updateArrayLiteral(node: ArrayLiteralExpression, elements: readonly Expression[]): ArrayLiteralExpression; - createObjectLiteral(properties?: readonly ObjectLiteralElementLike[], multiLine?: boolean): ObjectLiteralExpression; - updateObjectLiteral(node: ObjectLiteralExpression, properties: readonly ObjectLiteralElementLike[]): ObjectLiteralExpression; - createPropertyAccess(expression: Expression, name: string | Identifier | PrivateIdentifier): PropertyAccessExpression; - updatePropertyAccess(node: PropertyAccessExpression, expression: Expression, name: Identifier | PrivateIdentifier): PropertyAccessExpression; + createArrayLiteralExpression(elements?: readonly Expression[], multiLine?: boolean): ArrayLiteralExpression; + updateArrayLiteralExpression(node: ArrayLiteralExpression, elements: readonly Expression[]): ArrayLiteralExpression; + createObjectLiteralExpression(properties?: readonly ObjectLiteralElementLike[], multiLine?: boolean): ObjectLiteralExpression; + updateObjectLiteralExpression(node: ObjectLiteralExpression, properties: readonly ObjectLiteralElementLike[]): ObjectLiteralExpression; + createPropertyAccessExpression(expression: Expression, name: string | Identifier | PrivateIdentifier): PropertyAccessExpression; + updatePropertyAccessExpression(node: PropertyAccessExpression, expression: Expression, name: Identifier | PrivateIdentifier): PropertyAccessExpression; createPropertyAccessChain(expression: Expression, questionDotToken: QuestionDotToken | undefined, name: string | Identifier | PrivateIdentifier): PropertyAccessChain; updatePropertyAccessChain(node: PropertyAccessChain, expression: Expression, questionDotToken: QuestionDotToken | undefined, name: Identifier | PrivateIdentifier): PropertyAccessChain; - createElementAccess(expression: Expression, index: number | Expression): ElementAccessExpression; - updateElementAccess(node: ElementAccessExpression, expression: Expression, argumentExpression: Expression): ElementAccessExpression; + createElementAccessExpression(expression: Expression, index: number | Expression): ElementAccessExpression; + updateElementAccessExpression(node: ElementAccessExpression, expression: Expression, argumentExpression: Expression): ElementAccessExpression; createElementAccessChain(expression: Expression, questionDotToken: QuestionDotToken | undefined, index: number | Expression): ElementAccessChain; updateElementAccessChain(node: ElementAccessChain, expression: Expression, questionDotToken: QuestionDotToken | undefined, argumentExpression: Expression): ElementAccessChain; - createCall(expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined): CallExpression; - updateCall(node: CallExpression, expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[]): CallExpression; + createCallExpression(expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined): CallExpression; + updateCallExpression(node: CallExpression, expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[]): CallExpression; createCallChain(expression: Expression, questionDotToken: QuestionDotToken | undefined, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined): CallChain; updateCallChain(node: CallChain, expression: Expression, questionDotToken: QuestionDotToken | undefined, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[]): CallChain; - createNew(expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined): NewExpression; - updateNew(node: NewExpression, expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined): NewExpression; - createTaggedTemplate(tag: Expression, typeArguments: readonly TypeNode[] | undefined, template: TemplateLiteral): TaggedTemplateExpression; - updateTaggedTemplate(node: TaggedTemplateExpression, tag: Expression, typeArguments: readonly TypeNode[] | undefined, template: TemplateLiteral): TaggedTemplateExpression; + createNewExpression(expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined): NewExpression; + updateNewExpression(node: NewExpression, expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined): NewExpression; + createTaggedTemplateExpression(tag: Expression, typeArguments: readonly TypeNode[] | undefined, template: TemplateLiteral): TaggedTemplateExpression; + updateTaggedTemplateExpression(node: TaggedTemplateExpression, tag: Expression, typeArguments: readonly TypeNode[] | undefined, template: TemplateLiteral): TaggedTemplateExpression; createTypeAssertion(type: TypeNode, expression: Expression): TypeAssertion; updateTypeAssertion(node: TypeAssertion, type: TypeNode, expression: Expression): TypeAssertion; - createParen(expression: Expression): ParenthesizedExpression; - updateParen(node: ParenthesizedExpression, expression: Expression): ParenthesizedExpression; + createParenthesizedExpression(expression: Expression): ParenthesizedExpression; + updateParenthesizedExpression(node: ParenthesizedExpression, expression: Expression): ParenthesizedExpression; createFunctionExpression(modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[] | undefined, type: TypeNode | undefined, body: Block): FunctionExpression; updateFunctionExpression(node: FunctionExpression, modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block): FunctionExpression; createArrowFunction(modifiers: readonly Modifier[] | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, equalsGreaterThanToken: EqualsGreaterThanToken | undefined, body: ConciseBody): ArrowFunction; updateArrowFunction(node: ArrowFunction, modifiers: readonly Modifier[] | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, equalsGreaterThanToken: EqualsGreaterThanToken, body: ConciseBody): ArrowFunction; - createDelete(expression: Expression): DeleteExpression; - updateDelete(node: DeleteExpression, expression: Expression): DeleteExpression; - createTypeOf(expression: Expression): TypeOfExpression; - updateTypeOf(node: TypeOfExpression, expression: Expression): TypeOfExpression; - createVoid(expression: Expression): VoidExpression; - updateVoid(node: VoidExpression, expression: Expression): VoidExpression; - createAwait(expression: Expression): AwaitExpression; - updateAwait(node: AwaitExpression, expression: Expression): AwaitExpression; - createPrefix(operator: PrefixUnaryOperator, operand: Expression): PrefixUnaryExpression; - updatePrefix(node: PrefixUnaryExpression, operand: Expression): PrefixUnaryExpression; - createPostfix(operand: Expression, operator: PostfixUnaryOperator): PostfixUnaryExpression; - updatePostfix(node: PostfixUnaryExpression, operand: Expression): PostfixUnaryExpression; - createBinary(left: Expression, operator: BinaryOperator | BinaryOperatorToken, right: Expression): BinaryExpression; - updateBinary(node: BinaryExpression, left: Expression, operator: BinaryOperator | BinaryOperatorToken, right: Expression): BinaryExpression; - createConditional(condition: Expression, questionToken: QuestionToken | undefined, whenTrue: Expression, colonToken: ColonToken | undefined, whenFalse: Expression): ConditionalExpression; - updateConditional(node: ConditionalExpression, condition: Expression, questionToken: QuestionToken, whenTrue: Expression, colonToken: ColonToken, whenFalse: Expression): ConditionalExpression; + createDeleteExpression(expression: Expression): DeleteExpression; + updateDeleteExpression(node: DeleteExpression, expression: Expression): DeleteExpression; + createTypeOfExpression(expression: Expression): TypeOfExpression; + updateTypeOfExpression(node: TypeOfExpression, expression: Expression): TypeOfExpression; + createVoidExpression(expression: Expression): VoidExpression; + updateVoidExpression(node: VoidExpression, expression: Expression): VoidExpression; + createAwaitExpression(expression: Expression): AwaitExpression; + updateAwaitExpression(node: AwaitExpression, expression: Expression): AwaitExpression; + createPrefixUnaryExpression(operator: PrefixUnaryOperator, operand: Expression): PrefixUnaryExpression; + updatePrefixUnaryExpression(node: PrefixUnaryExpression, operand: Expression): PrefixUnaryExpression; + createPostfixUnaryExpression(operand: Expression, operator: PostfixUnaryOperator): PostfixUnaryExpression; + updatePostfixUnaryExpression(node: PostfixUnaryExpression, operand: Expression): PostfixUnaryExpression; + createBinaryExpression(left: Expression, operator: BinaryOperator | BinaryOperatorToken, right: Expression): BinaryExpression; + updateBinaryExpression(node: BinaryExpression, left: Expression, operator: BinaryOperator | BinaryOperatorToken, right: Expression): BinaryExpression; + createConditionalExpression(condition: Expression, questionToken: QuestionToken | undefined, whenTrue: Expression, colonToken: ColonToken | undefined, whenFalse: Expression): ConditionalExpression; + updateConditionalExpression(node: ConditionalExpression, condition: Expression, questionToken: QuestionToken, whenTrue: Expression, colonToken: ColonToken, whenFalse: Expression): ConditionalExpression; createTemplateExpression(head: TemplateHead, templateSpans: readonly TemplateSpan[]): TemplateExpression; updateTemplateExpression(node: TemplateExpression, head: TemplateHead, templateSpans: readonly TemplateSpan[]): TemplateExpression; createTemplateHead(text: string, rawText?: string, templateFlags?: TokenFlags): TemplateHead; @@ -3244,11 +3244,11 @@ declare namespace ts { createTemplateTail(text: string | undefined, rawText: string, templateFlags?: TokenFlags): TemplateTail; createNoSubstitutionTemplateLiteral(text: string, rawText?: string): NoSubstitutionTemplateLiteral; createNoSubstitutionTemplateLiteral(text: string | undefined, rawText: string): NoSubstitutionTemplateLiteral; - createYield(asteriskToken: AsteriskToken, expression: Expression): YieldExpression; - createYield(asteriskToken: undefined, expression: Expression | undefined): YieldExpression; - updateYield(node: YieldExpression, asteriskToken: AsteriskToken | undefined, expression: Expression | undefined): YieldExpression; - createSpread(expression: Expression): SpreadElement; - updateSpread(node: SpreadElement, expression: Expression): SpreadElement; + createYieldExpression(asteriskToken: AsteriskToken, expression: Expression): YieldExpression; + createYieldExpression(asteriskToken: undefined, expression: Expression | undefined): YieldExpression; + updateYieldExpression(node: YieldExpression, asteriskToken: AsteriskToken | undefined, expression: Expression | undefined): YieldExpression; + createSpreadElement(expression: Expression): SpreadElement; + updateSpreadElement(node: SpreadElement, expression: Expression): SpreadElement; createClassExpression(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassExpression; updateClassExpression(node: ClassExpression, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassExpression; createOmittedExpression(): OmittedExpression; @@ -3272,34 +3272,34 @@ declare namespace ts { createEmptyStatement(): EmptyStatement; createExpressionStatement(expression: Expression): ExpressionStatement; updateExpressionStatement(node: ExpressionStatement, expression: Expression): ExpressionStatement; - createIf(expression: Expression, thenStatement: Statement, elseStatement?: Statement): IfStatement; - updateIf(node: IfStatement, expression: Expression, thenStatement: Statement, elseStatement: Statement | undefined): IfStatement; - createDo(statement: Statement, expression: Expression): DoStatement; - updateDo(node: DoStatement, statement: Statement, expression: Expression): DoStatement; - createWhile(expression: Expression, statement: Statement): WhileStatement; - updateWhile(node: WhileStatement, expression: Expression, statement: Statement): WhileStatement; - createFor(initializer: ForInitializer | undefined, condition: Expression | undefined, incrementor: Expression | undefined, statement: Statement): ForStatement; - updateFor(node: ForStatement, initializer: ForInitializer | undefined, condition: Expression | undefined, incrementor: Expression | undefined, statement: Statement): ForStatement; - createForIn(initializer: ForInitializer, expression: Expression, statement: Statement): ForInStatement; - updateForIn(node: ForInStatement, initializer: ForInitializer, expression: Expression, statement: Statement): ForInStatement; - createForOf(awaitModifier: AwaitKeyword | undefined, initializer: ForInitializer, expression: Expression, statement: Statement): ForOfStatement; - updateForOf(node: ForOfStatement, awaitModifier: AwaitKeyword | undefined, initializer: ForInitializer, expression: Expression, statement: Statement): ForOfStatement; - createContinue(label?: string | Identifier): ContinueStatement; - updateContinue(node: ContinueStatement, label: Identifier | undefined): ContinueStatement; - createBreak(label?: string | Identifier): BreakStatement; - updateBreak(node: BreakStatement, label: Identifier | undefined): BreakStatement; - createReturn(expression?: Expression): ReturnStatement; - updateReturn(node: ReturnStatement, expression: Expression | undefined): ReturnStatement; - createWith(expression: Expression, statement: Statement): WithStatement; - updateWith(node: WithStatement, expression: Expression, statement: Statement): WithStatement; - createSwitch(expression: Expression, caseBlock: CaseBlock): SwitchStatement; - updateSwitch(node: SwitchStatement, expression: Expression, caseBlock: CaseBlock): SwitchStatement; - createLabel(label: string | Identifier, statement: Statement): LabeledStatement; - updateLabel(node: LabeledStatement, label: Identifier, statement: Statement): LabeledStatement; - createThrow(expression: Expression): ThrowStatement; - updateThrow(node: ThrowStatement, expression: Expression): ThrowStatement; - createTry(tryBlock: Block, catchClause: CatchClause | undefined, finallyBlock: Block | undefined): TryStatement; - updateTry(node: TryStatement, tryBlock: Block, catchClause: CatchClause | undefined, finallyBlock: Block | undefined): TryStatement; + createIfStatement(expression: Expression, thenStatement: Statement, elseStatement?: Statement): IfStatement; + updateIfStatement(node: IfStatement, expression: Expression, thenStatement: Statement, elseStatement: Statement | undefined): IfStatement; + createDoStatement(statement: Statement, expression: Expression): DoStatement; + updateDoStatement(node: DoStatement, statement: Statement, expression: Expression): DoStatement; + createWhileStatement(expression: Expression, statement: Statement): WhileStatement; + updateWhileStatement(node: WhileStatement, expression: Expression, statement: Statement): WhileStatement; + createForStatement(initializer: ForInitializer | undefined, condition: Expression | undefined, incrementor: Expression | undefined, statement: Statement): ForStatement; + updateForStatement(node: ForStatement, initializer: ForInitializer | undefined, condition: Expression | undefined, incrementor: Expression | undefined, statement: Statement): ForStatement; + createForInStatement(initializer: ForInitializer, expression: Expression, statement: Statement): ForInStatement; + updateForInStatement(node: ForInStatement, initializer: ForInitializer, expression: Expression, statement: Statement): ForInStatement; + createForOfStatement(awaitModifier: AwaitKeyword | undefined, initializer: ForInitializer, expression: Expression, statement: Statement): ForOfStatement; + updateForOfStatement(node: ForOfStatement, awaitModifier: AwaitKeyword | undefined, initializer: ForInitializer, expression: Expression, statement: Statement): ForOfStatement; + createContinueStatement(label?: string | Identifier): ContinueStatement; + updateContinueStatement(node: ContinueStatement, label: Identifier | undefined): ContinueStatement; + createBreakStatement(label?: string | Identifier): BreakStatement; + updateBreakStatement(node: BreakStatement, label: Identifier | undefined): BreakStatement; + createReturnStatement(expression?: Expression): ReturnStatement; + updateReturnStatement(node: ReturnStatement, expression: Expression | undefined): ReturnStatement; + createWithStatement(expression: Expression, statement: Statement): WithStatement; + updateWithStatement(node: WithStatement, expression: Expression, statement: Statement): WithStatement; + createSwitchStatement(expression: Expression, caseBlock: CaseBlock): SwitchStatement; + updateSwitchStatement(node: SwitchStatement, expression: Expression, caseBlock: CaseBlock): SwitchStatement; + createLabeledStatement(label: string | Identifier, statement: Statement): LabeledStatement; + updateLabeledStatement(node: LabeledStatement, label: Identifier, statement: Statement): LabeledStatement; + createThrowStatement(expression: Expression): ThrowStatement; + updateThrowStatement(node: ThrowStatement, expression: Expression): ThrowStatement; + createTryStatement(tryBlock: Block, catchClause: CatchClause | undefined, finallyBlock: Block | undefined): TryStatement; + updateTryStatement(node: TryStatement, tryBlock: Block, catchClause: CatchClause | undefined, finallyBlock: Block | undefined): TryStatement; createDebuggerStatement(): DebuggerStatement; createVariableDeclaration(name: string | BindingName, exclamationToken?: ExclamationToken, type?: TypeNode, initializer?: Expression): VariableDeclaration; updateVariableDeclaration(node: VariableDeclaration, name: BindingName, exclamationToken: ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): VariableDeclaration; @@ -3448,8 +3448,8 @@ declare namespace ts { createNotEmittedStatement(original: Node): NotEmittedStatement; createPartiallyEmittedExpression(expression: Expression, original?: Node): PartiallyEmittedExpression; updatePartiallyEmittedExpression(node: PartiallyEmittedExpression, expression: Expression): PartiallyEmittedExpression; - createCommaList(elements: readonly Expression[]): CommaListExpression; - updateCommaList(node: CommaListExpression, elements: readonly Expression[]): CommaListExpression; + createCommaListExpression(elements: readonly Expression[]): CommaListExpression; + updateCommaListExpression(node: CommaListExpression, elements: readonly Expression[]): CommaListExpression; createBundle(sourceFiles: readonly SourceFile[], prepends?: readonly (UnparsedSource | InputFiles)[]): Bundle; updateBundle(node: Bundle, sourceFiles: readonly SourceFile[], prepends?: readonly (UnparsedSource | InputFiles)[]): Bundle; createComma(left: Expression, right: Expression): BinaryExpression; diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts index ecbeaef1b55c6..0b62806635ec9 100644 --- a/tests/baselines/reference/api/typescript.d.ts +++ b/tests/baselines/reference/api/typescript.d.ts @@ -3190,50 +3190,50 @@ declare namespace ts { updateArrayBindingPattern(node: ArrayBindingPattern, elements: readonly ArrayBindingElement[]): ArrayBindingPattern; createBindingElement(dotDotDotToken: DotDotDotToken | undefined, propertyName: string | PropertyName | undefined, name: string | BindingName, initializer?: Expression): BindingElement; updateBindingElement(node: BindingElement, dotDotDotToken: DotDotDotToken | undefined, propertyName: PropertyName | undefined, name: BindingName, initializer: Expression | undefined): BindingElement; - createArrayLiteral(elements?: readonly Expression[], multiLine?: boolean): ArrayLiteralExpression; - updateArrayLiteral(node: ArrayLiteralExpression, elements: readonly Expression[]): ArrayLiteralExpression; - createObjectLiteral(properties?: readonly ObjectLiteralElementLike[], multiLine?: boolean): ObjectLiteralExpression; - updateObjectLiteral(node: ObjectLiteralExpression, properties: readonly ObjectLiteralElementLike[]): ObjectLiteralExpression; - createPropertyAccess(expression: Expression, name: string | Identifier | PrivateIdentifier): PropertyAccessExpression; - updatePropertyAccess(node: PropertyAccessExpression, expression: Expression, name: Identifier | PrivateIdentifier): PropertyAccessExpression; + createArrayLiteralExpression(elements?: readonly Expression[], multiLine?: boolean): ArrayLiteralExpression; + updateArrayLiteralExpression(node: ArrayLiteralExpression, elements: readonly Expression[]): ArrayLiteralExpression; + createObjectLiteralExpression(properties?: readonly ObjectLiteralElementLike[], multiLine?: boolean): ObjectLiteralExpression; + updateObjectLiteralExpression(node: ObjectLiteralExpression, properties: readonly ObjectLiteralElementLike[]): ObjectLiteralExpression; + createPropertyAccessExpression(expression: Expression, name: string | Identifier | PrivateIdentifier): PropertyAccessExpression; + updatePropertyAccessExpression(node: PropertyAccessExpression, expression: Expression, name: Identifier | PrivateIdentifier): PropertyAccessExpression; createPropertyAccessChain(expression: Expression, questionDotToken: QuestionDotToken | undefined, name: string | Identifier | PrivateIdentifier): PropertyAccessChain; updatePropertyAccessChain(node: PropertyAccessChain, expression: Expression, questionDotToken: QuestionDotToken | undefined, name: Identifier | PrivateIdentifier): PropertyAccessChain; - createElementAccess(expression: Expression, index: number | Expression): ElementAccessExpression; - updateElementAccess(node: ElementAccessExpression, expression: Expression, argumentExpression: Expression): ElementAccessExpression; + createElementAccessExpression(expression: Expression, index: number | Expression): ElementAccessExpression; + updateElementAccessExpression(node: ElementAccessExpression, expression: Expression, argumentExpression: Expression): ElementAccessExpression; createElementAccessChain(expression: Expression, questionDotToken: QuestionDotToken | undefined, index: number | Expression): ElementAccessChain; updateElementAccessChain(node: ElementAccessChain, expression: Expression, questionDotToken: QuestionDotToken | undefined, argumentExpression: Expression): ElementAccessChain; - createCall(expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined): CallExpression; - updateCall(node: CallExpression, expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[]): CallExpression; + createCallExpression(expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined): CallExpression; + updateCallExpression(node: CallExpression, expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[]): CallExpression; createCallChain(expression: Expression, questionDotToken: QuestionDotToken | undefined, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined): CallChain; updateCallChain(node: CallChain, expression: Expression, questionDotToken: QuestionDotToken | undefined, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[]): CallChain; - createNew(expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined): NewExpression; - updateNew(node: NewExpression, expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined): NewExpression; - createTaggedTemplate(tag: Expression, typeArguments: readonly TypeNode[] | undefined, template: TemplateLiteral): TaggedTemplateExpression; - updateTaggedTemplate(node: TaggedTemplateExpression, tag: Expression, typeArguments: readonly TypeNode[] | undefined, template: TemplateLiteral): TaggedTemplateExpression; + createNewExpression(expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined): NewExpression; + updateNewExpression(node: NewExpression, expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined): NewExpression; + createTaggedTemplateExpression(tag: Expression, typeArguments: readonly TypeNode[] | undefined, template: TemplateLiteral): TaggedTemplateExpression; + updateTaggedTemplateExpression(node: TaggedTemplateExpression, tag: Expression, typeArguments: readonly TypeNode[] | undefined, template: TemplateLiteral): TaggedTemplateExpression; createTypeAssertion(type: TypeNode, expression: Expression): TypeAssertion; updateTypeAssertion(node: TypeAssertion, type: TypeNode, expression: Expression): TypeAssertion; - createParen(expression: Expression): ParenthesizedExpression; - updateParen(node: ParenthesizedExpression, expression: Expression): ParenthesizedExpression; + createParenthesizedExpression(expression: Expression): ParenthesizedExpression; + updateParenthesizedExpression(node: ParenthesizedExpression, expression: Expression): ParenthesizedExpression; createFunctionExpression(modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[] | undefined, type: TypeNode | undefined, body: Block): FunctionExpression; updateFunctionExpression(node: FunctionExpression, modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block): FunctionExpression; createArrowFunction(modifiers: readonly Modifier[] | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, equalsGreaterThanToken: EqualsGreaterThanToken | undefined, body: ConciseBody): ArrowFunction; updateArrowFunction(node: ArrowFunction, modifiers: readonly Modifier[] | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, equalsGreaterThanToken: EqualsGreaterThanToken, body: ConciseBody): ArrowFunction; - createDelete(expression: Expression): DeleteExpression; - updateDelete(node: DeleteExpression, expression: Expression): DeleteExpression; - createTypeOf(expression: Expression): TypeOfExpression; - updateTypeOf(node: TypeOfExpression, expression: Expression): TypeOfExpression; - createVoid(expression: Expression): VoidExpression; - updateVoid(node: VoidExpression, expression: Expression): VoidExpression; - createAwait(expression: Expression): AwaitExpression; - updateAwait(node: AwaitExpression, expression: Expression): AwaitExpression; - createPrefix(operator: PrefixUnaryOperator, operand: Expression): PrefixUnaryExpression; - updatePrefix(node: PrefixUnaryExpression, operand: Expression): PrefixUnaryExpression; - createPostfix(operand: Expression, operator: PostfixUnaryOperator): PostfixUnaryExpression; - updatePostfix(node: PostfixUnaryExpression, operand: Expression): PostfixUnaryExpression; - createBinary(left: Expression, operator: BinaryOperator | BinaryOperatorToken, right: Expression): BinaryExpression; - updateBinary(node: BinaryExpression, left: Expression, operator: BinaryOperator | BinaryOperatorToken, right: Expression): BinaryExpression; - createConditional(condition: Expression, questionToken: QuestionToken | undefined, whenTrue: Expression, colonToken: ColonToken | undefined, whenFalse: Expression): ConditionalExpression; - updateConditional(node: ConditionalExpression, condition: Expression, questionToken: QuestionToken, whenTrue: Expression, colonToken: ColonToken, whenFalse: Expression): ConditionalExpression; + createDeleteExpression(expression: Expression): DeleteExpression; + updateDeleteExpression(node: DeleteExpression, expression: Expression): DeleteExpression; + createTypeOfExpression(expression: Expression): TypeOfExpression; + updateTypeOfExpression(node: TypeOfExpression, expression: Expression): TypeOfExpression; + createVoidExpression(expression: Expression): VoidExpression; + updateVoidExpression(node: VoidExpression, expression: Expression): VoidExpression; + createAwaitExpression(expression: Expression): AwaitExpression; + updateAwaitExpression(node: AwaitExpression, expression: Expression): AwaitExpression; + createPrefixUnaryExpression(operator: PrefixUnaryOperator, operand: Expression): PrefixUnaryExpression; + updatePrefixUnaryExpression(node: PrefixUnaryExpression, operand: Expression): PrefixUnaryExpression; + createPostfixUnaryExpression(operand: Expression, operator: PostfixUnaryOperator): PostfixUnaryExpression; + updatePostfixUnaryExpression(node: PostfixUnaryExpression, operand: Expression): PostfixUnaryExpression; + createBinaryExpression(left: Expression, operator: BinaryOperator | BinaryOperatorToken, right: Expression): BinaryExpression; + updateBinaryExpression(node: BinaryExpression, left: Expression, operator: BinaryOperator | BinaryOperatorToken, right: Expression): BinaryExpression; + createConditionalExpression(condition: Expression, questionToken: QuestionToken | undefined, whenTrue: Expression, colonToken: ColonToken | undefined, whenFalse: Expression): ConditionalExpression; + updateConditionalExpression(node: ConditionalExpression, condition: Expression, questionToken: QuestionToken, whenTrue: Expression, colonToken: ColonToken, whenFalse: Expression): ConditionalExpression; createTemplateExpression(head: TemplateHead, templateSpans: readonly TemplateSpan[]): TemplateExpression; updateTemplateExpression(node: TemplateExpression, head: TemplateHead, templateSpans: readonly TemplateSpan[]): TemplateExpression; createTemplateHead(text: string, rawText?: string, templateFlags?: TokenFlags): TemplateHead; @@ -3244,11 +3244,11 @@ declare namespace ts { createTemplateTail(text: string | undefined, rawText: string, templateFlags?: TokenFlags): TemplateTail; createNoSubstitutionTemplateLiteral(text: string, rawText?: string): NoSubstitutionTemplateLiteral; createNoSubstitutionTemplateLiteral(text: string | undefined, rawText: string): NoSubstitutionTemplateLiteral; - createYield(asteriskToken: AsteriskToken, expression: Expression): YieldExpression; - createYield(asteriskToken: undefined, expression: Expression | undefined): YieldExpression; - updateYield(node: YieldExpression, asteriskToken: AsteriskToken | undefined, expression: Expression | undefined): YieldExpression; - createSpread(expression: Expression): SpreadElement; - updateSpread(node: SpreadElement, expression: Expression): SpreadElement; + createYieldExpression(asteriskToken: AsteriskToken, expression: Expression): YieldExpression; + createYieldExpression(asteriskToken: undefined, expression: Expression | undefined): YieldExpression; + updateYieldExpression(node: YieldExpression, asteriskToken: AsteriskToken | undefined, expression: Expression | undefined): YieldExpression; + createSpreadElement(expression: Expression): SpreadElement; + updateSpreadElement(node: SpreadElement, expression: Expression): SpreadElement; createClassExpression(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassExpression; updateClassExpression(node: ClassExpression, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassExpression; createOmittedExpression(): OmittedExpression; @@ -3272,34 +3272,34 @@ declare namespace ts { createEmptyStatement(): EmptyStatement; createExpressionStatement(expression: Expression): ExpressionStatement; updateExpressionStatement(node: ExpressionStatement, expression: Expression): ExpressionStatement; - createIf(expression: Expression, thenStatement: Statement, elseStatement?: Statement): IfStatement; - updateIf(node: IfStatement, expression: Expression, thenStatement: Statement, elseStatement: Statement | undefined): IfStatement; - createDo(statement: Statement, expression: Expression): DoStatement; - updateDo(node: DoStatement, statement: Statement, expression: Expression): DoStatement; - createWhile(expression: Expression, statement: Statement): WhileStatement; - updateWhile(node: WhileStatement, expression: Expression, statement: Statement): WhileStatement; - createFor(initializer: ForInitializer | undefined, condition: Expression | undefined, incrementor: Expression | undefined, statement: Statement): ForStatement; - updateFor(node: ForStatement, initializer: ForInitializer | undefined, condition: Expression | undefined, incrementor: Expression | undefined, statement: Statement): ForStatement; - createForIn(initializer: ForInitializer, expression: Expression, statement: Statement): ForInStatement; - updateForIn(node: ForInStatement, initializer: ForInitializer, expression: Expression, statement: Statement): ForInStatement; - createForOf(awaitModifier: AwaitKeyword | undefined, initializer: ForInitializer, expression: Expression, statement: Statement): ForOfStatement; - updateForOf(node: ForOfStatement, awaitModifier: AwaitKeyword | undefined, initializer: ForInitializer, expression: Expression, statement: Statement): ForOfStatement; - createContinue(label?: string | Identifier): ContinueStatement; - updateContinue(node: ContinueStatement, label: Identifier | undefined): ContinueStatement; - createBreak(label?: string | Identifier): BreakStatement; - updateBreak(node: BreakStatement, label: Identifier | undefined): BreakStatement; - createReturn(expression?: Expression): ReturnStatement; - updateReturn(node: ReturnStatement, expression: Expression | undefined): ReturnStatement; - createWith(expression: Expression, statement: Statement): WithStatement; - updateWith(node: WithStatement, expression: Expression, statement: Statement): WithStatement; - createSwitch(expression: Expression, caseBlock: CaseBlock): SwitchStatement; - updateSwitch(node: SwitchStatement, expression: Expression, caseBlock: CaseBlock): SwitchStatement; - createLabel(label: string | Identifier, statement: Statement): LabeledStatement; - updateLabel(node: LabeledStatement, label: Identifier, statement: Statement): LabeledStatement; - createThrow(expression: Expression): ThrowStatement; - updateThrow(node: ThrowStatement, expression: Expression): ThrowStatement; - createTry(tryBlock: Block, catchClause: CatchClause | undefined, finallyBlock: Block | undefined): TryStatement; - updateTry(node: TryStatement, tryBlock: Block, catchClause: CatchClause | undefined, finallyBlock: Block | undefined): TryStatement; + createIfStatement(expression: Expression, thenStatement: Statement, elseStatement?: Statement): IfStatement; + updateIfStatement(node: IfStatement, expression: Expression, thenStatement: Statement, elseStatement: Statement | undefined): IfStatement; + createDoStatement(statement: Statement, expression: Expression): DoStatement; + updateDoStatement(node: DoStatement, statement: Statement, expression: Expression): DoStatement; + createWhileStatement(expression: Expression, statement: Statement): WhileStatement; + updateWhileStatement(node: WhileStatement, expression: Expression, statement: Statement): WhileStatement; + createForStatement(initializer: ForInitializer | undefined, condition: Expression | undefined, incrementor: Expression | undefined, statement: Statement): ForStatement; + updateForStatement(node: ForStatement, initializer: ForInitializer | undefined, condition: Expression | undefined, incrementor: Expression | undefined, statement: Statement): ForStatement; + createForInStatement(initializer: ForInitializer, expression: Expression, statement: Statement): ForInStatement; + updateForInStatement(node: ForInStatement, initializer: ForInitializer, expression: Expression, statement: Statement): ForInStatement; + createForOfStatement(awaitModifier: AwaitKeyword | undefined, initializer: ForInitializer, expression: Expression, statement: Statement): ForOfStatement; + updateForOfStatement(node: ForOfStatement, awaitModifier: AwaitKeyword | undefined, initializer: ForInitializer, expression: Expression, statement: Statement): ForOfStatement; + createContinueStatement(label?: string | Identifier): ContinueStatement; + updateContinueStatement(node: ContinueStatement, label: Identifier | undefined): ContinueStatement; + createBreakStatement(label?: string | Identifier): BreakStatement; + updateBreakStatement(node: BreakStatement, label: Identifier | undefined): BreakStatement; + createReturnStatement(expression?: Expression): ReturnStatement; + updateReturnStatement(node: ReturnStatement, expression: Expression | undefined): ReturnStatement; + createWithStatement(expression: Expression, statement: Statement): WithStatement; + updateWithStatement(node: WithStatement, expression: Expression, statement: Statement): WithStatement; + createSwitchStatement(expression: Expression, caseBlock: CaseBlock): SwitchStatement; + updateSwitchStatement(node: SwitchStatement, expression: Expression, caseBlock: CaseBlock): SwitchStatement; + createLabeledStatement(label: string | Identifier, statement: Statement): LabeledStatement; + updateLabeledStatement(node: LabeledStatement, label: Identifier, statement: Statement): LabeledStatement; + createThrowStatement(expression: Expression): ThrowStatement; + updateThrowStatement(node: ThrowStatement, expression: Expression): ThrowStatement; + createTryStatement(tryBlock: Block, catchClause: CatchClause | undefined, finallyBlock: Block | undefined): TryStatement; + updateTryStatement(node: TryStatement, tryBlock: Block, catchClause: CatchClause | undefined, finallyBlock: Block | undefined): TryStatement; createDebuggerStatement(): DebuggerStatement; createVariableDeclaration(name: string | BindingName, exclamationToken?: ExclamationToken, type?: TypeNode, initializer?: Expression): VariableDeclaration; updateVariableDeclaration(node: VariableDeclaration, name: BindingName, exclamationToken: ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): VariableDeclaration; @@ -3448,8 +3448,8 @@ declare namespace ts { createNotEmittedStatement(original: Node): NotEmittedStatement; createPartiallyEmittedExpression(expression: Expression, original?: Node): PartiallyEmittedExpression; updatePartiallyEmittedExpression(node: PartiallyEmittedExpression, expression: Expression): PartiallyEmittedExpression; - createCommaList(elements: readonly Expression[]): CommaListExpression; - updateCommaList(node: CommaListExpression, elements: readonly Expression[]): CommaListExpression; + createCommaListExpression(elements: readonly Expression[]): CommaListExpression; + updateCommaListExpression(node: CommaListExpression, elements: readonly Expression[]): CommaListExpression; createBundle(sourceFiles: readonly SourceFile[], prepends?: readonly (UnparsedSource | InputFiles)[]): Bundle; updateBundle(node: Bundle, sourceFiles: readonly SourceFile[], prepends?: readonly (UnparsedSource | InputFiles)[]): Bundle; createComma(left: Expression, right: Expression): BinaryExpression;