Add soft errors

Author: qnighy

CHANGELOG.md

@@ -1,5 +1,11 @@
 ## Unreleased
 
+- Added
+  - Implemented soft errors.
+    - From this version onward, it will try to generate special variables like `TODO_this` to indicate errors and continue transformation.
+    - It allows you to automate more transformation while using manual rewriting when necessary.
+    - Not all errors are soft errors, but we will continue to make as many errors soft errors as possible.
+
 ## 0.1.10
 
 - Misc

README.md

@@ -161,6 +161,16 @@ export const C = props => {
 };
 ```
 
+## Errors
+
+Hard errors are indicated by `/* react-declassify-disable Cannot perform transformation */`.
+
+Soft errors are indicated by special variable names including:
+
+- `TODO_this`
+
+Hard errors stop transformation of the whole class while stop errors do not. You need to fix the errors to conclude transformation.
+
 ## Configuration
 
 ### Disabling transformation

src/analysis.ts

@@ -8,7 +8,7 @@ import type {
   TSType,
   TSTypeParameterDeclaration,
 } from "@babel/types";
-import { AnalysisError } from "./analysis/error.js";
+import { AnalysisError, SoftErrorRepository } from "./analysis/error.js";
 import { BindThisSite, analyzeClassFields } from "./analysis/class_fields.js";
 import { analyzeState, StateObjAnalysis } from "./analysis/state.js";
 import { getAndDelete } from "./utils.js";
@@ -23,7 +23,7 @@ import type { PreAnalysisResult } from "./analysis/pre.js";
 import type { LibRef } from "./analysis/lib.js";
 import { EffectAnalysis, analyzeEffects } from "./analysis/effect.js";
 
-export { AnalysisError } from "./analysis/error.js";
+export { AnalysisError, SoftErrorRepository } from "./analysis/error.js";
 
 export type { LibRef } from "./analysis/lib.js";
 export type { PreAnalysisResult } from "./analysis/pre.js";
@@ -63,14 +63,15 @@ export type AnalysisResult = {
 
 export function analyzeClass(
   path: NodePath<ClassDeclaration>,
-  preanalysis: PreAnalysisResult
+  preanalysis: PreAnalysisResult,
+  softErrors: SoftErrorRepository
 ): AnalysisResult {
   const locals = new LocalManager(path);
   const {
     instanceFields: sites,
     staticFields,
     bindThisSites,
-  } = analyzeClassFields(path);
+  } = analyzeClassFields(path, softErrors);
 
   const propsObjAnalysis = getAndDelete(sites, "props") ?? { sites: [] };
   const defaultPropsObjAnalysis = getAndDelete(
@@ -84,6 +85,7 @@ export function analyzeClass(
     stateObjAnalysis,
     setStateAnalysis,
     locals,
+    softErrors,
     preanalysis
   );
 
@@ -102,8 +104,10 @@ export function analyzeClass(
   analyzeOuterCapturings(path, locals);
   let renderPath: NodePath<ClassMethod> | undefined = undefined;
   {
-    if (renderAnalysis.sites.some((site) => site.type === "expr")) {
-      throw new AnalysisError(`do not use this.render`);
+    for (const site of renderAnalysis.sites) {
+      if (site.type === "expr") {
+        softErrors.addThisError(site.thisPath);
+      }
     }
     const init = renderAnalysis.sites.find((site) => site.init);
     if (init) {
@@ -112,7 +116,7 @@ export function analyzeClass(
       }
     }
   }
-  const userDefined = analyzeUserDefined(sites);
+  const userDefined = analyzeUserDefined(sites, softErrors);
   for (const [name] of staticFields) {
     if (!SPECIAL_STATIC_NAMES.has(name)) {
       throw new AnalysisError(`Cannot transform static ${name}`);
@@ -127,6 +131,7 @@ export function analyzeClass(
     propsObjAnalysis,
     defaultPropsObjAnalysis,
     locals,
+    softErrors,
     preanalysis
   );
   postAnalyzeCallbackDependencies(userDefined, props, states, sites);

src/analysis/class_fields.ts

@@ -32,7 +32,7 @@ import {
   memberRefName,
   nonNullPath,
 } from "../utils.js";
-import { AnalysisError } from "./error.js";
+import { AnalysisError, SoftErrorRepository } from "./error.js";
 
 /**
  * Aggregated result of class field analysis.
@@ -103,6 +103,7 @@ export type ClassFieldExprSite = {
    * The node that accesses the field (both read and write)
    */
   path: NodePath<MemberExpression>;
+  thisPath: NodePath<ThisExpression>;
   owner: string | undefined;
   typing: undefined;
   init: undefined;
@@ -168,7 +169,8 @@ export type BindThisSite = {
  * - Static fields ... `C.foo`, where `C` is the class
  */
 export function analyzeClassFields(
-  path: NodePath<ClassDeclaration>
+  path: NodePath<ClassDeclaration>,
+  softErrors: SoftErrorRepository
 ): ClassFieldsAnalysis {
   const instanceFields = new Map<string, ClassFieldAnalysis>();
   const getInstanceField = (name: string) =>
@@ -188,7 +190,12 @@ export function analyzeClassFields(
       const isStatic = itemPath.node.static;
       const name = memberName(itemPath.node);
       if (name == null) {
-        throw new AnalysisError(`Unnamed class element`);
+        if (isStatic) {
+          throw new AnalysisError(`Unnamed class element`);
+        } else {
+          softErrors.addDeclError(itemPath);
+          continue;
+        }
       }
       const field = isStatic ? getStaticField(name) : getInstanceField(name);
       if (isClassPropertyLike(itemPath)) {
@@ -405,12 +412,14 @@ export function analyzeClassFields(
           });
           return;
         }
-        throw new AnalysisError(`Stray this`);
+        softErrors.addThisError(thisPath);
+        return;
       }
 
       const name = memberRefName(thisMemberPath.node);
       if (name == null) {
-        throw new AnalysisError(`Unrecognized this-property reference`);
+        softErrors.addThisError(thisPath);
+        return;
       }
 
       const field = getInstanceField(name)!;
@@ -431,6 +440,7 @@ export function analyzeClassFields(
         type: "expr",
         owner,
         path: thisMemberPath,
+        thisPath,
         typing: undefined,
         init: undefined,
         hasWrite,
@@ -521,6 +531,25 @@ export function analyzeClassFields(
   return { instanceFields, staticFields, bindThisSites };
 }
 
+export function addClassFieldError(
+  site: ClassFieldSite,
+  softErrors: SoftErrorRepository
+) {
+  if (site.type === "decl") {
+    if (isNamedClassElement(site.path)) {
+      softErrors.addDeclError(site.path);
+    } else if (site.path.isAssignmentExpression()) {
+      const left = site.path.get("left") as NodePath<MemberExpression>;
+      const object = left.get("object") as NodePath<ThisExpression>;
+      softErrors.addThisError(object);
+    } else {
+      throw new Error(`Unreachable: invalid type: ${site.path.node.type}`);
+    }
+  } else {
+    softErrors.addThisError(site.thisPath);
+  }
+}
+
 function traverseThis(
   path: NodePath,
   visit: (path: NodePath<ThisExpression>) => void

src/analysis/error.ts

@@ -1,3 +1,56 @@
+import type { NodePath } from "@babel/traverse";
+import type {
+  ClassAccessorProperty,
+  ClassMethod,
+  ClassPrivateMethod,
+  ClassPrivateProperty,
+  ClassProperty,
+  TSDeclareMethod,
+  ThisExpression,
+} from "@babel/types";
+
+export type SoftError = SoftErrorThisExpr | SoftErrorDecl;
+export type SoftErrorThisExpr = {
+  type: "invalid_this";
+  path: NodePath<ThisExpression>;
+};
+export type SoftErrorDecl = {
+  type: "invalid_decl";
+  path: NodePath<
+    | ClassProperty
+    | ClassPrivateProperty
+    | ClassMethod
+    | ClassPrivateMethod
+    | TSDeclareMethod
+    | ClassAccessorProperty
+  >;
+};
+
+export class SoftErrorRepository {
+  errors: SoftError[] = [];
+  addThisError(thisPath: NodePath<ThisExpression>) {
+    this.errors.push({
+      type: "invalid_this",
+      path: thisPath,
+    });
+  }
+  addDeclError(
+    declPath: NodePath<
+      | ClassProperty
+      | ClassPrivateProperty
+      | ClassMethod
+      | ClassPrivateMethod
+      | TSDeclareMethod
+      | ClassAccessorProperty
+    >
+  ) {
+    this.errors.push({
+      type: "invalid_decl",
+      path: declPath,
+    });
+  }
+}
+
 export class AnalysisError extends Error {
   static {
     this.prototype.name = "AnalysisError";

src/analysis/prop.ts

@@ -7,9 +7,9 @@ import type {
   TSPropertySignature,
 } from "@babel/types";
 import { getOr, memberName } from "../utils.js";
-import { AnalysisError } from "./error.js";
+import { AnalysisError, SoftErrorRepository } from "./error.js";
 import type { LocalManager } from "./local.js";
-import { ClassFieldAnalysis } from "./class_fields.js";
+import { ClassFieldAnalysis, addClassFieldError } from "./class_fields.js";
 import { trackMember } from "./track_member.js";
 import { PreAnalysisResult } from "./pre.js";
 
@@ -67,6 +67,7 @@ export function analyzeProps(
   propsObjAnalysis: ClassFieldAnalysis,
   defaultPropsObjAnalysis: ClassFieldAnalysis,
   locals: LocalManager,
+  softErrors: SoftErrorRepository,
   preanalysis: PreAnalysisResult
 ): PropsObjAnalysis {
   const defaultProps = analyzeDefaultProps(defaultPropsObjAnalysis);
@@ -80,7 +81,8 @@ export function analyzeProps(
 
   for (const site of propsObjAnalysis.sites) {
     if (site.type !== "expr" || site.hasWrite) {
-      throw new AnalysisError(`Invalid use of this.props`);
+      addClassFieldError(site, softErrors);
+      continue;
     }
     const memberAnalysis = trackMember(site.path);
     const parentSite: PropsObjSite = {
@@ -89,8 +91,8 @@ export function analyzeProps(
       decomposedAsAliases: false,
       child: undefined,
     };
-    newObjSites.push(parentSite);
     if (memberAnalysis.fullyDecomposed && memberAnalysis.memberAliases) {
+      newObjSites.push(parentSite);
       for (const [name, aliasing] of memberAnalysis.memberAliases) {
         getProp(name).aliases.push({
           scope: aliasing.scope,
@@ -102,10 +104,10 @@ export function analyzeProps(
       parentSite.decomposedAsAliases = true;
     } else {
       if (defaultProps && !memberAnalysis.memberExpr) {
-        throw new AnalysisError(
-          `Non-analyzable this.props in presence of defaultProps`
-        );
+        addClassFieldError(site, softErrors);
+        continue;
       }
+      newObjSites.push(parentSite);
       if (memberAnalysis.memberExpr) {
         const child: PropSite = {
           path: memberAnalysis.memberExpr.path,
@@ -145,7 +147,7 @@ function analyzeDefaultProps(
 ): Map<string, NodePath<Expression>> | undefined {
   for (const site of defaultPropsAnalysis.sites) {
     if (!site.init) {
-      throw new AnalysisError(`Invalid use of static defaultState`);
+      throw new AnalysisError(`Invalid use of static defaultProps`);
     }
   }