Simplify

Author: fisker

src/transform-ast.ts

@@ -68,7 +68,18 @@ class Transformer extends Source {
       ) as T;
     }
 
-    return node.visit(transformVisitor, this) as T;
+    const properties = node.visit(transformVisitor, this);
+
+    if (properties.range) {
+      properties.start ??= properties.range[0];
+      properties.end ??= properties.range[1];
+      return properties as T;
+    }
+
+    const { location = node.sourceSpan, ...restProperties } = properties;
+    const estreeNode = this.createNode(restProperties, location);
+
+    return estreeNode as T;
   }
 
   static transform(node: angular.AST, text: string) {

src/transforms/transform-binary-expression.ts

@@ -13,35 +13,36 @@ const isLogicalOperator = (
 ): operator is babel.LogicalExpression['operator'] =>
   operator === '&&' || operator === '||' || operator === '??';
 
-export const visitBinary = (node: Binary, transformer: Transformer) => {
+export const visitBinary = (
+  node: Binary,
+  transformer: Transformer,
+):
+  | babel.LogicalExpression
+  | babel.AssignmentExpression
+  | babel.BinaryExpression => {
   const { operation: operator } = node;
   const [left, right] = transformer.transformChildren<babel.Expression>([
     node.left,
     node.right,
   ]);
 
   if (isLogicalOperator(operator)) {
-    return transformer.createNode<babel.LogicalExpression>({
-      type: 'LogicalExpression',
-      operator,
-      left,
-      right,
-    });
+    return { type: 'LogicalExpression', operator, left, right };
   }
 
   if (isAssignmentOperator(operator)) {
-    return transformer.createNode<babel.AssignmentExpression>({
+    return {
       type: 'AssignmentExpression',
       left: left as babel.MemberExpression,
       right,
       operator: operator,
-    });
+    };
   }
 
-  return transformer.createNode<babel.BinaryExpression>({
+  return {
     left,
     right,
     type: 'BinaryExpression',
     operator: operator as babel.BinaryExpression['operator'],
-  });
+  };
 };

src/transforms/transform-call-expression.ts

@@ -20,24 +20,25 @@ const transformCall =
   <Visitor extends VisitorCall | VisitorSafeCall>({
     optional,
   }: Visitor['options']) =>
-  (node: Visitor['node'], transformer: Transformer) => {
+  (
+    node: Visitor['node'],
+    transformer: Transformer,
+  ): babel.CallExpression | babel.OptionalCallExpression => {
     const arguments_ = transformer.transformChildren<babel.Expression>(
       node.args,
     );
     const callee = transformer.transformChild<babel.Expression>(node.receiver);
-    const isOptionalReceiver = isOptionalObjectOrCallee(callee);
-    const nodeType =
-      optional || isOptionalReceiver
-        ? 'OptionalCallExpression'
-        : 'CallExpression';
-    return transformer.createNode<
-      babel.CallExpression | babel.OptionalCallExpression
-    >({
-      type: nodeType,
-      callee,
-      arguments: arguments_,
-      ...(nodeType === 'OptionalCallExpression' ? { optional } : undefined),
-    });
+
+    if (optional || isOptionalObjectOrCallee(callee)) {
+      return {
+        type: 'OptionalCallExpression',
+        callee,
+        arguments: arguments_,
+        optional,
+      };
+    }
+
+    return { type: 'CallExpression', callee, arguments: arguments_ };
   };
 
 export const visitCall = transformCall<VisitorCall>(callOptions);

src/transforms/transform-conditional-expression.ts

@@ -6,18 +6,18 @@ import { type Transformer } from '../transform-ast.ts';
 export const visitConditional = (
   node: Conditional,
   transformer: Transformer,
-) => {
+): babel.ConditionalExpression => {
   const [test, consequent, alternate] =
     transformer.transformChildren<babel.Expression>([
       node.condition,
       node.trueExp,
       node.falseExp,
     ]);
 
-  return transformer.createNode<babel.ConditionalExpression>({
+  return {
     type: 'ConditionalExpression',
     test,
     consequent,
     alternate,
-  });
+  };
 };

src/transforms/transform-literal.ts

@@ -4,39 +4,26 @@ import {
 } from '@angular/compiler';
 import type * as babel from '@babel/types';
 
-import { type Transformer } from '../transform-ast.ts';
-
 export const visitLiteralPrimitive = (
   node: LiteralPrimitive,
-  transformer: Transformer,
-) => {
+):
+  | babel.BooleanLiteral
+  | babel.NumericLiteral
+  | babel.NullLiteral
+  | babel.StringLiteral
+  | babel.Identifier => {
   const { value } = node;
-  console.log(node);
   switch (typeof value) {
     case 'boolean':
-      return transformer.createNode<babel.BooleanLiteral>({
-        type: 'BooleanLiteral',
-        value,
-      });
+      return { type: 'BooleanLiteral', value };
     case 'number':
-      return transformer.createNode<babel.NumericLiteral>({
-        type: 'NumericLiteral',
-        value,
-      });
+      return { type: 'NumericLiteral', value };
     case 'object':
-      return transformer.createNode<babel.NullLiteral>({
-        type: 'NullLiteral',
-      });
+      return { type: 'NullLiteral' };
     case 'string':
-      return transformer.createNode<babel.StringLiteral>({
-        type: 'StringLiteral',
-        value,
-      });
+      return { type: 'StringLiteral', value };
     case 'undefined':
-      return transformer.createNode<babel.Identifier>({
-        type: 'Identifier',
-        name: 'undefined',
-      });
+      return { type: 'Identifier', name: 'undefined' };
     /* c8 ignore next 4 */
     default:
       throw new Error(
@@ -47,10 +34,8 @@ export const visitLiteralPrimitive = (
 
 export const visitRegularExpressionLiteral = (
   node: RegularExpressionLiteral,
-  transformer: Transformer,
-) =>
-  transformer.createNode<babel.RegExpLiteral>({
-    type: 'RegExpLiteral',
-    pattern: node.body,
-    flags: node.flags ?? '',
-  });
+): babel.RegExpLiteral => ({
+  type: 'RegExpLiteral',
+  pattern: node.body,
+  flags: node.flags ?? '',
+});

src/transforms/transform-member-expression.ts

@@ -1,4 +1,5 @@
 import {
+  ImplicitReceiver,
   type KeyedRead,
   type PropertyRead,
   type SafeKeyedRead,
@@ -42,53 +43,57 @@ const transformMemberExpression =
     computed,
     optional,
   }: Visitor['options']) =>
-  (node: Visitor['node'], transformer: Transformer) => {
-    const object = transformer.transformChild<babel.Expression>(node.receiver);
+  (
+    node: Visitor['node'],
+    transformer: Transformer,
+  ):
+    | babel.OptionalMemberExpression
+    | babel.MemberExpression
+    | babel.Identifier => {
+    const { receiver } = node;
 
     let property;
     if (computed) {
       const { key } = node as KeyedRead | SafeKeyedRead;
       property = transformer.transformChild<babel.Expression>(key);
     } else {
+      const isImplicitReceiver = receiver instanceof ImplicitReceiver;
       const { name, nameSpan } = node as PropertyRead | SafePropertyRead;
       property = transformer.createNode<babel.Identifier>(
         { type: 'Identifier', name: name },
         nameSpan,
-        object ? [] : transformer.ancestors,
+        isImplicitReceiver ? transformer.ancestors : [],
       );
-    }
 
-    if (!object) {
-      return property;
+      if (isImplicitReceiver) {
+        return property;
+      }
     }
 
+    const object = transformer.transformChild<babel.Expression>(receiver);
+
     const isOptionalObject = isOptionalObjectOrCallee(object);
 
     if (optional || isOptionalObject) {
-      return transformer.createNode<babel.OptionalMemberExpression>({
+      return {
         type: 'OptionalMemberExpression',
         optional: optional || !isOptionalObject,
         computed,
         property,
         object,
-      });
+      };
     }
 
     if (computed) {
-      return transformer.createNode<babel.MemberExpressionComputed>({
-        type: 'MemberExpression',
-        property,
-        object,
-        computed: true,
-      });
+      return { type: 'MemberExpression', property, object, computed: true };
     }
 
-    return transformer.createNode<babel.MemberExpressionNonComputed>({
+    return {
       type: 'MemberExpression',
       object,
       property: property as babel.MemberExpressionNonComputed['property'],
       computed: false,
-    });
+    };
   };
 
 export const visitKeyedRead =

src/transforms/transform-object-expression.ts

@@ -7,15 +7,15 @@ import type { NGNode, RawNGSpan } from '../types.ts';
 export const visitLiteralMap = (
   node: angular.LiteralMap,
   transformer: Transformer,
-) => {
+): babel.ObjectExpression => {
   const { keys, values } = node;
   const createChild = <T extends NGNode>(
     properties: Partial<T> & { type: T['type'] },
     location: angular.AST | RawNGSpan | [number, number] = node,
   ) =>
     transformer.create(properties, location, [node, ...transformer.ancestors]);
 
-  return transformer.createNode<babel.ObjectExpression>({
+  return {
     type: 'ObjectExpression',
     properties: keys.map((keyNode, index) => {
       const valueNode = values[index];
@@ -40,5 +40,5 @@ export const visitLiteralMap = (
         [keyNode.sourceSpan.start, valueNode.sourceSpan.end],
       );
     }),
-  });
+  };
 };

src/transforms/transform-template-literal.ts

@@ -41,12 +41,10 @@ export const visitTemplateLiteralElement = (
   const start = node.sourceSpan.start + (isFirst ? 1 : 0);
   const raw = transformer.text.slice(start, end);
 
-  return transformer.createNode<babel.TemplateElement>(
-    {
-      type: 'TemplateElement',
-      value: { cooked: node.text, raw },
-      tail: isLast,
-    },
-    [start, end],
-  );
+  return {
+    type: 'TemplateElement',
+    value: { cooked: node.text, raw },
+    tail: isLast,
+    range: [start, end],
+  };
 };

src/transforms/transform-unary-expression.ts

@@ -30,26 +30,24 @@ const transformUnaryExpression =
   >(
     operator: Visitor['operator'],
   ) =>
-  (node: Visitor['node'], transformer: Transformer) =>
-    transformer.createNode<babel.UnaryExpression>(
-      {
-        type: 'UnaryExpression',
-        prefix: true,
-        operator,
-        argument: transformer.transformChild<babel.Expression>(node.expression),
-      },
-      node.sourceSpan,
-    );
+  (node: Visitor['node'], transformer: Transformer): babel.UnaryExpression => ({
+    type: 'UnaryExpression',
+    prefix: true,
+    operator,
+    argument: transformer.transformChild<babel.Expression>(node.expression),
+  });
 
 export const visitPrefixNot = transformUnaryExpression<VisitorPrefixNot>('!');
 export const visitTypeofExpression =
   transformUnaryExpression<VisitorTypeofExpression>('typeof');
 export const visitVoidExpression =
   transformUnaryExpression<VisitorVoidExpression>('void');
-export const visitUnary = (node: Unary, transformer: Transformer) =>
-  transformer.createNode<babel.UnaryExpression>({
-    type: 'UnaryExpression',
-    prefix: true,
-    argument: transformer.transformChild<babel.Expression>(node.expr),
-    operator: node.operator as '-' | '+',
-  });
+export const visitUnary = (
+  node: Unary,
+  transformer: Transformer,
+): babel.UnaryExpression => ({
+  type: 'UnaryExpression',
+  prefix: true,
+  argument: transformer.transformChild<babel.Expression>(node.expr),
+  operator: node.operator as '-' | '+',
+});

src/transforms/transform-unexpected-node.ts

@@ -0,0 +1,12 @@
+import { type ASTWithSource, type ImplicitReceiver } from '@angular/compiler';
+
+function transformUnexpectedNode<T extends ASTWithSource | ImplicitReceiver>(
+  node: T,
+) {
+  throw new Error(`Unexpected node type '${node.constructor.name}'`);
+}
+
+// Handled in `./transform-member-expression.ts`
+export const visitImplicitReceiver = transformUnexpectedNode<ImplicitReceiver>;
+// Unreachable
+export const visitASTWithSource = transformUnexpectedNode<ASTWithSource>;