[compiler] proof of concept to validate relay derived setStates

Summary:
Experimenting with this a bit. Not a serious change yet

Author: jorge-cab

compiler/packages/babel-plugin-react-compiler/src/HIR/DefaultModuleTypeProvider.ts

@@ -39,10 +39,33 @@ import {TypeConfig} from './TypeSchema';
  * The React team is open to collaborating with library authors to help develop compatible versions of these APIs,
  * and we have already reached out to the teams who own any API listed here to ensure they are aware of the issue.
  */
+
+const RELAY_HOOK_TYPE: TypeConfig = {
+  kind: 'hook',
+  positionalParams: [],
+  restParam: Effect.Freeze,
+  returnType: {kind: 'type', name: 'BuiltInUseFragment'},
+  returnValueKind: ValueKind.Frozen,
+  noAlias: true,
+};
+
 export function defaultModuleTypeProvider(
   moduleName: string,
 ): TypeConfig | null {
   switch (moduleName) {
+    case 'react-relay':
+    case 'shared-runtime': {
+      return {
+        kind: 'object',
+        properties: {
+          useFragment: RELAY_HOOK_TYPE,
+          usePaginationFragment: RELAY_HOOK_TYPE,
+          useRefetchableFragment: RELAY_HOOK_TYPE,
+          useLazyLoadQuery: RELAY_HOOK_TYPE,
+          usePreloadedQuery: RELAY_HOOK_TYPE,
+        },
+      };
+    }
     case 'react-hook-form': {
       return {
         kind: 'object',

compiler/packages/babel-plugin-react-compiler/src/HIR/Environment.ts

@@ -41,6 +41,7 @@ import {
 } from './HIR';
 import {
   BuiltInMixedReadonlyId,
+  BuiltInUseFragmentId,
   DefaultMutatingHook,
   DefaultNonmutatingHook,
   FunctionSignature,
@@ -819,14 +820,22 @@ export class Environment {
         ],
         suggestions: null,
       });
+      // Use BuiltInUseFragmentId for useFragment to enable tracking of fragment-derived values
+      const returnTypeShapeId =
+        hookName === 'useFragment'
+          ? BuiltInUseFragmentId
+          : hook.transitiveMixedData
+            ? BuiltInMixedReadonlyId
+            : null;
       this.#globals.set(
         hookName,
         addHook(this.#shapes, {
           positionalParams: [],
           restParam: hook.effectKind,
-          returnType: hook.transitiveMixedData
-            ? {kind: 'Object', shapeId: BuiltInMixedReadonlyId}
-            : {kind: 'Poly'},
+          returnType:
+            returnTypeShapeId != null
+              ? {kind: 'Object', shapeId: returnTypeShapeId}
+              : {kind: 'Poly'},
           returnValueKind: hook.valueKind,
           calleeEffect: Effect.Read,
           hookKind: 'Custom',

compiler/packages/babel-plugin-react-compiler/src/HIR/Globals.ts

@@ -20,6 +20,7 @@ import {
   BuiltInUseContextHookId,
   BuiltInUseEffectEventId,
   BuiltInUseEffectHookId,
+  BuiltInUseFragmentId,
   BuiltInUseInsertionEffectHookId,
   BuiltInUseLayoutEffectHookId,
   BuiltInUseOperatorId,
@@ -980,6 +981,9 @@ export function installTypeConfig(
         case 'MixedReadonly': {
           return {kind: 'Object', shapeId: BuiltInMixedReadonlyId};
         }
+        case 'BuiltInUseFragment': {
+          return {kind: 'Object', shapeId: BuiltInUseFragmentId};
+        }
         case 'Primitive': {
           return {kind: 'Primitive'};
         }

compiler/packages/babel-plugin-react-compiler/src/HIR/HIR.ts

@@ -1886,6 +1886,10 @@ export function isUseStateType(id: Identifier): boolean {
   return id.type.kind === 'Object' && id.type.shapeId === 'BuiltInUseState';
 }
 
+export function isUseFragmentType(id: Identifier): boolean {
+  return id.type.kind === 'Object' && id.type.shapeId === 'BuiltInUseFragment';
+}
+
 export function isJsxType(type: Type): boolean {
   return type.kind === 'Object' && type.shapeId === 'BuiltInJsx';
 }

compiler/packages/babel-plugin-react-compiler/src/HIR/ObjectShape.ts

@@ -392,6 +392,7 @@ export const BuiltInSetActionStateId = 'BuiltInSetActionState';
 export const BuiltInUseRefId = 'BuiltInUseRefId';
 export const BuiltInRefValueId = 'BuiltInRefValue';
 export const BuiltInMixedReadonlyId = 'BuiltInMixedReadonly';
+export const BuiltInUseFragmentId = 'BuiltInUseFragment';
 export const BuiltInUseEffectHookId = 'BuiltInUseEffectHook';
 export const BuiltInUseLayoutEffectHookId = 'BuiltInUseLayoutEffectHook';
 export const BuiltInUseInsertionEffectHookId = 'BuiltInUseInsertionEffectHook';
@@ -1475,6 +1476,16 @@ addObject(BUILTIN_SHAPES, BuiltInMixedReadonlyId, [
   ['*', {kind: 'Object', shapeId: BuiltInMixedReadonlyId}],
 ]);
 
+/**
+ * BuiltInUseFragment represents values returned from Relay's useFragment hook.
+ * The catch-all property ensures that property accesses on useFragment data
+ * are also typed as BuiltInUseFragmentId, enabling tracking of fragment-derived
+ * values through the program.
+ */
+addObject(BUILTIN_SHAPES, BuiltInUseFragmentId, [
+  ['*', {kind: 'Object', shapeId: BuiltInUseFragmentId}],
+]);
+
 addObject(BUILTIN_SHAPES, BuiltInJsxId, []);
 addObject(BUILTIN_SHAPES, BuiltInFunctionId, []);
 

compiler/packages/babel-plugin-react-compiler/src/HIR/TypeSchema.ts

@@ -294,13 +294,15 @@ export type BuiltInTypeConfig =
   | 'Ref'
   | 'Array'
   | 'Primitive'
-  | 'MixedReadonly';
+  | 'MixedReadonly'
+  | 'BuiltInUseFragment';
 export const BuiltInTypeSchema: z.ZodType<BuiltInTypeConfig> = z.union([
   z.literal('Any'),
   z.literal('Ref'),
   z.literal('Array'),
   z.literal('Primitive'),
   z.literal('MixedReadonly'),
+  z.literal('BuiltInUseFragment'),
 ]);
 
 export type TypeReferenceConfig = {

compiler/packages/babel-plugin-react-compiler/src/TypeInference/InferTypes.ts

@@ -33,6 +33,7 @@ import {
   BuiltInPropsId,
   BuiltInRefValueId,
   BuiltInSetStateId,
+  BuiltInUseFragmentId,
   BuiltInUseRefId,
 } from '../HIR/ObjectShape';
 import {eachInstructionLValue, eachInstructionOperand} from '../HIR/visitors';
@@ -859,12 +860,19 @@ function tryUnionTypes(ty1: Type, ty2: Type): Type | null {
   } else if (ty2.kind === 'Object' && ty2.shapeId === BuiltInMixedReadonlyId) {
     readonlyType = ty2;
     otherType = ty1;
+  } else if (ty1.kind === 'Object' && ty1.shapeId === BuiltInUseFragmentId) {
+    readonlyType = ty1;
+    otherType = ty2;
+  } else if (ty2.kind === 'Object' && ty2.shapeId === BuiltInUseFragmentId) {
+    readonlyType = ty2;
+    otherType = ty1;
   } else {
     return null;
   }
   if (otherType.kind === 'Primitive') {
     /**
      * Union(Primitive | MixedReadonly) = MixedReadonly
+     * Union(Primitive | UseFragment) = UseFragment
      *
      * For example, `data ?? null` could return `data`, the fact that RHS
      * is a primitive doesn't guarantee the result is a primitive.
@@ -876,6 +884,7 @@ function tryUnionTypes(ty1: Type, ty2: Type): Type | null {
   ) {
     /**
      * Union(Array | MixedReadonly) = Array
+     * Union(Array | UseFragment) = Array
      *
      * In practice this pattern means the result is always an array. Given
      * that this behavior requires opting-in to the mixedreadonly type

compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateNoDerivedComputationsInEffects_exp.ts

@@ -15,6 +15,7 @@ import {
   IdentifierId,
   isSetStateType,
   isUseEffectHookType,
+  isUseFragmentType,
   Place,
   CallExpression,
   Instruction,
@@ -28,7 +29,12 @@ import {eachInstructionLValue, eachInstructionOperand} from '../HIR/visitors';
 import {isMutable} from '../ReactiveScopes/InferReactiveScopeVariables';
 import {assertExhaustive} from '../Utils/utils';
 
-type TypeOfValue = 'ignored' | 'fromProps' | 'fromState' | 'fromPropsAndState';
+type TypeOfValue =
+  | 'ignored'
+  | 'fromProps'
+  | 'fromState'
+  | 'fromPropsAndState'
+  | 'fromRelay';
 
 type DerivationMetadata = {
   typeOfValue: TypeOfValue;
@@ -299,6 +305,9 @@ function joinValue(
   if (lvalueType === 'ignored') return valueType;
   if (valueType === 'ignored') return lvalueType;
   if (lvalueType === valueType) return lvalueType;
+  if (lvalueType === 'fromRelay' || valueType === 'fromRelay') {
+    return 'fromRelay';
+  }
   return 'fromPropsAndState';
 }
 
@@ -397,6 +406,16 @@ function recordInstructionDerivations(
         true,
       );
       return;
+    } else if (isUseFragmentType(lvalue.identifier)) {
+      console.log('relay');
+      typeOfValue = 'fromRelay';
+      context.derivationCache.addDerivationEntry(
+        lvalue,
+        new Set(),
+        typeOfValue,
+        true,
+      );
+      return;
     }
   } else if (value.kind === 'ArrayExpression') {
     context.candidateDependencies.set(lvalue.identifier.id, value);
@@ -796,6 +815,26 @@ function validateEffect(
         );
 
         if (argMetadata !== undefined) {
+          console.log(argMetadata.typeOfValue);
+          // Check if the value being set is derived from useFragment (Relay)
+          if (argMetadata.typeOfValue === 'fromRelay') {
+            context.errors.pushDiagnostic(
+              CompilerDiagnostic.create({
+                description:
+                  'Deriving value from Relay store. Instead of holding it in a local state, use a client schema extension to store the value directly in the Relay store.',
+                category: ErrorCategory.EffectDerivationsOfState,
+                reason:
+                  'Avoid storing Relay data in React state. Use client schema extensions instead.',
+              }).withDetails({
+                kind: 'error',
+                loc: instr.value.callee.loc,
+                message:
+                  'setState with Relay-derived value. Use client schema instead.',
+              }),
+            );
+            continue;
+          }
+
           effectDerivedSetStateCalls.push({
             value: instr.value,
             id: instr.value.callee.identifier.id,

packages/shared/ReactVersion.js

@@ -1,15 +1 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-// TODO: this is special because it gets imported during build.
-//
-// It exists as a placeholder so that DevTools can support work tag changes between releases.
-// When we next publish a release, update the matching TODO in backend/renderer.js
-// TODO: This module is used both by the release scripts and to expose a version
-// at runtime. We should instead inject the version number as part of the build
-// process, and use the ReactVersions.js module as the single source of truth.
-export default '19.3.0';
+export default '19.3.0-canary--';