Refactor: rename head -> preanalysis

qnighy · qnighy · commit 6a346a1cab4e · 2023-03-24T17:44:48.000+09:00
diff --git a/src/analysis.ts b/src/analysis.ts
@@ -8,15 +8,15 @@ import { getAndDelete } from "./utils.js";
 import { analyzeProps, PropsObjAnalysis } from "./analysis/prop.js";
 import { LocalManager, RemovableNode } from "./analysis/local.js";
 import { analyzeUserDefined, UserDefinedAnalysis } from "./analysis/user_defined.js";
-import { ComponentHead } from "./analysis/head.js";
+import { PreAnalysisResult } from "./analysis/head.js";
 
 export { AnalysisError } from "./analysis/error.js";
 
 export type { LibRef } from "./analysis/lib.js";
 export type {
-  ComponentHead
+  PreAnalysisResult
 } from "./analysis/head.js";
-export { analyzeHead } from "./analysis/head.js";
+export { preanalyzeClass } from "./analysis/head.js";
 export type { LocalManager } from "./analysis/local.js";
 export type { StateObjAnalysis } from "./analysis/state.js";
 export type { PropsObjAnalysis } from "./analysis/prop.js";
@@ -40,7 +40,7 @@ export type ComponentBody = {
 
 export function analyzeBody(
   path: NodePath<ClassDeclaration>,
-  head: ComponentHead
+  preanalysis: PreAnalysisResult
 ): ComponentBody {
   const locals = new LocalManager(path);
   const { thisFields: sites, staticFields } = analyzeThisFields(path);
@@ -50,7 +50,7 @@ export function analyzeBody(
 
   const stateObjSites = getAndDelete(sites, "state") ?? [];
   const setStateSites = getAndDelete(sites, "setState") ?? [];
-  const states = analyzeState(stateObjSites, setStateSites, locals, head);
+  const states = analyzeState(stateObjSites, setStateSites, locals, preanalysis);
 
   const renderSites = getAndDelete(sites, "render") ?? [];
 
@@ -78,7 +78,7 @@ export function analyzeBody(
   if (!renderPath) {
     throw new AnalysisError(`Missing render method`);
   }
-  const props = analyzeProps(propsObjSites, defaultPropsObjSites, locals, head);
+  const props = analyzeProps(propsObjSites, defaultPropsObjSites, locals, preanalysis);
   for (const [name, propAnalysis] of props.props) {
     if (propAnalysis.needsAlias) {
       propAnalysis.newAliasName = locals.newLocal(
diff --git a/src/analysis/head.ts b/src/analysis/head.ts
@@ -3,7 +3,7 @@ import type { BlockStatement, ClassDeclaration, Identifier, Program, TSInterface
 import { memberName, nonNullPath } from "../utils.js";
 import { analyzeLibRef, isReactRef, LibRef } from "./lib.js";
 
-export type ComponentHead = {
+export type PreAnalysisResult = {
   name?: Identifier | undefined;
   typeParameters?: NodePath<TSTypeParameterDeclaration> | undefined;
   superClassRef: LibRef;
@@ -13,7 +13,7 @@ export type ComponentHead = {
   states: Map<string, NodePath<TSPropertySignature | TSMethodSignature>>;
 };
 
-export function analyzeHead(path: NodePath<ClassDeclaration>): ComponentHead | undefined {
+export function preanalyzeClass(path: NodePath<ClassDeclaration>): PreAnalysisResult | undefined {
   if (path.node.leadingComments?.some((comment) => /react-declassify-disable/.test(comment.value))) {
     // Explicitly disabled
     return;
diff --git a/src/analysis/prop.ts b/src/analysis/prop.ts
@@ -6,7 +6,7 @@ import { AnalysisError } from "./error.js";
 import type { LocalManager } from "./local.js";
 import { StaticFieldSite, ThisFieldSite } from "./this_fields.js";
 import { trackMember } from "./track_member.js";
-import { ComponentHead } from "./head.js";
+import { PreAnalysisResult } from "./head.js";
 
 export type PropsObjAnalysis = {
   hasDefaults: boolean;
@@ -58,7 +58,7 @@ export function analyzeProps(
   propsObjSites: ThisFieldSite[],
   defaultPropsObjSites: StaticFieldSite[],
   locals: LocalManager,
-  head: ComponentHead,
+  preanalysis: PreAnalysisResult,
 ): PropsObjAnalysis {
   const defaultProps = analyzeDefaultProps(defaultPropsObjSites);
   const newObjSites: PropsObjSite[] = [];
@@ -93,7 +93,7 @@ export function analyzeProps(
       }
     }
   }
-  for (const [name, propTyping] of head.propsEach) {
+  for (const [name, propTyping] of preanalysis.propsEach) {
     getProp(name).typing = propTyping;
   }
   if (defaultProps) {
diff --git a/src/analysis/state.ts b/src/analysis/state.ts
@@ -2,7 +2,7 @@ import type { NodePath } from "@babel/core";
 import type { CallExpression, Expression, Identifier, ObjectProperty, RestElement, TSType } from "@babel/types";
 import { getOr, memberName } from "../utils.js";
 import { AnalysisError } from "./error.js";
-import { ComponentHead } from "./head.js";
+import { PreAnalysisResult } from "./head.js";
 import type { LocalManager } from "./local.js";
 import type { ThisFieldSite } from "./this_fields.js";
 import { trackMember } from "./track_member.js";
@@ -47,7 +47,7 @@ export function analyzeState(
   stateObjSites: ThisFieldSite[],
   setStateSites: ThisFieldSite[],
   locals: LocalManager,
-  head: ComponentHead,
+  preanalysis: PreAnalysisResult,
 ): StateObjAnalysis {
   const states = new Map<string, StateAnalysis>();
   const getState = (name: string) => getOr(states, name, () => ({
@@ -151,7 +151,7 @@ export function analyzeState(
       throw new AnalysisError(`Non-analyzable setState`);
     }
   }
-  for (const [name, stateType] of head.states) {
+  for (const [name, stateType] of preanalysis.states) {
     const state = getState(name);
     if (stateType.isTSPropertySignature()) {
       const annot = stateType.get("typeAnnotation");
diff --git a/src/index.ts b/src/index.ts
@@ -1,7 +1,7 @@
 import type { ArrowFunctionExpression, ClassMethod, ClassPrivateMethod, Expression, FunctionDeclaration, FunctionExpression, Identifier, ImportDeclaration, MemberExpression, ObjectMethod, Pattern, RestElement, Statement, TSEntityName, TSType, TSTypeAnnotation, TSTypeParameterDeclaration, VariableDeclaration } from "@babel/types";
 import type { NodePath, PluginObj, PluginPass } from "@babel/core";
 import { assignReturnType, assignTypeAnnotation, assignTypeArguments, assignTypeParameters, importName, isTS, nonNullPath } from "./utils.js";
-import { AnalysisError, analyzeBody, analyzeHead, ComponentBody, ComponentHead, needsProps, LibRef } from "./analysis.js";
+import { AnalysisError, analyzeBody, preanalyzeClass, ComponentBody, PreAnalysisResult, needsProps, LibRef } from "./analysis.js";
 
 type Options = {};
 
@@ -12,15 +12,15 @@ export default function plugin(babel: typeof import("@babel/core")): PluginObj<P
     visitor: {
       ClassDeclaration(path, state) {
         const ts = isTS(state);
-        const head = analyzeHead(path);
-        if (!head) {
+        const preanalysis = preanalyzeClass(path);
+        if (!preanalysis) {
           return;
         }
         if (path.parentPath.isExportDefaultDeclaration()) {
           const declPath = path.parentPath;
           try {
-            const body = analyzeBody(path, head);
-            const { funcNode, typeNode } = transformClass(head, body, { ts }, babel);
+            const body = analyzeBody(path, preanalysis);
+            const { funcNode, typeNode } = transformClass(preanalysis, body, { ts }, babel);
             if (path.node.id) {
               // Necessary to avoid false error regarding duplicate declaration.
               path.scope.removeBinding(path.node.id.name);
@@ -47,8 +47,8 @@ export default function plugin(babel: typeof import("@babel/core")): PluginObj<P
           }
         } else {
           try {
-            const body = analyzeBody(path, head);
-            const { funcNode, typeNode } = transformClass(head, body, { ts }, babel);
+            const body = analyzeBody(path, preanalysis);
+            const { funcNode, typeNode } = transformClass(preanalysis, body, { ts }, babel);
             // Necessary to avoid false error regarding duplicate declaration.
             path.scope.removeBinding(path.node.id.name);
             path.replaceWith(
@@ -77,7 +77,7 @@ type TransformResult = {
   typeNode?: TSType | undefined;
 };
 
-function transformClass(head: ComponentHead, body: ComponentBody, options: { ts: boolean }, babel: typeof import("@babel/core")): TransformResult {
+function transformClass(preanalysis: PreAnalysisResult, body: ComponentBody, options: { ts: boolean }, babel: typeof import("@babel/core")): TransformResult {
   const { types: t } = babel;
   const { ts } = options;
 
@@ -207,7 +207,7 @@ function transformClass(head: ComponentHead, body: ComponentBody, options: { ts:
   for (const field of body.state.values()) {
     // State declarations
     const call = t.callExpression(
-      getReactImport("useState", babel, head.superClassRef),
+      getReactImport("useState", babel, preanalysis.superClassRef),
       field.init ? [field.init.valuePath.node] : []
     );
     preamble.push(t.variableDeclaration("const", [
@@ -266,7 +266,7 @@ function transformClass(head: ComponentHead, body: ComponentBody, options: { ts:
     } else if (field.type === "user_defined_ref") {
       // const foo = useRef(null);
       const call = t.callExpression(
-        getReactImport("useRef", babel, head.superClassRef),
+        getReactImport("useRef", babel, preanalysis.superClassRef),
         [t.nullLiteral()]
       );
       preamble.push(t.variableDeclaration(
@@ -286,7 +286,7 @@ function transformClass(head: ComponentHead, body: ComponentBody, options: { ts:
     } else if (field.type === "user_defined_direct_ref") {
       // const foo = useRef(init);
       const call = t.callExpression(
-        getReactImport("useRef", babel, head.superClassRef),
+        getReactImport("useRef", babel, preanalysis.superClassRef),
         [field.init.node]
       );
       preamble.push(t.variableDeclaration(
@@ -309,26 +309,26 @@ function transformClass(head: ComponentHead, body: ComponentBody, options: { ts:
   bodyNode.body.splice(0, 0, ...preamble);
   // recast is not smart enough to correctly pretty-print type parameters for arrow functions.
   // so we fall back to functions when type parameters are present.
-  const functionNeeded = head.isPure || !!head.typeParameters;
+  const functionNeeded = preanalysis.isPure || !!preanalysis.typeParameters;
   const params = needsProps(body)
     ? [assignTypeAnnotation(
         t.identifier("props"),
         // If the function is generic, put type annotations here instead of the `const` to be defined.
         // TODO: take children into account, while being careful about difference between `@types/react` v17 and v18
-        head.typeParameters
-        ? head.props
-          ? t.tsTypeAnnotation(head.props.node)
+        preanalysis.typeParameters
+        ? preanalysis.props
+          ? t.tsTypeAnnotation(preanalysis.props.node)
           : undefined
         : undefined
       )]
     : [];
   // If the function is generic, put type annotations here instead of the `const` to be defined.
-  const returnType = head.typeParameters
+  const returnType = preanalysis.typeParameters
       // Construct `React.ReactElement | null`
     ? t.tsTypeAnnotation(
         t.tsUnionType([
           t.tsTypeReference(
-            toTSEntity(getReactImport("ReactElement", babel, head.superClassRef), babel)
+            toTSEntity(getReactImport("ReactElement", babel, preanalysis.superClassRef), babel)
           ),
           t.tsNullKeyword(),
         ])
@@ -338,7 +338,7 @@ function transformClass(head: ComponentHead, body: ComponentBody, options: { ts:
     assignReturnType(
       functionNeeded
         ? t.functionExpression(
-          head.name ? t.cloneNode(head.name) : undefined,
+          preanalysis.name ? t.cloneNode(preanalysis.name) : undefined,
           params,
           bodyNode
         )
@@ -348,20 +348,20 @@ function transformClass(head: ComponentHead, body: ComponentBody, options: { ts:
         ),
       returnType
     ),
-    head.typeParameters?.node
+    preanalysis.typeParameters?.node
   );
   return {
-    funcNode: head.isPure
+    funcNode: preanalysis.isPure
       ? t.callExpression(
-          getReactImport("memo", babel, head.superClassRef),
+          getReactImport("memo", babel, preanalysis.superClassRef),
           [funcNode]
         )
       : funcNode,
-    typeNode: ts && !head.typeParameters
+    typeNode: ts && !preanalysis.typeParameters
       ? t.tsTypeReference(
-        toTSEntity(getReactImport("FC", babel, head.superClassRef), babel),
-        head.props
-        ? t.tsTypeParameterInstantiation([head.props.node])
+        toTSEntity(getReactImport("FC", babel, preanalysis.superClassRef), babel),
+        preanalysis.props
+        ? t.tsTypeParameterInstantiation([preanalysis.props.node])
         : null
       )
       : undefined,

Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@ import { AnalysisError } from "./error.js";`
`6`	`6`	`import type { LocalManager } from "./local.js";`
`7`	`7`	`import { StaticFieldSite, ThisFieldSite } from "./this_fields.js";`
`8`	`8`	`import { trackMember } from "./track_member.js";`
`9`		`-import { ComponentHead } from "./head.js";`
	`9`	`+import { PreAnalysisResult } from "./head.js";`
`10`	`10`
`11`	`11`	`export type PropsObjAnalysis = {`
`12`	`12`	`hasDefaults: boolean;`
`@@ -58,7 +58,7 @@ export function analyzeProps(`
`58`	`58`	`propsObjSites: ThisFieldSite[],`
`59`	`59`	`defaultPropsObjSites: StaticFieldSite[],`
`60`	`60`	`locals: LocalManager,`
`61`		`- head: ComponentHead,`
	`61`	`+ preanalysis: PreAnalysisResult,`
`62`	`62`	`): PropsObjAnalysis {`
`63`	`63`	`const defaultProps = analyzeDefaultProps(defaultPropsObjSites);`
`64`	`64`	`const newObjSites: PropsObjSite[] = [];`
`@@ -93,7 +93,7 @@ export function analyzeProps(`
`93`	`93`	`}`
`94`	`94`	`}`
`95`	`95`	`}`
`96`		`- for (const [name, propTyping] of head.propsEach) {`
	`96`	`+ for (const [name, propTyping] of preanalysis.propsEach) {`
`97`	`97`	`getProp(name).typing = propTyping;`
`98`	`98`	`}`
`99`	`99`	`if (defaultProps) {`