Remove preprinter, add parenthesizer callback to emit

src/compiler/factory/nodeFactory.ts

@@ -2139,7 +2139,7 @@ namespace ts {
  /*decorators*/ undefined,
  /*modifiers*/ undefined,
  name,
- initializer
+ initializer && parenthesizerRules().parenthesizeExpressionForDisallowedComma(initializer)
  );
  node.propertyName = asName(propertyName);
  node.dotDotDotToken = dotDotDotToken;

src/compiler/factory/parenthesizerRules.ts

@@ -5,7 +5,12 @@ namespace ts {
  cachedLiteralKind: SyntaxKind;
  }
 
+ let binaryLeftOperandParenthesizerCache: ESMap<BinaryOperator, (node: Expression) => Expression> | undefined;
+ let binaryRightOperandParenthesizerCache: ESMap<BinaryOperator, (node: Expression) => Expression> | undefined;
+
  return {
+ getParenthesizeLeftSideOfBinaryForOperator,
+ getParenthesizeRightSideOfBinaryForOperator,
  parenthesizeLeftSideOfBinary,
  parenthesizeRightSideOfBinary,
  parenthesizeExpressionOfComputedPropertyName,
@@ -27,6 +32,26 @@ namespace ts {
  parenthesizeTypeArguments,
  };
 
+ function getParenthesizeLeftSideOfBinaryForOperator(operatorKind: BinaryOperator) {
+ binaryLeftOperandParenthesizerCache ||= new Map();
+ let parenthesizerRule = binaryLeftOperandParenthesizerCache.get(operatorKind);
+ if (!parenthesizerRule) {
+ parenthesizerRule = node => parenthesizeLeftSideOfBinary(operatorKind, node);
+ binaryLeftOperandParenthesizerCache.set(operatorKind, parenthesizerRule);
+ }
+ return parenthesizerRule;
+ }
+
+ function getParenthesizeRightSideOfBinaryForOperator(operatorKind: BinaryOperator) {
+ binaryRightOperandParenthesizerCache ||= new Map();
+ let parenthesizerRule = binaryRightOperandParenthesizerCache.get(operatorKind);
+ if (!parenthesizerRule) {
+ parenthesizerRule = node => parenthesizeRightSideOfBinary(operatorKind, /*leftSide*/ undefined, node);
+ binaryRightOperandParenthesizerCache.set(operatorKind, parenthesizerRule);
+ }
+ return parenthesizerRule;
+ }
+
  /**
  * Determines whether the operand to a BinaryExpression needs to be parenthesized.
  *
@@ -210,7 +235,7 @@ namespace ts {
  return parenthesizeBinaryOperand(binaryOperator, leftSide, /*isLeftSideOfBinary*/ true);
  }
 
