feat: Add isPreserveResolvedSetTags flag for independent set tag preservation

Add a new context configuration flag that allows set tags with fully
resolved RHS values to be preserved in output, independent of macro
deferral behavior. This enables both:
- Macros to partially evaluate (preserving only undefined vars within)
- Set tags to be preserved as {% set x = 'value' %} for multi-pass rendering

Also adds import/from macro tests to verify partial macro evaluation.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <[email protected]>

Author: hs-lsong

src/main/java/com/hubspot/jinjava/interpret/Context.java

@@ -875,6 +875,15 @@ public TemporaryValueClosable<Boolean> withPartialMacroEvaluation(
     return temporaryValueClosable;
   }
 
+  public boolean isPreserveResolvedSetTags() {
+    return contextConfiguration.isPreserveResolvedSetTags();
+  }
+
+  public void setPreserveResolvedSetTags(boolean preserveResolvedSetTags) {
+    contextConfiguration =
+      contextConfiguration.withPreserveResolvedSetTags(preserveResolvedSetTags);
+  }
+
   public boolean isUnwrapRawOverride() {
     return contextConfiguration.isUnwrapRawOverride();
   }

src/main/java/com/hubspot/jinjava/interpret/ContextConfigurationIF.java

@@ -38,6 +38,11 @@ default boolean isPartialMacroEvaluation() {
     return false;
   }
 
+  @Default
+  default boolean isPreserveResolvedSetTags() {
+    return false;
+  }
+
   @Default
   default boolean isUnwrapRawOverride() {
     return false;

src/main/java/com/hubspot/jinjava/lib/tag/eager/EagerSetTagStrategy.java

@@ -58,6 +58,7 @@ public String run(TagNode tagNode, JinjavaInterpreter interpreter) {
     if (
       eagerExecutionResult.getResult().isFullyResolved() &&
       !interpreter.getContext().isDeferredExecutionMode() &&
+      !interpreter.getContext().isPreserveResolvedSetTags() &&
       (Arrays
           .stream(variables)
           .noneMatch(RelativePathResolver.CURRENT_PATH_CONTEXT_KEY::equals) ||

src/main/java/com/hubspot/jinjava/mode/PreserveUndefinedExecutionMode.java

@@ -14,13 +14,16 @@
  *   <li>Expressions with undefined variables are preserved: {@code {{ unknown }}} → {@code {{ unknown }}}</li>
  *   <li>Expressions with defined variables are evaluated: {@code {{ name }}} with {name: "World"} → "World"</li>
  *   <li>Control structures (if/for) with undefined conditions/iterables are preserved</li>
- *   <li>Set tags with undefined RHS are preserved</li>
+ *   <li>Set tags are preserved with evaluated RHS: {@code {% set x = name %}}
+ *       with {name: "World"} → {@code {% set x = 'World' %}}</li>
+ *   <li>Macros are executed; undefined variables within macro output are preserved</li>
  *   <li>Variables explicitly set to null are also preserved</li>
  * </ul>
  *
  * <p>This mode extends {@link EagerExecutionMode} to preserve control structures and tags,
  * but uses a custom expression strategy to preserve the original expression syntax
- * instead of internal representations.
+ * instead of internal representations. It enables partial macro evaluation so that
+ * macros can execute and produce output with undefined parts preserved.
  */
 public class PreserveUndefinedExecutionMode extends EagerExecutionMode {
 
@@ -37,6 +40,7 @@ public void prepareContext(Context context) {
     super.prepareContext(context);
     context.setExpressionStrategy(new PreserveUndefinedExpressionStrategy());
     context.setDynamicVariableResolver(varName -> DeferredValue.instance());
-    context.setDeferredExecutionMode(true);
+    context.setPartialMacroEvaluation(true);
+    context.setPreserveResolvedSetTags(true);
   }
 }

src/test/java/com/hubspot/jinjava/mode/PreserveUndefinedExecutionModeTest.java

@@ -148,6 +148,7 @@ public void itPreservesSetTagWithKnownRHSValue() {
     Map<String, Object> context = new HashMap<>();
     context.put("name", "World");
     String output = render("{% set x = name %}{{ x }}", context);
+    // Set tag is preserved with evaluated RHS for multi-pass rendering
     assertThat(output).isEqualTo("{% set x = 'World' %}World");
   }
 
@@ -174,4 +175,50 @@ public void itPreservesForTagWithUnknownIterable() {
     String output = render("{% for item in items %}{{ item }}{% endfor %}");
     assertThat(output).isEqualTo("{% for item in items %}{{ item }}{% endfor %}");
   }
+
+  @Test
+  public void itPreservesUndefinedInImportedMacro() {
+    jinjava.setResourceLocator((fullName, encoding, interpreter) -> {
+      if (fullName.equals("macros.jinja")) {
+        return "{% macro greet(name) %}Hello {{ name }}, {{ title }}!{% endmacro %}";
+      }
+      return "";
+    });
+
+    String template = "{% import 'macros.jinja' as m %}{{ m.greet('World') }}";
+    String output = render(template);
+    assertThat(output).isEqualTo("Hello World, {{ title }}!");
+  }
+
+  @Test
+  public void itEvaluatesMacroWithAllDefinedVariables() {
+    jinjava.setResourceLocator((fullName, encoding, interpreter) -> {
+      if (fullName.equals("macros.jinja")) {
+        return "{% macro greet(name) %}Hello {{ name }}, {{ title }}!{% endmacro %}";
+      }
+      return "";
+    });
+
+    Map<String, Object> context = new HashMap<>();
+    context.put("title", "Mr");
+    String template = "{% import 'macros.jinja' as m %}{{ m.greet('World') }}";
+    String output = render(template, context);
+    // When all variables are defined, macro fully evaluates
+    assertThat(output).isEqualTo("Hello World, Mr!");
+  }
+
+  @Test
+  public void itPreservesUndefinedInFromImportMacro() {
+    jinjava.setResourceLocator((fullName, encoding, interpreter) -> {
+      if (fullName.equals("macros.jinja")) {
+        return "{% macro greet() %}Hello {{ unknown }}!{% endmacro %}";
+      }
+      return "";
+    });
+
+    String template = "{% from 'macros.jinja' import greet %}{{ greet() }}";
+    String output = render(template);
+    // Macro executes, but undefined variables are preserved
+    assertThat(output).isEqualTo("Hello {{ unknown }}!");
+  }
 }