@reckona/mreact-compiler 0.0.66 → 0.0.68

package/src/ir.ts

@@ -0,0 +1,151 @@
+import type { SourceLocation } from "./types.js";
+
+export interface ModuleIr {
+  userImports: string[];
+  moduleStatements: string[];
+  moduleBindingNames: string[];
+  components: ComponentIr[];
+}
+
+export interface ComponentIr {
+  name: string;
+  exportName: string;
+  exported?: boolean;
+  exportDefault?: boolean;
+  async?: boolean;
+  parameters: string[];
+  bodyStatements: string[];
+  bindingNames: string[];
+  root: JsxNodeIr;
+}
+
+export type JsxNodeIr =
+  | JsxElementIr
+  | ComponentRefIr
+  | JsxFragmentIr
+  | ConditionalIr
+  | ListIr
+  | TextIr
+  | ExprIr
+  | AsyncBoundaryIr;
+
+export interface JsxElementIr {
+  kind: "element";
+  tagName: string;
+  keyCode?: string;
+  attributes: AttributeIr[];
+  children: JsxNodeIr[];
+}
+
+export interface ComponentRefIr {
+  kind: "component";
+  name: string;
+  loc?: SourceLocation;
+  runtime?: "compat";
+  async?: boolean;
+  clientReference?: ClientReferenceIr;
+  keyCode?: string;
+  props: ComponentPropIr[];
+  children: JsxNodeIr[];
+}
+
+export interface ClientReferenceIr {
+  moduleId: string;
+  exportName: string;
+}
+
+export type ComponentPropIr = ComponentNamedPropIr | ComponentRenderPropIr | ComponentSpreadPropIr;
+
+export interface ComponentNamedPropIr {
+  kind: "prop";
+  name: string;
+  code: string;
+}
+
+export interface ComponentRenderPropIr {
+  kind: "render-prop";
+  name: string;
+  valueName?: string;
+  children: JsxNodeIr[];
+}
+
+export interface ComponentSpreadPropIr {
+  kind: "spread-prop";
+  code: string;
+}
+
+export interface JsxFragmentIr {
+  kind: "fragment";
+  children: JsxNodeIr[];
+}
+
+export interface ConditionalIr {
+  kind: "conditional";
+  conditionCode: string;
+  whenTrue: JsxNodeIr[];
+  whenFalse: JsxNodeIr[];
+}
+
+export interface ListIr {
+  kind: "list";
+  itemsCode: string;
+  itemName: string;
+  indexName?: string;
+  keyCode?: string;
+  bodyStatements?: string[];
+  children: JsxNodeIr[];
+}
+
+export interface TextIr {
+  kind: "text";
+  value: string;
+}
+
+export interface ExprIr {
+  kind: "expr";
+  code: string;
+  renderMode?: "dynamic" | "html" | "react-node" | "stream-node";
+}
+
+export interface AsyncBoundaryIr {
+  kind: "async-boundary";
+  loc?: SourceLocation;
+  valueCode: string;
+  valueName: string;
+  children: JsxNodeIr[];
+  placeholderChildren?: JsxNodeIr[];
+  placeholderTagCode?: string;
+  catchName?: string;
+  catchChildren?: JsxNodeIr[];
+  awaitId?: string;
+}
+
+export type AttributeIr =
+  | StaticAttributeIr
+  | DynamicAttributeIr
+  | EventAttributeIr
+  | SpreadAttributeIr;
+
+export interface StaticAttributeIr {
+  kind: "static-attr";
+  name: string;
+  value: string;
+}
+
+export interface DynamicAttributeIr {
+  kind: "dynamic-attr";
+  name: string;
+  code: string;
+}
+
+export interface EventAttributeIr {
+  kind: "event";
+  name: string;
+  eventName: string;
+  code: string;
+}
+
+export interface SpreadAttributeIr {
+  kind: "spread-attr";
+  code: string;
+}

package/src/oxc-analysis-types.ts

@@ -0,0 +1,5 @@
+export type OxcBodyStatementJsxMode =
+  | "dom-node"
+  | "compat-object"
+  | "server-string"
+  | "unsupported";

package/src/oxc-await-analysis.ts

