typings: intersect input node types for is* functions

babel · Jul 8, 2022 · 32dfc31 · 32dfc31
1 parent 5d769d0
commit 32dfc31
Show file tree

Hide file tree

Showing 14 changed files with 1,322 additions and 502 deletions.
diff --git a/packages/babel-helper-create-class-features-plugin/src/decorators.ts b/packages/babel-helper-create-class-features-plugin/src/decorators.ts
@@ -94,13 +94,17 @@ function extractElementDescriptor(
 
   const { node, scope } = path as NodePath<SupportedElement>;
 
-  new ReplaceSupers({
-    methodPath: path,
-    objectRef: classRef,
-    superRef,
-    file,
-    refToPreserve: classRef,
-  }).replace();
+  if (!path.isTSDeclareMethod()) {
+    new ReplaceSupers({
+      methodPath: path as NodePath<
+        Exclude<SupportedElement, t.TSDeclareMethod>
+      >,
+      objectRef: classRef,
+      superRef,
+      file,
+      refToPreserve: classRef,
+    }).replace();
+  }
 
   const properties: t.ObjectExpression["properties"] = [
     prop("kind", t.stringLiteral(t.isClassMethod(node) ? node.kind : "field")),

diff --git a/packages/babel-helper-create-class-features-plugin/src/misc.ts b/packages/babel-helper-create-class-features-plugin/src/misc.ts
@@ -122,7 +122,7 @@ export function extractComputedKeys(
   };
   for (const computedPath of computedPaths) {
     const computedKey = computedPath.get("key");
-    if (computedKey.isIdentifier() && computedKey.isReferencedIdentifier()) {
+    if (computedKey.isReferencedIdentifier()) {
       handleClassTDZ(computedKey, state);
     } else {
       computedKey.traverse(classFieldDefinitionEvaluationTDZVisitor, state);

diff --git a/packages/babel-helper-remap-async-to-generator/src/index.ts b/packages/babel-helper-remap-async-to-generator/src/index.ts
@@ -36,7 +36,7 @@ const awaitVisitor = traverse.visitors.merge<{ wrapAwait: t.Expression }>([
 ]);
 
 export default function (
-  path: NodePath<any>,
+  path: NodePath<t.Function>,
   helpers: {
     wrapAsync: t.Expression;
     wrapAwait?: t.Expression;

diff --git a/packages/babel-helper-replace-supers/src/index.ts b/packages/babel-helper-replace-supers/src/index.ts
@@ -1,4 +1,4 @@
-import type { HubInterface, NodePath, Scope } from "@babel/traverse";
+import type { NodePath, Scope } from "@babel/traverse";
 import traverse from "@babel/traverse";
 import memberExpressionToFunctions from "@babel/helper-member-expression-to-functions";
 import type { HandlerState } from "@babel/helper-member-expression-to-functions";
@@ -317,9 +317,16 @@ const looseHandlers = {
 };
 
 type ReplaceSupersOptionsBase = {
-  methodPath: NodePath<any>;
+  methodPath: NodePath<
+    | t.ClassMethod
+    | t.ClassProperty
+    | t.ObjectMethod
+    | t.ClassPrivateMethod
+    | t.ClassPrivateProperty
+    | t.StaticBlock
+  >;
   constantSuper?: boolean;
-  file: any;
+  file: File;
   // objectRef might have been shadowed in child scopes,
   // in that case, we need to rename related variables.
   refToPreserve?: t.Identifier;
@@ -336,7 +343,7 @@ type ReplaceSupersOptions = ReplaceSupersOptionsBase &
   );
 
 interface ReplaceState {
-  file: unknown;
+  file: File;
   scope: Scope;
   isDerivedConstructor: boolean;
   isStatic: boolean;
@@ -353,7 +360,10 @@ export default class ReplaceSupers {
     this.isDerivedConstructor =
       path.isClassMethod({ kind: "constructor" }) && !!opts.superRef;
     this.isStatic =
-      path.isObjectMethod() || path.node.static || path.isStaticBlock?.();
+      path.isObjectMethod() ||
+      // @ts-expect-error static is not in ClassPrivateMethod
+      path.node.static ||
+      path.isStaticBlock?.();
     this.isPrivateMethod = path.isPrivate() && path.isMethod();
 
     this.file = opts.file;
@@ -364,7 +374,7 @@ export default class ReplaceSupers {
     this.opts = opts;
   }
 
-  declare file: HubInterface;
+  declare file: File;
   declare isDerivedConstructor: boolean;
   declare constantSuper: boolean;
   declare isPrivateMethod: boolean;

diff --git a/packages/babel-helper-wrap-function/src/index.ts b/packages/babel-helper-wrap-function/src/index.ts
@@ -40,7 +40,7 @@ const buildDeclarationWrapper = template.statements(`
 
 function classOrObjectMethod(
   path: NodePath<t.ClassMethod | t.ClassPrivateMethod | t.ObjectMethod>,
-  callId: any,
+  callId: t.Expression,
 ) {
   const node = path.node;
   const body = node.body;
@@ -67,31 +67,34 @@ function classOrObjectMethod(
 }
 
 function plainFunction(
-  path: NodePath<any>,
-  callId: any,
+  path: NodePath<Exclude<t.Function, t.Method>>,
+  callId: t.Expression,
   noNewArrows: boolean,
   ignoreFunctionLength: boolean,
 ) {
+  if (path.isArrowFunctionExpression()) {
+    path.arrowFunctionToExpression({ noNewArrows });
+  }
   const node = path.node;
   const isDeclaration = path.isFunctionDeclaration();
+  // @ts-expect-error node is FunctionDeclaration|FunctionExpression
   const functionId = node.id;
   const wrapper = isDeclaration
     ? buildDeclarationWrapper
     : functionId
     ? buildNamedExpressionWrapper
     : buildAnonymousExpressionWrapper;
 
-  if (path.isArrowFunctionExpression()) {
-    path.arrowFunctionToExpression({ noNewArrows });
-  }
-
+  // @ts-expect-error node is FunctionDeclaration|FunctionExpression
   node.id = null;
 
   if (isDeclaration) {
     node.type = "FunctionExpression";
   }
 
-  const built = callExpression(callId, [node]);
+  const built = callExpression(callId, [
+    node as Exclude<t.Function, t.Method | t.FunctionDeclaration>,
+  ]);
 
   const params: t.Identifier[] = [];
   for (const param of node.params) {
@@ -138,15 +141,20 @@ function plainFunction(
 }
 
 export default function wrapFunction(
-  path: NodePath,
-  callId: any,
+  path: NodePath<t.Function>,
+  callId: t.Expression,
   // TODO(Babel 8): Consider defaulting to false for spec compliancy
   noNewArrows: boolean = true,
   ignoreFunctionLength: boolean = false,
 ) {
   if (path.isMethod()) {
     classOrObjectMethod(path, callId);
   } else {
-    plainFunction(path, callId, noNewArrows, ignoreFunctionLength);
+    plainFunction(
+      path as NodePath<Exclude<t.Function, t.Method>>,
+      callId,
+      noNewArrows,
+      ignoreFunctionLength,
+    );
   }
 }
diff --git a/packages/babel-plugin-bugfix-v8-spread-parameters-in-optional-chaining/src/util.ts b/packages/babel-plugin-bugfix-v8-spread-parameters-in-optional-chaining/src/util.ts
@@ -24,17 +24,15 @@ export function shouldTransform(
 ): boolean {
   let optionalPath: NodePath<t.Expression> = path;
   const chains = [];
-  while (
-    optionalPath.isOptionalMemberExpression() ||
-    optionalPath.isOptionalCallExpression()
-  ) {
-    const { node } = optionalPath;
-    chains.push(node);
-
+  for (;;) {
     if (optionalPath.isOptionalMemberExpression()) {
       optionalPath = skipTransparentExprWrappers(optionalPath.get("object"));
+      chains.push(optionalPath.node);
     } else if (optionalPath.isOptionalCallExpression()) {
       optionalPath = skipTransparentExprWrappers(optionalPath.get("callee"));
+      chains.push(optionalPath.node);
+    } else {
+      break;
     }
   }
   for (let i = 0; i < chains.length; i++) {

diff --git a/packages/babel-plugin-proposal-class-static-block/src/index.ts b/packages/babel-plugin-proposal-class-static-block/src/index.ts
@@ -49,10 +49,7 @@ export default declare(({ types: t, template, assertVersion }) => {
         const body = classBody.get("body");
         for (const path of body) {
           if (path.isPrivate()) {
-            privateNames.add(
-              // @ts-expect-error TS can't infer that NodePath<t.ClassBody[body][number]> & NodePath<t.Private> equals to NodePath<t.ClassBody[body][number] & isPrivate>
-              path.get("key.id").node.name,
-            );
+            privateNames.add(path.get("key.id").node.name);
           }
         }
         for (const path of body) {

diff --git a/packages/babel-plugin-proposal-decorators/src/transformer-2021-12.ts b/packages/babel-plugin-proposal-decorators/src/transformer-2021-12.ts
@@ -685,10 +685,10 @@ function transformClass(
 
           const replaceSupers = new ReplaceSupers({
             constantSuper,
-            methodPath: element,
+            methodPath: element as NodePath<t.ClassPrivateMethod>,
             objectRef: classLocal,
             superRef: path.node.superClass,
-            file: state,
+            file: state.file,
             refToPreserve: classLocal,
           });
 

diff --git a/packages/babel-plugin-proposal-object-rest-spread/src/index.ts b/packages/babel-plugin-proposal-object-rest-spread/src/index.ts
@@ -243,7 +243,9 @@ export default declare((api, opts: Options) => {
 
   function replaceRestElement(
     parentPath: NodePath<t.Function | t.CatchClause>,
-    paramPath: Param | NodePath<t.AssignmentPattern["left"]>,
+    paramPath: NodePath<
+      t.Function["params"][number] | t.AssignmentPattern["left"]
+    >,
     container?: t.VariableDeclaration[],
   ): void {
     if (paramPath.isAssignmentPattern()) {
@@ -255,12 +257,7 @@ export default declare((api, opts: Options) => {
       const elements = paramPath.get("elements");
 
       for (let i = 0; i < elements.length; i++) {
-        replaceRestElement(
-          parentPath,
-          // @ts-expect-error Fixme: handle TSAsExpression
-          elements[i],
-          container,
-        );
+        replaceRestElement(parentPath, elements[i], container);
       }
     }
 

diff --git a/packages/babel-plugin-transform-typescript/src/enum.ts b/packages/babel-plugin-transform-typescript/src/enum.ts
@@ -156,10 +156,7 @@ export function translateEnumValues(
       } else {
         const initializerPath = memberPath.get("initializer");
 
-        if (
-          initializerPath.isIdentifier() &&
-          initializerPath.isReferencedIdentifier()
-        ) {
+        if (initializerPath.isReferencedIdentifier()) {
           ReferencedIdentifier(initializerPath, {
             t,
             seen,

diff --git a/packages/babel-traverse/scripts/generators/validators.js b/packages/babel-traverse/scripts/generators/validators.js
@@ -14,7 +14,7 @@ export interface NodePathValidators {
 `;
 
   for (const type of [...t.TYPES].sort()) {
-    output += `is${type}(opts?: object): this is NodePath<t.${type}>;`;
+    output += `is${type}<T extends t.Node>(this: NodePath<T>, opts?: object): this is NodePath<T & t.${type}>;`;
   }
 
   for (const type of Object.keys(virtualTypes)) {
@@ -24,9 +24,9 @@ export interface NodePathValidators {
     const { types } = virtualTypes[type];
     if (type[0] === "_") continue;
     if (t.NODE_FIELDS[type] || t.FLIPPED_ALIAS_KEYS[type]) {
-      output += `is${type}(opts?: object): this is NodePath<t.${type}>;`;
+      output += `is${type}<T extends t.Node>(this: NodePath<T>, opts?: object): this is NodePath<T & t.${type}>;`;
     } else if (types /* in VirtualTypeAliases */) {
-      output += `is${type}(opts?: object): this is NodePath<VirtualTypeAliases["${type}"]>;`;
+      output += `is${type}<T extends t.Node>(this: NodePath<T>, opts?: object): this is NodePath<T & VirtualTypeAliases["${type}"]>;`;
     } else if (type === "Pure") {
       output += `isPure(constantsOnly?: boolean): boolean;`;
     } else {