Tighten Node types

fisker · fisker · commit 31470c2edeab · 2026-01-11T02:54:58.000+08:00
diff --git a/src/ast-transform/node-types.ts b/src/ast-transform/node-types.ts
@@ -19,7 +19,12 @@ export type NGOwnNode =
   | NGPipeExpression
   | NGChainedExpression;
 
-export type NGNode = babel.Node | NGOwnNode;
+export type NGNode =
+  | babel.Expression
+  | babel.ObjectProperty
+  | babel.SpreadElement
+  | babel.TemplateElement
+  | NGOwnNode;
 
 export interface NGEmptyExpression extends NGBaseNode {
   type: 'NGEmptyExpression';
diff --git a/src/ast-transform/transforms/transform-array-expression.ts b/src/ast-transform/transforms/transform-array-expression.ts
@@ -9,6 +9,6 @@ export const visitLiteralArray = (
 ): babel.ArrayExpression => ({
   type: 'ArrayExpression',
   elements: transformer.transformChildren<
-    babel.Expression | babel.SpreadElement
+    Exclude<babel.ArrayExpression['elements'][number], null>
   >(node.expressions),
 });
diff --git a/src/ast-transform/transforms/transform-ast-with-source.ts b/src/ast-transform/transforms/transform-ast-with-source.ts
@@ -1,9 +1,9 @@
 import { type ASTWithSource } from '@angular/compiler';
-import type * as babel from '@babel/types';
 
+import type { NGNode } from '../../types.ts';
 import { type NodeTransformer } from '../node-transformer.ts';
 
 export const visitASTWithSource = (
   node: ASTWithSource,
   transformer: NodeTransformer,
-) => transformer.transformChild<babel.Expression>(node.ast);
+) => transformer.transformChild<NGNode>(node.ast);
diff --git a/src/ast-transform/transforms/transform-interpolation.ts b/src/ast-transform/transforms/transform-interpolation.ts
@@ -1,7 +1,7 @@
 import { type Interpolation } from '@angular/compiler';
-import type * as babel from '@babel/types';
 
 import { type NodeTransformer } from '../node-transformer.ts';
+import type { NGNode } from '../node-types.ts';
 
 export const visitInterpolation = (
   node: Interpolation,
@@ -14,5 +14,5 @@ export const visitInterpolation = (
     throw new Error("Unexpected 'Interpolation'");
   }
 
-  return transformer.transformChild<babel.Expression>(expressions[0]);
+  return transformer.transformChild<NGNode>(expressions[0]);
 };
diff --git a/src/ast-transform/transforms/transform-member-expression.ts b/src/ast-transform/transforms/transform-member-expression.ts
@@ -55,7 +55,7 @@ const transformMemberExpression =
     let property;
     if (computed) {
       const { key } = node as KeyedRead | SafeKeyedRead;
-      property = transformer.transformChild<babel.Expression>(key);
+      property = transformer.transformChild<babel.Identifier>(key);
     } else {
       const isImplicitReceiver = receiver instanceof ImplicitReceiver;
       const { name, nameSpan } = node as PropertyRead | SafePropertyRead;
@@ -72,28 +72,15 @@ const transformMemberExpression =
 
     const object = transformer.transformChild<babel.Expression>(receiver);
 
-    const isOptionalObject = isOptionalObjectOrCallee(object);
-
-    if (optional || isOptionalObject) {
-      return {
-        type: 'OptionalMemberExpression',
-        optional: optional || !isOptionalObject,
-        computed,
-        property,
-        object,
-      };
-    }
-
-    if (computed) {
-      return { type: 'MemberExpression', property, object, computed: true };
-    }
-
-    return {
-      type: 'MemberExpression',
-      object,
-      property: property as babel.MemberExpressionNonComputed['property'],
-      computed: false,
-    };
+    return optional || isOptionalObjectOrCallee(object)
+      ? {
+          type: 'OptionalMemberExpression',
+          optional: optional,
+          property,
+          object,
+          computed,
+        }
+      : { type: 'MemberExpression', property, object, computed };
   };
 
 export const visitKeyedRead =
diff --git a/src/ast-transform/transforms/transform-object-expression.ts b/src/ast-transform/transforms/transform-object-expression.ts
@@ -48,6 +48,11 @@ export const visitLiteralMap = (
           type: 'ObjectProperty',
           key,
           value: transformer.transformChild<babel.Expression>(valueNode),
+          // TODO: Use this instead, https://github.com/babel/babel/pull/17703
+          // value:
+          //   transformer.transformChild<babel.ObjectProperty['value']>(
+          //     valueNode,
+          //   ),
           shorthand,
           computed: false,
           // @ts-expect-error -- Missed in types
diff --git a/src/ast-transform/transforms/transform-pipe-expression.ts b/src/ast-transform/transforms/transform-pipe-expression.ts
@@ -1,14 +1,13 @@
 import { type BindingPipe } from '@angular/compiler';
 import type * as babel from '@babel/types';
 
-import { type IncompleteNode } from '../../source.ts';
 import type { NGPipeExpression } from '../../types.ts';
 import { type NodeTransformer } from '../node-transformer.ts';
 
 export const visitPipe = (
   node: BindingPipe,
   transformer: NodeTransformer,
-): IncompleteNode<NGPipeExpression> => ({
+): Omit<NGPipeExpression, 'start' | 'end' | 'range'> => ({
   type: 'NGPipeExpression',
   left: transformer.transformChild<babel.Expression>(node.exp),
   right: transformer.create<babel.Identifier>(
diff --git a/src/ast-transform/transforms/transform-template-literal.ts b/src/ast-transform/transforms/transform-template-literal.ts
@@ -10,29 +10,27 @@ import { type NodeTransformer } from '../node-transformer.ts';
 export const visitTaggedTemplateLiteral = (
   node: TaggedTemplateLiteral,
   transformer: NodeTransformer,
-) =>
-  transformer.create<babel.TaggedTemplateExpression>({
-    type: 'TaggedTemplateExpression',
-    tag: transformer.transformChild<babel.Expression>(node.tag),
-    quasi: transformer.transformChild<babel.TemplateLiteral>(node.template),
-  });
+): babel.TaggedTemplateExpression => ({
+  type: 'TaggedTemplateExpression',
+  tag: transformer.transformChild<babel.Expression>(node.tag),
+  quasi: transformer.transformChild<babel.TemplateLiteral>(node.template),
+});
 
 export const visitTemplateLiteral = (
   node: TemplateLiteral,
   transformer: NodeTransformer,
-) =>
-  transformer.create<babel.TemplateLiteral>({
-    type: 'TemplateLiteral',
-    quasis: transformer.transformChildren<babel.TemplateElement>(node.elements),
-    expressions: transformer.transformChildren<babel.Expression>(
-      node.expressions,
-    ),
-  });
+): babel.TemplateLiteral => ({
+  type: 'TemplateLiteral',
+  quasis: transformer.transformChildren<babel.TemplateElement>(node.elements),
+  expressions: transformer.transformChildren<babel.Expression>(
+    node.expressions,
+  ),
+});
 
 export const visitTemplateLiteralElement = (
   node: TemplateLiteralElement,
   transformer: NodeTransformer,
-) => {
+): babel.TemplateElement => {
   const [parent] = transformer.ancestors;
   const { elements } = parent as TemplateLiteral;
   const elementIndex = elements.indexOf(node);