- function parenthesizeRightSideOfBinary(binaryOperator: SyntaxKind, leftSide: Expression, rightSide: Expression): Expression {
+ function parenthesizeRightSideOfBinary(binaryOperator: SyntaxKind, leftSide: Expression | undefined, rightSide: Expression): Expression {
  return parenthesizeBinaryOperand(binaryOperator, rightSide, /*isLeftSideOfBinary*/ false, leftSide);
  }
 
@@ -352,6 +377,8 @@ namespace ts {
  return expression;
  }
 
+ function parenthesizeConciseBodyOfArrowFunction(body: Expression): Expression;
+ function parenthesizeConciseBodyOfArrowFunction(body: ConciseBody): ConciseBody;
  function parenthesizeConciseBodyOfArrowFunction(body: ConciseBody): ConciseBody {
  if (!isBlock(body) && (isCommaSequence(body) || getLeftmostExpression(body, /*stopAtCallExpressions*/ false).kind === SyntaxKind.ObjectLiteralExpression)) {
  // TODO(rbuckton): Verifiy whether `setTextRange` is needed.
@@ -403,6 +430,8 @@ namespace ts {
  }
 
  export const nullParenthesizerRules: ParenthesizerRules = {
+ getParenthesizeLeftSideOfBinaryForOperator: _ => identity,
+ getParenthesizeRightSideOfBinaryForOperator: _ => identity,
  parenthesizeLeftSideOfBinary: (_binaryOperator, leftSide) => leftSide,
  parenthesizeRightSideOfBinary: (_binaryOperator, _leftSide, rightSide) => rightSide,
  parenthesizeExpressionOfComputedPropertyName: identity,

src/compiler/transformer.ts

@@ -562,31 +562,31 @@ namespace ts {
  }
 
  export const nullTransformationContext: TransformationContext = {
- get factory() { return factory; },
- enableEmitNotification: noop,
- enableSubstitution: noop,
- endLexicalEnvironment: returnUndefined,
+ factory,
  getCompilerOptions: () => ({}),
- getEmitHost: notImplemented,
  getEmitResolver: notImplemented,
+ getEmitHost: notImplemented,
  getEmitHelperFactory: notImplemented,
+ startLexicalEnvironment: noop,
+ resumeLexicalEnvironment: noop,
+ suspendLexicalEnvironment: noop,
+ endLexicalEnvironment: returnUndefined,
  setLexicalEnvironmentFlags: noop,
  getLexicalEnvironmentFlags: () => 0,
- hoistFunctionDeclaration: noop,
  hoistVariableDeclaration: noop,
+ hoistFunctionDeclaration: noop,
  addInitializationStatement: noop,
- isEmitNotificationEnabled: notImplemented,
- isSubstitutionEnabled: notImplemented,
- onEmitNode: noop,
- onSubstituteNode: notImplemented,
- readEmitHelpers: notImplemented,
- requestEmitHelper: noop,
- resumeLexicalEnvironment: noop,
- startLexicalEnvironment: noop,
- suspendLexicalEnvironment: noop,
- addDiagnostic: noop,
  startBlockScope: noop,
  endBlockScope: returnUndefined,
- addBlockScopedVariable: noop
+ addBlockScopedVariable: noop,
+ requestEmitHelper: noop,
+ readEmitHelpers: notImplemented,
+ enableSubstitution: noop,
+ enableEmitNotification: noop,
+ isSubstitutionEnabled: notImplemented,
+ isEmitNotificationEnabled: notImplemented,
+ onSubstituteNode: noEmitSubstitution,
+ onEmitNode: noEmitNotification,
+ addDiagnostic: noop,
  };
 }

src/compiler/types.ts

@@ -6785,6 +6785,8 @@ namespace ts {
 
  /* @internal */
  export interface ParenthesizerRules {
+ getParenthesizeLeftSideOfBinaryForOperator(binaryOperator: SyntaxKind): (leftSide: Expression) => Expression;
+ getParenthesizeRightSideOfBinaryForOperator(binaryOperator: SyntaxKind): (rightSide: Expression) => Expression;
  parenthesizeLeftSideOfBinary(binaryOperator: SyntaxKind, leftSide: Expression): Expression;
  parenthesizeRightSideOfBinary(binaryOperator: SyntaxKind, leftSide: Expression | undefined, rightSide: Expression): Expression;
  parenthesizeExpressionOfComputedPropertyName(expression: Expression): Expression;
@@ -6798,6 +6800,7 @@ namespace ts {
  parenthesizeExpressionsOfCommaDelimitedList(elements: readonly Expression[]): NodeArray<Expression>;
  parenthesizeExpressionForDisallowedComma(expression: Expression): Expression;
  parenthesizeExpressionOfExpressionStatement(expression: Expression): Expression;
+ parenthesizeConciseBodyOfArrowFunction(body: Expression): Expression;
  parenthesizeConciseBodyOfArrowFunction(body: ConciseBody): ConciseBody;
  parenthesizeMemberOfConditionalType(member: TypeNode): TypeNode;
  parenthesizeMemberOfElementType(member: TypeNode): TypeNode;

tests/baselines/reference/inlineJsxFactoryDeclarationsLocalTypes.js

@@ -161,4 +161,6 @@ var _brokenTree = (0, renderer_1.dom)(component_1.MySFC, { x: 1, y: 2 },
  (0, renderer_1.dom)(component_1.MyClass, { x: 3, y: 4 }),
  (0, renderer_1.dom)(component_1.MyClass, { x: 5, y: 6 }));
 // Should fail, nondom isn't allowed as children of dom
-var _brokenTree2 = (0, renderer_1.dom)(DOMSFC, { x: 1, y: 2 }, component_1.tree, component_1.tree);
+var _brokenTree2 = (0, renderer_1.dom)(DOMSFC, { x: 1, y: 2 },
+ component_1.tree,
+ component_1.tree);

tests/baselines/reference/jsxCheckJsxNoTypeArgumentsAllowed.js

@@ -23,5 +23,5 @@ let x = <MyComp<Prop> a={10} b="hi" />; // error, no type arguments in js
 exports.__esModule = true;
 var component_1 = require("./component");
 var React = require("react");
-var x = (<component_1.MyComp />, <Prop> a={10} b="hi" />; // error, no type arguments in js
-</>);
+var x = <component_1.MyComp />, <Prop> a={10} b="hi" />; // error, no type arguments in js
+</>;