p5 2.2.2 → 2.2.3-rc.0

package/dist/strands/ir_types.js

@@ -37,6 +37,7 @@ const BaseType = {
   BOOL: "bool",
   MAT: "mat",
   DEFER: "defer",
+  ASSIGN_ON_USE: "assign_on_use",
   SAMPLER2D: "sampler2D",
   SAMPLER: "sampler",
 };
@@ -46,6 +47,7 @@ const BasePriority = {
   [BaseType.BOOL]: 1,
   [BaseType.MAT]: 0,
   [BaseType.DEFER]: -1,
+  [BaseType.ASSIGN_ON_USE]: -2,
   [BaseType.SAMPLER2D]: -10,
   [BaseType.SAMPLER]: -11,
 };
@@ -66,6 +68,7 @@ const DataType = {
   mat3: { fnName: "mat3x3", baseType: BaseType.MAT, dimension:3, priority: 0,  },
   mat4: { fnName: "mat4x4", baseType: BaseType.MAT, dimension:4, priority: 0,  },
   defer: { fnName:  null, baseType: BaseType.DEFER, dimension: null, priority: -1 },
+  assign_on_use: { fnName: null, baseType: BaseType.ASSIGN_ON_USE, dimension: null, priority: -2 },
   sampler2D: { fnName: "sampler2D", baseType: BaseType.SAMPLER2D, dimension: 1, priority: -10 },
   sampler: { fnName: "sampler", baseType: BaseType.SAMPLER, dimension: 1, priority: -11 },
 };
