tsc-ts 0.0.4 → 0.0.5

package/src/compiler/transformers/subtree-facts.ts

@@ -0,0 +1,245 @@
+// Whether a subtree contains TypeScript-only syntax, computed as tsgo's subtree facts are.
+// Transforms skip subtrees without it; that also decides how malformed code is emitted.
+import {
+  ClassDeclaration,
+  ClassExpression,
+  ConstructorDeclaration,
+  ExportAssignment,
+  ExportDeclaration,
+  ExportSpecifier,
+  FunctionDeclaration,
+  GetAccessorDeclaration,
+  Identifier,
+  ImportClause,
+  ImportEqualsDeclaration,
+  ImportSpecifier,
+  MethodDeclaration,
+  ModifierFlags,
+  type Node,
+  NodeVisitor,
+  ParameterDeclaration,
+  PropertyDeclaration,
+  SetAccessorDeclaration,
+  VariableDeclaration,
+  VariableStatement,
+  ArrowFunction,
+  FunctionExpression,
+  CallExpression,
+  NewExpression,
+  TaggedTemplateExpression,
+  ExpressionWithTypeArguments,
+  JsxOpeningElement,
+  JsxSelfClosingElement,
+  HeritageClause,
+  getModifiers,
+} from '../ast.js';
+import { isTypeNodeKind } from '../printer/utilities.js';
+import { SyntaxKind } from '../syntax-kind.js';
+
+const enum Facts {
+  None = 0,
+  TypeScript = 1,
+  /** The node's own syntax decides; children aren't consulted. */
+  Final = 2,
+}
+
+/** Memoized `containsTypeScript` answers for one emit. */
+export class TypeScriptFacts extends NodeVisitor {
+  private readonly cache: Map<Node, boolean>;
+  private found: boolean;
+
+  constructor() {
+    super();
+    this.cache = new Map<Node, boolean>();
+    this.found = false;
+  }
+
+  containsTypeScript(node: Node): boolean {
+    const cached = this.cache.get(node);
+    if (cached !== undefined) return cached;
+    const own = ownFacts(node);
+    let result = (own & Facts.TypeScript) !== 0;
+    if (!result && (own & Facts.Final) === 0) {
+      const saved = this.found;
+      this.found = false;
+      node.forEachChild(this);
+      result = this.found;
+      this.found = saved;
+    }
+    this.cache.set(node, result);
+    return result;
+  }
+
+  visitNode(node: Node): boolean {
+    if (this.containsTypeScript(node)) this.found = true;
+    return this.found;
+  }
+}
+
+function ambient(node: Node): boolean {
+  const modifiers = getModifiers(node);
+  return modifiers !== undefined && (modifiers.modifierFlags & ModifierFlags.Ambient) !== 0;
+}
+
+/** TypeScript syntax of the node itself, beyond what its children contribute. */
+function ownFacts(node: Node): Facts {
+  const kind = node.kind;
+  if (isTypeNodeKind(kind) && kind !== SyntaxKind.ExpressionWithTypeArguments) return Facts.TypeScript;
+  switch (kind) {
+    case SyntaxKind.PublicKeyword:
+    case SyntaxKind.PrivateKeyword:
+    case SyntaxKind.ProtectedKeyword:
+    case SyntaxKind.ReadonlyKeyword:
+    case SyntaxKind.AbstractKeyword:
+    case SyntaxKind.DeclareKeyword:
+    case SyntaxKind.ConstKeyword:
+    case SyntaxKind.InKeyword:
+    case SyntaxKind.OutKeyword:
+    case SyntaxKind.OverrideKeyword:
+    case SyntaxKind.ExportKeyword:
+    case SyntaxKind.Decorator:
+    case SyntaxKind.EnumMember:
+    case SyntaxKind.EnumDeclaration:
+    case SyntaxKind.ModuleDeclaration:
+    case SyntaxKind.ShorthandPropertyAssignment:
+    case SyntaxKind.AsExpression:
+    case SyntaxKind.SatisfiesExpression:
+    case SyntaxKind.NonNullExpression:
+    case SyntaxKind.TypeAssertionExpression:
+    case SyntaxKind.InterfaceDeclaration:
+    case SyntaxKind.TypeAliasDeclaration:
+    case SyntaxKind.JSTypeAliasDeclaration:
+    case SyntaxKind.NamespaceExportDeclaration:
+    case SyntaxKind.CallSignature:
+    case SyntaxKind.ConstructSignature:
+    case SyntaxKind.IndexSignature:
+    case SyntaxKind.MethodSignature:
+    case SyntaxKind.PropertySignature:
+    case SyntaxKind.TypeParameter:
+      return Facts.TypeScript;
+    case SyntaxKind.VariableStatement:
+      return node instanceof VariableStatement && ambient(node) ? Facts.TypeScript : Facts.None;
+    case SyntaxKind.VariableDeclaration:
+      return node instanceof VariableDeclaration && (node.exclamationToken !== undefined || node.type !== undefined)
+        ? Facts.TypeScript
+        : Facts.None;
+    case SyntaxKind.Parameter:
+      if (node instanceof ParameterDeclaration)
+        return (node.name instanceof Identifier && node.name.text === 'this') ||
+          node.questionToken !== undefined ||
+          node.type !== undefined
+          ? Facts.TypeScript
+          : Facts.None;
+      break;
+    case SyntaxKind.FunctionDeclaration:
+      if (node instanceof FunctionDeclaration)
+        return node.body === undefined ||
+          ambient(node) ||
+          node.typeParameters !== undefined ||
+          node.type !== undefined ||
+          node.fullSignature !== undefined
+          ? Facts.TypeScript
+          : Facts.None;
+      break;
+    case SyntaxKind.ClassDeclaration:
+      if (node instanceof ClassDeclaration)
+        return ambient(node) || node.typeParameters !== undefined ? Facts.TypeScript : Facts.None;
+      break;
+    case SyntaxKind.ClassExpression:
+      if (node instanceof ClassExpression)
+        return ambient(node) || node.typeParameters !== undefined ? Facts.TypeScript : Facts.None;
+      break;
+    case SyntaxKind.HeritageClause:
+      if (node instanceof HeritageClause) {
+        if (node.token === SyntaxKind.ImplementsKeyword) return Facts.TypeScript;
+        return node.token === SyntaxKind.ExtendsKeyword ? Facts.None : Facts.Final;
+      }
+      break;
+    case SyntaxKind.ImportEqualsDeclaration:
+      if (node instanceof ImportEqualsDeclaration)
+        return node.isTypeOnly || node.moduleReference.kind !== SyntaxKind.ExternalModuleReference
+          ? Facts.TypeScript
+          : Facts.None;
+      break;
+    case SyntaxKind.ImportSpecifier:
+      return node instanceof ImportSpecifier && node.isTypeOnly ? Facts.TypeScript : Facts.None;
+    case SyntaxKind.ImportClause:
+      return node instanceof ImportClause && node.phaseModifier === SyntaxKind.TypeKeyword
+        ? Facts.TypeScript
+        : Facts.None;
+    case SyntaxKind.ExportAssignment:
+      return node instanceof ExportAssignment && node.isExportEquals ? Facts.TypeScript : Facts.None;
+    case SyntaxKind.ExportDeclaration:
+      return node instanceof ExportDeclaration && node.isTypeOnly ? Facts.TypeScript : Facts.None;
+    case SyntaxKind.ExportSpecifier:
+      return node instanceof ExportSpecifier && node.isTypeOnly ? Facts.TypeScript : Facts.None;
+    case SyntaxKind.Constructor:
+      if (node instanceof ConstructorDeclaration)
+        return node.body === undefined ||
+          node.typeParameters !== undefined ||
+          node.type !== undefined ||
+          node.fullSignature !== undefined
+          ? Facts.TypeScript
+          : Facts.None;
+      break;
+    case SyntaxKind.GetAccessor:
+      if (node instanceof GetAccessorDeclaration)
+        return node.body === undefined ||
+          node.typeParameters !== undefined ||
+          node.type !== undefined ||
+          node.fullSignature !== undefined
+          ? Facts.TypeScript
+          : Facts.None;
+      break;
+    case SyntaxKind.SetAccessor:
+      if (node instanceof SetAccessorDeclaration)
+        return node.body === undefined ||
+          node.typeParameters !== undefined ||
+          node.type !== undefined ||
+          node.fullSignature !== undefined
+          ? Facts.TypeScript
+          : Facts.None;
+      break;
+    case SyntaxKind.MethodDeclaration:
+      if (node instanceof MethodDeclaration)
+        return node.body === undefined ||
+          node.postfixToken !== undefined ||
+          node.typeParameters !== undefined ||
+          node.type !== undefined ||
+          node.fullSignature !== undefined
+          ? Facts.TypeScript
+          : Facts.None;
+      break;
+    case SyntaxKind.PropertyDeclaration:
+      return node instanceof PropertyDeclaration && (node.postfixToken !== undefined || node.type !== undefined)
+        ? Facts.TypeScript
+        : Facts.None;
+    case SyntaxKind.ArrowFunction:
+      return node instanceof ArrowFunction &&
+        (node.typeParameters !== undefined || node.type !== undefined || node.fullSignature !== undefined)
+        ? Facts.TypeScript
+        : Facts.None;
+    case SyntaxKind.FunctionExpression:
+      return node instanceof FunctionExpression &&
+        (node.typeParameters !== undefined || node.type !== undefined || node.fullSignature !== undefined)
+        ? Facts.TypeScript
+        : Facts.None;
+    case SyntaxKind.CallExpression:
+      return node instanceof CallExpression && node.typeArguments !== undefined ? Facts.TypeScript : Facts.None;
+    case SyntaxKind.NewExpression:
+      return node instanceof NewExpression && node.typeArguments !== undefined ? Facts.TypeScript : Facts.None;
+    case SyntaxKind.TaggedTemplateExpression:
+      return node instanceof TaggedTemplateExpression && node.typeArguments !== undefined
+        ? Facts.TypeScript
+        : Facts.None;
+    case SyntaxKind.ExpressionWithTypeArguments:
+      return node instanceof ExpressionWithTypeArguments && node.typeArguments !== undefined
+        ? Facts.TypeScript
+        : Facts.None;
+    case SyntaxKind.JsxOpeningElement:
+      return node instanceof JsxOpeningElement && node.typeArguments !== undefined ? Facts.TypeScript : Facts.None;
+    case SyntaxKind.JsxSelfClosingElement:
+      return node instanceof JsxSelfClosingElement && node.typeArguments !== undefined ? Facts.TypeScript : Facts.None;
+  }
+  return Facts.None;
+}

