Simplify parser errors creation (#15884)

* Simplify parser errors creation

* Better type for `code`

packages/babel-parser/src/parse-error.ts

@@ -1,14 +1,18 @@
 import { Position } from "./util/location";
-import {
-  instantiate,
-  ParseErrorCode,
-  type ParseErrorCredentials,
-  type ToMessage,
-  type SyntaxPlugin,
-} from "./parse-error/credentials";
 import type { Undone } from "./parser/node";
 import type { Node } from "./types";
 
+type SyntaxPlugin =
+  | "flow"
+  | "typescript"
+  | "jsx"
+  | "pipelineOperator"
+  | "placeholders";
+
+type ParseErrorCode =
+  | "BABEL_PARSER_SYNTAX_ERROR"
+  | "BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED";
+
 // Babel uses "normal" SyntaxErrors for it's errors, but adds some extra
 // functionality. This functionality is defined in the
 // `ParseErrorSpecification` interface below. We may choose to change to someday
@@ -47,6 +51,23 @@ export type ParseErrorConstructor<ErrorDetails> = (a: {
   details: ErrorDetails;
 }) => ParseError<ErrorDetails>;
 
+type ToMessage<ErrorDetails> = (self: ErrorDetails) => string;
+
+type ParseErrorCredentials<ErrorDetails> = {
+  code: string;
+  reasonCode: string;
+  syntaxPlugin?: SyntaxPlugin;
+  toMessage: ToMessage<ErrorDetails>;
+};
+
+function defineHidden(obj: object, key: string, value: unknown) {
+  Object.defineProperty(obj, key, {
+    enumerable: false,
+    configurable: true,
+    value,
+  });
+}
+
 function toParseErrorConstructor<ErrorDetails extends object>({
   toMessage,
   ...properties
@@ -57,53 +78,48 @@ function toParseErrorConstructor<ErrorDetails extends object>({
   };
 
   return function constructor({ loc, details }: ConstructorArgument) {
-    return instantiate(
-      SyntaxError,
-      { ...properties, loc },
-      {
-        clone(
-          overrides: {
-            loc?: Position;
-            details?: ErrorDetails;
-          } = {},
-        ) {
-          const loc = (overrides.loc || {}) as Partial<Position>;
-          return constructor({
-            loc: new Position(
-              "line" in loc ? loc.line : this.loc.line,
-              "column" in loc ? loc.column : this.loc.column,
-              "index" in loc ? loc.index : this.loc.index,
-            ),
-            details: { ...this.details, ...overrides.details },
-          });
-        },
-        details: { value: details, enumerable: false },
-        message: {
-          get(this: ConstructorArgument): string {
-            return `${toMessage(this.details)} (${this.loc.line}:${
-              this.loc.column
-            })`;
-          },
-          set(value: string) {
-            Object.defineProperty(this, "message", { value });
-          },
-        },
-        pos: { reflect: "loc.index", enumerable: true },
-        missingPlugin: "missingPlugin" in details && {
-          reflect: "details.missingPlugin",
-          enumerable: true,
-        },
+    const error = new SyntaxError();
+    Object.assign(error, properties, { loc, pos: loc.index });
+    if ("missingPlugin" in details) {
+      Object.assign(error, { missingPlugin: details.missingPlugin });
+    }
+
+    type Overrides = {
+      loc?: Position;
+      details?: ErrorDetails;
+    };
+    defineHidden(error, "clone", function clone(overrides: Overrides = {}) {
+      const { line, column, index } = overrides.loc ?? loc;
+      return constructor({
+        loc: new Position(line, column, index),
+        details: { ...details, ...overrides.details },
+      });
+    });
+
+    defineHidden(error, "details", details);
+
+    Object.defineProperty(error, "message", {
+      configurable: true,
+      get(this: ParseError<ErrorDetails>): string {
+        const message = `${toMessage(details)} (${loc.line}:${loc.column})`;
+        this.message = message;
+        return message;
       },
-    ) as ParseError<ErrorDetails>;
+      set(value: string) {
+        Object.defineProperty(this, "message", { value, writable: true });
+      },
+    });
+
+    return error as ParseError<ErrorDetails>;
   };
 }
 
 type ParseErrorTemplate =
   | string
   | ToMessage<any>
-  | { message: string | ToMessage<any> };
+  | { message: string | ToMessage<any>; code?: ParseErrorCode };
 
-type ParseErrorTemplates = { [reasonCode: string]: ParseErrorTemplate };
+export type ParseErrorTemplates = { [reasonCode: string]: ParseErrorTemplate };
 
 // This is the templated form of `ParseErrorEnum`.
 //
@@ -156,7 +172,7 @@ export function ParseErrorEnum<T extends ParseErrorTemplates>(
 //   ErrorWithDynamicMessage: ({ type } : { type: string }) => `${type}`),
 //   ErrorWithOverriddenCodeAndOrReasonCode: {
 //     message: ({ type }: { type: string }) => `${type}`),
-//     code: ParseErrorCode.SourceTypeModuleError,
+//     code: "AN_ERROR_CODE",
 //     ...(BABEL_8_BREAKING ? { } : { reasonCode: "CustomErrorReasonCode" })
 //   }
 // });
@@ -189,7 +205,7 @@ export function ParseErrorEnum(
     const toMessage = typeof message === "string" ? () => message : message;
 
     ParseErrorConstructors[reasonCode] = toParseErrorConstructor({
-      code: ParseErrorCode.SyntaxError,
+      code: "BABEL_PARSER_SYNTAX_ERROR",
       reasonCode,
       toMessage,
       ...(syntaxPlugin ? { syntaxPlugin } : {}),
@@ -217,5 +233,3 @@ export const Errors = {
 };
 
 export type { LValAncestor } from "./parse-error/standard-errors";
-
-export * from "./parse-error/credentials";

packages/babel-parser/src/parse-error/module-errors.ts

@@ -1,12 +1,14 @@
-import { ParseErrorCode } from "../parse-error";
+import type { ParseErrorTemplates } from "../parse-error";
+
+const code = "BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED";
 
 export default {
   ImportMetaOutsideModule: {
     message: `import.meta may appear only with 'sourceType: "module"'`,
-    code: ParseErrorCode.SourceTypeModuleError,
+    code,
   },
   ImportOutsideModule: {
     message: `'import' and 'export' may appear only with 'sourceType: "module"'`,
-    code: ParseErrorCode.SourceTypeModuleError,
+    code,
   },
-};
+} satisfies ParseErrorTemplates;

packages/babel-parser/src/parse-error/pipeline-operator-errors.ts

@@ -1,3 +1,4 @@
+import type { ParseErrorTemplates } from "../parse-error";
 import toNodeDescription from "./to-node-description";
 
 export const UnparenthesizedPipeBodyDescriptions = new Set([
@@ -48,4 +49,4 @@ export default {
     "Topic reference was used in a lexical context without topic binding.",
   PrimaryTopicRequiresSmartPipeline:
     'Topic reference is used, but the pipelineOperator plugin was not passed a "proposal": "hack" or "smart" option.',
-};
+} satisfies ParseErrorTemplates;

packages/babel-parser/src/parse-error/standard-errors.ts

@@ -1,3 +1,4 @@
+import type { ParseErrorTemplates } from "../parse-error";
 import toNodeDescription from "./to-node-description";
 
 export type LValAncestor =
@@ -312,4 +313,4 @@ export default {
   YieldInParameter: "Yield expression is not allowed in formal parameters.",
   ZeroDigitNumericSeparator:
     "Numeric separator can not be used after leading 0.",
-};
+} satisfies ParseErrorTemplates;

packages/babel-parser/src/parse-error/strict-mode-errors.ts

@@ -1,3 +1,5 @@
+import type { ParseErrorTemplates } from "../parse-error";
+
 export default {
   StrictDelete: "Deleting local variable in strict mode.",
 
@@ -25,4 +27,4 @@ export default {
   StrictOctalLiteral: "Legacy octal literals are not allowed in strict mode.",
 
   StrictWith: "'with' in strict mode.",
-};
+} satisfies ParseErrorTemplates;