@@ -137,7 +140,7 @@ const OpCode = {
   }
 };
 const OperatorTable = [
-  { arity: "unary", name: "not", symbol: "!", opCode: OpCode.Unary.LOGICAL_NOT },
+  { arity: "unary", boolean: true, name: "not", symbol: "!", opCode: OpCode.Unary.LOGICAL_NOT },
   { arity: "unary", name: "neg", symbol: "-", opCode: OpCode.Unary.NEGATE },
   { arity: "unary", name: "plus", symbol: "+", opCode: OpCode.Unary.PLUS },
   { arity: "binary", name: "add", symbol: "+", opCode: OpCode.Binary.ADD },
@@ -145,14 +148,14 @@ const OperatorTable = [
   { arity: "binary", name: "mult", symbol: "*", opCode: OpCode.Binary.MULTIPLY },
   { arity: "binary", name: "div", symbol: "/", opCode: OpCode.Binary.DIVIDE },
   { arity: "binary", name: "mod", symbol: "%", opCode: OpCode.Binary.MODULO },
-  { arity: "binary", name: "equalTo", symbol: "==", opCode: OpCode.Binary.EQUAL },
-  { arity: "binary", name: "notEqual", symbol: "!=", opCode: OpCode.Binary.NOT_EQUAL },
-  { arity: "binary", name: "greaterThan", symbol: ">", opCode: OpCode.Binary.GREATER_THAN },
-  { arity: "binary", name: "greaterEqual", symbol: ">=", opCode: OpCode.Binary.GREATER_EQUAL },
-  { arity: "binary", name: "lessThan", symbol: "<", opCode: OpCode.Binary.LESS_THAN },
-  { arity: "binary", name: "lessEqual", symbol: "<=", opCode: OpCode.Binary.LESS_EQUAL },
-  { arity: "binary", name: "and", symbol: "&&", opCode: OpCode.Binary.LOGICAL_AND },
-  { arity: "binary", name: "or", symbol: "||", opCode: OpCode.Binary.LOGICAL_OR },
+  { arity: "binary", boolean: true, name: "equalTo", symbol: "==", opCode: OpCode.Binary.EQUAL },
+  { arity: "binary", boolean: true, name: "notEqual", symbol: "!=", opCode: OpCode.Binary.NOT_EQUAL },
+  { arity: "binary", boolean: true, name: "greaterThan", symbol: ">", opCode: OpCode.Binary.GREATER_THAN },
+  { arity: "binary", boolean: true, name: "greaterEqual", symbol: ">=", opCode: OpCode.Binary.GREATER_EQUAL },
+  { arity: "binary", boolean: true, name: "lessThan", symbol: "<", opCode: OpCode.Binary.LESS_THAN },
+  { arity: "binary", boolean: true, name: "lessEqual", symbol: "<=", opCode: OpCode.Binary.LESS_EQUAL },
+  { arity: "binary", boolean: true, name: "and", symbol: "&&", opCode: OpCode.Binary.LOGICAL_AND },
+  { arity: "binary", boolean: true, name: "or", symbol: "||", opCode: OpCode.Binary.LOGICAL_OR },
 ];
 const ConstantFolding = {
   [OpCode.Binary.ADD]: (a, b) => a + b,
@@ -173,7 +176,8 @@ const ConstantFolding = {
 const OpCodeToSymbol = {};
 const UnarySymbolToName = {};
 const BinarySymbolToName = {};
-for (const { symbol, opCode, name, arity } of OperatorTable) {
+const booleanOpCode = {};
+for (const { symbol, opCode, name, arity, boolean } of OperatorTable) {
   // SymbolToOpCode[symbol] = opCode;
   OpCodeToSymbol[opCode] = symbol;
   if (arity === 'unary') {
@@ -182,6 +186,9 @@ for (const { symbol, opCode, name, arity } of OperatorTable) {
   if (arity === 'binary') {
     BinarySymbolToName[symbol] = name;
   }
+  if (boolean) {
+    booleanOpCode[opCode] = true;
+  }
 }
 const BlockType = {
   GLOBAL: 'global',
@@ -200,4 +207,4 @@ const BlockTypeToName = Object.fromEntries(
   Object.entries(BlockType).map(([key, val]) => [val, key])
 );
 
-export { BasePriority, BaseType, BinarySymbolToName, BlockType, BlockTypeToName, ConstantFolding, DataType, GenType, NodeType, NodeTypeRequiredFields, NodeTypeToName, OpCode, OpCodeToSymbol, OperatorTable, StatementType, TypeInfoFromGLSLName, UnarySymbolToName, isStructType, structType, typeEquals };
+export { BasePriority, BaseType, BinarySymbolToName, BlockType, BlockTypeToName, ConstantFolding, DataType, GenType, NodeType, NodeTypeRequiredFields, NodeTypeToName, OpCode, OpCodeToSymbol, OperatorTable, StatementType, TypeInfoFromGLSLName, UnarySymbolToName, booleanOpCode, isStructType, structType, typeEquals };

package/dist/strands/p5.strands.js

@@ -8,7 +8,7 @@ import 'acorn';
 import 'acorn-walk';
 import 'escodegen';
 import './strands_FES.js';
-import '../ir_builders-w12-GSxu.js';
+import '../ir_builders-DMfaOLIL.js';
 import './strands_builtins.js';
 import './strands_conditionals.js';
 import './strands_phi_utils.js';
@@ -50,6 +50,7 @@ function strands(p5, fn) {
     ctx.previousFES = p5.disableFriendlyErrors;
     ctx.windowOverrides = {};
     ctx.fnOverrides = {};
+    ctx.graphicsOverrides = {};
     if (active) {
       p5.disableFriendlyErrors = true;
     }
@@ -72,6 +73,17 @@ function strands(p5, fn) {
     for (const key in ctx.fnOverrides) {
       fn[key] = ctx.fnOverrides[key];
     }
+    // Clean up the hooks temporarily installed on p5.Graphics.prototype (#8549)
+    const GraphicsProto = p5.Graphics?.prototype;
+    if (GraphicsProto) {
+      for (const key in ctx.graphicsOverrides) {
+        if (ctx.graphicsOverrides[key] === undefined) {
+          delete GraphicsProto[key];
+        } else {
+          GraphicsProto[key] = ctx.graphicsOverrides[key];
+        }
+      }
+    }
   }
 
   const strandsContext = {};
@@ -640,7 +652,8 @@ if (typeof p5 !== "undefined") {
  *     filterColor.texCoord.x,
  *     filterColor.texCoord.y + 0.1 * sin(filterColor.texCoord.x * 10)
  *   ];
- *   filterColor.set(getTexture(canvasContent, warped));
+ *   let tex = filterColor.canvasContent;
+ *   filterColor.set(getTexture(tex, warped));
  *   filterColor.end();
  * }
  *

package/dist/strands/strands_api.js

@@ -1,4 +1,4 @@
-import { u as unaryOpNode, c as createStrandsNode, s as statementNode, v as variableNode, S as StrandsNode, p as primitiveConstructorNode, f as functionCallNode, a as structInstanceNode, b as structConstructorNode, d as binaryOpNode } from '../ir_builders-w12-GSxu.js';
+import { u as unaryOpNode, c as createStrandsNode, S as StrandsNode, p as primitiveConstructorNode, v as variableNode, b as binaryOpNode, s as statementNode, f as functionCallNode, a as structInstanceNode, d as structConstructorNode } from '../ir_builders-DMfaOLIL.js';
 import { OperatorTable, StatementType, NodeType, DataType, BaseType, BlockType, isStructType, structType } from './ir_types.js';
 import { strandsBuiltinFunctions } from './strands_builtins.js';
 import { StrandsConditional } from './strands_conditionals.js';
@@ -101,6 +101,42 @@ function installBuiltinGlobalAccessors(strandsContext) {
   strandsContext._builtinGlobalsAccessorsInstalled = true;
 }
 
+//////////////////////////////////////////////
+// Prototype mirroring helpers
+//////////////////////////////////////////////
+
+/*
+ * Permanently augment both p5.prototype (fn) and p5.Graphics.prototype
+ * with a strands function. Overwrites unconditionally - strands wrappers
+ * are the correct dual mode implementation.
+ */
+function augmentFn(fn, p5, name, value) {
+  fn[name] = value;
+  const GraphicsProto = p5?.Graphics?.prototype;
+  if (GraphicsProto) {
+    GraphicsProto[name] = value;
+  }
+}
+
+/*
+ * Temporarily augment window, p5.prototype (fn), and p5.Graphics.prototype
+ * with a hook function. Saves previous values into strandsContext override
+ * stores so deinitStrandsContext can restore them.
+ */
+function augmentFnTemporary(fn, strandsContext, name, value) {
+  strandsContext.windowOverrides[name] = window[name];
+  strandsContext.fnOverrides[name] = fn[name];
+  window[name] = value;
+  fn[name] = value;
+  const GraphicsProto = strandsContext.p5?.Graphics?.prototype;
+  if (GraphicsProto) {
+    strandsContext.graphicsOverrides[name] = Object.prototype.hasOwnProperty.call(GraphicsProto, name)
+      ? GraphicsProto[name]
+      : undefined;
+    GraphicsProto[name] = value;
+  }
+}
+
 //////////////////////////////////////////////
 // User nodes
 //////////////////////////////////////////////
@@ -124,27 +160,27 @@ function initGlobalStrandsAPI(p5, fn, strandsContext) {
   //////////////////////////////////////////////
   // Unique Functions
   //////////////////////////////////////////////
-  fn.discard = function() {
+  augmentFn(fn, p5, 'discard', function() {
     statementNode(strandsContext, StatementType.DISCARD);
-  };
-  fn.break = function() {
+  });
+  augmentFn(fn, p5, 'break', function() {
     statementNode(strandsContext, StatementType.BREAK);
-  };
+  });
   p5.break = fn.break;
-  fn.instanceID = function() {
+  augmentFn(fn, p5, 'instanceID', function() {
     const node = variableNode(strandsContext, { baseType: BaseType.INT, dimension: 1 }, strandsContext.backend.instanceIdReference());
     return createStrandsNode(node.id, node.dimension, strandsContext);
-  };
+  });
   // Internal methods use p5 static methods; user-facing methods use fn.
   // Some methods need to be used by both.
   p5.strandsIf = function(conditionNode, ifBody) {
     return new StrandsConditional(strandsContext, conditionNode, ifBody);
   };
-  fn.strandsIf = p5.strandsIf;
+  augmentFn(fn, p5, 'strandsIf', p5.strandsIf);
   p5.strandsFor = function(initialCb, conditionCb, updateCb, bodyCb, initialVars) {
     return new StrandsFor(strandsContext, initialCb, conditionCb, updateCb, bodyCb, initialVars).build();
   };
-  fn.strandsFor = p5.strandsFor;
+  augmentFn(fn, p5, 'strandsFor', p5.strandsFor);
   p5.strandsEarlyReturn = function(value) {
     const { dag, cfg } = strandsContext;
 
@@ -177,7 +213,7 @@ function initGlobalStrandsAPI(p5, fn, strandsContext) {
 
     return valueNode;
   };
-  fn.strandsEarlyReturn = p5.strandsEarlyReturn;
+  augmentFn(fn, p5, 'strandsEarlyReturn', p5.strandsEarlyReturn);
   p5.strandsNode = function(...args) {
     if (args.length === 1 && args[0] instanceof StrandsNode) {
       return args[0];
@@ -185,7 +221,20 @@ function initGlobalStrandsAPI(p5, fn, strandsContext) {
     if (args.length > 4) {
       userError("type error", "It looks like you've tried to construct a p5.strands node implicitly, with more than 4 components. This is currently not supported.");
     }
-    const { id, dimension } = primitiveConstructorNode(strandsContext, { baseType: BaseType.FLOAT, dimension: null }, args.flat());
+    // Filter out undefined/null values
+    const flatArgs = args.flat();
+    const definedArgs = flatArgs.filter(a => a !== undefined && a !== null);
+
+    // If all args are undefined, this is likely a `let myVar` at the
+    // start of an if statement and it will be assigned within the branches.
+    // For that, we use an assign-on-use node, meaning we'll take the type of the
+    // values assigned to it.
+    if (definedArgs.length === 0) {
+      const { id, dimension } = primitiveConstructorNode(strandsContext, { baseType: BaseType.ASSIGN_ON_USE, dimension: null }, [0]);
+      return createStrandsNode(id, dimension, strandsContext);
+    }
+
+    const { id, dimension } = primitiveConstructorNode(strandsContext, { baseType: BaseType.FLOAT, dimension: null }, definedArgs);
     return createStrandsNode(id, dimension, strandsContext);//new StrandsNode(id, dimension, strandsContext);
   };
   //////////////////////////////////////////////
@@ -195,16 +244,16 @@ function initGlobalStrandsAPI(p5, fn, strandsContext) {
     const isp5Function = overrides[0].isp5Function;
     if (isp5Function) {
       const originalFn = fn[functionName];
-      fn[functionName] = function(...args) {
+      augmentFn(fn, p5, functionName, function(...args) {
         if (strandsContext.active) {
           const { id, dimension } =  functionCallNode(strandsContext, functionName, args);
           return createStrandsNode(id, dimension, strandsContext);
         } else {
           return originalFn.apply(this, args);
         }
-      };
+      });
     } else {
-      fn[functionName] = function (...args) {
+      augmentFn(fn, p5, functionName, function (...args) {
         if (strandsContext.active) {
           const { id, dimension } = functionCallNode(strandsContext, functionName, args);
           return createStrandsNode(id, dimension, strandsContext);
@@ -213,11 +262,11 @@ function initGlobalStrandsAPI(p5, fn, strandsContext) {
             `It looks like you've called ${functionName} outside of a shader's modify() function.`
           );
         }
-      };
+      });
     }
   }
 
-  fn.getTexture = function (...rawArgs) {
+  augmentFn(fn, p5, 'getTexture', function (...rawArgs) {
     if (strandsContext.active) {
       const { id, dimension } = strandsContext.backend.createGetTextureCall(strandsContext, rawArgs);
       return createStrandsNode(id, dimension, strandsContext);
@@ -226,17 +275,17 @@ function initGlobalStrandsAPI(p5, fn, strandsContext) {
         `It looks like you've called getTexture outside of a shader's modify() function.`
       );
     }
-  };
+  });
 
   // Add texture function as alias for getTexture with p5 fallback
   const originalTexture = fn.texture;
-  fn.texture = function (...args) {
+  augmentFn(fn, p5, 'texture', function (...args) {
     if (strandsContext.active) {
       return this.getTexture(...args);
     } else {
       return originalTexture.apply(this, args);
     }
-  };
+  });
 
   // Add noise function with backend-agnostic implementation
   const originalNoise = fn.noise;
@@ -246,16 +295,16 @@ function initGlobalStrandsAPI(p5, fn, strandsContext) {
   strandsContext._noiseOctaves = null;
   strandsContext._noiseAmpFalloff = null;
 
-  fn.noiseDetail = function (lod, falloff = 0.5) {
+  augmentFn(fn, p5, 'noiseDetail', function (lod, falloff = 0.5) {
     if (!strandsContext.active) {
       return originalNoiseDetail.apply(this, arguments);
     }
 
     strandsContext._noiseOctaves = lod;
     strandsContext._noiseAmpFalloff = falloff;
-  };
+  });
 
-  fn.noise = function (...args) {
+  augmentFn(fn, p5, 'noise', function (...args) {
     if (!strandsContext.active) {
       return originalNoise.apply(this, args); // fallback to regular p5.js noise
     }
@@ -302,9 +351,9 @@ function initGlobalStrandsAPI(p5, fn, strandsContext) {
       }]
     });
     return createStrandsNode(id, dimension, strandsContext);
-  };
+  });
 
-  fn.millis = function (...args) {
+  augmentFn(fn, p5, 'millis', function (...args) {
     if (!strandsContext.active) {
       return originalMillis.apply(this, args);
     }
@@ -317,14 +366,14 @@ function initGlobalStrandsAPI(p5, fn, strandsContext) {
         return instance ? instance.millis() : undefined;
       }
     );
-  };
+  });
 
   // Next is type constructors and uniform functions.
   // For some of them, we have aliases so that you can write either a more human-readable
   // variant or also one more directly translated from GLSL, or to be more compatible with
   // APIs we documented at the release of 2.x and have to continue supporting.
   for (const type in DataType) {
-    if (type === BaseType.DEFER || type === 'sampler') {
+    if (type === BaseType.DEFER || type === BaseType.ASSIGN_ON_USE || type === 'sampler') {
       continue;
     }
     const typeInfo = DataType[type];
@@ -346,13 +395,13 @@ function initGlobalStrandsAPI(p5, fn, strandsContext) {
         typeAliases.push(pascalTypeName.replace('Vec', 'Vector'));
       }
     }
-    fn[`uniform${pascalTypeName}`] = function(name, defaultValue) {
+    augmentFn(fn, p5, `uniform${pascalTypeName}`, function(name, defaultValue) {
       const { id, dimension } = variableNode(strandsContext, typeInfo, name);
       strandsContext.uniforms.push({ name, typeInfo, defaultValue });
       return createStrandsNode(id, dimension, strandsContext);
-    };
+    });
     // Shared variables with smart context detection
-    fn[`shared${pascalTypeName}`] = function(name) {
+    augmentFn(fn, p5, `shared${pascalTypeName}`, function(name) {
       const { id, dimension } = variableNode(strandsContext, typeInfo, name);
 
       // Initialize shared variables tracking if not present
@@ -369,20 +418,20 @@ function initGlobalStrandsAPI(p5, fn, strandsContext) {
       });
 
       return createStrandsNode(id, dimension, strandsContext);
-    };
+    });
 
     // Alias varying* as shared* for backward compatibility
-    fn[`varying${pascalTypeName}`] = fn[`shared${pascalTypeName}`];
+    augmentFn(fn, p5, `varying${pascalTypeName}`, fn[`shared${pascalTypeName}`]);
 
     for (const typeAlias of typeAliases) {
       // For compatibility, also alias uniformVec2 as uniformVector2, what we initially
       // documented these as
-      fn[`uniform${typeAlias}`] = fn[`uniform${pascalTypeName}`];
-      fn[`varying${typeAlias}`] = fn[`varying${pascalTypeName}`];
-      fn[`shared${typeAlias}`] = fn[`shared${pascalTypeName}`];
+      augmentFn(fn, p5, `uniform${typeAlias}`, fn[`uniform${pascalTypeName}`]);
+      augmentFn(fn, p5, `varying${typeAlias}`, fn[`varying${pascalTypeName}`]);
+      augmentFn(fn, p5, `shared${typeAlias}`, fn[`shared${pascalTypeName}`]);
     }
     const originalp5Fn = fn[typeInfo.fnName];
-    fn[typeInfo.fnName] = function(...args) {
+    augmentFn(fn, p5, typeInfo.fnName, function(...args) {
       if (strandsContext.active) {
         if (args.length === 1 && args[0].dimension && args[0].dimension === typeInfo.dimension) {
           const { id, dimension } = functionCallNode(
@@ -414,7 +463,7 @@ function initGlobalStrandsAPI(p5, fn, strandsContext) {
           `It looks like you've called ${typeInfo.fnName} outside of a shader's modify() function.`
         );
       }
-    };
+    });
   }
 }
 //////////////////////////////////////////////
@@ -695,10 +744,7 @@ function createShaderHooksFunctions(strandsContext, fn, shader) {
     }
 
     for (const name of aliases) {
-      strandsContext.windowOverrides[name] = window[name];
-      strandsContext.fnOverrides[name] = fn[name];
-      window[name] = hook;
-      fn[name] = hook;
+      augmentFnTemporary(fn, strandsContext, name, hook);
     }
     hook.earlyReturns = [];
   }

package/dist/strands/strands_conditionals.js

@@ -1,7 +1,7 @@
 import { createBasicBlock, addEdge, pushBlock, popBlock, pushBlockForModification, recordInBasicBlock } from './ir_cfg.js';
 import { getOrCreateNode } from './ir_dag.js';
 import { BlockType, NodeType } from './ir_types.js';
-import { c as createStrandsNode } from '../ir_builders-w12-GSxu.js';
+import { c as createStrandsNode } from '../ir_builders-DMfaOLIL.js';
 import { createPhiNode } from './strands_phi_utils.js';
 import './strands_FES.js';
 import './strands_builtins.js';

package/dist/strands/strands_for.js

@@ -1,7 +1,7 @@
 import { createBasicBlock, addEdge, pushBlock, popBlock, pushBlockForModification, recordInBasicBlock } from './ir_cfg.js';
 import { getNodeDataFromID, createNodeData, getOrCreateNode } from './ir_dag.js';
 import { BlockType, NodeType, StatementType, OpCode, BaseType } from './ir_types.js';
-import { c as createStrandsNode, p as primitiveConstructorNode } from '../ir_builders-w12-GSxu.js';
+import { c as createStrandsNode, p as primitiveConstructorNode } from '../ir_builders-DMfaOLIL.js';
 import { createPhiNode } from './strands_phi_utils.js';
 import './strands_FES.js';
 import './strands_builtins.js';

package/dist/strands/strands_node.js

@@ -1,4 +1,4 @@
-export { S as StrandsNode, c as createStrandsNode } from '../ir_builders-w12-GSxu.js';
+export { S as StrandsNode, c as createStrandsNode } from '../ir_builders-DMfaOLIL.js';
 import './ir_types.js';
 import './ir_dag.js';
 import './ir_cfg.js';

package/dist/strands/strands_phi_utils.js

@@ -1,6 +1,6 @@
 import { recordInBasicBlock } from './ir_cfg.js';
-import { getNodeDataFromID, getOrCreateNode } from './ir_dag.js';
-import { NodeType } from './ir_types.js';
+import { getNodeDataFromID, propagateTypeToAssignOnUse, getOrCreateNode } from './ir_dag.js';
+import { BaseType, NodeType } from './ir_types.js';
 import './strands_FES.js';
 
 function createPhiNode(strandsContext, phiInputs, varName) {
@@ -9,13 +9,31 @@ function createPhiNode(strandsContext, phiInputs, varName) {
   if (validInputs.length === 0) {
     throw new Error(`No valid inputs for phi node for variable ${varName}`);
   }
-  // Get dimension and baseType from first valid input
-  let firstInput = validInputs
-    .map((input) => getNodeDataFromID(strandsContext.dag, input.value.id))
-    .find((input) => input.dimension) ??
-      getNodeDataFromID(strandsContext.dag, validInputs[0].value.id);
-  const dimension = firstInput.dimension;
-  const baseType = firstInput.baseType;
+
+  // Get dimension and baseType from first valid input, skipping ASSIGN_ON_USE nodes
+  const inputNodes = validInputs.map((input) => getNodeDataFromID(strandsContext.dag, input.value.id));
+
+  // Find first non-ASSIGN_ON_USE input to determine type
+  let typeSource = inputNodes.find((input) => input.baseType !== BaseType.ASSIGN_ON_USE && input.dimension) ??
+    inputNodes.find((input) => input.baseType !== BaseType.ASSIGN_ON_USE);
+
+  // If all are ASSIGN_ON_USE, fall back to first input
+  if (!typeSource) {
+    typeSource = inputNodes[0];
+  }
+
+  const dimension = typeSource.dimension;
+  const baseType = typeSource.baseType;
+
+  // Propagate the type to all ASSIGN_ON_USE inputs
+  if (baseType !== BaseType.ASSIGN_ON_USE) {
+    for (const input of inputNodes) {
+      if (input.baseType === BaseType.ASSIGN_ON_USE) {
+        propagateTypeToAssignOnUse(strandsContext.dag, input.id, baseType, dimension);
+      }
+    }
+  }
+
   const nodeData = {
     nodeType: NodeType.PHI,
     dimension,