package/src/compiler/transformers/syntax-facts.ts

@@ -0,0 +1,353 @@
+// What syntax a subtree contains, computed as tsgo's subtree facts are. Downlevel transforms
+// skip subtrees without the syntax they lower.
+import {
+  BinaryExpression,
+  BindingElement,
+  BindingPattern,
+  CallExpression,
+  CatchClause,
+  ForInOrOfStatement,
+  FunctionDeclaration,
+  FunctionExpression,
+  Identifier,
+  MetaProperty,
+  MethodDeclaration,
+  ModifierFlags,
+  type ModifierList,
+  type Node,
+  NodeFlags,
+  NodeVisitor,
+  NoSubstitutionTemplateLiteral,
+  PropertyAccessExpression,
+  TemplateHead,
+  TemplateMiddle,
+  TemplateTail,
+  VariableDeclarationList,
+  getModifiers,
+  getName,
+} from '../ast.js';
+import { isTypeNodeKind } from '../printer/utilities.js';
+import { SyntaxKind } from '../syntax-kind.js';
+import { TokenFlags } from '../types.js';
+import { getElementsOfBindingOrAssignmentPattern, getTargetOfBindingOrAssignmentElement } from './destructuring.js';
+
+export const enum SubtreeFacts {
+  None = 0,
+  ContainsTypeScript = 1 << 0,
+  ContainsJsx = 1 << 1,
+  ContainsUsing = 1 << 2,
+  ContainsLogicalAssignments = 1 << 3,
+  ContainsNullishCoalescing = 1 << 4,
+  ContainsOptionalChaining = 1 << 5,
+  ContainsMissingCatchClauseVariable = 1 << 6,
+  /** A `...` in an object literal or object pattern somewhere inside; never cleared. */
+  ContainsESObjectRestOrSpread = 1 << 7,
+  ContainsForAwaitOrAsyncGenerator = 1 << 8,
+  ContainsAnyAwait = 1 << 9,
+  ContainsExponentiationOperator = 1 << 10,
+  ContainsLexicalThis = 1 << 11,
+  ContainsLexicalSuper = 1 << 12,
+  /** A `...` anywhere; cleared when leaving a binding pattern. */
+  ContainsRestOrSpread = 1 << 13,
+  /** A `{ ...x }`; cleared when leaving most scopes. */
+  ContainsObjectRestOrSpread = 1 << 14,
+  ContainsAwait = 1 << 15,
+  ContainsDynamicImport = 1 << 16,
+  ContainsClassFields = 1 << 17,
+  ContainsDecorators = 1 << 18,
+  ContainsIdentifier = 1 << 19,
+  ContainsPrivateIdentifierInExpression = 1 << 20,
+  ContainsInvalidTemplateEscape = 1 << 21,
+
+  ContainsLexicalThisOrSuper = ContainsLexicalThis | ContainsLexicalSuper,
+}
+
+// Facts that don't propagate out of a node to its parent.
+const enum Exclusions {
+  None = 0,
+  ArrowFunction = SubtreeFacts.ContainsAwait | SubtreeFacts.ContainsObjectRestOrSpread,
+  Function = SubtreeFacts.ContainsLexicalThisOrSuper |
+    SubtreeFacts.ContainsAwait |
+    SubtreeFacts.ContainsObjectRestOrSpread,
+  Property = SubtreeFacts.ContainsLexicalThisOrSuper,
+  Module = SubtreeFacts.ContainsLexicalThisOrSuper,
+  ObjectRestOrSpread = SubtreeFacts.ContainsObjectRestOrSpread,
+  BindingPattern = SubtreeFacts.ContainsRestOrSpread,
+}
+
+/** Memoized subtree facts for one emit; synthesized nodes get theirs on first use. */
+export class SyntaxFacts extends NodeVisitor {
+  private readonly cache: Map<Node, SubtreeFacts>;
+  private collected: SubtreeFacts;
+
+  constructor() {
+    super();
+    this.cache = new Map<Node, SubtreeFacts>();
+    this.collected = SubtreeFacts.None;
+  }
+
+  of(node: Node): SubtreeFacts {
+    const cached = this.cache.get(node);
+    if (cached !== undefined) return cached;
+    const facts = this.compute(node);
+    this.cache.set(node, facts);
+    return facts;
+  }
+
+  has(node: Node, facts: SubtreeFacts): boolean {
+    return (this.of(node) & facts) !== 0;
+  }
+
+  /** Whether the subtree has a `...` in a pattern or literal. */
+  hasRestOrSpread(node: Node): boolean {
+    return this.has(node, SubtreeFacts.ContainsRestOrSpread | SubtreeFacts.ContainsObjectRestOrSpread);
+  }
+
+  /** Whether the subtree has a `{ ...x }` in a pattern or literal, outside nested scopes. */
+  hasObjectRestOrSpread(node: Node): boolean {
+    return this.has(node, SubtreeFacts.ContainsObjectRestOrSpread);
+  }
+
+  /** The facts `node` contributes to its parent. */
+  propagate(node: Node | undefined): SubtreeFacts {
+    if (node === undefined) return SubtreeFacts.None;
+    const kind = node.kind;
+    if (isTypeNodeKind(kind) && kind !== SyntaxKind.ExpressionWithTypeArguments) return SubtreeFacts.ContainsTypeScript;
+    const facts = this.of(node);
+    switch (kind) {
+      case SyntaxKind.ArrowFunction:
+        return facts & ~Exclusions.ArrowFunction;
+      case SyntaxKind.FunctionDeclaration:
+      case SyntaxKind.FunctionExpression:
+      case SyntaxKind.Constructor:
+        return facts & ~Exclusions.Function;
+      case SyntaxKind.MethodDeclaration:
+      case SyntaxKind.GetAccessor:
+      case SyntaxKind.SetAccessor:
+        return (facts & ~Exclusions.Function) | this.propagate(getName(node));
+      case SyntaxKind.PropertyDeclaration:
+        return (facts & ~Exclusions.Property) | this.propagate(getName(node));
+      case SyntaxKind.ModuleDeclaration:
+        return facts & ~Exclusions.Module;
+      case SyntaxKind.ObjectLiteralExpression:
+      case SyntaxKind.VariableDeclarationList:
+      case SyntaxKind.CatchClause:
+        return facts & ~Exclusions.ObjectRestOrSpread;
+      case SyntaxKind.ObjectBindingPattern:
+      case SyntaxKind.ArrayBindingPattern:
+        return facts & ~Exclusions.BindingPattern;
+    }
+    return facts;
+  }
+
+  visitNode(node: Node): boolean {
+    this.collected |= this.propagate(node);
+    return false;
+  }
+
+  private children(node: Node): SubtreeFacts {
+    const saved = this.collected;
+    this.collected = SubtreeFacts.None;
+    node.forEachChild(this);
+    const facts = this.collected;
+    this.collected = saved;
+    return facts;
+  }
+
+  private compute(node: Node): SubtreeFacts {
+    switch (node.kind) {
+      case SyntaxKind.UsingKeyword:
+        return SubtreeFacts.ContainsUsing;
+      case SyntaxKind.AccessorKeyword:
+      case SyntaxKind.PrivateIdentifier:
+        return SubtreeFacts.ContainsClassFields;
+      case SyntaxKind.AsyncKeyword:
+        return SubtreeFacts.ContainsAnyAwait;
+      case SyntaxKind.SuperKeyword:
+        return SubtreeFacts.ContainsLexicalSuper;
+      case SyntaxKind.ThisKeyword:
+        return SubtreeFacts.ContainsLexicalThis;
+      case SyntaxKind.AsteriskAsteriskToken:
+      case SyntaxKind.AsteriskAsteriskEqualsToken:
+        return SubtreeFacts.ContainsExponentiationOperator;
+      case SyntaxKind.QuestionQuestionToken:
+        return SubtreeFacts.ContainsNullishCoalescing;
+      case SyntaxKind.QuestionDotToken:
+        return SubtreeFacts.ContainsOptionalChaining;
+      case SyntaxKind.QuestionQuestionEqualsToken:
+      case SyntaxKind.BarBarEqualsToken:
+      case SyntaxKind.AmpersandAmpersandEqualsToken:
+        return SubtreeFacts.ContainsLogicalAssignments;
+      case SyntaxKind.Identifier:
+        return SubtreeFacts.ContainsIdentifier;
+      case SyntaxKind.NoSubstitutionTemplateLiteral:
+        return node instanceof NoSubstitutionTemplateLiteral && invalidEscape(node.templateFlags)
+          ? SubtreeFacts.ContainsInvalidTemplateEscape
+          : SubtreeFacts.None;
+      case SyntaxKind.TemplateHead:
+        return node instanceof TemplateHead && invalidEscape(node.templateFlags)
+          ? SubtreeFacts.ContainsInvalidTemplateEscape
+          : SubtreeFacts.None;
+      case SyntaxKind.TemplateMiddle:
+        return node instanceof TemplateMiddle && invalidEscape(node.templateFlags)
+          ? SubtreeFacts.ContainsInvalidTemplateEscape
+          : SubtreeFacts.None;
+      case SyntaxKind.TemplateTail:
+        return node instanceof TemplateTail && invalidEscape(node.templateFlags)
+          ? SubtreeFacts.ContainsInvalidTemplateEscape
+          : SubtreeFacts.None;
+      case SyntaxKind.Decorator:
+        return this.children(node) | SubtreeFacts.ContainsTypeScript | SubtreeFacts.ContainsDecorators;
+      case SyntaxKind.ForInStatement:
+      case SyntaxKind.ForOfStatement:
+        return (
+          this.children(node) |
+          (node instanceof ForInOrOfStatement && node.awaitModifier !== undefined
+            ? SubtreeFacts.ContainsForAwaitOrAsyncGenerator
+            : SubtreeFacts.None)
+        );
+      case SyntaxKind.ReturnStatement:
+      case SyntaxKind.YieldExpression:
+        // Returns and yields in an ES2018 async generator are awaited.
+        return this.children(node) | SubtreeFacts.ContainsForAwaitOrAsyncGenerator;
+      case SyntaxKind.AwaitExpression:
+        return (
+          this.children(node) |
+          SubtreeFacts.ContainsAwait |
+          SubtreeFacts.ContainsAnyAwait |
+          SubtreeFacts.ContainsForAwaitOrAsyncGenerator
+        );
+      case SyntaxKind.CatchClause:
+        return (
+          this.children(node) |
+          (node instanceof CatchClause && node.variableDeclaration === undefined
+            ? SubtreeFacts.ContainsMissingCatchClauseVariable
+            : SubtreeFacts.None)
+        );
+      case SyntaxKind.VariableDeclarationList:
+        return (
+          this.children(node) |
+          (node instanceof VariableDeclarationList && (node.flags & NodeFlags.Using) !== 0
+            ? SubtreeFacts.ContainsUsing
+            : SubtreeFacts.None)
+        );
+      case SyntaxKind.ObjectBindingPattern:
+      case SyntaxKind.ArrayBindingPattern:
+        return this.bindingPattern(node as BindingPattern);
+      case SyntaxKind.BindingElement:
+        return (
+          this.children(node) |
+          (node instanceof BindingElement && node.dotDotDotToken !== undefined
+            ? SubtreeFacts.ContainsRestOrSpread
+            : SubtreeFacts.None)
+        );
+      case SyntaxKind.FunctionDeclaration:
+        return this.children(node) | asyncFacts(node, (node as FunctionDeclaration).asteriskToken !== undefined);
+      case SyntaxKind.FunctionExpression:
+        return this.children(node) | asyncFacts(node, (node as FunctionExpression).asteriskToken !== undefined);
+      case SyntaxKind.MethodDeclaration:
+        return this.children(node) | asyncFacts(node, (node as MethodDeclaration).asteriskToken !== undefined);
+      case SyntaxKind.ArrowFunction:
+        return this.children(node) | asyncFacts(node, false);
+      case SyntaxKind.PropertyDeclaration:
+      case SyntaxKind.ClassStaticBlockDeclaration:
+        return this.children(node) | SubtreeFacts.ContainsClassFields;
+      case SyntaxKind.BinaryExpression:
+        return this.children(node) | this.binaryFacts(node as BinaryExpression);
+      case SyntaxKind.PropertyAccessExpression:
+        return (
+          this.children(node) |
+          (node instanceof PropertyAccessExpression && !(node.name instanceof Identifier)
+            ? SubtreeFacts.ContainsPrivateIdentifierInExpression
+            : SubtreeFacts.None)
+        );
+      case SyntaxKind.CallExpression:
+        return (
+          this.children(node) |
+          (node instanceof CallExpression && node.expression.kind === SyntaxKind.ImportKeyword
+            ? SubtreeFacts.ContainsDynamicImport
+            : SubtreeFacts.None)
+        );
+      case SyntaxKind.MetaProperty:
+        return node instanceof MetaProperty ? this.propagate(node.name) & ~SubtreeFacts.ContainsIdentifier : 0;
+      case SyntaxKind.SpreadElement:
+        return this.children(node) | SubtreeFacts.ContainsRestOrSpread;
+      case SyntaxKind.SpreadAssignment:
+        return (
+          this.children(node) | SubtreeFacts.ContainsESObjectRestOrSpread | SubtreeFacts.ContainsObjectRestOrSpread
+        );
+      case SyntaxKind.JsxElement:
+      case SyntaxKind.JsxAttributes:
+      case SyntaxKind.JsxNamespacedName:
+      case SyntaxKind.JsxOpeningElement:
+      case SyntaxKind.JsxSelfClosingElement:
+      case SyntaxKind.JsxFragment:
+      case SyntaxKind.JsxOpeningFragment:
+      case SyntaxKind.JsxClosingFragment:
+      case SyntaxKind.JsxAttribute:
+      case SyntaxKind.JsxSpreadAttribute:
+      case SyntaxKind.JsxClosingElement:
+      case SyntaxKind.JsxExpression:
+      case SyntaxKind.JsxText:
+        return this.children(node) | SubtreeFacts.ContainsJsx;
+    }
+    return this.children(node);
+  }
+
+  private bindingPattern(node: BindingPattern): SubtreeFacts {
+    const elements = node.elements.nodes;
+    const object = node.kind === SyntaxKind.ObjectBindingPattern;
+    let facts = SubtreeFacts.None;
+    for (const child of elements) {
+      let element = this.propagate(child);
+      if ((element & SubtreeFacts.ContainsRestOrSpread) !== 0) {
+        element &= ~SubtreeFacts.ContainsRestOrSpread;
+        if (object) element |= SubtreeFacts.ContainsObjectRestOrSpread | SubtreeFacts.ContainsESObjectRestOrSpread;
+      }
+      facts |= element;
+    }
+    return facts;
+  }
+
+  private binaryFacts(node: BinaryExpression): SubtreeFacts {
+    const operator = node.operatorToken.kind;
+    if (operator === SyntaxKind.InKeyword && node.left.kind === SyntaxKind.PrivateIdentifier)
+      return SubtreeFacts.ContainsClassFields | SubtreeFacts.ContainsPrivateIdentifierInExpression;
+    if (
+      operator === SyntaxKind.EqualsToken &&
+      (node.left.kind === SyntaxKind.ObjectLiteralExpression || node.left.kind === SyntaxKind.ArrayLiteralExpression) &&
+      this.containsObjectRestOrSpread(node.left)
+    )
+      return SubtreeFacts.ContainsObjectRestOrSpread;
+    return SubtreeFacts.None;
+  }
+
+  /** Whether a pattern has an object rest element, at any depth of nested assignment patterns. */
+  containsObjectRestOrSpread(node: Node): boolean {
+    const facts = this.of(node);
+    if ((facts & SubtreeFacts.ContainsObjectRestOrSpread) !== 0) return true;
+    if ((facts & SubtreeFacts.ContainsESObjectRestOrSpread) === 0) return false;
+    // Nested spreads, as in `{ x: { a, ...b } = foo } = c`.
+    const elements = getElementsOfBindingOrAssignmentPattern(node);
+    for (const element of elements) {
+      const target = getTargetOfBindingOrAssignmentElement(element);
+      if (
+        target !== undefined &&
+        (target.kind === SyntaxKind.ObjectLiteralExpression || target.kind === SyntaxKind.ArrayLiteralExpression) &&
+        this.containsObjectRestOrSpread(target)
+      )
+        return true;
+    }
+    return false;
+  }
+}
+
+function invalidEscape(flags: TokenFlags): boolean {
+  return (flags & TokenFlags.ContainsInvalidEscape) !== 0;
+}
+
+function asyncFacts(node: Node, generator: boolean): SubtreeFacts {
+  const modifiers: ModifierList | undefined = getModifiers(node);
+  if (modifiers === undefined || (modifiers.modifierFlags & ModifierFlags.Async) === 0) return SubtreeFacts.None;
+  return generator ? SubtreeFacts.ContainsForAwaitOrAsyncGenerator : SubtreeFacts.ContainsAnyAwait;
+}