@reckona/mreact-compiler 0.0.161 → 0.0.163

package/src/oxc-compat-create-element.ts

@@ -8,6 +8,7 @@ import { readArray, readObject, readSource, unwrapOxcParentheses } from "./oxc-n
 // interpreter semantics never get half-applied.
 
 const COMPAT_CREATE_ELEMENT_SOURCES = new Set(["react", "@reckona/mreact-compat"]);
+const COMPAT_RENDER_TO_STRING_SOURCES = new Set(["@reckona/mreact-compat"]);
 
 export function collectCompatCreateElementNames(program: unknown): Set<string> {
   const names = new Set<string>();
@@ -44,6 +45,41 @@ export function collectCompatCreateElementNames(program: unknown): Set<string> {
   return names;
 }
 
+export function collectCompatRenderToStringNames(program: unknown): Set<string> {
+  const names = new Set<string>();
+
+  for (const statement of readArray(readObject(program).body)) {
+    const declaration = readObject(statement);
+
+    if (declaration.type !== "ImportDeclaration") {
+      continue;
+    }
+
+    const source = readObject(declaration.source);
+
+    if (typeof source.value !== "string" || !COMPAT_RENDER_TO_STRING_SOURCES.has(source.value)) {
+      continue;
+    }
+
+    for (const specifier of readArray(declaration.specifiers)) {
+      const specifierObject = readObject(specifier);
+
+      if (specifierObject.type !== "ImportSpecifier") {
+        continue;
+      }
+
+      const imported = readObject(specifierObject.imported);
+      const local = readObject(specifierObject.local);
+
+      if (imported.name === "renderToString" && typeof local.name === "string") {
+        names.add(local.name);
+      }
+    }
+  }
+
+  return names;
+}
+
 // Mirrors packages/react-compat/src/server-render.ts attribute serialization
 // for compile-time-known prop values. Keep these tables in sync with the
 // interpreter; parity tests compare emitted bytes against renderToString.
@@ -363,6 +399,40 @@ export function analyzeCompatCreateElementRoot(
   return lowerCreateElementCall(code, unwrapOxcParentheses(expression), scope);
 }
 
+export function analyzeCompatCreateElementFunctionRoot(
+  code: string,
+  functionLike: Record<string, unknown>,
+  names: ReadonlySet<string>,
+): JsxNodeIr | undefined {
+  if (names.size === 0) {
+    return undefined;
+  }
+
+  const shadowed = collectFunctionShadowedNames(functionLike, names);
+  const scope: CompatCreateElementScope = { names, shadowed };
+  const body = unwrapOxcParentheses(readObject(functionLike.body));
+
+  if (body.type !== "BlockStatement") {
+    return lowerCreateElementCall(code, body, scope);
+  }
+
+  for (const statement of readArray(body.body)) {
+    const statementObject = readObject(statement);
+
+    if (statementObject.type !== "ReturnStatement") {
+      continue;
+    }
+
+    return lowerCreateElementCall(
+      code,
+      unwrapOxcParentheses(readObject(statementObject.argument)),
+      scope,
+    );
+  }
+
+  return undefined;
+}
+
 function lowerCreateElementCall(
   code: string,
   expression: Record<string, unknown>,
@@ -493,6 +563,45 @@ function lowerCreateElementChild(
     }
   }
 
+  if (child.type === "ConditionalExpression") {
+    const whenTrue = lowerCreateElementDynamicBranch(code, readObject(child.consequent), scope);
+    const whenFalse = lowerCreateElementDynamicBranch(code, readObject(child.alternate), scope);
+
+    if (whenTrue !== undefined && whenFalse !== undefined) {
+      return [
+        {
+          kind: "conditional",
+          conditionCode: readSource(code, readObject(child.test)),
+          whenTrue,
+          whenFalse,
+        },
+      ];
+    }
+  }
+
+  if (child.type === "LogicalExpression" && child.operator === "&&") {
+    const whenTrue = lowerCreateElementDynamicBranch(code, readObject(child.right), scope);
+
+    if (whenTrue !== undefined) {
+      const conditionValueName = logicalConditionValueName(readObject(child.left));
+
+      return [
+        {
+          kind: "conditional",
+          conditionCode: readSource(code, readObject(child.left)),
+          conditionValueName,
+          whenTrue,
+          whenFalse: [
+            {
+              kind: "expr",
+              code: renderableFalsyConditionValueCode(conditionValueName),
+            },
+          ],
+        },
+      ];
+    }
+  }
+
   // Provably-string expressions escape directly (and stay batchable); the
   // interpreter would emit the same escaped bytes for them.
   if (isProvablyStringExpression(child, scope)) {
@@ -505,6 +614,28 @@ function lowerCreateElementChild(
   return [{ kind: "expr", code: readSource(code, child), renderMode: "compat-child" }];
 }
 
+function lowerCreateElementDynamicBranch(
+  code: string,
+  expression: Record<string, unknown>,
+  scope: CompatCreateElementScope,
+): JsxNodeIr[] | undefined {
+  const unwrapped = unwrapOxcParentheses(expression);
+
+  if (unwrapped.type === "Literal" && (unwrapped.value === null || unwrapped.value === false)) {
+    return [];
+  }
+
+  return lowerCreateElementChild(code, unwrapped, scope);
+}
+
+function logicalConditionValueName(expression: Record<string, unknown>): string {
+  return `__mreactLogical_${typeof expression.start === "number" ? expression.start : "value"}`;
+}
+
+function renderableFalsyConditionValueCode(name: string): string {
+  return `((typeof ${name} === "number" || typeof ${name} === "bigint") ? ${name} : null)`;
+}
+
 function isProvablyStringExpression(
   expression: Record<string, unknown>,
   scope: CompatCreateElementScope,
@@ -623,31 +754,7 @@ export function hasLowerableCompatCreateElementReturn(
   functionLike: Record<string, unknown>,
   names: ReadonlySet<string>,
 ): boolean {
-  if (names.size === 0) {
-    return false;
-  }
-
-  const shadowed = collectFunctionShadowedNames(functionLike, names);
-  const scope: CompatCreateElementScope = { names, shadowed };
-  const body = unwrapOxcParentheses(readObject(functionLike.body));
-
-  if (body.type !== "BlockStatement") {
-    return lowerCreateElementCall(code, body, scope) !== undefined;
-  }
-
-  for (const statement of readArray(body.body)) {
-    const statementObject = readObject(statement);
-
-    if (statementObject.type !== "ReturnStatement") {
-      continue;
-    }
-
-    const argument = unwrapOxcParentheses(readObject(statementObject.argument));
-
-    return lowerCreateElementCall(code, argument, scope) !== undefined;
-  }
-
-  return false;
+  return analyzeCompatCreateElementFunctionRoot(code, functionLike, names) !== undefined;
 }
 
 export function collectFunctionShadowedNames(

package/src/oxc.ts

@@ -71,8 +71,10 @@ import {
   type OxcChildAnalysisContext,
 } from "./oxc-child-analysis.js";
 import {
+  analyzeCompatCreateElementFunctionRoot,
   analyzeCompatCreateElementRoot,
   collectCompatCreateElementNames,
+  collectCompatRenderToStringNames,
   collectFunctionShadowedNames,
   hasLowerableCompatCreateElementReturn,
 } from "./oxc-compat-create-element.js";
@@ -249,11 +251,23 @@ function analyzeOxcToIr(
       : undefined;
   const localJsxReturnFunctionNames =
     target === "server" ? collectOxcLocalJsxReturnFunctionNames(program) : new Set<string>();
-  // Stream emit keeps interpreting compat trees for now; only the string
-  // pipeline lowers createElement calls.
   const compatCreateElementNames =
-    target === "server" && options?.serverOutput !== "stream"
-      ? collectCompatCreateElementNames(program)
+    target === "server" ? collectCompatCreateElementNames(program) : new Set<string>();
+  const compatRenderToStringNames =
+    target === "server" ? collectCompatRenderToStringNames(program) : new Set<string>();
+  const compatCreateElementLocalFunctionLikes =
+    target === "server"
+      ? collectCompatCreateElementLocalFunctionLikes(program)
+      : new Map<string, Record<string, unknown>>();
+  const compatRenderToStringLowerableTargets =
+    target === "server"
+      ? collectCompatRenderToStringLowerableTargets(
+          code,
+          body,
+          compatCreateElementNames,
+          compatRenderToStringNames,
+          compatCreateElementLocalFunctionLikes,
+        )
       : new Set<string>();
   const localJsxHelperHtmlParameters =
     target === "server"
@@ -281,7 +295,15 @@ function analyzeOxcToIr(
 
     if (
       isOxcJsxComponentStatement(statement, localJsxReturnFunctionNames) ||
-      isCompatCreateElementComponentStatement(code, statement, compatCreateElementNames) ||
+      isCompatCreateElementComponentStatement(
+        code,
+        statement,
+        compatCreateElementNames,
+        compatRenderToStringNames,
+        compatCreateElementLocalFunctionLikes,
+        compatRenderToStringLowerableTargets,
+        options?.serverOutput,
+      ) ||
       (options?.compatReactNodeReturn === true && isOxcExportedFunctionLike(statement))
     ) {
       const declaration = readObject(readObject(statement).declaration);
@@ -346,6 +368,9 @@ function analyzeOxcToIr(
       diagnostics,
       options?.bodyStatementJsx ?? "dom-node",
       compatCreateElementNames,
+      compatRenderToStringNames,
+      compatCreateElementLocalFunctionLikes,
+      compatRenderToStringLowerableTargets,
       moduleRenderValueBindings,
       options?.compatReactNodeReturn === true,
       options?.serverOutput,
@@ -557,32 +582,292 @@ function readCompatCreateElementPlainComponent(
   return undefined;
 }
 
+function collectCompatCreateElementLocalFunctionLikes(
+  program: unknown,
+): Map<string, Record<string, unknown>> {
+  const functionLikes = new Map<string, Record<string, unknown>>();
+
+  for (const statement of readArray(readObject(program).body)) {
+    const object = readObject(statement);
+    const declaration =
+      object.type === "ExportNamedDeclaration" ? readObject(object.declaration) : object;
+
+    if (declaration.type === "FunctionDeclaration") {
+      const id = readObject(declaration.id);
+
+      if (typeof id.name === "string") {
+        functionLikes.set(id.name, declaration);
+      }
+      continue;
+    }
+
+    if (declaration.type !== "VariableDeclaration") {
+      continue;
+    }
+
+    for (const declarator of readArray(declaration.declarations)) {
+      const declaratorObject = readObject(declarator);
+      const id = readObject(declaratorObject.id);
+      const initializer = unwrapOxcComponentFunctionLikeInitializer(
+        readObject(declaratorObject.init),
+      );
+
+      if (typeof id.name === "string" && initializer !== undefined) {
+        functionLikes.set(id.name, initializer);
+      }
+    }
+  }
+
+  return functionLikes;
+}
+
+function collectCompatRenderToStringLowerableTargets(
+  code: string,
+  body: readonly unknown[],
+  createElementNames: ReadonlySet<string>,
+  renderToStringNames: ReadonlySet<string>,
+  localFunctionLikes: ReadonlyMap<string, Record<string, unknown>>,
+): Set<string> {
+  const targets = new Set<string>();
+
+  if (createElementNames.size === 0 || renderToStringNames.size === 0) {
+    return targets;
+  }
+
+  for (const statement of body) {
+    const functionLike = unwrapOxcStatementFunctionLike(statement);
+
+    if (functionLike === undefined) {
+      continue;
+    }
+
+    const targetName = readCompatRenderToStringWrapperTargetName(
+      code,
+      functionLike,
+      renderToStringNames,
+    );
+    const targetFunctionLike =
+      targetName === undefined ? undefined : localFunctionLikes.get(targetName);
+
+    if (
+      targetName !== undefined &&
+      targetFunctionLike !== undefined &&
+      analyzeCompatCreateElementFunctionRoot(code, targetFunctionLike, createElementNames) !==
+        undefined
+    ) {
+      targets.add(targetName);
+    }
+  }
+
+  return targets;
+}
+
+function unwrapOxcStatementFunctionLike(statement: unknown): Record<string, unknown> | undefined {
+  const object = readObject(statement);
+  const declaration =
+    object.type === "ExportNamedDeclaration" || object.type === "ExportDefaultDeclaration"
+      ? readObject(object.declaration)
+      : object;
+
+  if (declaration.type === "FunctionDeclaration") {
+    return declaration;
+  }
+
+  if (declaration.type !== "VariableDeclaration") {
+    return unwrapOxcComponentFunctionLikeInitializer(declaration);
+  }
+
+  for (const declarator of readArray(declaration.declarations)) {
+    const initializer = unwrapOxcComponentFunctionLikeInitializer(
+      readObject(readObject(declarator).init),
+    );
+
+    if (initializer !== undefined) {
+      return initializer;
+    }
+  }
+
+  return undefined;
+}
+
+function readCompatRenderToStringWrapperTargetName(
+  code: string,
+  functionLike: Record<string, unknown>,
+  renderToStringNames: ReadonlySet<string>,
+): string | undefined {
+  const expression = readCompatRenderToStringWrapperReturnExpression(functionLike);
+
+  if (expression === undefined) {
+    return undefined;
+  }
+
+  return readCompatRenderToStringTargetName(
+    expression,
+    renderToStringNames,
+    collectFunctionShadowedNames(functionLike, renderToStringNames),
+  );
+}
+
+function readCompatRenderToStringWrapperReturnExpression(
+  functionLike: Record<string, unknown>,
+): Record<string, unknown> | undefined {
+  const body = unwrapOxcParentheses(readObject(functionLike.body));
+
+  if (body.type !== "BlockStatement") {
+    return body;
+  }
+
+  for (const statement of readArray(body.body)) {
+    const statementObject = readObject(statement);
+
+    if (statementObject.type === "ReturnStatement") {
+      return unwrapOxcParentheses(readObject(statementObject.argument));
+    }
+  }
+
+  return undefined;
+}
+
+function readCompatRenderToStringTargetName(
+  expression: Record<string, unknown>,
+  renderToStringNames: ReadonlySet<string>,
+  shadowedNames: ReadonlySet<string>,
+): string | undefined {
+  if (
+    renderToStringNames.size === 0 ||
+    expression.type !== "CallExpression" ||
+    expression.optional === true
+  ) {
+    return undefined;
+  }
+
+  const callee = unwrapOxcParentheses(readObject(expression.callee));
+
+  if (
+    callee.type !== "Identifier" ||
+    typeof callee.name !== "string" ||
+    !renderToStringNames.has(callee.name) ||
+    shadowedNames.has(callee.name)
+  ) {
+    return undefined;
+  }
+
+  const args = readArray(expression.arguments);
+
+  if (args.length !== 1) {
+    return undefined;
+  }
+
+  const target = unwrapOxcParentheses(readObject(args[0]));
+
+  return target.type === "Identifier" && typeof target.name === "string" ? target.name : undefined;
+}
+
+function hasCompatRenderToStringWrapperReturn(
+  code: string,
+  functionLike: Record<string, unknown>,
+  renderToStringNames: ReadonlySet<string>,
+): boolean {
+  return (
+    readCompatRenderToStringWrapperTargetName(code, functionLike, renderToStringNames) !== undefined
+  );
+}
+
+function analyzeCompatRenderToStringWrapperRoot(
+  code: string,
+  functionLike: Record<string, unknown>,
+  returnExpression: Record<string, unknown>,
+  createElementNames: ReadonlySet<string>,
+  renderToStringNames: ReadonlySet<string>,
+  localFunctionLikes: ReadonlyMap<string, Record<string, unknown>>,
+): ComponentIr["root"] | undefined {
+  const targetName = readCompatRenderToStringTargetName(
+    returnExpression,
+    renderToStringNames,
+    collectFunctionShadowedNames(functionLike, renderToStringNames),
+  );
+
+  if (targetName === undefined) {
+    return undefined;
+  }
+
+  const targetFunctionLike = localFunctionLikes.get(targetName);
+  const lowered =
+    targetFunctionLike === undefined
+      ? undefined
+      : analyzeCompatCreateElementFunctionRoot(code, targetFunctionLike, createElementNames);
+
+  if (lowered !== undefined) {
+    return lowered;
+  }
+
+  return {
+    kind: "expr",
+    code: normalizeOxcExpressionCode(readSource(code, returnExpression)),
+    renderMode: "html",
+  };
+}
+
 function isCompatCreateElementComponentStatement(
   code: string,
   statement: unknown,
   names: ReadonlySet<string>,
+  renderToStringNames: ReadonlySet<string>,
+  localFunctionLikes: ReadonlyMap<string, Record<string, unknown>>,
+  renderToStringLowerableTargets: ReadonlySet<string>,
+  serverOutput?: AnalyzeModuleOptions["serverOutput"],
 ): boolean {
-  if (names.size === 0) {
+  if (names.size === 0 && renderToStringNames.size === 0) {
     return false;
   }
 
   const object = readObject(statement);
 
   if (object.type === "ExportDefaultDeclaration") {
-    return readCompatCreateElementFunctionLike(code, readObject(object.declaration), names) !== undefined;
+    const functionLike = unwrapOxcComponentFunctionLikeInitializer(readObject(object.declaration));
+
+    return (
+      readCompatCreateElementFunctionLike(code, readObject(object.declaration), names) !==
+        undefined ||
+      (functionLike !== undefined &&
+        hasCompatRenderToStringWrapperReturn(code, functionLike, renderToStringNames))
+    );
   }
 
   if (object.type === "ExportNamedDeclaration") {
     const declaration = readObject(object.declaration);
 
     if (declaration.type === "FunctionDeclaration") {
-      return hasLowerableCompatCreateElementReturn(code, declaration, names);
+      return (
+        hasLowerableCompatCreateElementReturn(code, declaration, names) ||
+        hasCompatRenderToStringWrapperReturn(code, declaration, renderToStringNames)
+      );
     }
 
     return readCompatCreateElementPlainComponent(code, declaration, names) !== undefined;
   }
 
-  return readCompatCreateElementPlainComponent(code, statement, names) !== undefined;
+  const plainComponent = readCompatCreateElementPlainComponent(code, statement, names);
+
+  if (serverOutput === "stream") {
+    return (
+      plainComponent !== undefined &&
+      renderToStringLowerableTargets.has(plainComponent.name) &&
+      localFunctionLikes.get(plainComponent.name) === plainComponent.initializer
+    );
+  }
+
+  if (plainComponent !== undefined) {
+    return true;
+  }
+
+  const functionLike = unwrapOxcStatementFunctionLike(statement);
+
+  if (functionLike === undefined) {
+    return false;
+  }
+
+  return hasCompatRenderToStringWrapperReturn(code, functionLike, renderToStringNames);
 }
 
 function analyzeOxcComponent(
@@ -593,6 +878,9 @@ function analyzeOxcComponent(
   diagnostics: Diagnostic[],
   bodyStatementJsx: OxcBodyStatementJsxMode,
   compatCreateElementNames: ReadonlySet<string>,
+  compatRenderToStringNames: ReadonlySet<string>,
+  compatCreateElementLocalFunctionLikes: ReadonlyMap<string, Record<string, unknown>>,
+  compatRenderToStringLowerableTargets: ReadonlySet<string>,
   moduleRenderValueBindings: Set<string>,
   compatReactNodeReturn: boolean,
   serverOutput: AnalyzeModuleOptions["serverOutput"],
@@ -610,7 +898,8 @@ function analyzeOxcComponent(
     if (
       declaration === undefined ||
       (!hasOxcFunctionLikeComponentReturn(declaration) &&
-        !hasLowerableCompatCreateElementReturn(code, declaration, compatCreateElementNames))
+        !hasLowerableCompatCreateElementReturn(code, declaration, compatCreateElementNames) &&
+        !hasCompatRenderToStringWrapperReturn(code, declaration, compatRenderToStringNames))
     ) {
       return [];
     }
@@ -628,6 +917,8 @@ function analyzeOxcComponent(
         diagnostics,
         bodyStatementJsx,
         compatCreateElementNames,
+        compatRenderToStringNames,
+        compatCreateElementLocalFunctionLikes,
         moduleRenderValueBindings,
         compatReactNodeReturn,
         serverOutput,
@@ -644,12 +935,18 @@ function analyzeOxcComponent(
   if (object.type !== "ExportNamedDeclaration") {
     const plainComponent =
       readOxcPlainComponent(statement) ??
-      readCompatCreateElementPlainComponent(code, statement, compatCreateElementNames);
+      (serverOutput === "stream"
+        ? undefined
+        : readCompatCreateElementPlainComponent(code, statement, compatCreateElementNames));
 
     if (plainComponent === undefined) {
       return [];
     }
 
+    if (compatRenderToStringLowerableTargets.has(plainComponent.name)) {
+      return [];
+    }
+
     return [
       {
         ...analyzeOxcFunctionLikeComponent(
@@ -662,6 +959,8 @@ function analyzeOxcComponent(
           diagnostics,
           bodyStatementJsx,
           compatCreateElementNames,
+          compatRenderToStringNames,
+          compatCreateElementLocalFunctionLikes,
           moduleRenderValueBindings,
           compatReactNodeReturn,
           serverOutput,
@@ -698,6 +997,8 @@ function analyzeOxcComponent(
         diagnostics,
         bodyStatementJsx,
         compatCreateElementNames,
+        compatRenderToStringNames,
+        compatCreateElementLocalFunctionLikes,
         moduleRenderValueBindings,
         compatReactNodeReturn,
         serverOutput,
@@ -715,7 +1016,8 @@ function analyzeOxcComponent(
     (!compatReactNodeReturn &&
       !hasComponentReturn(declaration.body) &&
       !hasLocalJsxHelperCallReturn(declaration.body, localJsxReturnFunctionNames) &&
-      !hasLowerableCompatCreateElementReturn(code, declaration, compatCreateElementNames))
+      !hasLowerableCompatCreateElementReturn(code, declaration, compatCreateElementNames) &&
+      !hasCompatRenderToStringWrapperReturn(code, declaration, compatRenderToStringNames))
   ) {
     return [];
   }
@@ -737,6 +1039,8 @@ function analyzeOxcComponent(
       diagnostics,
       bodyStatementJsx,
       compatCreateElementNames,
+      compatRenderToStringNames,
+      compatCreateElementLocalFunctionLikes,
       moduleRenderValueBindings,
       compatReactNodeReturn,
       serverOutput,
@@ -787,6 +1091,8 @@ function analyzeOxcFunctionLikeComponent(
   diagnostics: Diagnostic[],
   bodyStatementJsx: OxcBodyStatementJsxMode,
   compatCreateElementNames: ReadonlySet<string>,
+  compatRenderToStringNames: ReadonlySet<string>,
+  compatCreateElementLocalFunctionLikes: ReadonlyMap<string, Record<string, unknown>>,
   moduleRenderValueBindings: Set<string>,
   compatReactNodeReturn: boolean,
   serverOutput: AnalyzeModuleOptions["serverOutput"],
@@ -873,6 +1179,14 @@ function analyzeOxcFunctionLikeComponent(
           names: compatCreateElementNames,
           shadowed: collectFunctionShadowedNames(functionLike, compatCreateElementNames),
         })) ??
+    analyzeCompatRenderToStringWrapperRoot(
+      code,
+      functionLike,
+      returnExpression,
+      compatCreateElementNames,
+      compatRenderToStringNames,
+      compatCreateElementLocalFunctionLikes,
+    ) ??
     (isJsxRoot(returnExpression.type) || returnExpression.type === "JSXFragment"
       ? analyzeOxcJsxNode(code, returnExpression, childAnalysisContext)
       : isOxcComponentCallExpression(returnExpression)