Fall back to un-optimized filter chain for unknown filters

When AstFilterChain optimization is enabled and a filter chain contains
an unknown filter (e.g. local_dt), fall back to the standard nested
AstMethod evaluation at parse time instead of failing with an
"Unknown filter" error and returning null.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: hs-lsong

src/main/java/com/hubspot/jinjava/el/ext/AstFilterChain.java

@@ -88,6 +88,18 @@ public Object eval(Bindings bindings, ELContext context) {
         return null;
       }
       if (filter == null) {
+        interpreter.addError(
+          new TemplateError(
+            ErrorType.WARNING,
+            ErrorReason.UNKNOWN,
+            ErrorItem.FILTER,
+            String.format("Unknown filter: %s", spec.getName()),
+            spec.getName(),
+            interpreter.getLineNumber(),
+            -1,
+            null
+          )
+        );
         return null;
       }
 

src/main/java/com/hubspot/jinjava/el/ext/ExtendedParser.java

@@ -24,6 +24,7 @@
 import com.google.common.collect.Sets;
 import com.hubspot.jinjava.JinjavaConfig;
 import com.hubspot.jinjava.LegacyOverrides;
+import com.hubspot.jinjava.interpret.DisabledException;
 import com.hubspot.jinjava.interpret.JinjavaInterpreter;
 import de.odysseus.el.tree.impl.Builder;
 import de.odysseus.el.tree.impl.Builder.Feature;
@@ -581,9 +582,49 @@ private AstNode parseFiltersAsChain(AstNode left) throws ScanException, ParseExc
       filterSpecs.add(new FilterSpec(filterName, filterParams));
     } while ("|".equals(getToken().getImage()));
 
+    if (hasUnknownFilter(filterSpecs)) {
+      return buildUnoptimizedFromSpecs(left, filterSpecs);
+    }
     return createAstFilterChain(left, filterSpecs);
   }
 
+  private boolean hasUnknownFilter(List<FilterSpec> filterSpecs) {
+    return JinjavaInterpreter
+      .getCurrentMaybe()
+      .map(interp -> {
+        for (FilterSpec spec : filterSpecs) {
+          try {
+            if (interp.getContext().getFilter(spec.getName()) == null) {
+              return true;
+            }
+          } catch (DisabledException e) {
+            return false;
+          }
+        }
+        return false;
+      })
+      .orElse(false);
+  }
+
+  private AstNode buildUnoptimizedFromSpecs(AstNode input, List<FilterSpec> filterSpecs) {
+    AstNode v = input;
+    for (FilterSpec spec : filterSpecs) {
+      List<AstNode> filterParams = Lists.newArrayList(v, interpreter());
+      if (spec.hasParams()) {
+        for (int i = 0; i < spec.getParams().getCardinality(); i++) {
+          filterParams.add(spec.getParams().getChild(i));
+        }
+      }
+      AstProperty filterProperty = createAstDot(
+        identifier(FILTER_PREFIX + spec.getName()),
+        "filter",
+        true
+      );
+      v = createAstMethod(filterProperty, createAstParameters(filterParams));
+    }
+    return v;
+  }
+
   protected AstNode parseFiltersAsNestedMethods(AstNode left)
     throws ScanException, ParseException {
     AstNode v = left;

src/test/java/com/hubspot/jinjava/el/ext/AstFilterChainTest.java

@@ -4,6 +4,9 @@
 
 import com.hubspot.jinjava.Jinjava;
 import com.hubspot.jinjava.JinjavaConfig;
+import com.hubspot.jinjava.interpret.RenderResult;
+import com.hubspot.jinjava.objects.date.PyishDate;
+import java.time.ZonedDateTime;
 import java.util.HashMap;
 import java.util.Map;
 import org.junit.Before;
@@ -67,4 +70,40 @@ public void itHandlesFilterWithStringConversion() {
     String result = jinjava.render("{{ number|string|length }}", context);
     assertThat(result).isEqualTo("5");
   }
+
+  @Test
+  public void itFallsBackToUnoptimizedForUnknownFilterInChain() {
+    context.put("module", new PyishDate(ZonedDateTime.parse("2024-01-15T10:30:00Z")));
+    RenderResult renderResult = jinjava.renderForResult(
+      "{% set mid = module | local_dt|unixtimestamp | pprint | md5 %}{{ mid }}",
+      context
+    );
+    assertThat(renderResult.getOutput())
+      .as("Should produce MD5 output since chain continues past unknown filter")
+      .hasSize(32);
+    assertThat(
+      renderResult
+        .getErrors()
+        .stream()
+        .noneMatch(e -> e.getMessage().contains("Unknown filter"))
+    )
+      .as("Should not report 'Unknown filter' error when falling back")
+      .isTrue();
+  }
+
+  @Test
+  public void itFallsBackToUnoptimizedForUnknownFilterParity() {
+    String template = "{{ name | unknown_filter | lower | md5 }}";
+    Jinjava jinjavaUnoptimized = new Jinjava(
+      JinjavaConfig.newBuilder().withEnableFilterChainOptimization(false).build()
+    );
+    RenderResult optimizedResult = jinjava.renderForResult(template, context);
+    RenderResult unoptimizedResult = jinjavaUnoptimized.renderForResult(
+      template,
+      context
+    );
+    assertThat(optimizedResult.getOutput())
+      .as("Optimized should match un-optimized for unknown filter in chain")
+      .isEqualTo(unoptimizedResult.getOutput());
+  }
 }