@@ -0,0 +1,165 @@
+import { readArray, readObject, readSource, unwrapOxcParentheses } from "./oxc-node-utils.js";
+
+const UNSERIALIZABLE_CONSTRUCTORS = new Set([
+  "Date",
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "RegExp",
+  "Error",
+]);
+
+const UNSERIALIZABLE_CALLEES = new Set(["Symbol", "BigInt"]);
+
+export function detectUnserializableAwaitValueReason(
+  expression: Record<string, unknown>,
+  bindings: ReadonlyMap<string, Record<string, unknown>> | undefined = undefined,
+  visited: Set<string> = new Set(),
+): string | undefined {
+  const type = String(expression.type ?? "");
+
+  if (type === "Identifier") {
+    if (bindings === undefined) {
+      return undefined;
+    }
+
+    const name = String(expression.name ?? "");
+
+    if (name === "" || visited.has(name)) {
+      return undefined;
+    }
+
+    const initializer = bindings.get(name);
+
+    if (initializer === undefined) {
+      return undefined;
+    }
+
+    visited.add(name);
+    return detectUnserializableAwaitValueReason(initializer, bindings, visited);
+  }
+
+  if (type === "NewExpression") {
+    const callee = readObject(expression.callee);
+    const calleeName = String(callee.name ?? "");
+
+    if (UNSERIALIZABLE_CONSTRUCTORS.has(calleeName)) {
+      return `new ${calleeName}() is not JSON-serializable`;
+    }
+  }
+
+  if (type === "CallExpression") {
+    const callee = readObject(expression.callee);
+
+    if (callee.type === "Identifier" && UNSERIALIZABLE_CALLEES.has(String(callee.name ?? ""))) {
+      return `${String(callee.name)}(...) returns a non-JSON-serializable primitive`;
+    }
+
+    if (
+      callee.type === "MemberExpression" &&
+      String(readObject(callee.object).name ?? "") === "Promise"
+    ) {
+      const property = readObject(callee.property);
+      const propertyName = String(property.name ?? "");
+
+      if (propertyName === "resolve" || propertyName === "all" || propertyName === "allSettled") {
+        const args = readArray(expression.arguments);
+        const firstArg = args[0];
+
+        if (firstArg !== undefined) {
+          const reason = detectUnserializableAwaitValueReason(
+            readObject(firstArg),
+            bindings,
+            visited,
+          );
+
+          if (reason !== undefined) {
+            return reason;
+          }
+        }
+      }
+    }
+  }
+
+  if (type === "FunctionExpression" || type === "ArrowFunctionExpression") {
+    return "function expressions cannot be JSON-serialized";
+  }
+
+  return undefined;
+}
+
+export function collectOxcVariableInitializers(
+  bodyStatements: readonly unknown[],
+): Map<string, Record<string, unknown>> {
+  const bindings = new Map<string, Record<string, unknown>>();
+
+  for (const statement of bodyStatements) {
+    const stmt = readObject(statement);
+
+    if (stmt.type !== "VariableDeclaration") {
+      continue;
+    }
+
+    for (const declarator of readArray(stmt.declarations)) {
+      const decl = readObject(declarator);
+
+      if (decl.type !== "VariableDeclarator") {
+        continue;
+      }
+
+      const id = readObject(decl.id);
+
+      if (id.type !== "Identifier") {
+        continue;
+      }
+
+      const init = decl.init;
+
+      if (init === null || init === undefined) {
+        continue;
+      }
+
+      const initObject = unwrapOxcParentheses(readObject(init));
+      const name = String(id.name ?? "");
+
+      if (name === "") {
+        continue;
+      }
+
+      bindings.set(name, initObject);
+    }
+  }
+
+  return bindings;
+}
+
+export function readOxcExpressionAttribute(
+  code: string,
+  attributes: readonly unknown[],
+  name: string,
+): string | undefined {
+  const expression = readOxcExpressionAttributeNode(attributes, name);
+  return expression === undefined ? undefined : readSource(code, expression);
+}
+
+export function readOxcExpressionAttributeNode(
+  attributes: readonly unknown[],
+  name: string,
+): Record<string, unknown> | undefined {
+  for (const attr of attributes) {
+    const object = readObject(attr);
+
+    if (object.type !== "JSXAttribute" || String(readObject(object.name).name) !== name) {
+      continue;
+    }
+
+    const value = readObject(object.value);
+
+    if (value.type === "JSXExpressionContainer") {
+      return unwrapOxcParentheses(readObject(value.expression));
+    }
+  }
+
+  return undefined;
+}

