babel-plugin-react-compiler 0.0.0-experimental-dc8bd44-20241120 → 0.0.0-experimental-df7b47d-20241124

package/dist/index.js

@@ -136714,6 +136714,17 @@ const EnvironmentConfigSchema = z.object({
   enableForest: z.boolean().default(false),
   enableUseTypeAnnotations: z.boolean().default(false),
   enableFunctionDependencyRewrite: z.boolean().default(true),
+  enableOptionalDependencies: z.boolean().default(true),
+  inferEffectDependencies: z
+    .nullable(
+      z.array(
+        z.object({
+          function: ExternalFunctionSchema,
+          numRequiredArgs: z.number(),
+        })
+      )
+    )
+    .default(null),
   inlineJsxTransform: ReactElementSymbolSchema.nullable().default(null),
   validateHooksUsage: z.boolean().default(true),
   validateRefAccessDuringRender: z.boolean().default(true),
@@ -136777,6 +136788,19 @@ const testComplexConfigDefaults = {
     source: 'react-compiler-runtime',
     importSpecifierName: 'useContext_withSelector',
   },
+  inferEffectDependencies: [
+    {
+      function: {source: 'react', importSpecifierName: 'useEffect'},
+      numRequiredArgs: 1,
+    },
+    {
+      function: {
+        source: 'shared-runtime',
+        importSpecifierName: 'useSpecialEffect',
+      },
+      numRequiredArgs: 2,
+    },
+  ],
 };
 function parseConfigPragmaForTests(pragma) {
   const maybeConfig = {};
@@ -141015,25 +141039,25 @@ function rewriteInstruction(instr, state) {
   if (instr.value.kind === 'Destructure') {
     switch (instr.value.lvalue.pattern.kind) {
       case 'ArrayPattern': {
-        let nextItems = null;
-        const originalItems = instr.value.lvalue.pattern.items;
-        for (let i = originalItems.length - 1; i >= 0; i--) {
-          const item = originalItems[i];
+        let lastEntryIndex = 0;
+        const items = instr.value.lvalue.pattern.items;
+        for (let i = 0; i < items.length; i++) {
+          const item = items[i];
           if (item.kind === 'Identifier') {
-            if (state.isIdOrNameUsed(item.identifier)) {
-              nextItems = originalItems.slice(0, i + 1);
-              break;
+            if (!state.isIdOrNameUsed(item.identifier)) {
+              items[i] = {kind: 'Hole'};
+            } else {
+              lastEntryIndex = i;
             }
           } else if (item.kind === 'Spread') {
-            if (state.isIdOrNameUsed(item.place.identifier)) {
-              nextItems = originalItems.slice(0, i + 1);
-              break;
+            if (!state.isIdOrNameUsed(item.place.identifier)) {
+              items[i] = {kind: 'Hole'};
+            } else {
+              lastEntryIndex = i;
             }
           }
         }
-        if (nextItems !== null) {
-          instr.value.lvalue.pattern.items = nextItems;
-        }
+        items.length = lastEntryIndex + 1;
         break;
       }
       case 'ObjectPattern': {
@@ -151483,6 +151507,199 @@ function declareTemporary(env, block, result) {
     },
   });
 }
+function inferEffectDependencies(fn) {
+  let hasRewrite = false;
+  const fnExpressions = new Map();
+  const autodepFnConfigs = new Map();
+  for (const effectTarget of fn.env.config.inferEffectDependencies) {
+    const moduleTargets = getOrInsertWith(
+      autodepFnConfigs,
+      effectTarget.function.source,
+      () => new Map()
+    );
+    moduleTargets.set(
+      effectTarget.function.importSpecifierName,
+      effectTarget.numRequiredArgs
+    );
+  }
+  const autodepFnLoads = new Map();
+  const scopeInfos = new Map();
+  const reactiveIds = inferReactiveIdentifiers(fn);
+  for (const [, block] of fn.body.blocks) {
+    if (
+      block.terminal.kind === 'scope' ||
+      block.terminal.kind === 'pruned-scope'
+    ) {
+      const scopeBlock = fn.body.blocks.get(block.terminal.block);
+      scopeInfos.set(block.terminal.scope.id, {
+        pruned: block.terminal.kind === 'pruned-scope',
+        deps: block.terminal.scope.dependencies,
+        hasSingleInstr:
+          scopeBlock.instructions.length === 1 &&
+          scopeBlock.terminal.kind === 'goto' &&
+          scopeBlock.terminal.block === block.terminal.fallthrough,
+      });
+    }
+    const rewriteInstrs = new Map();
+    for (const instr of block.instructions) {
+      const {value: value, lvalue: lvalue} = instr;
+      if (value.kind === 'FunctionExpression') {
+        fnExpressions.set(lvalue.identifier.id, instr);
+      } else if (
+        value.kind === 'LoadGlobal' &&
+        value.binding.kind === 'ImportSpecifier'
+      ) {
+        const moduleTargets = autodepFnConfigs.get(value.binding.module);
+        if (moduleTargets != null) {
+          const numRequiredArgs = moduleTargets.get(value.binding.imported);
+          if (numRequiredArgs != null) {
+            autodepFnLoads.set(lvalue.identifier.id, numRequiredArgs);
+          }
+        }
+      } else if (
+        value.kind === 'CallExpression' &&
+        autodepFnLoads.get(value.callee.identifier.id) === value.args.length &&
+        value.args[0].kind === 'Identifier'
+      ) {
+        const fnExpr = fnExpressions.get(value.args[0].identifier.id);
+        if (fnExpr != null) {
+          const scopeInfo =
+            fnExpr.lvalue.identifier.scope != null
+              ? scopeInfos.get(fnExpr.lvalue.identifier.scope.id)
+              : null;
+          CompilerError.invariant(scopeInfo != null, {
+            reason: 'Expected function expression scope to exist',
+            loc: value.loc,
+          });
+          if (scopeInfo.pruned || !scopeInfo.hasSingleInstr) {
+            CompilerError.throwTodo({
+              reason:
+                '[InferEffectDependencies] Expected effect function to have non-pruned scope and its scope to have exactly one instruction',
+              loc: fnExpr.loc,
+            });
+          }
+          const effectDeps = [];
+          const newInstructions = [];
+          for (const dep of scopeInfo.deps) {
+            const {place: place, instructions: instructions} =
+              writeDependencyToInstructions(
+                dep,
+                reactiveIds.has(dep.identifier.id),
+                fn.env,
+                fnExpr.loc
+              );
+            newInstructions.push(...instructions);
+            effectDeps.push(place);
+          }
+          const deps = {
+            kind: 'ArrayExpression',
+            elements: effectDeps,
+            loc: GeneratedSource,
+          };
+          const depsPlace = createTemporaryPlace(fn.env, GeneratedSource);
+          depsPlace.effect = exports.Effect.Read;
+          newInstructions.push({
+            id: makeInstructionId(0),
+            loc: GeneratedSource,
+            lvalue: Object.assign(Object.assign({}, depsPlace), {
+              effect: exports.Effect.Mutate,
+            }),
+            value: deps,
+          });
+          value.args.push(
+            Object.assign(Object.assign({}, depsPlace), {
+              effect: exports.Effect.Freeze,
+            })
+          );
+          rewriteInstrs.set(instr.id, newInstructions);
+        }
+      }
+    }
+    if (rewriteInstrs.size > 0) {
+      hasRewrite = true;
+      const newInstrs = [];
+      for (const instr of block.instructions) {
+        const newInstr = rewriteInstrs.get(instr.id);
+        if (newInstr != null) {
+          newInstrs.push(...newInstr, instr);
+        } else {
+          newInstrs.push(instr);
+        }
+      }
+      block.instructions = newInstrs;
+    }
+  }
+  if (hasRewrite) {
+    markInstructionIds(fn.body);
+    fixScopeAndIdentifierRanges(fn.body);
+  }
+}
+function writeDependencyToInstructions(dep, reactive, env, loc) {
+  const instructions = [];
+  let currValue = createTemporaryPlace(env, GeneratedSource);
+  currValue.reactive = reactive;
+  instructions.push({
+    id: makeInstructionId(0),
+    loc: GeneratedSource,
+    lvalue: Object.assign(Object.assign({}, currValue), {
+      effect: exports.Effect.Mutate,
+    }),
+    value: {
+      kind: 'LoadLocal',
+      place: {
+        kind: 'Identifier',
+        identifier: dep.identifier,
+        effect: exports.Effect.Capture,
+        reactive: reactive,
+        loc: loc,
+      },
+      loc: loc,
+    },
+  });
+  for (const path of dep.path) {
+    if (path.optional) {
+      break;
+    }
+    const nextValue = createTemporaryPlace(env, GeneratedSource);
+    nextValue.reactive = reactive;
+    instructions.push({
+      id: makeInstructionId(0),
+      loc: GeneratedSource,
+      lvalue: Object.assign(Object.assign({}, nextValue), {
+        effect: exports.Effect.Mutate,
+      }),
+      value: {
+        kind: 'PropertyLoad',
+        object: Object.assign(Object.assign({}, currValue), {
+          effect: exports.Effect.Capture,
+        }),
+        property: path.property,
+        loc: loc,
+      },
+    });
+    currValue = nextValue;
+  }
+  currValue.effect = exports.Effect.Freeze;
+  return {place: currValue, instructions: instructions};
+}
+function inferReactiveIdentifiers(fn) {
+  const reactiveIds = new Set();
+  for (const [, block] of fn.body.blocks) {
+    for (const instr of block.instructions) {
+      for (const place of eachInstructionOperand(instr)) {
+        if (place.reactive) {
+          reactiveIds.add(place.identifier.id);
+        }
+      }
+    }
+    for (const place of eachTerminalOperand(block.terminal)) {
+      if (place.reactive) {
+        reactiveIds.add(place.identifier.id);
+      }
+    }
+  }
+  return reactiveIds;
+}
 function instructionReordering(fn) {
   var _a;
   const shared = new Map();
@@ -157156,6 +157373,9 @@ function* runWithEnvironment(func, env) {
   assertTerminalPredsExist(hir);
   propagateScopeDependenciesHIR(hir);
   yield log({kind: 'hir', name: 'PropagateScopeDependenciesHIR', value: hir});
+  if (env.config.inferEffectDependencies) {
+    inferEffectDependencies(hir);
+  }
   if (env.config.inlineJsxTransform) {
     inlineJsxTransform(hir, env.config.inlineJsxTransform);
     yield log({kind: 'hir', name: 'inlineJsxTransform', value: hir});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "babel-plugin-react-compiler",
-  "version": "0.0.0-experimental-dc8bd44-20241120",
+  "version": "0.0.0-experimental-df7b47d-20241124",
   "description": "Babel plugin for React Compiler.",
   "main": "dist/index.js",
   "license": "MIT",