package/src/oxc-await-ids.ts

@@ -0,0 +1,62 @@
+import type { JsxNodeIr, ModuleIr } from "./ir.js";
+
+export function assignOxcAwaitIds(ir: ModuleIr): void {
+  let counter = 0;
+
+  for (const component of ir.components) {
+    counter = walkForAwaitIds(component.root, counter);
+  }
+}
+
+function walkForAwaitIds(node: JsxNodeIr, counter: number): number {
+  let next = counter;
+
+  if (node.kind === "async-boundary") {
+    node.awaitId = `await${next.toString(36)}`;
+    next += 1;
+
+    for (const child of node.children) {
+      next = walkForAwaitIds(child, next);
+    }
+
+    if (node.placeholderChildren !== undefined) {
+      for (const child of node.placeholderChildren) {
+        next = walkForAwaitIds(child, next);
+      }
+    }
+
+    if (node.catchChildren !== undefined) {
+      for (const child of node.catchChildren) {
+        next = walkForAwaitIds(child, next);
+      }
+    }
+
+    return next;
+  }
+
+  if (node.kind === "element" || node.kind === "fragment" || node.kind === "component") {
+    for (const child of node.children) {
+      next = walkForAwaitIds(child, next);
+    }
+    return next;
+  }
+
+  if (node.kind === "conditional") {
+    for (const child of node.whenTrue) {
+      next = walkForAwaitIds(child, next);
+    }
+    for (const child of node.whenFalse) {
+      next = walkForAwaitIds(child, next);
+    }
+    return next;
+  }
+
+  if (node.kind === "list") {
+    for (const child of node.children) {
+      next = walkForAwaitIds(child, next);
+    }
+    return next;
+  }
+
+  return next;
+}

package/src/oxc-await-validation.ts

@@ -0,0 +1,117 @@
+import {
+  unsupportedAwaitInnerComponentDiagnostic,
+  unsupportedNestedAwaitDiagnostic,
+} from "./diagnostics.js";
+import type { JsxNodeIr } from "./ir.js";
+import type { Diagnostic } from "./types.js";
+
+export function validateOxcAwaitCompatComponents(
+  node: JsxNodeIr,
+  diagnostics: Diagnostic[],
+  options: { allowCompatComponents?: boolean } = {},
+  insideAwait = false,
+): void {
+  if (node.kind === "component") {
+    if (insideAwait && node.runtime === "compat" && options.allowCompatComponents !== true) {
+      diagnostics.push(unsupportedAwaitInnerComponentDiagnostic(node.name, node.loc));
+    }
+
+    for (const prop of node.props) {
+      if (prop.kind === "render-prop") {
+        for (const child of prop.children) {
+          validateOxcAwaitCompatComponents(child, diagnostics, options, insideAwait);
+        }
+      }
+    }
+    for (const child of node.children) {
+      validateOxcAwaitCompatComponents(child, diagnostics, options, insideAwait);
+    }
+    return;
+  }
+
+  if (node.kind === "async-boundary") {
+    for (const child of [
+      ...node.children,
+      ...(node.placeholderChildren ?? []),
+      ...(node.catchChildren ?? []),
+    ]) {
+      validateOxcAwaitCompatComponents(child, diagnostics, options, true);
+    }
+    return;
+  }
+
+  if (node.kind === "conditional") {
+    for (const child of [...node.whenTrue, ...node.whenFalse]) {
+      validateOxcAwaitCompatComponents(child, diagnostics, options, insideAwait);
+    }
+    return;
+  }
+
+  if (node.kind === "list") {
+    for (const child of node.children) {
+      validateOxcAwaitCompatComponents(child, diagnostics, options, insideAwait);
+    }
+    return;
+  }
+
+  if (node.kind === "element" || node.kind === "fragment") {
+    for (const child of node.children) {
+      validateOxcAwaitCompatComponents(child, diagnostics, options, insideAwait);
+    }
+  }
+}
+
+export function validateOxcNestedAwait(
+  node: JsxNodeIr,
+  diagnostics: Diagnostic[],
+  insideAwait = false,
+): void {
+  if (node.kind === "async-boundary") {
+    if (insideAwait) {
+      diagnostics.push(unsupportedNestedAwaitDiagnostic(node.loc));
+    }
+
+    for (const child of [
+      ...node.children,
+      ...(node.placeholderChildren ?? []),
+      ...(node.catchChildren ?? []),
+    ]) {
+      validateOxcNestedAwait(child, diagnostics, true);
+    }
+    return;
+  }
+
+  if (node.kind === "component") {
+    for (const prop of node.props) {
+      if (prop.kind === "render-prop") {
+        for (const child of prop.children) {
+          validateOxcNestedAwait(child, diagnostics, insideAwait);
+        }
+      }
+    }
+    for (const child of node.children) {
+      validateOxcNestedAwait(child, diagnostics, insideAwait);
+    }
+    return;
+  }
+
+  if (node.kind === "conditional") {
+    for (const child of [...node.whenTrue, ...node.whenFalse]) {
+      validateOxcNestedAwait(child, diagnostics, insideAwait);
+    }
+    return;
+  }
+
+  if (node.kind === "list") {
+    for (const child of node.children) {
+      validateOxcNestedAwait(child, diagnostics, insideAwait);
+    }
+    return;
+  }
+
+  if (node.kind === "element" || node.kind === "fragment") {
+    for (const child of node.children) {
+      validateOxcNestedAwait(child, diagnostics, insideAwait);
+    }
+  }
+}

package/src/oxc-bindings.ts

@@ -0,0 +1,70 @@
+import { stripTypeScriptWithOxc } from "./oxc-transform.js";
+import { readArray, readObject, readSource } from "./oxc-node-utils.js";
+
+export function formatStatement(code: string, statement: unknown): string {
+  const source = readSource(code, statement);
+  return stripTypeScriptWithOxc(source).replace("() => {}", "() => { }");
+}
+
+export function collectBindingNames(statement: unknown): string[] {
+  const object = readObject(statement);
+
+  if (object.type === "ExportNamedDeclaration") {
+    return collectBindingNames(object.declaration);
+  }
+
+  if (object.type === "ExportDefaultDeclaration") {
+    return collectBindingNames(object.declaration);
+  }
+
+  if (object.type === "FunctionDeclaration" || object.type === "ClassDeclaration") {
+    const id = readObject(object.id);
+    return typeof id.name === "string" ? [id.name] : [];
+  }
+
+  if (object.type === "ForStatement") {
+    return collectBindingNames(object.init);
+  }
+
+  if (object.type === "IfStatement") {
+    return [...collectBindingNames(object.consequent), ...collectBindingNames(object.alternate)];
+  }
+
+  if (object.type === "BlockStatement") {
+    return readArray(object.body).flatMap(collectBindingNames);
+  }
+
+  if (object.type !== "VariableDeclaration") {
+    return readArray(object.body).flatMap(collectBindingNames);
+  }
+
+  return readArray(object.declarations).flatMap((declaration) => {
+    const id = readObject(readObject(declaration).id);
+    return typeof id.name === "string" ? [id.name] : [];
+  });
+}
+
+export function collectImportBindingNames(statement: unknown): string[] {
+  return readArray(readObject(statement).specifiers).flatMap((specifier) => {
+    const local = readObject(readObject(specifier).local);
+    return typeof local.name === "string" ? [local.name] : [];
+  });
+}
+
+export function readOxcParameterName(code: string, parameter: unknown): string {
+  const object = readObject(parameter);
+
+  if (typeof object.name === "string") {
+    return object.name;
+  }
+
+  if (object.type === "AssignmentPattern") {
+    return readOxcParameterName(code, object.left);
+  }
+
+  if (object.type === "RestElement") {
+    return `...${readOxcParameterName(code, object.argument)}`;
+  }
+
+  return readSource(code, parameter);
+}