diff --git a/spicy/toolchain/include/ast/types/unit.h b/spicy/toolchain/include/ast/types/unit.h
index b85db4f8b..e673b5324 100644
--- a/spicy/toolchain/include/ast/types/unit.h
+++ b/spicy/toolchain/include/ast/types/unit.h
@@ -155,15 +155,6 @@ class Unit : detail::AssignIndices,
      */
     bool usesRandomAccess() const { return propertyItem("%random-access").has_value(); }
 
-    /**
-     * Returns true if this unit type supports connecting a filter.
-     *
-     * \todo Currently we tie this capability to unit types being public,
-     * which is just a hack until we get something better. Eventually we
-     * should support this automatically as needed, through static analysis.
-     */
-    bool supportsFilters() const { return isPublic(); }
-
     /**
      * Returns true if this unit type can act as a filter.
      *
diff --git a/spicy/toolchain/src/compiler/codegen/parser-builder.cc b/spicy/toolchain/src/compiler/codegen/parser-builder.cc
index ac48dd7ec..8beef1588 100644
--- a/spicy/toolchain/src/compiler/codegen/parser-builder.cc
+++ b/spicy/toolchain/src/compiler/codegen/parser-builder.cc
@@ -260,7 +260,7 @@ struct ProductionVisitor
 
                     builder()->addLocal("filtered", hilti::builder::strong_reference(type::Stream()));
 
-                    if ( unit && unit->supportsFilters() ) {
+                    if ( unit ) {
                         pb->guardFeatureCode(*unit, "supports_filters", [&]() {
                             // If we have a filter attached, we initialize it and change to parse from its output.
                             auto filtered = builder::assign(builder::id("filtered"),
@@ -377,7 +377,7 @@ struct ProductionVisitor
                 // stage1 method is already declared (but not
                 // implemented) by the struct that unit-builder is
                 // declaring.
-                if ( unit && unit->supportsFilters() ) {
+                if ( unit ) {
                     addParseMethod(id_stage1.str() != "__parse_stage1", id_stage1, build_parse_stage1(), addl_param,
                                    p.location());
                     addParseMethod(true, id_stage2, build_parse_stage12_or_stage2(false), addl_param, p.location());
@@ -1724,9 +1724,8 @@ void ParserBuilder::finalizeUnit(bool success, const Location& l) {
     else
         builder()->addMemberCall(state().self, "__on_0x25_error", {}, l);
 
-    if ( unit.supportsFilters() )
-        guardFeatureCode(unit, "supports_filters",
-                         [&]() { builder()->addCall("spicy_rt::filter_disconnect", {state().self}); });
+    guardFeatureCode(unit, "supports_filters",
+                     [&]() { builder()->addCall("spicy_rt::filter_disconnect", {state().self}); });
 
     if ( unit.isFilter() )
         guardFeatureCode(unit, "is_filter",
@@ -1736,14 +1735,7 @@ void ParserBuilder::finalizeUnit(bool success, const Location& l) {
         builder()->addMemberCall(builder::member(state().self, s.id()), "close", {}, l);
 }
 
-static Expression _filters(const ParserState& state) {
-    hilti::Expression filters;
-
-    if ( state.unit.get().supportsFilters() )
-        return builder::member(state.self, ID("__filters"));
-
-    return builder::null();
-}
+static Expression _filters(const ParserState& state) { return builder::member(state.self, ID("__filters")); }
 
 Expression ParserBuilder::waitForInputOrEod() {
     return builder::call("spicy_rt::waitForInputOrEod", {state().data, state().cur, _filters(state())});
diff --git a/spicy/toolchain/src/compiler/codegen/unit-builder.cc b/spicy/toolchain/src/compiler/codegen/unit-builder.cc
index b8f740cac..3880ea6bd 100644
--- a/spicy/toolchain/src/compiler/codegen/unit-builder.cc
+++ b/spicy/toolchain/src/compiler/codegen/unit-builder.cc
@@ -182,13 +182,11 @@ Type CodeGen::compileUnit(const type::Unit& unit, bool declare_only) {
         if ( unit.isFilter() )
             addDeclaration(builder::constant(ID(fmt("__feat%%%s%%is_filter", typeID)), builder::bool_(true)));
 
-        if ( unit.supportsFilters() )
-            addDeclaration(builder::constant(ID(fmt("__feat%%%s%%supports_filters", typeID)), builder::bool_(true)));
-
-        addDeclaration(builder::constant(ID(fmt("__feat%%%s%%supports_sinks", typeID)), builder::bool_(true)));
-
         if ( unit.usesRandomAccess() )
             addDeclaration(builder::constant(ID(fmt("__feat%%%s%%uses_random_access", typeID)), builder::bool_(true)));
+
+        addDeclaration(builder::constant(ID(fmt("__feat%%%s%%supports_filters", typeID)), builder::bool_(true)));
+        addDeclaration(builder::constant(ID(fmt("__feat%%%s%%supports_sinks", typeID)), builder::bool_(true)));
     }
 
     add_hook("0x25_gap", {builder::parameter("seq", type::UnsignedInteger(64)),
@@ -240,14 +238,11 @@ Type CodeGen::compileUnit(const type::Unit& unit, bool declare_only) {
         v.addField(std::move(sink));
     }
 
-    if ( unit.supportsFilters() ) {
-        auto filters = hilti::declaration::Field(ID("__filters"),
-                                                 hilti::type::StrongReference(builder::typeByID("spicy_rt::Filters")),
-                                                 AttributeSet({Attribute("&internal"),
-                                                               Attribute("&needed-by-feature",
-                                                                         builder::string("supports_filters"))}));
-        v.addField(std::move(filters));
-    }
+    auto filters =
+        hilti::declaration::Field(ID("__filters"), hilti::type::StrongReference(builder::typeByID("spicy_rt::Filters")),
+                                  AttributeSet({Attribute("&internal"),
+                                                Attribute("&needed-by-feature", builder::string("supports_filters"))}));
+    v.addField(std::move(filters));
 
     if ( unit.isFilter() ) {
         auto forward =
diff --git a/spicy/toolchain/src/compiler/visitors/validator.cc b/spicy/toolchain/src/compiler/visitors/validator.cc
index 77638d6e2..0a24cea30 100644
--- a/spicy/toolchain/src/compiler/visitors/validator.cc
+++ b/spicy/toolchain/src/compiler/visitors/validator.cc
@@ -801,9 +801,6 @@ struct VisitorPost : public hilti::visitor::PreOrder<void, VisitorPost>, public
     }
 
     void operator()(const operator_::unit::ConnectFilter& n, position_t p) {
-        if ( auto x = n.op0().type().tryAs<type::Unit>(); x && ! x->supportsFilters() )
-            error("unit type does not support filters", p);
-
         if ( const auto& y =
                  methodArgument(n, 0).type().as<type::StrongReference>().dereferencedType().as<type::Unit>();
              ! y.isFilter() )
diff --git a/tests/Baseline/spicy.optimization.default-parser-functions/log b/tests/Baseline/spicy.optimization.default-parser-functions/log
index 6013de9e8..479a07959 100644
--- a/tests/Baseline/spicy.optimization.default-parser-functions/log
+++ b/tests/Baseline/spicy.optimization.default-parser-functions/log
@@ -1,9 +1,13 @@
 ### BTest baseline data generated by btest-diff. Do not edit. Use "btest -U/-u" to update. Requires BTest >= 0.63.
+[debug/optimizer] disabling feature 'supports_filters' of type 'foo::P0' since it is not used
 [debug/optimizer] disabling feature 'supports_filters' of type 'foo::P1' since it is not used
 [debug/optimizer] disabling feature 'supports_sinks' of type 'foo::P0' since it is not used
 [debug/optimizer] disabling feature 'supports_sinks' of type 'foo::P1' since it is not used
 [debug/optimizer] disabling feature 'supports_sinks' of type 'foo::P2' since it is not used
 [debug/optimizer] disabling feature 'uses_random_access' of type 'foo::P2' since it is not used
+[debug/optimizer] inlining constant 'foo::__feat%foo__P0%supports_filters'
+[debug/optimizer] inlining constant 'foo::__feat%foo__P0%supports_filters'
+[debug/optimizer] inlining constant 'foo::__feat%foo__P0%supports_filters'
 [debug/optimizer] inlining constant 'foo::__feat%foo__P1%supports_filters'
 [debug/optimizer] inlining constant 'foo::__feat%foo__P1%supports_filters'
 [debug/optimizer] inlining constant 'foo::__feat%foo__P1%supports_filters'
@@ -85,6 +89,7 @@
 [debug/optimizer] removing field for unused method foo::__register_foo_P2::<anon-struct-9>::parse1
 [debug/optimizer] removing field for unused method foo::__register_foo_P2::<anon-struct-9>::parse2
 [debug/optimizer] removing field for unused method foo::__register_foo_P2::<anon-struct-9>::parse3
+[debug/optimizer] removing unused member 'foo::P0::__filters'
 [debug/optimizer] removing unused member 'foo::P0::__sink'
 [debug/optimizer] removing unused member 'foo::P1::__filters'
 [debug/optimizer] removing unused member 'foo::P1::__sink'
diff --git a/tests/Baseline/spicy.optimization.default-parser-functions/noopt.hlt b/tests/Baseline/spicy.optimization.default-parser-functions/noopt.hlt
index 5f549b97e..098808c9b 100644
--- a/tests/Baseline/spicy.optimization.default-parser-functions/noopt.hlt
+++ b/tests/Baseline/spicy.optimization.default-parser-functions/noopt.hlt
@@ -7,6 +7,7 @@ import hilti;
 type P0 = struct {
     spicy_rt::Parser __parser &static &internal &needed-by-feature="supports_sinks";
     spicy_rt::SinkState __sink &internal &needed-by-feature="supports_sinks";
+    strong_ref<spicy_rt::Filters> __filters &internal &needed-by-feature="supports_filters";
     hook void __on_0x25_init();
     hook void __on_0x25_done();
     hook void __on_0x25_error();
@@ -20,6 +21,7 @@ type P0 = struct {
     method extern view<stream> parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse2(inout value_ref<P0> unit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse3(inout value_ref<spicy_rt::ParsedUnit> gunit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
+    method tuple<view<stream>, int<64>, iterator<stream>> __parse_foo_P0_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe);
 } &on-heap;
 public type P1 = struct {
     spicy_rt::Parser __parser &static &internal &needed-by-feature="supports_sinks";
@@ -67,24 +69,46 @@ public type P2 = struct {
     method tuple<view<stream>, int<64>, iterator<stream>> __parse_foo_P2_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe);
 } &on-heap;
 
+const bool __feat%foo__P0%supports_filters = True;
 const bool __feat%foo__P0%supports_sinks = True;
 const bool __feat%foo__P1%supports_filters = True;
 const bool __feat%foo__P1%supports_sinks = True;
+const bool __feat%foo__P2%uses_random_access = True;
 const bool __feat%foo__P2%supports_filters = True;
 const bool __feat%foo__P2%supports_sinks = True;
-const bool __feat%foo__P2%uses_random_access = True;
 
 method method tuple<view<stream>, int<64>, iterator<stream>> foo::P0::__parse_stage1(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe) &always-emit {
     local tuple<view<stream>, int<64>, iterator<stream>> __result;
     try {
         hilti::debugIndent("spicy");
         (*self).__on_0x25_init();
-        (*self).__on_0x25_done();
-        hilti::debugDedent("spicy");
-        __result = (__cur, __lah, __lahe);
+        local strong_ref<stream> filtered = Null;
+
+        if ( __feat%foo__P0%supports_filters ) 
+
+            if ( filtered = spicy_rt::filter_init(self, __data, __cur) ) {
+                local value_ref<stream> filtered_data = filtered;
+                (*self).__parse_foo_P0_stage2(filtered_data, (*filtered_data), __trim, __lah, __lahe);
+                __cur = __cur.advance(|__cur|);
+
+                if ( __trim ) 
+                    (*__data).trim(begin(__cur));
+
+                __result = (__cur, __lah, __lahe);
+            }
+
+
+
+        if ( ! filtered ) 
+            __result = (*self).__parse_foo_P0_stage2(__data, __cur, __trim, __lah, __lahe);
+
     }
     catch {
         (*self).__on_0x25_error();
+
+        if ( __feat%foo__P0%supports_filters ) 
+            spicy_rt::filter_disconnect(self);
+
         (*self).__on_0x25_finally();
         throw;
     }
@@ -93,6 +117,18 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::P0::__parse_st
     return __result;
 }
 
+method method tuple<view<stream>, int<64>, iterator<stream>> foo::P0::__parse_foo_P0_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe) &always-emit {
+    local tuple<view<stream>, int<64>, iterator<stream>> __result;
+    (*self).__on_0x25_done();
+
+    if ( __feat%foo__P0%supports_filters ) 
+        spicy_rt::filter_disconnect(self);
+
+    hilti::debugDedent("spicy");
+    __result = (__cur, __lah, __lahe);
+    return __result;
+}
+
 method extern method view<stream> foo::P0::parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit {
     local value_ref<P0> unit = value_ref(default<P0>())value_ref(default<P0>());
     local view<stream> ncur = cur ? (*cur) : cast<view<stream>>((*data));
diff --git a/tests/Baseline/spicy.optimization.default-parser-functions/opt.hlt b/tests/Baseline/spicy.optimization.default-parser-functions/opt.hlt
index 21c6b7cfd..263b204c8 100644
--- a/tests/Baseline/spicy.optimization.default-parser-functions/opt.hlt
+++ b/tests/Baseline/spicy.optimization.default-parser-functions/opt.hlt
@@ -10,6 +10,7 @@ type P0 = struct {
     method extern view<stream> parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse2(inout value_ref<P0> unit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse3(inout value_ref<spicy_rt::ParsedUnit> gunit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
+    method tuple<view<stream>, int<64>, iterator<stream>> __parse_foo_P0_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe);
 } &on-heap;
 public type P1 = struct {
     spicy_rt::Parser __parser &static &internal &needed-by-feature="supports_sinks";
@@ -33,21 +34,24 @@ public type P2 = struct {
     method tuple<view<stream>, int<64>, iterator<stream>> __parse_foo_P2_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe);
 } &on-heap;
 
+const bool __feat%foo__P0%supports_filters = False;
 const bool __feat%foo__P0%supports_sinks = False;
 const bool __feat%foo__P1%supports_filters = False;
 const bool __feat%foo__P1%supports_sinks = False;
+const bool __feat%foo__P2%uses_random_access = False;
 const bool __feat%foo__P2%supports_filters = True;
 const bool __feat%foo__P2%supports_sinks = False;
-const bool __feat%foo__P2%uses_random_access = False;
 
 method method tuple<view<stream>, int<64>, iterator<stream>> foo::P0::__parse_stage1(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe) &always-emit {
     local tuple<view<stream>, int<64>, iterator<stream>> __result;
     try {
         hilti::debugIndent("spicy");
         default<void>();
-        default<void>();
-        hilti::debugDedent("spicy");
-        __result = (__cur, __lah, __lahe);
+        local strong_ref<stream> filtered = Null;
+
+        if ( ! filtered ) 
+            __result = (*self).__parse_foo_P0_stage2(__data, __cur, __trim, __lah, __lahe);
+
     }
     catch {
         default<void>();
@@ -59,6 +63,14 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::P0::__parse_st
     return __result;
 }
 
+method method tuple<view<stream>, int<64>, iterator<stream>> foo::P0::__parse_foo_P0_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe) &always-emit {
+    local tuple<view<stream>, int<64>, iterator<stream>> __result;
+    default<void>();
+    hilti::debugDedent("spicy");
+    __result = (__cur, __lah, __lahe);
+    return __result;
+}
+
 method extern method view<stream> foo::P0::parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit {
     local value_ref<P0> unit = value_ref(default<P0>())value_ref(default<P0>());
     local view<stream> ncur = cur ? (*cur) : cast<view<stream>>((*data));
diff --git a/tests/Baseline/spicy.optimization.feature_requirements/log b/tests/Baseline/spicy.optimization.feature_requirements/log
index ef1fe5f30..5cfe46585 100644
--- a/tests/Baseline/spicy.optimization.feature_requirements/log
+++ b/tests/Baseline/spicy.optimization.feature_requirements/log
@@ -1,11 +1,19 @@
 ### BTest baseline data generated by btest-diff. Do not edit. Use "btest -U/-u" to update. Requires BTest >= 0.63.
 [debug/optimizer] disabling feature 'is_filter' of type 'foo::X3' since it is not used
+[debug/optimizer] disabling feature 'supports_filters' of type 'foo::X1' since it is not used
+[debug/optimizer] disabling feature 'supports_filters' of type 'foo::X2' since it is not used
+[debug/optimizer] disabling feature 'supports_filters' of type 'foo::X3' since it is not used
+[debug/optimizer] disabling feature 'supports_filters' of type 'foo::X4' since it is not used
+[debug/optimizer] disabling feature 'supports_filters' of type 'foo::X6' since it is not used
 [debug/optimizer] disabling feature 'supports_sinks' of type 'foo::X1' since it is not used
 [debug/optimizer] disabling feature 'supports_sinks' of type 'foo::X2' since it is not used
 [debug/optimizer] disabling feature 'supports_sinks' of type 'foo::X3' since it is not used
 [debug/optimizer] disabling feature 'supports_sinks' of type 'foo::X4' since it is not used
 [debug/optimizer] disabling feature 'supports_sinks' of type 'foo::X5' since it is not used
 [debug/optimizer] disabling feature 'uses_random_access' of type 'foo::X2' since it is not used
+[debug/optimizer] inlining constant 'foo::__feat%foo__X1%supports_filters'
+[debug/optimizer] inlining constant 'foo::__feat%foo__X1%supports_filters'
+[debug/optimizer] inlining constant 'foo::__feat%foo__X1%supports_filters'
 [debug/optimizer] inlining constant 'foo::__feat%foo__X1%uses_random_access'
 [debug/optimizer] inlining constant 'foo::__feat%foo__X1%uses_random_access'
 [debug/optimizer] inlining constant 'foo::__feat%foo__X1%uses_random_access'
@@ -20,6 +28,9 @@
 [debug/optimizer] inlining constant 'foo::__feat%foo__X1%uses_random_access'
 [debug/optimizer] inlining constant 'foo::__feat%foo__X1%uses_random_access'
 [debug/optimizer] inlining constant 'foo::__feat%foo__X1%uses_random_access'
+[debug/optimizer] inlining constant 'foo::__feat%foo__X2%supports_filters'
+[debug/optimizer] inlining constant 'foo::__feat%foo__X2%supports_filters'
+[debug/optimizer] inlining constant 'foo::__feat%foo__X2%supports_filters'
 [debug/optimizer] inlining constant 'foo::__feat%foo__X2%uses_random_access'
 [debug/optimizer] inlining constant 'foo::__feat%foo__X2%uses_random_access'
 [debug/optimizer] inlining constant 'foo::__feat%foo__X2%uses_random_access'
@@ -36,11 +47,20 @@
 [debug/optimizer] inlining constant 'foo::__feat%foo__X2%uses_random_access'
 [debug/optimizer] inlining constant 'foo::__feat%foo__X3%is_filter'
 [debug/optimizer] inlining constant 'foo::__feat%foo__X3%is_filter'
+[debug/optimizer] inlining constant 'foo::__feat%foo__X3%supports_filters'
+[debug/optimizer] inlining constant 'foo::__feat%foo__X3%supports_filters'
+[debug/optimizer] inlining constant 'foo::__feat%foo__X3%supports_filters'
 [debug/optimizer] inlining constant 'foo::__feat%foo__X4%is_filter'
 [debug/optimizer] inlining constant 'foo::__feat%foo__X4%is_filter'
+[debug/optimizer] inlining constant 'foo::__feat%foo__X4%supports_filters'
+[debug/optimizer] inlining constant 'foo::__feat%foo__X4%supports_filters'
+[debug/optimizer] inlining constant 'foo::__feat%foo__X4%supports_filters'
 [debug/optimizer] inlining constant 'foo::__feat%foo__X5%supports_filters'
 [debug/optimizer] inlining constant 'foo::__feat%foo__X5%supports_filters'
 [debug/optimizer] inlining constant 'foo::__feat%foo__X5%supports_filters'
+[debug/optimizer] inlining constant 'foo::__feat%foo__X6%supports_filters'
+[debug/optimizer] inlining constant 'foo::__feat%foo__X6%supports_filters'
+[debug/optimizer] inlining constant 'foo::__feat%foo__X6%supports_filters'
 [debug/optimizer] removing declaration for unused function hilti::abort
 [debug/optimizer] removing declaration for unused function hilti::current_time
 [debug/optimizer] removing declaration for unused function hilti::debug
@@ -129,15 +149,20 @@
 [debug/optimizer] removing field for unused method foo::__register_foo_X6::<anon-struct-18>::parse1
 [debug/optimizer] removing field for unused method foo::__register_foo_X6::<anon-struct-18>::parse2
 [debug/optimizer] removing field for unused method foo::__register_foo_X6::<anon-struct-18>::parse3
+[debug/optimizer] removing unused member 'foo::X1::__filters'
 [debug/optimizer] removing unused member 'foo::X1::__sink'
 [debug/optimizer] removing unused member 'foo::X2::__begin'
+[debug/optimizer] removing unused member 'foo::X2::__filters'
 [debug/optimizer] removing unused member 'foo::X2::__position'
 [debug/optimizer] removing unused member 'foo::X2::__position_update'
 [debug/optimizer] removing unused member 'foo::X2::__sink'
+[debug/optimizer] removing unused member 'foo::X3::__filters'
 [debug/optimizer] removing unused member 'foo::X3::__forward'
 [debug/optimizer] removing unused member 'foo::X3::__sink'
+[debug/optimizer] removing unused member 'foo::X4::__filters'
 [debug/optimizer] removing unused member 'foo::X4::__sink'
 [debug/optimizer] removing unused member 'foo::X5::__sink'
+[debug/optimizer] removing unused member 'foo::X6::__filters'
 [debug/optimizer] removing unused member 'spicy_rt::Sink::connect_mime_type'
 [debug/optimizer] removing unused member 'spicy_rt::Sink::connect_mime_type'
 [debug/optimizer] replacing call to unimplemented function foo::X1::__on_0x25_done with default value
diff --git a/tests/Baseline/spicy.optimization.feature_requirements/noopt.hlt b/tests/Baseline/spicy.optimization.feature_requirements/noopt.hlt
index 1250a1adf..0baf704c9 100644
--- a/tests/Baseline/spicy.optimization.feature_requirements/noopt.hlt
+++ b/tests/Baseline/spicy.optimization.feature_requirements/noopt.hlt
@@ -10,6 +10,7 @@ type X1 = struct {
     optional<iterator<stream>> __position_update &internal &needed-by-feature="uses_random_access";
     spicy_rt::Parser __parser &static &internal &needed-by-feature="supports_sinks";
     spicy_rt::SinkState __sink &internal &needed-by-feature="supports_sinks";
+    strong_ref<spicy_rt::Filters> __filters &internal &needed-by-feature="supports_filters";
     hook void __on_0x25_init();
     hook void __on_0x25_done();
     hook void __on_0x25_error();
@@ -23,6 +24,7 @@ type X1 = struct {
     method extern view<stream> parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse2(inout value_ref<X1> unit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse3(inout value_ref<spicy_rt::ParsedUnit> gunit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
+    method tuple<view<stream>, int<64>, iterator<stream>> __parse_foo_X1_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe);
 } &on-heap;
 type X2 = struct {
     optional<iterator<stream>> __begin &internal &needed-by-feature="uses_random_access";
@@ -30,6 +32,7 @@ type X2 = struct {
     optional<iterator<stream>> __position_update &internal &needed-by-feature="uses_random_access";
     spicy_rt::Parser __parser &static &internal &needed-by-feature="supports_sinks";
     spicy_rt::SinkState __sink &internal &needed-by-feature="supports_sinks";
+    strong_ref<spicy_rt::Filters> __filters &internal &needed-by-feature="supports_filters";
     hook void __on_0x25_init();
     hook void __on_0x25_done();
     hook void __on_0x25_error();
@@ -43,10 +46,12 @@ type X2 = struct {
     method extern view<stream> parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse2(inout value_ref<X2> unit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse3(inout value_ref<spicy_rt::ParsedUnit> gunit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
+    method tuple<view<stream>, int<64>, iterator<stream>> __parse_foo_X2_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe);
 } &on-heap;
 type X3 = struct {
     spicy_rt::Parser __parser &static &internal &needed-by-feature="supports_sinks" &needed-by-feature="is_filter";
     spicy_rt::SinkState __sink &internal &needed-by-feature="supports_sinks";
+    strong_ref<spicy_rt::Filters> __filters &internal &needed-by-feature="supports_filters";
     weak_ref<spicy_rt::Forward> __forward &internal &needed-by-feature="is_filter";
     hook void __on_0x25_init();
     hook void __on_0x25_done();
@@ -61,10 +66,12 @@ type X3 = struct {
     method extern view<stream> parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse2(inout value_ref<X3> unit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse3(inout value_ref<spicy_rt::ParsedUnit> gunit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
+    method tuple<view<stream>, int<64>, iterator<stream>> __parse_foo_X3_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe);
 } &on-heap;
 type X4 = struct {
     spicy_rt::Parser __parser &static &internal &needed-by-feature="supports_sinks" &needed-by-feature="is_filter";
     spicy_rt::SinkState __sink &internal &needed-by-feature="supports_sinks";
+    strong_ref<spicy_rt::Filters> __filters &internal &needed-by-feature="supports_filters";
     weak_ref<spicy_rt::Forward> __forward &internal &needed-by-feature="is_filter";
     hook void __on_0x25_init();
     hook void __on_0x25_done();
@@ -79,6 +86,7 @@ type X4 = struct {
     method extern view<stream> parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse2(inout value_ref<X4> unit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse3(inout value_ref<spicy_rt::ParsedUnit> gunit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
+    method tuple<view<stream>, int<64>, iterator<stream>> __parse_foo_X4_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe);
 } &on-heap;
 public type X5 = struct {
     spicy_rt::Parser __parser &static &internal &needed-by-feature="supports_sinks";
@@ -103,6 +111,7 @@ type X6 = struct {
     strong_ref<spicy_rt::Sink> data &default=new spicy_rt::Sink() &internal &needed-by-feature="supports_sinks";
     spicy_rt::Parser __parser &static &internal &needed-by-feature="supports_sinks";
     spicy_rt::SinkState __sink &internal &needed-by-feature="supports_sinks";
+    strong_ref<spicy_rt::Filters> __filters &internal &needed-by-feature="supports_filters";
     hook void __on_0x25_init();
     hook void __on_0x25_done();
     hook void __on_0x25_error();
@@ -116,18 +125,24 @@ type X6 = struct {
     method extern view<stream> parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse2(inout value_ref<X6> unit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse3(inout value_ref<spicy_rt::ParsedUnit> gunit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
+    method tuple<view<stream>, int<64>, iterator<stream>> __parse_foo_X6_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe);
 } &on-heap;
 
-const bool __feat%foo__X1%supports_sinks = True;
 const bool __feat%foo__X1%uses_random_access = True;
-const bool __feat%foo__X2%supports_sinks = True;
+const bool __feat%foo__X1%supports_filters = True;
+const bool __feat%foo__X1%supports_sinks = True;
 const bool __feat%foo__X2%uses_random_access = True;
+const bool __feat%foo__X2%supports_filters = True;
+const bool __feat%foo__X2%supports_sinks = True;
 const bool __feat%foo__X3%is_filter = True;
+const bool __feat%foo__X3%supports_filters = True;
 const bool __feat%foo__X3%supports_sinks = True;
 const bool __feat%foo__X4%is_filter = True;
+const bool __feat%foo__X4%supports_filters = True;
 const bool __feat%foo__X4%supports_sinks = True;
 const bool __feat%foo__X5%supports_filters = True;
 const bool __feat%foo__X5%supports_sinks = True;
+const bool __feat%foo__X6%supports_filters = True;
 const bool __feat%foo__X6%supports_sinks = True;
 
 method hook void foo::X1::__on_0x25_init() {
@@ -158,26 +173,26 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::X1::__parse_st
             }
 
 
+        local strong_ref<stream> filtered = Null;
 
-        if ( __feat%foo__X1%uses_random_access ) 
-            (*self).__position = begin(__cur);
+        if ( __feat%foo__X1%supports_filters ) 
 
+            if ( filtered = spicy_rt::filter_init(self, __data, __cur) ) {
+                local value_ref<stream> filtered_data = filtered;
+                (*self).__parse_foo_X1_stage2(filtered_data, (*filtered_data), __trim, __lah, __lahe);
+                __cur = __cur.advance(|__cur|);
 
-        if ( __feat%foo__X1%uses_random_access ) 
-            (*self).__position_update = Null;
+                if ( __trim ) 
+                    (*__data).trim(begin(__cur));
 
-        (*self).__on_0x25_done();
+                __result = (__cur, __lah, __lahe);
+            }
 
-        if ( __feat%foo__X1%uses_random_access ) 
 
-            if ( (*self).__position_update ) {
-                __cur = __cur.advance((*(*self).__position_update));
-                (*self).__position_update = Null;
-            }
 
+        if ( ! filtered ) 
+            __result = (*self).__parse_foo_X1_stage2(__data, __cur, __trim, __lah, __lahe);
 
-        hilti::debugDedent("spicy");
-        __result = (__cur, __lah, __lahe);
     }
     catch {
 
@@ -186,6 +201,10 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::X1::__parse_st
 
         (*self).__on_0x25_error();
 
+        if ( __feat%foo__X1%supports_filters ) 
+            spicy_rt::filter_disconnect(self);
+
+
         if ( __feat%foo__X1%uses_random_access ) 
             (*self).__position_update = Null;
 
@@ -219,6 +238,35 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::X1::__parse_st
     return __result;
 }
 
+method method tuple<view<stream>, int<64>, iterator<stream>> foo::X1::__parse_foo_X1_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe) &always-emit {
+    local tuple<view<stream>, int<64>, iterator<stream>> __result;
+
+    if ( __feat%foo__X1%uses_random_access ) 
+        (*self).__position = begin(__cur);
+
+
+    if ( __feat%foo__X1%uses_random_access ) 
+        (*self).__position_update = Null;
+
+    (*self).__on_0x25_done();
+
+    if ( __feat%foo__X1%uses_random_access ) 
+
+        if ( (*self).__position_update ) {
+            __cur = __cur.advance((*(*self).__position_update));
+            (*self).__position_update = Null;
+        }
+
+
+
+    if ( __feat%foo__X1%supports_filters ) 
+        spicy_rt::filter_disconnect(self);
+
+    hilti::debugDedent("spicy");
+    __result = (__cur, __lah, __lahe);
+    return __result;
+}
+
 method extern method view<stream> foo::X1::parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit {
     local value_ref<X1> unit = value_ref(default<X1>())value_ref(default<X1>());
     local view<stream> ncur = cur ? (*cur) : cast<view<stream>>((*data));
@@ -299,26 +347,26 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::X2::__parse_st
             }
 
 
+        local strong_ref<stream> filtered = Null;
 
-        if ( __feat%foo__X2%uses_random_access ) 
-            (*self).__position = begin(__cur);
+        if ( __feat%foo__X2%supports_filters ) 
 
+            if ( filtered = spicy_rt::filter_init(self, __data, __cur) ) {
+                local value_ref<stream> filtered_data = filtered;
+                (*self).__parse_foo_X2_stage2(filtered_data, (*filtered_data), __trim, __lah, __lahe);
+                __cur = __cur.advance(|__cur|);
 
-        if ( __feat%foo__X2%uses_random_access ) 
-            (*self).__position_update = Null;
+                if ( __trim ) 
+                    (*__data).trim(begin(__cur));
 
-        (*self).__on_0x25_done();
+                __result = (__cur, __lah, __lahe);
+            }
 
-        if ( __feat%foo__X2%uses_random_access ) 
 
-            if ( (*self).__position_update ) {
-                __cur = __cur.advance((*(*self).__position_update));
-                (*self).__position_update = Null;
-            }
 
+        if ( ! filtered ) 
+            __result = (*self).__parse_foo_X2_stage2(__data, __cur, __trim, __lah, __lahe);
 
-        hilti::debugDedent("spicy");
-        __result = (__cur, __lah, __lahe);
     }
     catch {
 
@@ -327,6 +375,10 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::X2::__parse_st
 
         (*self).__on_0x25_error();
 
+        if ( __feat%foo__X2%supports_filters ) 
+            spicy_rt::filter_disconnect(self);
+
+
         if ( __feat%foo__X2%uses_random_access ) 
             (*self).__position_update = Null;
 
@@ -360,6 +412,35 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::X2::__parse_st
     return __result;
 }
 
+method method tuple<view<stream>, int<64>, iterator<stream>> foo::X2::__parse_foo_X2_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe) &always-emit {
+    local tuple<view<stream>, int<64>, iterator<stream>> __result;
+
+    if ( __feat%foo__X2%uses_random_access ) 
+        (*self).__position = begin(__cur);
+
+
+    if ( __feat%foo__X2%uses_random_access ) 
+        (*self).__position_update = Null;
+
+    (*self).__on_0x25_done();
+
+    if ( __feat%foo__X2%uses_random_access ) 
+
+        if ( (*self).__position_update ) {
+            __cur = __cur.advance((*(*self).__position_update));
+            (*self).__position_update = Null;
+        }
+
+
+
+    if ( __feat%foo__X2%supports_filters ) 
+        spicy_rt::filter_disconnect(self);
+
+    hilti::debugDedent("spicy");
+    __result = (__cur, __lah, __lahe);
+    return __result;
+}
+
 method extern method view<stream> foo::X2::parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit {
     local value_ref<X2> unit = value_ref(default<X2>())value_ref(default<X2>());
     local view<stream> ncur = cur ? (*cur) : cast<view<stream>>((*data));
@@ -421,17 +502,34 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::X3::__parse_st
     try {
         hilti::debugIndent("spicy");
         (*self).__on_0x25_init();
-        (*self).__on_0x25_done();
+        local strong_ref<stream> filtered = Null;
 
-        if ( __feat%foo__X3%is_filter ) 
-            spicy_rt::filter_forward_eod(self);
+        if ( __feat%foo__X3%supports_filters ) 
+
+            if ( filtered = spicy_rt::filter_init(self, __data, __cur) ) {
+                local value_ref<stream> filtered_data = filtered;
+                (*self).__parse_foo_X3_stage2(filtered_data, (*filtered_data), __trim, __lah, __lahe);
+                __cur = __cur.advance(|__cur|);
+
+                if ( __trim ) 
+                    (*__data).trim(begin(__cur));
+
+                __result = (__cur, __lah, __lahe);
+            }
+
+
+
+        if ( ! filtered ) 
+            __result = (*self).__parse_foo_X3_stage2(__data, __cur, __trim, __lah, __lahe);
 
-        hilti::debugDedent("spicy");
-        __result = (__cur, __lah, __lahe);
     }
     catch {
         (*self).__on_0x25_error();
 
+        if ( __feat%foo__X3%supports_filters ) 
+            spicy_rt::filter_disconnect(self);
+
+
         if ( __feat%foo__X3%is_filter ) 
             spicy_rt::filter_forward_eod(self);
 
@@ -443,6 +541,22 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::X3::__parse_st
     return __result;
 }
 
+method method tuple<view<stream>, int<64>, iterator<stream>> foo::X3::__parse_foo_X3_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe) &always-emit {
+    local tuple<view<stream>, int<64>, iterator<stream>> __result;
+    (*self).__on_0x25_done();
+
+    if ( __feat%foo__X3%supports_filters ) 
+        spicy_rt::filter_disconnect(self);
+
+
+    if ( __feat%foo__X3%is_filter ) 
+        spicy_rt::filter_forward_eod(self);
+
+    hilti::debugDedent("spicy");
+    __result = (__cur, __lah, __lahe);
+    return __result;
+}
+
 method extern method view<stream> foo::X3::parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit {
     local value_ref<X3> unit = value_ref(default<X3>())value_ref(default<X3>());
     local view<stream> ncur = cur ? (*cur) : cast<view<stream>>((*data));
@@ -492,17 +606,34 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::X4::__parse_st
     try {
         hilti::debugIndent("spicy");
         (*self).__on_0x25_init();
-        (*self).__on_0x25_done();
+        local strong_ref<stream> filtered = Null;
+
+        if ( __feat%foo__X4%supports_filters ) 
+
+            if ( filtered = spicy_rt::filter_init(self, __data, __cur) ) {
+                local value_ref<stream> filtered_data = filtered;
+                (*self).__parse_foo_X4_stage2(filtered_data, (*filtered_data), __trim, __lah, __lahe);
+                __cur = __cur.advance(|__cur|);
+
+                if ( __trim ) 
+                    (*__data).trim(begin(__cur));
+
+                __result = (__cur, __lah, __lahe);
+            }
 
-        if ( __feat%foo__X4%is_filter ) 
-            spicy_rt::filter_forward_eod(self);
 
-        hilti::debugDedent("spicy");
-        __result = (__cur, __lah, __lahe);
+
+        if ( ! filtered ) 
+            __result = (*self).__parse_foo_X4_stage2(__data, __cur, __trim, __lah, __lahe);
+
     }
     catch {
         (*self).__on_0x25_error();
 
+        if ( __feat%foo__X4%supports_filters ) 
+            spicy_rt::filter_disconnect(self);
+
+
         if ( __feat%foo__X4%is_filter ) 
             spicy_rt::filter_forward_eod(self);
 
@@ -514,6 +645,22 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::X4::__parse_st
     return __result;
 }
 
+method method tuple<view<stream>, int<64>, iterator<stream>> foo::X4::__parse_foo_X4_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe) &always-emit {
+    local tuple<view<stream>, int<64>, iterator<stream>> __result;
+    (*self).__on_0x25_done();
+
+    if ( __feat%foo__X4%supports_filters ) 
+        spicy_rt::filter_disconnect(self);
+
+
+    if ( __feat%foo__X4%is_filter ) 
+        spicy_rt::filter_forward_eod(self);
+
+    hilti::debugDedent("spicy");
+    __result = (__cur, __lah, __lahe);
+    return __result;
+}
+
 method extern method view<stream> foo::X4::parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit {
     local value_ref<X4> unit = value_ref(default<X4>())value_ref(default<X4>());
     local view<stream> ncur = cur ? (*cur) : cast<view<stream>>((*data));
@@ -667,13 +814,33 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::X6::__parse_st
     try {
         hilti::debugIndent("spicy");
         (*self).__on_0x25_init();
-        (*self).__on_0x25_done();
-        (*(*self).data).close();
-        hilti::debugDedent("spicy");
-        __result = (__cur, __lah, __lahe);
+        local strong_ref<stream> filtered = Null;
+
+        if ( __feat%foo__X6%supports_filters ) 
+
+            if ( filtered = spicy_rt::filter_init(self, __data, __cur) ) {
+                local value_ref<stream> filtered_data = filtered;
+                (*self).__parse_foo_X6_stage2(filtered_data, (*filtered_data), __trim, __lah, __lahe);
+                __cur = __cur.advance(|__cur|);
+
+                if ( __trim ) 
+                    (*__data).trim(begin(__cur));
+
+                __result = (__cur, __lah, __lahe);
+            }
+
+
+
+        if ( ! filtered ) 
+            __result = (*self).__parse_foo_X6_stage2(__data, __cur, __trim, __lah, __lahe);
+
     }
     catch {
         (*self).__on_0x25_error();
+
+        if ( __feat%foo__X6%supports_filters ) 
+            spicy_rt::filter_disconnect(self);
+
         (*(*self).data).close();
         (*self).__on_0x25_finally();
         throw;
@@ -683,6 +850,19 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::X6::__parse_st
     return __result;
 }
 
+method method tuple<view<stream>, int<64>, iterator<stream>> foo::X6::__parse_foo_X6_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe) &always-emit {
+    local tuple<view<stream>, int<64>, iterator<stream>> __result;
+    (*self).__on_0x25_done();
+
+    if ( __feat%foo__X6%supports_filters ) 
+        spicy_rt::filter_disconnect(self);
+
+    (*(*self).data).close();
+    hilti::debugDedent("spicy");
+    __result = (__cur, __lah, __lahe);
+    return __result;
+}
+
 method extern method view<stream> foo::X6::parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit {
     local value_ref<X6> unit = value_ref(default<X6>())value_ref(default<X6>());
     local view<stream> ncur = cur ? (*cur) : cast<view<stream>>((*data));
diff --git a/tests/Baseline/spicy.optimization.feature_requirements/opt.hlt b/tests/Baseline/spicy.optimization.feature_requirements/opt.hlt
index 5975ae7b9..31e5d09af 100644
--- a/tests/Baseline/spicy.optimization.feature_requirements/opt.hlt
+++ b/tests/Baseline/spicy.optimization.feature_requirements/opt.hlt
@@ -14,6 +14,7 @@ type X1 = struct {
     method extern view<stream> parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse2(inout value_ref<X1> unit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse3(inout value_ref<spicy_rt::ParsedUnit> gunit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
+    method tuple<view<stream>, int<64>, iterator<stream>> __parse_foo_X1_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe);
 } &on-heap;
 type X2 = struct {
     spicy_rt::Parser __parser &static &internal &needed-by-feature="supports_sinks";
@@ -21,6 +22,7 @@ type X2 = struct {
     method extern view<stream> parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse2(inout value_ref<X2> unit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse3(inout value_ref<spicy_rt::ParsedUnit> gunit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
+    method tuple<view<stream>, int<64>, iterator<stream>> __parse_foo_X2_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe);
 } &on-heap;
 type X3 = struct {
     spicy_rt::Parser __parser &static &internal &needed-by-feature="supports_sinks" &needed-by-feature="is_filter";
@@ -28,6 +30,7 @@ type X3 = struct {
     method extern view<stream> parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse2(inout value_ref<X3> unit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse3(inout value_ref<spicy_rt::ParsedUnit> gunit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
+    method tuple<view<stream>, int<64>, iterator<stream>> __parse_foo_X3_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe);
 } &on-heap;
 type X4 = struct {
     spicy_rt::Parser __parser &static &internal &needed-by-feature="supports_sinks" &needed-by-feature="is_filter";
@@ -36,6 +39,7 @@ type X4 = struct {
     method extern view<stream> parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse2(inout value_ref<X4> unit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse3(inout value_ref<spicy_rt::ParsedUnit> gunit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
+    method tuple<view<stream>, int<64>, iterator<stream>> __parse_foo_X4_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe);
 } &on-heap;
 public type X5 = struct {
     spicy_rt::Parser __parser &static &internal &needed-by-feature="supports_sinks";
@@ -56,18 +60,24 @@ type X6 = struct {
     method extern view<stream> parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse2(inout value_ref<X6> unit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse3(inout value_ref<spicy_rt::ParsedUnit> gunit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
+    method tuple<view<stream>, int<64>, iterator<stream>> __parse_foo_X6_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe);
 } &on-heap;
 
-const bool __feat%foo__X1%supports_sinks = False;
 const bool __feat%foo__X1%uses_random_access = True;
-const bool __feat%foo__X2%supports_sinks = False;
+const bool __feat%foo__X1%supports_filters = False;
+const bool __feat%foo__X1%supports_sinks = False;
 const bool __feat%foo__X2%uses_random_access = False;
+const bool __feat%foo__X2%supports_filters = False;
+const bool __feat%foo__X2%supports_sinks = False;
 const bool __feat%foo__X3%is_filter = False;
+const bool __feat%foo__X3%supports_filters = False;
 const bool __feat%foo__X3%supports_sinks = False;
 const bool __feat%foo__X4%is_filter = True;
+const bool __feat%foo__X4%supports_filters = False;
 const bool __feat%foo__X4%supports_sinks = False;
 const bool __feat%foo__X5%supports_filters = True;
 const bool __feat%foo__X5%supports_sinks = False;
+const bool __feat%foo__X6%supports_filters = False;
 const bool __feat%foo__X6%supports_sinks = True;
 
 method hook void foo::X1::__on_0x25_init() {
@@ -95,23 +105,11 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::X1::__parse_st
             }
 
 
-        
-            (*self).__position = begin(__cur);
-
-        
-            (*self).__position_update = Null;
-
-        default<void>();
-        
-
-            if ( (*self).__position_update ) {
-                __cur = __cur.advance((*(*self).__position_update));
-                (*self).__position_update = Null;
-            }
+        local strong_ref<stream> filtered = Null;
 
+        if ( ! filtered ) 
+            __result = (*self).__parse_foo_X1_stage2(__data, __cur, __trim, __lah, __lahe);
 
-        hilti::debugDedent("spicy");
-        __result = (__cur, __lah, __lahe);
     }
     catch {
         
@@ -148,6 +146,28 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::X1::__parse_st
     return __result;
 }
 
+method method tuple<view<stream>, int<64>, iterator<stream>> foo::X1::__parse_foo_X1_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe) &always-emit {
+    local tuple<view<stream>, int<64>, iterator<stream>> __result;
+    
+        (*self).__position = begin(__cur);
+
+    
+        (*self).__position_update = Null;
+
+    default<void>();
+    
+
+        if ( (*self).__position_update ) {
+            __cur = __cur.advance((*(*self).__position_update));
+            (*self).__position_update = Null;
+        }
+
+
+    hilti::debugDedent("spicy");
+    __result = (__cur, __lah, __lahe);
+    return __result;
+}
+
 method extern method view<stream> foo::X1::parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit {
     local value_ref<X1> unit = value_ref(default<X1>())value_ref(default<X1>());
     local view<stream> ncur = cur ? (*cur) : cast<view<stream>>((*data));
@@ -206,9 +226,11 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::X2::__parse_st
     try {
         hilti::debugIndent("spicy");
         default<void>();
-        default<void>();
-        hilti::debugDedent("spicy");
-        __result = (__cur, __lah, __lahe);
+        local strong_ref<stream> filtered = Null;
+
+        if ( ! filtered ) 
+            __result = (*self).__parse_foo_X2_stage2(__data, __cur, __trim, __lah, __lahe);
+
     }
     catch {
         default<void>();
@@ -220,6 +242,14 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::X2::__parse_st
     return __result;
 }
 
+method method tuple<view<stream>, int<64>, iterator<stream>> foo::X2::__parse_foo_X2_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe) &always-emit {
+    local tuple<view<stream>, int<64>, iterator<stream>> __result;
+    default<void>();
+    hilti::debugDedent("spicy");
+    __result = (__cur, __lah, __lahe);
+    return __result;
+}
+
 method extern method view<stream> foo::X2::parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit {
     local value_ref<X2> unit = value_ref(default<X2>())value_ref(default<X2>());
     local view<stream> ncur = cur ? (*cur) : cast<view<stream>>((*data));
@@ -269,9 +299,11 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::X3::__parse_st
     try {
         hilti::debugIndent("spicy");
         default<void>();
-        default<void>();
-        hilti::debugDedent("spicy");
-        __result = (__cur, __lah, __lahe);
+        local strong_ref<stream> filtered = Null;
+
+        if ( ! filtered ) 
+            __result = (*self).__parse_foo_X3_stage2(__data, __cur, __trim, __lah, __lahe);
+
     }
     catch {
         default<void>();
@@ -283,6 +315,14 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::X3::__parse_st
     return __result;
 }
 
+method method tuple<view<stream>, int<64>, iterator<stream>> foo::X3::__parse_foo_X3_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe) &always-emit {
+    local tuple<view<stream>, int<64>, iterator<stream>> __result;
+    default<void>();
+    hilti::debugDedent("spicy");
+    __result = (__cur, __lah, __lahe);
+    return __result;
+}
+
 method extern method view<stream> foo::X3::parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit {
     local value_ref<X3> unit = value_ref(default<X3>())value_ref(default<X3>());
     local view<stream> ncur = cur ? (*cur) : cast<view<stream>>((*data));
@@ -332,12 +372,11 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::X4::__parse_st
     try {
         hilti::debugIndent("spicy");
         default<void>();
-        default<void>();
-        
-            spicy_rt::filter_forward_eod(self);
+        local strong_ref<stream> filtered = Null;
+
+        if ( ! filtered ) 
+            __result = (*self).__parse_foo_X4_stage2(__data, __cur, __trim, __lah, __lahe);
 
-        hilti::debugDedent("spicy");
-        __result = (__cur, __lah, __lahe);
     }
     catch {
         default<void>();
@@ -352,6 +391,17 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::X4::__parse_st
     return __result;
 }
 
+method method tuple<view<stream>, int<64>, iterator<stream>> foo::X4::__parse_foo_X4_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe) &always-emit {
+    local tuple<view<stream>, int<64>, iterator<stream>> __result;
+    default<void>();
+    
+        spicy_rt::filter_forward_eod(self);
+
+    hilti::debugDedent("spicy");
+    __result = (__cur, __lah, __lahe);
+    return __result;
+}
+
 method extern method view<stream> foo::X4::parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit {
     local value_ref<X4> unit = value_ref(default<X4>())value_ref(default<X4>());
     local view<stream> ncur = cur ? (*cur) : cast<view<stream>>((*data));
@@ -502,10 +552,11 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::X6::__parse_st
     try {
         hilti::debugIndent("spicy");
         (*self).__on_0x25_init();
-        default<void>();
-        (*(*self).data).close();
-        hilti::debugDedent("spicy");
-        __result = (__cur, __lah, __lahe);
+        local strong_ref<stream> filtered = Null;
+
+        if ( ! filtered ) 
+            __result = (*self).__parse_foo_X6_stage2(__data, __cur, __trim, __lah, __lahe);
+
     }
     catch {
         default<void>();
@@ -518,6 +569,15 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::X6::__parse_st
     return __result;
 }
 
+method method tuple<view<stream>, int<64>, iterator<stream>> foo::X6::__parse_foo_X6_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe) &always-emit {
+    local tuple<view<stream>, int<64>, iterator<stream>> __result;
+    default<void>();
+    (*(*self).data).close();
+    hilti::debugDedent("spicy");
+    __result = (__cur, __lah, __lahe);
+    return __result;
+}
+
 method extern method view<stream> foo::X6::parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit {
     local value_ref<X6> unit = value_ref(default<X6>())value_ref(default<X6>());
     local view<stream> ncur = cur ? (*cur) : cast<view<stream>>((*data));
diff --git a/tests/Baseline/spicy.optimization.unused-functions/log b/tests/Baseline/spicy.optimization.unused-functions/log
index 2e3692fe8..a29a3eee4 100644
--- a/tests/Baseline/spicy.optimization.unused-functions/log
+++ b/tests/Baseline/spicy.optimization.unused-functions/log
@@ -1,20 +1,32 @@
 ### BTest baseline data generated by btest-diff. Do not edit. Use "btest -U/-u" to update. Requires BTest >= 0.63.
 [debug/optimizer] disabling feature 'is_filter' of type 'foo::F' since it is not used
+[debug/optimizer] disabling feature 'supports_filters' of type 'foo::A' since it is not used
 [debug/optimizer] disabling feature 'supports_filters' of type 'foo::B' since it is not used
+[debug/optimizer] disabling feature 'supports_filters' of type 'foo::C' since it is not used
 [debug/optimizer] disabling feature 'supports_filters' of type 'foo::D' since it is not used
+[debug/optimizer] disabling feature 'supports_filters' of type 'foo::F' since it is not used
 [debug/optimizer] disabling feature 'supports_sinks' of type 'foo::A' since it is not used
 [debug/optimizer] disabling feature 'supports_sinks' of type 'foo::B' since it is not used
 [debug/optimizer] disabling feature 'supports_sinks' of type 'foo::C' since it is not used
 [debug/optimizer] disabling feature 'supports_sinks' of type 'foo::D' since it is not used
 [debug/optimizer] disabling feature 'supports_sinks' of type 'foo::F' since it is not used
+[debug/optimizer] inlining constant 'foo::__feat%foo__A%supports_filters'
+[debug/optimizer] inlining constant 'foo::__feat%foo__A%supports_filters'
+[debug/optimizer] inlining constant 'foo::__feat%foo__A%supports_filters'
 [debug/optimizer] inlining constant 'foo::__feat%foo__B%supports_filters'
 [debug/optimizer] inlining constant 'foo::__feat%foo__B%supports_filters'
 [debug/optimizer] inlining constant 'foo::__feat%foo__B%supports_filters'
+[debug/optimizer] inlining constant 'foo::__feat%foo__C%supports_filters'
+[debug/optimizer] inlining constant 'foo::__feat%foo__C%supports_filters'
+[debug/optimizer] inlining constant 'foo::__feat%foo__C%supports_filters'
 [debug/optimizer] inlining constant 'foo::__feat%foo__D%supports_filters'
 [debug/optimizer] inlining constant 'foo::__feat%foo__D%supports_filters'
 [debug/optimizer] inlining constant 'foo::__feat%foo__D%supports_filters'
 [debug/optimizer] inlining constant 'foo::__feat%foo__F%is_filter'
 [debug/optimizer] inlining constant 'foo::__feat%foo__F%is_filter'
+[debug/optimizer] inlining constant 'foo::__feat%foo__F%supports_filters'
+[debug/optimizer] inlining constant 'foo::__feat%foo__F%supports_filters'
+[debug/optimizer] inlining constant 'foo::__feat%foo__F%supports_filters'
 [debug/optimizer] removing declaration for unused function foo::f1
 [debug/optimizer] removing declaration for unused function foo::f2
 [debug/optimizer] removing declaration for unused function hilti::abort
@@ -100,12 +112,15 @@
 [debug/optimizer] removing field for unused method foo::__register_foo_F::<anon-struct-16>::parse1
 [debug/optimizer] removing field for unused method foo::__register_foo_F::<anon-struct-16>::parse2
 [debug/optimizer] removing field for unused method foo::__register_foo_F::<anon-struct-16>::parse3
+[debug/optimizer] removing unused member 'foo::A::__filters'
 [debug/optimizer] removing unused member 'foo::A::__sink'
 [debug/optimizer] removing unused member 'foo::B::__filters'
 [debug/optimizer] removing unused member 'foo::B::__sink'
+[debug/optimizer] removing unused member 'foo::C::__filters'
 [debug/optimizer] removing unused member 'foo::C::__sink'
 [debug/optimizer] removing unused member 'foo::D::__filters'
 [debug/optimizer] removing unused member 'foo::D::__sink'
+[debug/optimizer] removing unused member 'foo::F::__filters'
 [debug/optimizer] removing unused member 'foo::F::__forward'
 [debug/optimizer] removing unused member 'foo::F::__sink'
 [debug/optimizer] removing unused member 'spicy_rt::Sink::connect_mime_type'
diff --git a/tests/Baseline/spicy.optimization.unused-functions/noopt.hlt b/tests/Baseline/spicy.optimization.unused-functions/noopt.hlt
index baee32aae..9fc44035a 100644
--- a/tests/Baseline/spicy.optimization.unused-functions/noopt.hlt
+++ b/tests/Baseline/spicy.optimization.unused-functions/noopt.hlt
@@ -7,6 +7,7 @@ import hilti;
 type A = struct {
     spicy_rt::Parser __parser &static &internal &needed-by-feature="supports_sinks";
     spicy_rt::SinkState __sink &internal &needed-by-feature="supports_sinks";
+    strong_ref<spicy_rt::Filters> __filters &internal &needed-by-feature="supports_filters";
     hook void __on_0x25_init();
     hook void __on_0x25_done();
     hook void __on_0x25_error();
@@ -20,6 +21,7 @@ type A = struct {
     method extern view<stream> parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse2(inout value_ref<A> unit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse3(inout value_ref<spicy_rt::ParsedUnit> gunit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
+    method tuple<view<stream>, int<64>, iterator<stream>> __parse_foo_A_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe);
 } &on-heap;
 public type B = struct {
     spicy_rt::Parser __parser &static &internal &needed-by-feature="supports_sinks";
@@ -43,6 +45,7 @@ public type B = struct {
 type C = struct {
     spicy_rt::Parser __parser &static &internal &needed-by-feature="supports_sinks";
     spicy_rt::SinkState __sink &internal &needed-by-feature="supports_sinks";
+    strong_ref<spicy_rt::Filters> __filters &internal &needed-by-feature="supports_filters";
     hook void __on_0x25_init();
     hook void __on_0x25_done();
     hook void __on_0x25_error();
@@ -56,6 +59,7 @@ type C = struct {
     method extern view<stream> parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse2(inout value_ref<C> unit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse3(inout value_ref<spicy_rt::ParsedUnit> gunit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
+    method tuple<view<stream>, int<64>, iterator<stream>> __parse_foo_C_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe);
 } &on-heap;
 public type D = struct {
     value_ref<C> anon &optional &no-emit;
@@ -80,6 +84,7 @@ public type D = struct {
 type F = struct {
     spicy_rt::Parser __parser &static &internal &needed-by-feature="supports_sinks" &needed-by-feature="is_filter";
     spicy_rt::SinkState __sink &internal &needed-by-feature="supports_sinks";
+    strong_ref<spicy_rt::Filters> __filters &internal &needed-by-feature="supports_filters";
     weak_ref<spicy_rt::Forward> __forward &internal &needed-by-feature="is_filter";
     hook void __on_0x25_init();
     hook void __on_0x25_done();
@@ -94,15 +99,19 @@ type F = struct {
     method extern view<stream> parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse2(inout value_ref<F> unit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse3(inout value_ref<spicy_rt::ParsedUnit> gunit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
+    method tuple<view<stream>, int<64>, iterator<stream>> __parse_foo_F_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe);
 } &on-heap;
 
+const bool __feat%foo__A%supports_filters = True;
 const bool __feat%foo__A%supports_sinks = True;
 const bool __feat%foo__B%supports_filters = True;
 const bool __feat%foo__B%supports_sinks = True;
+const bool __feat%foo__C%supports_filters = True;
 const bool __feat%foo__C%supports_sinks = True;
 const bool __feat%foo__D%supports_filters = True;
 const bool __feat%foo__D%supports_sinks = True;
 const bool __feat%foo__F%is_filter = True;
+const bool __feat%foo__F%supports_filters = True;
 const bool __feat%foo__F%supports_sinks = True;
 
 function void f1() {
@@ -116,12 +125,33 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::A::__parse_sta
     try {
         hilti::debugIndent("spicy");
         (*self).__on_0x25_init();
-        (*self).__on_0x25_done();
-        hilti::debugDedent("spicy");
-        __result = (__cur, __lah, __lahe);
+        local strong_ref<stream> filtered = Null;
+
+        if ( __feat%foo__A%supports_filters ) 
+
+            if ( filtered = spicy_rt::filter_init(self, __data, __cur) ) {
+                local value_ref<stream> filtered_data = filtered;
+                (*self).__parse_foo_A_stage2(filtered_data, (*filtered_data), __trim, __lah, __lahe);
+                __cur = __cur.advance(|__cur|);
+
+                if ( __trim ) 
+                    (*__data).trim(begin(__cur));
+
+                __result = (__cur, __lah, __lahe);
+            }
+
+
+
+        if ( ! filtered ) 
+            __result = (*self).__parse_foo_A_stage2(__data, __cur, __trim, __lah, __lahe);
+
     }
     catch {
         (*self).__on_0x25_error();
+
+        if ( __feat%foo__A%supports_filters ) 
+            spicy_rt::filter_disconnect(self);
+
         (*self).__on_0x25_finally();
         throw;
     }
@@ -130,6 +160,18 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::A::__parse_sta
     return __result;
 }
 
+method method tuple<view<stream>, int<64>, iterator<stream>> foo::A::__parse_foo_A_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe) &always-emit {
+    local tuple<view<stream>, int<64>, iterator<stream>> __result;
+    (*self).__on_0x25_done();
+
+    if ( __feat%foo__A%supports_filters ) 
+        spicy_rt::filter_disconnect(self);
+
+    hilti::debugDedent("spicy");
+    __result = (__cur, __lah, __lahe);
+    return __result;
+}
+
 method extern method view<stream> foo::A::parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit {
     local value_ref<A> unit = value_ref(default<A>())value_ref(default<A>());
     local view<stream> ncur = cur ? (*cur) : cast<view<stream>>((*data));
@@ -275,12 +317,33 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::C::__parse_sta
     try {
         hilti::debugIndent("spicy");
         (*self).__on_0x25_init();
-        (*self).__on_0x25_done();
-        hilti::debugDedent("spicy");
-        __result = (__cur, __lah, __lahe);
+        local strong_ref<stream> filtered = Null;
+
+        if ( __feat%foo__C%supports_filters ) 
+
+            if ( filtered = spicy_rt::filter_init(self, __data, __cur) ) {
+                local value_ref<stream> filtered_data = filtered;
+                (*self).__parse_foo_C_stage2(filtered_data, (*filtered_data), __trim, __lah, __lahe);
+                __cur = __cur.advance(|__cur|);
+
+                if ( __trim ) 
+                    (*__data).trim(begin(__cur));
+
+                __result = (__cur, __lah, __lahe);
+            }
+
+
+
+        if ( ! filtered ) 
+            __result = (*self).__parse_foo_C_stage2(__data, __cur, __trim, __lah, __lahe);
+
     }
     catch {
         (*self).__on_0x25_error();
+
+        if ( __feat%foo__C%supports_filters ) 
+            spicy_rt::filter_disconnect(self);
+
         (*self).__on_0x25_finally();
         throw;
     }
@@ -289,6 +352,18 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::C::__parse_sta
     return __result;
 }
 
+method method tuple<view<stream>, int<64>, iterator<stream>> foo::C::__parse_foo_C_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe) &always-emit {
+    local tuple<view<stream>, int<64>, iterator<stream>> __result;
+    (*self).__on_0x25_done();
+
+    if ( __feat%foo__C%supports_filters ) 
+        spicy_rt::filter_disconnect(self);
+
+    hilti::debugDedent("spicy");
+    __result = (__cur, __lah, __lahe);
+    return __result;
+}
+
 method extern method view<stream> foo::C::parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit {
     local value_ref<C> unit = value_ref(default<C>())value_ref(default<C>());
     local view<stream> ncur = cur ? (*cur) : cast<view<stream>>((*data));
@@ -441,17 +516,34 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::F::__parse_sta
     try {
         hilti::debugIndent("spicy");
         (*self).__on_0x25_init();
-        (*self).__on_0x25_done();
+        local strong_ref<stream> filtered = Null;
 
-        if ( __feat%foo__F%is_filter ) 
-            spicy_rt::filter_forward_eod(self);
+        if ( __feat%foo__F%supports_filters ) 
+
+            if ( filtered = spicy_rt::filter_init(self, __data, __cur) ) {
+                local value_ref<stream> filtered_data = filtered;
+                (*self).__parse_foo_F_stage2(filtered_data, (*filtered_data), __trim, __lah, __lahe);
+                __cur = __cur.advance(|__cur|);
+
+                if ( __trim ) 
+                    (*__data).trim(begin(__cur));
+
+                __result = (__cur, __lah, __lahe);
+            }
+
+
+
+        if ( ! filtered ) 
+            __result = (*self).__parse_foo_F_stage2(__data, __cur, __trim, __lah, __lahe);
 
-        hilti::debugDedent("spicy");
-        __result = (__cur, __lah, __lahe);
     }
     catch {
         (*self).__on_0x25_error();
 
+        if ( __feat%foo__F%supports_filters ) 
+            spicy_rt::filter_disconnect(self);
+
+
         if ( __feat%foo__F%is_filter ) 
             spicy_rt::filter_forward_eod(self);
 
@@ -463,6 +555,22 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::F::__parse_sta
     return __result;
 }
 
+method method tuple<view<stream>, int<64>, iterator<stream>> foo::F::__parse_foo_F_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe) &always-emit {
+    local tuple<view<stream>, int<64>, iterator<stream>> __result;
+    (*self).__on_0x25_done();
+
+    if ( __feat%foo__F%supports_filters ) 
+        spicy_rt::filter_disconnect(self);
+
+
+    if ( __feat%foo__F%is_filter ) 
+        spicy_rt::filter_forward_eod(self);
+
+    hilti::debugDedent("spicy");
+    __result = (__cur, __lah, __lahe);
+    return __result;
+}
+
 method extern method view<stream> foo::F::parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit {
     local value_ref<F> unit = value_ref(default<F>())value_ref(default<F>());
     local view<stream> ncur = cur ? (*cur) : cast<view<stream>>((*data));
diff --git a/tests/Baseline/spicy.optimization.unused-functions/opt.hlt b/tests/Baseline/spicy.optimization.unused-functions/opt.hlt
index 0991fbb0d..480aeea55 100644
--- a/tests/Baseline/spicy.optimization.unused-functions/opt.hlt
+++ b/tests/Baseline/spicy.optimization.unused-functions/opt.hlt
@@ -10,6 +10,7 @@ type A = struct {
     method extern view<stream> parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse2(inout value_ref<A> unit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse3(inout value_ref<spicy_rt::ParsedUnit> gunit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
+    method tuple<view<stream>, int<64>, iterator<stream>> __parse_foo_A_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe);
 } &on-heap;
 public type B = struct {
     spicy_rt::Parser __parser &static &internal &needed-by-feature="supports_sinks";
@@ -25,6 +26,7 @@ type C = struct {
     method extern view<stream> parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse2(inout value_ref<C> unit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse3(inout value_ref<spicy_rt::ParsedUnit> gunit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
+    method tuple<view<stream>, int<64>, iterator<stream>> __parse_foo_C_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe);
 } &on-heap;
 public type D = struct {
     value_ref<C> anon &optional &no-emit;
@@ -41,15 +43,19 @@ type F = struct {
     method extern view<stream> parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse2(inout value_ref<F> unit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse3(inout value_ref<spicy_rt::ParsedUnit> gunit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
+    method tuple<view<stream>, int<64>, iterator<stream>> __parse_foo_F_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe);
 } &on-heap;
 
+const bool __feat%foo__A%supports_filters = False;
 const bool __feat%foo__A%supports_sinks = False;
 const bool __feat%foo__B%supports_filters = False;
 const bool __feat%foo__B%supports_sinks = False;
+const bool __feat%foo__C%supports_filters = False;
 const bool __feat%foo__C%supports_sinks = False;
 const bool __feat%foo__D%supports_filters = False;
 const bool __feat%foo__D%supports_sinks = False;
 const bool __feat%foo__F%is_filter = False;
+const bool __feat%foo__F%supports_filters = False;
 const bool __feat%foo__F%supports_sinks = False;
 
 method method tuple<view<stream>, int<64>, iterator<stream>> foo::A::__parse_stage1(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe) &always-emit {
@@ -57,9 +63,11 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::A::__parse_sta
     try {
         hilti::debugIndent("spicy");
         default<void>();
-        default<void>();
-        hilti::debugDedent("spicy");
-        __result = (__cur, __lah, __lahe);
+        local strong_ref<stream> filtered = Null;
+
+        if ( ! filtered ) 
+            __result = (*self).__parse_foo_A_stage2(__data, __cur, __trim, __lah, __lahe);
+
     }
     catch {
         default<void>();
@@ -71,6 +79,14 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::A::__parse_sta
     return __result;
 }
 
+method method tuple<view<stream>, int<64>, iterator<stream>> foo::A::__parse_foo_A_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe) &always-emit {
+    local tuple<view<stream>, int<64>, iterator<stream>> __result;
+    default<void>();
+    hilti::debugDedent("spicy");
+    __result = (__cur, __lah, __lahe);
+    return __result;
+}
+
 method extern method view<stream> foo::A::parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit {
     local value_ref<A> unit = value_ref(default<A>())value_ref(default<A>());
     local view<stream> ncur = cur ? (*cur) : cast<view<stream>>((*data));
@@ -193,9 +209,11 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::C::__parse_sta
     try {
         hilti::debugIndent("spicy");
         default<void>();
-        default<void>();
-        hilti::debugDedent("spicy");
-        __result = (__cur, __lah, __lahe);
+        local strong_ref<stream> filtered = Null;
+
+        if ( ! filtered ) 
+            __result = (*self).__parse_foo_C_stage2(__data, __cur, __trim, __lah, __lahe);
+
     }
     catch {
         default<void>();
@@ -207,6 +225,14 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::C::__parse_sta
     return __result;
 }
 
+method method tuple<view<stream>, int<64>, iterator<stream>> foo::C::__parse_foo_C_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe) &always-emit {
+    local tuple<view<stream>, int<64>, iterator<stream>> __result;
+    default<void>();
+    hilti::debugDedent("spicy");
+    __result = (__cur, __lah, __lahe);
+    return __result;
+}
+
 method extern method view<stream> foo::C::parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit {
     local value_ref<C> unit = value_ref(default<C>())value_ref(default<C>());
     local view<stream> ncur = cur ? (*cur) : cast<view<stream>>((*data));
@@ -336,9 +362,11 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::F::__parse_sta
     try {
         hilti::debugIndent("spicy");
         default<void>();
-        default<void>();
-        hilti::debugDedent("spicy");
-        __result = (__cur, __lah, __lahe);
+        local strong_ref<stream> filtered = Null;
+
+        if ( ! filtered ) 
+            __result = (*self).__parse_foo_F_stage2(__data, __cur, __trim, __lah, __lahe);
+
     }
     catch {
         default<void>();
@@ -350,6 +378,14 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::F::__parse_sta
     return __result;
 }
 
+method method tuple<view<stream>, int<64>, iterator<stream>> foo::F::__parse_foo_F_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe) &always-emit {
+    local tuple<view<stream>, int<64>, iterator<stream>> __result;
+    default<void>();
+    hilti::debugDedent("spicy");
+    __result = (__cur, __lah, __lahe);
+    return __result;
+}
+
 method extern method view<stream> foo::F::parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit {
     local value_ref<F> unit = value_ref(default<F>())value_ref(default<F>());
     local view<stream> ncur = cur ? (*cur) : cast<view<stream>>((*data));
diff --git a/tests/Baseline/spicy.optimization.unused-types/log b/tests/Baseline/spicy.optimization.unused-types/log
index 6f4230097..b146c68a5 100644
--- a/tests/Baseline/spicy.optimization.unused-types/log
+++ b/tests/Baseline/spicy.optimization.unused-types/log
@@ -1,5 +1,11 @@
 ### BTest baseline data generated by btest-diff. Do not edit. Use "btest -U/-u" to update. Requires BTest >= 0.63.
+[debug/optimizer] disabling feature 'supports_filters' of type 'foo::Priv1' since it is not used
 [debug/optimizer] disabling feature 'supports_filters' of type 'foo::Priv10' since it is not used
+[debug/optimizer] disabling feature 'supports_filters' of type 'foo::Priv2' since it is not used
+[debug/optimizer] disabling feature 'supports_filters' of type 'foo::Priv3' since it is not used
+[debug/optimizer] disabling feature 'supports_filters' of type 'foo::Priv4' since it is not used
+[debug/optimizer] disabling feature 'supports_filters' of type 'foo::Priv5' since it is not used
+[debug/optimizer] disabling feature 'supports_filters' of type 'foo::Priv6' since it is not used
 [debug/optimizer] disabling feature 'supports_filters' of type 'foo::Pub2' since it is not used
 [debug/optimizer] disabling feature 'supports_filters' of type 'foo::Pub3' since it is not used
 [debug/optimizer] disabling feature 'supports_sinks' of type 'foo::Priv1' since it is not used
@@ -11,9 +17,27 @@
 [debug/optimizer] disabling feature 'supports_sinks' of type 'foo::Priv6' since it is not used
 [debug/optimizer] disabling feature 'supports_sinks' of type 'foo::Pub2' since it is not used
 [debug/optimizer] disabling feature 'supports_sinks' of type 'foo::Pub3' since it is not used
+[debug/optimizer] inlining constant 'foo::__feat%foo__Priv1%supports_filters'
+[debug/optimizer] inlining constant 'foo::__feat%foo__Priv1%supports_filters'
+[debug/optimizer] inlining constant 'foo::__feat%foo__Priv1%supports_filters'
 [debug/optimizer] inlining constant 'foo::__feat%foo__Priv10%supports_filters'
 [debug/optimizer] inlining constant 'foo::__feat%foo__Priv10%supports_filters'
 [debug/optimizer] inlining constant 'foo::__feat%foo__Priv10%supports_filters'
+[debug/optimizer] inlining constant 'foo::__feat%foo__Priv2%supports_filters'
+[debug/optimizer] inlining constant 'foo::__feat%foo__Priv2%supports_filters'
+[debug/optimizer] inlining constant 'foo::__feat%foo__Priv2%supports_filters'
+[debug/optimizer] inlining constant 'foo::__feat%foo__Priv3%supports_filters'
+[debug/optimizer] inlining constant 'foo::__feat%foo__Priv3%supports_filters'
+[debug/optimizer] inlining constant 'foo::__feat%foo__Priv3%supports_filters'
+[debug/optimizer] inlining constant 'foo::__feat%foo__Priv4%supports_filters'
+[debug/optimizer] inlining constant 'foo::__feat%foo__Priv4%supports_filters'
+[debug/optimizer] inlining constant 'foo::__feat%foo__Priv4%supports_filters'
+[debug/optimizer] inlining constant 'foo::__feat%foo__Priv5%supports_filters'
+[debug/optimizer] inlining constant 'foo::__feat%foo__Priv5%supports_filters'
+[debug/optimizer] inlining constant 'foo::__feat%foo__Priv5%supports_filters'
+[debug/optimizer] inlining constant 'foo::__feat%foo__Priv6%supports_filters'
+[debug/optimizer] inlining constant 'foo::__feat%foo__Priv6%supports_filters'
+[debug/optimizer] inlining constant 'foo::__feat%foo__Priv6%supports_filters'
 [debug/optimizer] inlining constant 'foo::__feat%foo__Pub2%supports_filters'
 [debug/optimizer] inlining constant 'foo::__feat%foo__Pub2%supports_filters'
 [debug/optimizer] inlining constant 'foo::__feat%foo__Pub2%supports_filters'
@@ -155,11 +179,17 @@
 [debug/optimizer] removing field for unused method foo::__register_foo_Pub3::<anon-struct-28>::parse3
 [debug/optimizer] removing unused member 'foo::Priv10::__filters'
 [debug/optimizer] removing unused member 'foo::Priv10::__sink'
+[debug/optimizer] removing unused member 'foo::Priv1::__filters'
 [debug/optimizer] removing unused member 'foo::Priv1::__sink'
+[debug/optimizer] removing unused member 'foo::Priv2::__filters'
 [debug/optimizer] removing unused member 'foo::Priv2::__sink'
+[debug/optimizer] removing unused member 'foo::Priv3::__filters'
 [debug/optimizer] removing unused member 'foo::Priv3::__sink'
+[debug/optimizer] removing unused member 'foo::Priv4::__filters'
 [debug/optimizer] removing unused member 'foo::Priv4::__sink'
+[debug/optimizer] removing unused member 'foo::Priv5::__filters'
 [debug/optimizer] removing unused member 'foo::Priv5::__sink'
+[debug/optimizer] removing unused member 'foo::Priv6::__filters'
 [debug/optimizer] removing unused member 'foo::Priv6::__sink'
 [debug/optimizer] removing unused member 'foo::Pub2::__filters'
 [debug/optimizer] removing unused member 'foo::Pub2::__sink'
diff --git a/tests/Baseline/spicy.optimization.unused-types/noopt.hlt b/tests/Baseline/spicy.optimization.unused-types/noopt.hlt
index c62b580e5..a084581f7 100644
--- a/tests/Baseline/spicy.optimization.unused-types/noopt.hlt
+++ b/tests/Baseline/spicy.optimization.unused-types/noopt.hlt
@@ -7,6 +7,7 @@ import hilti;
 type Priv1 = struct {
     spicy_rt::Parser __parser &static &internal &needed-by-feature="supports_sinks";
     spicy_rt::SinkState __sink &internal &needed-by-feature="supports_sinks";
+    strong_ref<spicy_rt::Filters> __filters &internal &needed-by-feature="supports_filters";
     hook void __on_0x25_init();
     hook void __on_0x25_done();
     hook void __on_0x25_error();
@@ -20,6 +21,7 @@ type Priv1 = struct {
     method extern view<stream> parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse2(inout value_ref<Priv1> unit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse3(inout value_ref<spicy_rt::ParsedUnit> gunit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
+    method tuple<view<stream>, int<64>, iterator<stream>> __parse_foo_Priv1_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe);
 } &on-heap;
 public type Pub2 = struct {
     spicy_rt::Parser __parser &static &internal &needed-by-feature="supports_sinks";
@@ -43,6 +45,7 @@ public type Pub2 = struct {
 type Priv2 = struct {
     spicy_rt::Parser __parser &static &internal &needed-by-feature="supports_sinks";
     spicy_rt::SinkState __sink &internal &needed-by-feature="supports_sinks";
+    strong_ref<spicy_rt::Filters> __filters &internal &needed-by-feature="supports_filters";
     hook void __on_0x25_init();
     hook void __on_0x25_done();
     hook void __on_0x25_error();
@@ -56,10 +59,12 @@ type Priv2 = struct {
     method extern view<stream> parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse2(inout value_ref<Priv2> unit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse3(inout value_ref<spicy_rt::ParsedUnit> gunit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
+    method tuple<view<stream>, int<64>, iterator<stream>> __parse_foo_Priv2_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe);
 } &on-heap;
 type Priv3 = struct {
     spicy_rt::Parser __parser &static &internal &needed-by-feature="supports_sinks";
     spicy_rt::SinkState __sink &internal &needed-by-feature="supports_sinks";
+    strong_ref<spicy_rt::Filters> __filters &internal &needed-by-feature="supports_filters";
     hook void __on_0x25_init();
     hook void __on_0x25_done();
     hook void __on_0x25_error();
@@ -73,12 +78,14 @@ type Priv3 = struct {
     method extern view<stream> parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse2(inout value_ref<Priv3> unit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse3(inout value_ref<spicy_rt::ParsedUnit> gunit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
+    method tuple<view<stream>, int<64>, iterator<stream>> __parse_foo_Priv3_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe);
 } &on-heap;
 type Priv4 = struct {
     value_ref<Priv2> anon &optional &no-emit;
     value_ref<Priv3> x &optional;
     spicy_rt::Parser __parser &static &internal &needed-by-feature="supports_sinks";
     spicy_rt::SinkState __sink &internal &needed-by-feature="supports_sinks";
+    strong_ref<spicy_rt::Filters> __filters &internal &needed-by-feature="supports_filters";
     hook void __on_x(value_ref<Priv3> __dd);
     hook void __on_0x25_init();
     hook void __on_0x25_done();
@@ -93,10 +100,12 @@ type Priv4 = struct {
     method extern view<stream> parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse2(inout value_ref<Priv4> unit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse3(inout value_ref<spicy_rt::ParsedUnit> gunit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
+    method tuple<view<stream>, int<64>, iterator<stream>> __parse_foo_Priv4_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe);
 } &on-heap;
 type Priv5 = struct {
     spicy_rt::Parser __parser &static &internal &needed-by-feature="supports_sinks";
     spicy_rt::SinkState __sink &internal &needed-by-feature="supports_sinks";
+    strong_ref<spicy_rt::Filters> __filters &internal &needed-by-feature="supports_filters";
     hook void __on_0x25_init();
     hook void __on_0x25_done();
     hook void __on_0x25_error();
@@ -110,10 +119,12 @@ type Priv5 = struct {
     method extern view<stream> parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse2(inout value_ref<Priv5> unit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse3(inout value_ref<spicy_rt::ParsedUnit> gunit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
+    method tuple<view<stream>, int<64>, iterator<stream>> __parse_foo_Priv5_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe);
 } &on-heap;
 type Priv6 = struct {
     spicy_rt::Parser __parser &static &internal &needed-by-feature="supports_sinks";
     spicy_rt::SinkState __sink &internal &needed-by-feature="supports_sinks";
+    strong_ref<spicy_rt::Filters> __filters &internal &needed-by-feature="supports_filters";
     hook void __on_0x25_init();
     hook void __on_0x25_done();
     hook void __on_0x25_error();
@@ -127,6 +138,7 @@ type Priv6 = struct {
     method extern view<stream> parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse2(inout value_ref<Priv6> unit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse3(inout value_ref<spicy_rt::ParsedUnit> gunit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
+    method tuple<view<stream>, int<64>, iterator<stream>> __parse_foo_Priv6_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe);
 } &on-heap;
 public type Pub3 = struct {
     value_ref<Priv5> anon_2 &optional &no-emit;
@@ -178,13 +190,19 @@ public type Priv10 = struct {
 type Priv11 = enum { A = 0, B = 1, C = 2 };
 type Priv12 = enum { A = 0, B = 1, C = 2 };
 
+const bool __feat%foo__Priv1%supports_filters = True;
 const bool __feat%foo__Priv1%supports_sinks = True;
 const bool __feat%foo__Pub2%supports_filters = True;
 const bool __feat%foo__Pub2%supports_sinks = True;
+const bool __feat%foo__Priv2%supports_filters = True;
 const bool __feat%foo__Priv2%supports_sinks = True;
+const bool __feat%foo__Priv3%supports_filters = True;
 const bool __feat%foo__Priv3%supports_sinks = True;
+const bool __feat%foo__Priv4%supports_filters = True;
 const bool __feat%foo__Priv4%supports_sinks = True;
+const bool __feat%foo__Priv5%supports_filters = True;
 const bool __feat%foo__Priv5%supports_sinks = True;
+const bool __feat%foo__Priv6%supports_filters = True;
 const bool __feat%foo__Priv6%supports_sinks = True;
 const bool __feat%foo__Pub3%supports_filters = True;
 const bool __feat%foo__Pub3%supports_sinks = True;
@@ -199,12 +217,33 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::Priv1::__parse
     try {
         hilti::debugIndent("spicy");
         (*self).__on_0x25_init();
-        (*self).__on_0x25_done();
-        hilti::debugDedent("spicy");
-        __result = (__cur, __lah, __lahe);
+        local strong_ref<stream> filtered = Null;
+
+        if ( __feat%foo__Priv1%supports_filters ) 
+
+            if ( filtered = spicy_rt::filter_init(self, __data, __cur) ) {
+                local value_ref<stream> filtered_data = filtered;
+                (*self).__parse_foo_Priv1_stage2(filtered_data, (*filtered_data), __trim, __lah, __lahe);
+                __cur = __cur.advance(|__cur|);
+
+                if ( __trim ) 
+                    (*__data).trim(begin(__cur));
+
+                __result = (__cur, __lah, __lahe);
+            }
+
+
+
+        if ( ! filtered ) 
+            __result = (*self).__parse_foo_Priv1_stage2(__data, __cur, __trim, __lah, __lahe);
+
     }
     catch {
         (*self).__on_0x25_error();
+
+        if ( __feat%foo__Priv1%supports_filters ) 
+            spicy_rt::filter_disconnect(self);
+
         (*self).__on_0x25_finally();
         throw;
     }
@@ -213,6 +252,18 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::Priv1::__parse
     return __result;
 }
 
+method method tuple<view<stream>, int<64>, iterator<stream>> foo::Priv1::__parse_foo_Priv1_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe) &always-emit {
+    local tuple<view<stream>, int<64>, iterator<stream>> __result;
+    (*self).__on_0x25_done();
+
+    if ( __feat%foo__Priv1%supports_filters ) 
+        spicy_rt::filter_disconnect(self);
+
+    hilti::debugDedent("spicy");
+    __result = (__cur, __lah, __lahe);
+    return __result;
+}
+
 method extern method view<stream> foo::Priv1::parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit {
     local value_ref<Priv1> unit = value_ref(default<Priv1>())value_ref(default<Priv1>());
     local view<stream> ncur = cur ? (*cur) : cast<view<stream>>((*data));
@@ -358,12 +409,33 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::Priv2::__parse
     try {
         hilti::debugIndent("spicy");
         (*self).__on_0x25_init();
-        (*self).__on_0x25_done();
-        hilti::debugDedent("spicy");
-        __result = (__cur, __lah, __lahe);
+        local strong_ref<stream> filtered = Null;
+
+        if ( __feat%foo__Priv2%supports_filters ) 
+
+            if ( filtered = spicy_rt::filter_init(self, __data, __cur) ) {
+                local value_ref<stream> filtered_data = filtered;
+                (*self).__parse_foo_Priv2_stage2(filtered_data, (*filtered_data), __trim, __lah, __lahe);
+                __cur = __cur.advance(|__cur|);
+
+                if ( __trim ) 
+                    (*__data).trim(begin(__cur));
+
+                __result = (__cur, __lah, __lahe);
+            }
+
+
+
+        if ( ! filtered ) 
+            __result = (*self).__parse_foo_Priv2_stage2(__data, __cur, __trim, __lah, __lahe);
+
     }
     catch {
         (*self).__on_0x25_error();
+
+        if ( __feat%foo__Priv2%supports_filters ) 
+            spicy_rt::filter_disconnect(self);
+
         (*self).__on_0x25_finally();
         throw;
     }
@@ -372,6 +444,18 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::Priv2::__parse
     return __result;
 }
 
+method method tuple<view<stream>, int<64>, iterator<stream>> foo::Priv2::__parse_foo_Priv2_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe) &always-emit {
+    local tuple<view<stream>, int<64>, iterator<stream>> __result;
+    (*self).__on_0x25_done();
+
+    if ( __feat%foo__Priv2%supports_filters ) 
+        spicy_rt::filter_disconnect(self);
+
+    hilti::debugDedent("spicy");
+    __result = (__cur, __lah, __lahe);
+    return __result;
+}
+
 method extern method view<stream> foo::Priv2::parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit {
     local value_ref<Priv2> unit = value_ref(default<Priv2>())value_ref(default<Priv2>());
     local view<stream> ncur = cur ? (*cur) : cast<view<stream>>((*data));
@@ -421,12 +505,33 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::Priv3::__parse
     try {
         hilti::debugIndent("spicy");
         (*self).__on_0x25_init();
-        (*self).__on_0x25_done();
-        hilti::debugDedent("spicy");
-        __result = (__cur, __lah, __lahe);
+        local strong_ref<stream> filtered = Null;
+
+        if ( __feat%foo__Priv3%supports_filters ) 
+
+            if ( filtered = spicy_rt::filter_init(self, __data, __cur) ) {
+                local value_ref<stream> filtered_data = filtered;
+                (*self).__parse_foo_Priv3_stage2(filtered_data, (*filtered_data), __trim, __lah, __lahe);
+                __cur = __cur.advance(|__cur|);
+
+                if ( __trim ) 
+                    (*__data).trim(begin(__cur));
+
+                __result = (__cur, __lah, __lahe);
+            }
+
+
+
+        if ( ! filtered ) 
+            __result = (*self).__parse_foo_Priv3_stage2(__data, __cur, __trim, __lah, __lahe);
+
     }
     catch {
         (*self).__on_0x25_error();
+
+        if ( __feat%foo__Priv3%supports_filters ) 
+            spicy_rt::filter_disconnect(self);
+
         (*self).__on_0x25_finally();
         throw;
     }
@@ -435,6 +540,18 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::Priv3::__parse
     return __result;
 }
 
+method method tuple<view<stream>, int<64>, iterator<stream>> foo::Priv3::__parse_foo_Priv3_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe) &always-emit {
+    local tuple<view<stream>, int<64>, iterator<stream>> __result;
+    (*self).__on_0x25_done();
+
+    if ( __feat%foo__Priv3%supports_filters ) 
+        spicy_rt::filter_disconnect(self);
+
+    hilti::debugDedent("spicy");
+    __result = (__cur, __lah, __lahe);
+    return __result;
+}
+
 method extern method view<stream> foo::Priv3::parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit {
     local value_ref<Priv3> unit = value_ref(default<Priv3>())value_ref(default<Priv3>());
     local view<stream> ncur = cur ? (*cur) : cast<view<stream>>((*data));
@@ -484,25 +601,33 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::Priv4::__parse
     try {
         hilti::debugIndent("spicy");
         (*self).__on_0x25_init();
-        local value_ref<Priv2> __transient_anon;
-
-        # Begin parsing production: Unit: foo_Priv2_2 ->
-        __transient_anon = default<Priv2>();
-        (__cur, __lah, __lahe) = (*__transient_anon).__parse_stage1(__data, __cur, __trim, __lah, __lahe);
-        # End parsing production: Unit: foo_Priv2_2 ->
-
-        # Begin parsing production: Unit: foo_Priv3_2 ->
-        (*self).x = default<Priv3>();
-        (__cur, __lah, __lahe) = (*(*self).x).__parse_stage1(__data, __cur, __trim, __lah, __lahe);
-        # End parsing production: Unit: foo_Priv3_2 ->
-
-        (*self).__on_x((*self).x);
-        (*self).__on_0x25_done();
-        hilti::debugDedent("spicy");
-        __result = (__cur, __lah, __lahe);
+        local strong_ref<stream> filtered = Null;
+
+        if ( __feat%foo__Priv4%supports_filters ) 
+
+            if ( filtered = spicy_rt::filter_init(self, __data, __cur) ) {
+                local value_ref<stream> filtered_data = filtered;
+                (*self).__parse_foo_Priv4_stage2(filtered_data, (*filtered_data), __trim, __lah, __lahe);
+                __cur = __cur.advance(|__cur|);
+
+                if ( __trim ) 
+                    (*__data).trim(begin(__cur));
+
+                __result = (__cur, __lah, __lahe);
+            }
+
+
+
+        if ( ! filtered ) 
+            __result = (*self).__parse_foo_Priv4_stage2(__data, __cur, __trim, __lah, __lahe);
+
     }
     catch {
         (*self).__on_0x25_error();
+
+        if ( __feat%foo__Priv4%supports_filters ) 
+            spicy_rt::filter_disconnect(self);
+
         (*self).__on_0x25_finally();
         throw;
     }
@@ -511,6 +636,31 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::Priv4::__parse
     return __result;
 }
 
+method method tuple<view<stream>, int<64>, iterator<stream>> foo::Priv4::__parse_foo_Priv4_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe) &always-emit {
+    local tuple<view<stream>, int<64>, iterator<stream>> __result;
+    local value_ref<Priv2> __transient_anon;
+
+    # Begin parsing production: Unit: foo_Priv2_2 ->
+    __transient_anon = default<Priv2>();
+    (__cur, __lah, __lahe) = (*__transient_anon).__parse_stage1(__data, __cur, __trim, __lah, __lahe);
+    # End parsing production: Unit: foo_Priv2_2 ->
+
+    # Begin parsing production: Unit: foo_Priv3_2 ->
+    (*self).x = default<Priv3>();
+    (__cur, __lah, __lahe) = (*(*self).x).__parse_stage1(__data, __cur, __trim, __lah, __lahe);
+    # End parsing production: Unit: foo_Priv3_2 ->
+
+    (*self).__on_x((*self).x);
+    (*self).__on_0x25_done();
+
+    if ( __feat%foo__Priv4%supports_filters ) 
+        spicy_rt::filter_disconnect(self);
+
+    hilti::debugDedent("spicy");
+    __result = (__cur, __lah, __lahe);
+    return __result;
+}
+
 method extern method view<stream> foo::Priv4::parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit {
     local value_ref<Priv4> unit = value_ref(default<Priv4>())value_ref(default<Priv4>());
     local view<stream> ncur = cur ? (*cur) : cast<view<stream>>((*data));
@@ -560,12 +710,33 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::Priv5::__parse
     try {
         hilti::debugIndent("spicy");
         (*self).__on_0x25_init();
-        (*self).__on_0x25_done();
-        hilti::debugDedent("spicy");
-        __result = (__cur, __lah, __lahe);
+        local strong_ref<stream> filtered = Null;
+
+        if ( __feat%foo__Priv5%supports_filters ) 
+
+            if ( filtered = spicy_rt::filter_init(self, __data, __cur) ) {
+                local value_ref<stream> filtered_data = filtered;
+                (*self).__parse_foo_Priv5_stage2(filtered_data, (*filtered_data), __trim, __lah, __lahe);
+                __cur = __cur.advance(|__cur|);
+
+                if ( __trim ) 
+                    (*__data).trim(begin(__cur));
+
+                __result = (__cur, __lah, __lahe);
+            }
+
+
+
+        if ( ! filtered ) 
+            __result = (*self).__parse_foo_Priv5_stage2(__data, __cur, __trim, __lah, __lahe);
+
     }
     catch {
         (*self).__on_0x25_error();
+
+        if ( __feat%foo__Priv5%supports_filters ) 
+            spicy_rt::filter_disconnect(self);
+
         (*self).__on_0x25_finally();
         throw;
     }
@@ -574,6 +745,18 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::Priv5::__parse
     return __result;
 }
 
+method method tuple<view<stream>, int<64>, iterator<stream>> foo::Priv5::__parse_foo_Priv5_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe) &always-emit {
+    local tuple<view<stream>, int<64>, iterator<stream>> __result;
+    (*self).__on_0x25_done();
+
+    if ( __feat%foo__Priv5%supports_filters ) 
+        spicy_rt::filter_disconnect(self);
+
+    hilti::debugDedent("spicy");
+    __result = (__cur, __lah, __lahe);
+    return __result;
+}
+
 method extern method view<stream> foo::Priv5::parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit {
     local value_ref<Priv5> unit = value_ref(default<Priv5>())value_ref(default<Priv5>());
     local view<stream> ncur = cur ? (*cur) : cast<view<stream>>((*data));
@@ -623,12 +806,33 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::Priv6::__parse
     try {
         hilti::debugIndent("spicy");
         (*self).__on_0x25_init();
-        (*self).__on_0x25_done();
-        hilti::debugDedent("spicy");
-        __result = (__cur, __lah, __lahe);
+        local strong_ref<stream> filtered = Null;
+
+        if ( __feat%foo__Priv6%supports_filters ) 
+
+            if ( filtered = spicy_rt::filter_init(self, __data, __cur) ) {
+                local value_ref<stream> filtered_data = filtered;
+                (*self).__parse_foo_Priv6_stage2(filtered_data, (*filtered_data), __trim, __lah, __lahe);
+                __cur = __cur.advance(|__cur|);
+
+                if ( __trim ) 
+                    (*__data).trim(begin(__cur));
+
+                __result = (__cur, __lah, __lahe);
+            }
+
+
+
+        if ( ! filtered ) 
+            __result = (*self).__parse_foo_Priv6_stage2(__data, __cur, __trim, __lah, __lahe);
+
     }
     catch {
         (*self).__on_0x25_error();
+
+        if ( __feat%foo__Priv6%supports_filters ) 
+            spicy_rt::filter_disconnect(self);
+
         (*self).__on_0x25_finally();
         throw;
     }
@@ -637,6 +841,18 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::Priv6::__parse
     return __result;
 }
 
+method method tuple<view<stream>, int<64>, iterator<stream>> foo::Priv6::__parse_foo_Priv6_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe) &always-emit {
+    local tuple<view<stream>, int<64>, iterator<stream>> __result;
+    (*self).__on_0x25_done();
+
+    if ( __feat%foo__Priv6%supports_filters ) 
+        spicy_rt::filter_disconnect(self);
+
+    hilti::debugDedent("spicy");
+    __result = (__cur, __lah, __lahe);
+    return __result;
+}
+
 method extern method view<stream> foo::Priv6::parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit {
     local value_ref<Priv6> unit = value_ref(default<Priv6>())value_ref(default<Priv6>());
     local view<stream> ncur = cur ? (*cur) : cast<view<stream>>((*data));
diff --git a/tests/Baseline/spicy.optimization.unused-types/opt.hlt b/tests/Baseline/spicy.optimization.unused-types/opt.hlt
index a1d4ece2f..b75ae62c7 100644
--- a/tests/Baseline/spicy.optimization.unused-types/opt.hlt
+++ b/tests/Baseline/spicy.optimization.unused-types/opt.hlt
@@ -10,6 +10,7 @@ type Priv1 = struct {
     method extern view<stream> parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse2(inout value_ref<Priv1> unit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse3(inout value_ref<spicy_rt::ParsedUnit> gunit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
+    method tuple<view<stream>, int<64>, iterator<stream>> __parse_foo_Priv1_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe);
 } &on-heap;
 public type Pub2 = struct {
     spicy_rt::Parser __parser &static &internal &needed-by-feature="supports_sinks";
@@ -25,6 +26,7 @@ type Priv2 = struct {
     method extern view<stream> parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse2(inout value_ref<Priv2> unit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse3(inout value_ref<spicy_rt::ParsedUnit> gunit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
+    method tuple<view<stream>, int<64>, iterator<stream>> __parse_foo_Priv2_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe);
 } &on-heap;
 type Priv3 = struct {
     spicy_rt::Parser __parser &static &internal &needed-by-feature="supports_sinks";
@@ -32,6 +34,7 @@ type Priv3 = struct {
     method extern view<stream> parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse2(inout value_ref<Priv3> unit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse3(inout value_ref<spicy_rt::ParsedUnit> gunit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
+    method tuple<view<stream>, int<64>, iterator<stream>> __parse_foo_Priv3_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe);
 } &on-heap;
 type Priv4 = struct {
     value_ref<Priv2> anon &optional &no-emit;
@@ -41,6 +44,7 @@ type Priv4 = struct {
     method extern view<stream> parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse2(inout value_ref<Priv4> unit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse3(inout value_ref<spicy_rt::ParsedUnit> gunit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
+    method tuple<view<stream>, int<64>, iterator<stream>> __parse_foo_Priv4_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe);
 } &on-heap;
 type Priv5 = struct {
     spicy_rt::Parser __parser &static &internal &needed-by-feature="supports_sinks";
@@ -48,6 +52,7 @@ type Priv5 = struct {
     method extern view<stream> parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse2(inout value_ref<Priv5> unit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse3(inout value_ref<spicy_rt::ParsedUnit> gunit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
+    method tuple<view<stream>, int<64>, iterator<stream>> __parse_foo_Priv5_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe);
 } &on-heap;
 type Priv6 = struct {
     spicy_rt::Parser __parser &static &internal &needed-by-feature="supports_sinks";
@@ -55,6 +60,7 @@ type Priv6 = struct {
     method extern view<stream> parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse2(inout value_ref<Priv6> unit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
     method extern view<stream> parse3(inout value_ref<spicy_rt::ParsedUnit> gunit, inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit;
+    method tuple<view<stream>, int<64>, iterator<stream>> __parse_foo_Priv6_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe);
 } &on-heap;
 public type Pub3 = struct {
     value_ref<Priv5> anon_2 &optional &no-emit;
@@ -82,13 +88,19 @@ public type Priv10 = struct {
 type Priv11 = enum { A = 0, B = 1, C = 2 };
 type Priv12 = enum { A = 0, B = 1, C = 2 };
 
+const bool __feat%foo__Priv1%supports_filters = False;
 const bool __feat%foo__Priv1%supports_sinks = False;
 const bool __feat%foo__Pub2%supports_filters = False;
 const bool __feat%foo__Pub2%supports_sinks = False;
+const bool __feat%foo__Priv2%supports_filters = False;
 const bool __feat%foo__Priv2%supports_sinks = False;
+const bool __feat%foo__Priv3%supports_filters = False;
 const bool __feat%foo__Priv3%supports_sinks = False;
+const bool __feat%foo__Priv4%supports_filters = False;
 const bool __feat%foo__Priv4%supports_sinks = False;
+const bool __feat%foo__Priv5%supports_filters = False;
 const bool __feat%foo__Priv5%supports_sinks = False;
+const bool __feat%foo__Priv6%supports_filters = False;
 const bool __feat%foo__Priv6%supports_sinks = False;
 const bool __feat%foo__Pub3%supports_filters = False;
 const bool __feat%foo__Pub3%supports_sinks = False;
@@ -103,9 +115,11 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::Priv1::__parse
     try {
         hilti::debugIndent("spicy");
         default<void>();
-        default<void>();
-        hilti::debugDedent("spicy");
-        __result = (__cur, __lah, __lahe);
+        local strong_ref<stream> filtered = Null;
+
+        if ( ! filtered ) 
+            __result = (*self).__parse_foo_Priv1_stage2(__data, __cur, __trim, __lah, __lahe);
+
     }
     catch {
         default<void>();
@@ -117,6 +131,14 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::Priv1::__parse
     return __result;
 }
 
+method method tuple<view<stream>, int<64>, iterator<stream>> foo::Priv1::__parse_foo_Priv1_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe) &always-emit {
+    local tuple<view<stream>, int<64>, iterator<stream>> __result;
+    default<void>();
+    hilti::debugDedent("spicy");
+    __result = (__cur, __lah, __lahe);
+    return __result;
+}
+
 method extern method view<stream> foo::Priv1::parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit {
     local value_ref<Priv1> unit = value_ref(default<Priv1>())value_ref(default<Priv1>());
     local view<stream> ncur = cur ? (*cur) : cast<view<stream>>((*data));
@@ -239,9 +261,11 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::Priv2::__parse
     try {
         hilti::debugIndent("spicy");
         default<void>();
-        default<void>();
-        hilti::debugDedent("spicy");
-        __result = (__cur, __lah, __lahe);
+        local strong_ref<stream> filtered = Null;
+
+        if ( ! filtered ) 
+            __result = (*self).__parse_foo_Priv2_stage2(__data, __cur, __trim, __lah, __lahe);
+
     }
     catch {
         default<void>();
@@ -253,6 +277,14 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::Priv2::__parse
     return __result;
 }
 
+method method tuple<view<stream>, int<64>, iterator<stream>> foo::Priv2::__parse_foo_Priv2_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe) &always-emit {
+    local tuple<view<stream>, int<64>, iterator<stream>> __result;
+    default<void>();
+    hilti::debugDedent("spicy");
+    __result = (__cur, __lah, __lahe);
+    return __result;
+}
+
 method extern method view<stream> foo::Priv2::parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit {
     local value_ref<Priv2> unit = value_ref(default<Priv2>())value_ref(default<Priv2>());
     local view<stream> ncur = cur ? (*cur) : cast<view<stream>>((*data));
@@ -302,9 +334,11 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::Priv3::__parse
     try {
         hilti::debugIndent("spicy");
         default<void>();
-        default<void>();
-        hilti::debugDedent("spicy");
-        __result = (__cur, __lah, __lahe);
+        local strong_ref<stream> filtered = Null;
+
+        if ( ! filtered ) 
+            __result = (*self).__parse_foo_Priv3_stage2(__data, __cur, __trim, __lah, __lahe);
+
     }
     catch {
         default<void>();
@@ -316,6 +350,14 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::Priv3::__parse
     return __result;
 }
 
+method method tuple<view<stream>, int<64>, iterator<stream>> foo::Priv3::__parse_foo_Priv3_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe) &always-emit {
+    local tuple<view<stream>, int<64>, iterator<stream>> __result;
+    default<void>();
+    hilti::debugDedent("spicy");
+    __result = (__cur, __lah, __lahe);
+    return __result;
+}
+
 method extern method view<stream> foo::Priv3::parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit {
     local value_ref<Priv3> unit = value_ref(default<Priv3>())value_ref(default<Priv3>());
     local view<stream> ncur = cur ? (*cur) : cast<view<stream>>((*data));
@@ -365,22 +407,11 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::Priv4::__parse
     try {
         hilti::debugIndent("spicy");
         default<void>();
-        local value_ref<Priv2> __transient_anon;
-
-        # Begin parsing production: Unit: foo_Priv2_2 ->
-        __transient_anon = default<Priv2>();
-        (__cur, __lah, __lahe) = (*__transient_anon).__parse_stage1(__data, __cur, __trim, __lah, __lahe);
-        # End parsing production: Unit: foo_Priv2_2 ->
+        local strong_ref<stream> filtered = Null;
 
-        # Begin parsing production: Unit: foo_Priv3_2 ->
-        (*self).x = default<Priv3>();
-        (__cur, __lah, __lahe) = (*(*self).x).__parse_stage1(__data, __cur, __trim, __lah, __lahe);
-        # End parsing production: Unit: foo_Priv3_2 ->
+        if ( ! filtered ) 
+            __result = (*self).__parse_foo_Priv4_stage2(__data, __cur, __trim, __lah, __lahe);
 
-        default<void>();
-        default<void>();
-        hilti::debugDedent("spicy");
-        __result = (__cur, __lah, __lahe);
     }
     catch {
         default<void>();
@@ -392,6 +423,27 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::Priv4::__parse
     return __result;
 }
 
+method method tuple<view<stream>, int<64>, iterator<stream>> foo::Priv4::__parse_foo_Priv4_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe) &always-emit {
+    local tuple<view<stream>, int<64>, iterator<stream>> __result;
+    local value_ref<Priv2> __transient_anon;
+
+    # Begin parsing production: Unit: foo_Priv2_2 ->
+    __transient_anon = default<Priv2>();
+    (__cur, __lah, __lahe) = (*__transient_anon).__parse_stage1(__data, __cur, __trim, __lah, __lahe);
+    # End parsing production: Unit: foo_Priv2_2 ->
+
+    # Begin parsing production: Unit: foo_Priv3_2 ->
+    (*self).x = default<Priv3>();
+    (__cur, __lah, __lahe) = (*(*self).x).__parse_stage1(__data, __cur, __trim, __lah, __lahe);
+    # End parsing production: Unit: foo_Priv3_2 ->
+
+    default<void>();
+    default<void>();
+    hilti::debugDedent("spicy");
+    __result = (__cur, __lah, __lahe);
+    return __result;
+}
+
 method extern method view<stream> foo::Priv4::parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit {
     local value_ref<Priv4> unit = value_ref(default<Priv4>())value_ref(default<Priv4>());
     local view<stream> ncur = cur ? (*cur) : cast<view<stream>>((*data));
@@ -441,9 +493,11 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::Priv5::__parse
     try {
         hilti::debugIndent("spicy");
         default<void>();
-        default<void>();
-        hilti::debugDedent("spicy");
-        __result = (__cur, __lah, __lahe);
+        local strong_ref<stream> filtered = Null;
+
+        if ( ! filtered ) 
+            __result = (*self).__parse_foo_Priv5_stage2(__data, __cur, __trim, __lah, __lahe);
+
     }
     catch {
         default<void>();
@@ -455,6 +509,14 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::Priv5::__parse
     return __result;
 }
 
+method method tuple<view<stream>, int<64>, iterator<stream>> foo::Priv5::__parse_foo_Priv5_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe) &always-emit {
+    local tuple<view<stream>, int<64>, iterator<stream>> __result;
+    default<void>();
+    hilti::debugDedent("spicy");
+    __result = (__cur, __lah, __lahe);
+    return __result;
+}
+
 method extern method view<stream> foo::Priv5::parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit {
     local value_ref<Priv5> unit = value_ref(default<Priv5>())value_ref(default<Priv5>());
     local view<stream> ncur = cur ? (*cur) : cast<view<stream>>((*data));
@@ -504,9 +566,11 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::Priv6::__parse
     try {
         hilti::debugIndent("spicy");
         default<void>();
-        default<void>();
-        hilti::debugDedent("spicy");
-        __result = (__cur, __lah, __lahe);
+        local strong_ref<stream> filtered = Null;
+
+        if ( ! filtered ) 
+            __result = (*self).__parse_foo_Priv6_stage2(__data, __cur, __trim, __lah, __lahe);
+
     }
     catch {
         default<void>();
@@ -518,6 +582,14 @@ method method tuple<view<stream>, int<64>, iterator<stream>> foo::Priv6::__parse
     return __result;
 }
 
+method method tuple<view<stream>, int<64>, iterator<stream>> foo::Priv6::__parse_foo_Priv6_stage2(inout value_ref<stream> __data, copy view<stream> __cur, copy bool __trim, copy int<64> __lah, copy iterator<stream> __lahe) &always-emit {
+    local tuple<view<stream>, int<64>, iterator<stream>> __result;
+    default<void>();
+    hilti::debugDedent("spicy");
+    __result = (__cur, __lah, __lahe);
+    return __result;
+}
+
 method extern method view<stream> foo::Priv6::parse1(inout value_ref<stream> data, optional<view<stream>> cur = Null, optional<spicy_rt::UnitContext> context) &static &always-emit {
     local value_ref<Priv6> unit = value_ref(default<Priv6>())value_ref(default<Priv6>());
     local view<stream> ncur = cur ? (*cur) : cast<view<stream>>((*data));
diff --git a/tests/Baseline/spicy.types.unit.canonical-ids/output b/tests/Baseline/spicy.types.unit.canonical-ids/output
index c187af325..888384d74 100644
--- a/tests/Baseline/spicy.types.unit.canonical-ids/output
+++ b/tests/Baseline/spicy.types.unit.canonical-ids/output
@@ -247,6 +247,7 @@
 [debug/ast-declarations]           - Parameter "data" (DNS::Label::__on_0x25_undelivered::data)
 [debug/ast-declarations]       - Field "__parser" (DNS::Label::__parser)
 [debug/ast-declarations]       - Field "__sink" (DNS::Label::__sink)
+[debug/ast-declarations]       - Field "__filters" (DNS::Label::__filters)
 [debug/ast-declarations]       - Field "__parse_stage1" (DNS::Label::__parse_stage1)
 [debug/ast-declarations]           - Parameter "__data" (DNS::Label::__parse_stage1::__data)
 [debug/ast-declarations]           - Parameter "__cur" (DNS::Label::__parse_stage1::__cur)
@@ -267,6 +268,12 @@
 [debug/ast-declarations]           - Parameter "data" (DNS::Label::parse3::data)
 [debug/ast-declarations]           - Parameter "cur" (DNS::Label::parse3::cur)
 [debug/ast-declarations]           - Parameter "context" (DNS::Label::parse3::context)
+[debug/ast-declarations]       - Field "__parse_DNS_Label_stage2" (DNS::Label::__parse_DNS_Label_stage2)
+[debug/ast-declarations]           - Parameter "__data" (DNS::Label::__parse_DNS_Label_stage2::__data)
+[debug/ast-declarations]           - Parameter "__cur" (DNS::Label::__parse_DNS_Label_stage2::__cur)
+[debug/ast-declarations]           - Parameter "__trim" (DNS::Label::__parse_DNS_Label_stage2::__trim)
+[debug/ast-declarations]           - Parameter "__lah" (DNS::Label::__parse_DNS_Label_stage2::__lah)
+[debug/ast-declarations]           - Parameter "__lahe" (DNS::Label::__parse_DNS_Label_stage2::__lahe)
 [debug/ast-declarations]   - Type "Pointer" (DNS::Pointer)
 [debug/ast-declarations]       - Expression "self" (DNS::Pointer::self)
 [debug/ast-declarations]       - Field "name" (DNS::Pointer::name)
@@ -291,6 +298,7 @@
 [debug/ast-declarations]           - Parameter "data" (DNS::Pointer::__on_0x25_undelivered::data)
 [debug/ast-declarations]       - Field "__parser" (DNS::Pointer::__parser)
 [debug/ast-declarations]       - Field "__sink" (DNS::Pointer::__sink)
+[debug/ast-declarations]       - Field "__filters" (DNS::Pointer::__filters)
 [debug/ast-declarations]       - Field "__parse_stage1" (DNS::Pointer::__parse_stage1)
 [debug/ast-declarations]           - Parameter "__data" (DNS::Pointer::__parse_stage1::__data)
 [debug/ast-declarations]           - Parameter "__cur" (DNS::Pointer::__parse_stage1::__cur)
@@ -311,8 +319,15 @@
 [debug/ast-declarations]           - Parameter "data" (DNS::Pointer::parse3::data)
 [debug/ast-declarations]           - Parameter "cur" (DNS::Pointer::parse3::cur)
 [debug/ast-declarations]           - Parameter "context" (DNS::Pointer::parse3::context)
+[debug/ast-declarations]       - Field "__parse_DNS_Pointer_2_stage2" (DNS::Pointer::__parse_DNS_Pointer_2_stage2)
+[debug/ast-declarations]           - Parameter "__data" (DNS::Pointer::__parse_DNS_Pointer_2_stage2::__data)
+[debug/ast-declarations]           - Parameter "__cur" (DNS::Pointer::__parse_DNS_Pointer_2_stage2::__cur)
+[debug/ast-declarations]           - Parameter "__trim" (DNS::Pointer::__parse_DNS_Pointer_2_stage2::__trim)
+[debug/ast-declarations]           - Parameter "__lah" (DNS::Pointer::__parse_DNS_Pointer_2_stage2::__lah)
+[debug/ast-declarations]           - Parameter "__lahe" (DNS::Pointer::__parse_DNS_Pointer_2_stage2::__lahe)
 [debug/ast-declarations]   - ImportedModule "spicy_rt" (spicy_rt)
 [debug/ast-declarations]   - ImportedModule "hilti" (hilti)
+[debug/ast-declarations]   - Constant "__feat%DNS__Label%supports_filters" (DNS::__feat%DNS__Label%supports_filters)
 [debug/ast-declarations]   - Constant "__feat%DNS__Label%supports_sinks" (DNS::__feat%DNS__Label%supports_sinks)
 [debug/ast-declarations]   - Function "DNS::Label::__parse_stage1" (DNS::Label::__parse_stage1)
 [debug/ast-declarations]         - Parameter "__data" (DNS::Label::__parse_stage1::__data)
@@ -321,12 +336,31 @@
 [debug/ast-declarations]         - Parameter "__lah" (DNS::Label::__parse_stage1::__lah)
 [debug/ast-declarations]         - Parameter "__lahe" (DNS::Label::__parse_stage1::__lahe)
 [debug/ast-declarations]           - LocalVariable "__result" (DNS::Label::__parse_stage1::__result)
-[debug/ast-declarations]                       - Parameter "__data" (DNS::Pointer::__parse_stage1::__data)
-[debug/ast-declarations]                       - Parameter "__cur" (DNS::Pointer::__parse_stage1::__cur)
-[debug/ast-declarations]                       - Parameter "__trim" (DNS::Pointer::__parse_stage1::__trim)
-[debug/ast-declarations]                       - Parameter "__lah" (DNS::Pointer::__parse_stage1::__lah)
-[debug/ast-declarations]                       - Parameter "__lahe" (DNS::Pointer::__parse_stage1::__lahe)
-[debug/ast-declarations]                     - Parameter "__dd" (DNS::Label::__on_ptr::__dd)
+[debug/ast-declarations]               - LocalVariable "filtered" (DNS::Label::__parse_stage1::filtered)
+[debug/ast-declarations]                       - LocalVariable "filtered_data" (DNS::Label::__parse_stage1::filtered_data)
+[debug/ast-declarations]                             - Parameter "__data" (DNS::Label::__parse_DNS_Label_stage2::__data)
+[debug/ast-declarations]                             - Parameter "__cur" (DNS::Label::__parse_DNS_Label_stage2::__cur)
+[debug/ast-declarations]                             - Parameter "__trim" (DNS::Label::__parse_DNS_Label_stage2::__trim)
+[debug/ast-declarations]                             - Parameter "__lah" (DNS::Label::__parse_DNS_Label_stage2::__lah)
+[debug/ast-declarations]                             - Parameter "__lahe" (DNS::Label::__parse_DNS_Label_stage2::__lahe)
+[debug/ast-declarations]                           - Parameter "__data" (DNS::Label::__parse_DNS_Label_stage2::__data)
+[debug/ast-declarations]                           - Parameter "__cur" (DNS::Label::__parse_DNS_Label_stage2::__cur)
+[debug/ast-declarations]                           - Parameter "__trim" (DNS::Label::__parse_DNS_Label_stage2::__trim)
+[debug/ast-declarations]                           - Parameter "__lah" (DNS::Label::__parse_DNS_Label_stage2::__lah)
+[debug/ast-declarations]                           - Parameter "__lahe" (DNS::Label::__parse_DNS_Label_stage2::__lahe)
+[debug/ast-declarations]   - Function "DNS::Label::__parse_DNS_Label_stage2" (DNS::Label::__parse_DNS_Label_stage2)
+[debug/ast-declarations]         - Parameter "__data" (DNS::Label::__parse_DNS_Label_stage2::__data)
+[debug/ast-declarations]         - Parameter "__cur" (DNS::Label::__parse_DNS_Label_stage2::__cur)
+[debug/ast-declarations]         - Parameter "__trim" (DNS::Label::__parse_DNS_Label_stage2::__trim)
+[debug/ast-declarations]         - Parameter "__lah" (DNS::Label::__parse_DNS_Label_stage2::__lah)
+[debug/ast-declarations]         - Parameter "__lahe" (DNS::Label::__parse_DNS_Label_stage2::__lahe)
+[debug/ast-declarations]           - LocalVariable "__result" (DNS::Label::__parse_DNS_Label_stage2::__result)
+[debug/ast-declarations]                   - Parameter "__data" (DNS::Pointer::__parse_stage1::__data)
+[debug/ast-declarations]                   - Parameter "__cur" (DNS::Pointer::__parse_stage1::__cur)
+[debug/ast-declarations]                   - Parameter "__trim" (DNS::Pointer::__parse_stage1::__trim)
+[debug/ast-declarations]                   - Parameter "__lah" (DNS::Pointer::__parse_stage1::__lah)
+[debug/ast-declarations]                   - Parameter "__lahe" (DNS::Pointer::__parse_stage1::__lahe)
+[debug/ast-declarations]                 - Parameter "__dd" (DNS::Label::__on_ptr::__dd)
 [debug/ast-declarations]   - Function "DNS::Label::parse1" (DNS::Label::parse1)
 [debug/ast-declarations]         - Parameter "data" (DNS::Label::parse1::data)
 [debug/ast-declarations]         - Parameter "cur" (DNS::Label::parse1::cur)
@@ -369,6 +403,7 @@
 [debug/ast-declarations]                             - Parameter "data" (DNS::Label::__on_0x25_undelivered::data)
 [debug/ast-declarations]                         - Field "__parser" (DNS::Label::__parser)
 [debug/ast-declarations]                         - Field "__sink" (DNS::Label::__sink)
+[debug/ast-declarations]                         - Field "__filters" (DNS::Label::__filters)
 [debug/ast-declarations]                         - Field "__parse_stage1" (DNS::Label::__parse_stage1)
 [debug/ast-declarations]                             - Parameter "__data" (DNS::Label::__parse_stage1::__data)
 [debug/ast-declarations]                             - Parameter "__cur" (DNS::Label::__parse_stage1::__cur)
@@ -389,6 +424,12 @@
 [debug/ast-declarations]                             - Parameter "data" (DNS::Label::parse3::data)
 [debug/ast-declarations]                             - Parameter "cur" (DNS::Label::parse3::cur)
 [debug/ast-declarations]                             - Parameter "context" (DNS::Label::parse3::context)
+[debug/ast-declarations]                         - Field "__parse_DNS_Label_stage2" (DNS::Label::__parse_DNS_Label_stage2)
+[debug/ast-declarations]                             - Parameter "__data" (DNS::Label::__parse_DNS_Label_stage2::__data)
+[debug/ast-declarations]                             - Parameter "__cur" (DNS::Label::__parse_DNS_Label_stage2::__cur)
+[debug/ast-declarations]                             - Parameter "__trim" (DNS::Label::__parse_DNS_Label_stage2::__trim)
+[debug/ast-declarations]                             - Parameter "__lah" (DNS::Label::__parse_DNS_Label_stage2::__lah)
+[debug/ast-declarations]                             - Parameter "__lahe" (DNS::Label::__parse_DNS_Label_stage2::__lahe)
 [debug/ast-declarations]           - LocalVariable "ncur" (DNS::Label::parse3::ncur)
 [debug/ast-declarations]           - LocalVariable "lahead" (DNS::Label::parse3::lahead)
 [debug/ast-declarations]           - LocalVariable "lahead_end" (DNS::Label::parse3::lahead_end)
@@ -433,6 +474,7 @@
 [debug/ast-declarations]                     - Field "description" (DNS::__register_DNS_Label::<anon-struct-4>::description)
 [debug/ast-declarations]                     - Field "mime_types" (DNS::__register_DNS_Label::<anon-struct-4>::mime_types)
 [debug/ast-declarations]                     - Field "ports" (DNS::__register_DNS_Label::<anon-struct-4>::ports)
+[debug/ast-declarations]   - Constant "__feat%DNS__Pointer%supports_filters" (DNS::__feat%DNS__Pointer%supports_filters)
 [debug/ast-declarations]   - Constant "__feat%DNS__Pointer%supports_sinks" (DNS::__feat%DNS__Pointer%supports_sinks)
 [debug/ast-declarations]   - Function "DNS::Pointer::__parse_stage1" (DNS::Pointer::__parse_stage1)
 [debug/ast-declarations]         - Parameter "__data" (DNS::Pointer::__parse_stage1::__data)
@@ -441,12 +483,31 @@
 [debug/ast-declarations]         - Parameter "__lah" (DNS::Pointer::__parse_stage1::__lah)
 [debug/ast-declarations]         - Parameter "__lahe" (DNS::Pointer::__parse_stage1::__lahe)
 [debug/ast-declarations]           - LocalVariable "__result" (DNS::Pointer::__parse_stage1::__result)
-[debug/ast-declarations]                       - Parameter "__data" (DNS::Label::__parse_stage1::__data)
-[debug/ast-declarations]                       - Parameter "__cur" (DNS::Label::__parse_stage1::__cur)
-[debug/ast-declarations]                       - Parameter "__trim" (DNS::Label::__parse_stage1::__trim)
-[debug/ast-declarations]                       - Parameter "__lah" (DNS::Label::__parse_stage1::__lah)
-[debug/ast-declarations]                       - Parameter "__lahe" (DNS::Label::__parse_stage1::__lahe)
-[debug/ast-declarations]                     - Parameter "__dd" (DNS::Pointer::__on_name::__dd)
+[debug/ast-declarations]               - LocalVariable "filtered" (DNS::Pointer::__parse_stage1::filtered)
+[debug/ast-declarations]                       - LocalVariable "filtered_data" (DNS::Pointer::__parse_stage1::filtered_data)
+[debug/ast-declarations]                             - Parameter "__data" (DNS::Pointer::__parse_DNS_Pointer_2_stage2::__data)
+[debug/ast-declarations]                             - Parameter "__cur" (DNS::Pointer::__parse_DNS_Pointer_2_stage2::__cur)
+[debug/ast-declarations]                             - Parameter "__trim" (DNS::Pointer::__parse_DNS_Pointer_2_stage2::__trim)
+[debug/ast-declarations]                             - Parameter "__lah" (DNS::Pointer::__parse_DNS_Pointer_2_stage2::__lah)
+[debug/ast-declarations]                             - Parameter "__lahe" (DNS::Pointer::__parse_DNS_Pointer_2_stage2::__lahe)
+[debug/ast-declarations]                           - Parameter "__data" (DNS::Pointer::__parse_DNS_Pointer_2_stage2::__data)
+[debug/ast-declarations]                           - Parameter "__cur" (DNS::Pointer::__parse_DNS_Pointer_2_stage2::__cur)
+[debug/ast-declarations]                           - Parameter "__trim" (DNS::Pointer::__parse_DNS_Pointer_2_stage2::__trim)
+[debug/ast-declarations]                           - Parameter "__lah" (DNS::Pointer::__parse_DNS_Pointer_2_stage2::__lah)
+[debug/ast-declarations]                           - Parameter "__lahe" (DNS::Pointer::__parse_DNS_Pointer_2_stage2::__lahe)
+[debug/ast-declarations]   - Function "DNS::Pointer::__parse_DNS_Pointer_2_stage2" (DNS::Pointer::__parse_DNS_Pointer_2_stage2)
+[debug/ast-declarations]         - Parameter "__data" (DNS::Pointer::__parse_DNS_Pointer_2_stage2::__data)
+[debug/ast-declarations]         - Parameter "__cur" (DNS::Pointer::__parse_DNS_Pointer_2_stage2::__cur)
+[debug/ast-declarations]         - Parameter "__trim" (DNS::Pointer::__parse_DNS_Pointer_2_stage2::__trim)
+[debug/ast-declarations]         - Parameter "__lah" (DNS::Pointer::__parse_DNS_Pointer_2_stage2::__lah)
+[debug/ast-declarations]         - Parameter "__lahe" (DNS::Pointer::__parse_DNS_Pointer_2_stage2::__lahe)
+[debug/ast-declarations]           - LocalVariable "__result" (DNS::Pointer::__parse_DNS_Pointer_2_stage2::__result)
+[debug/ast-declarations]                   - Parameter "__data" (DNS::Label::__parse_stage1::__data)
+[debug/ast-declarations]                   - Parameter "__cur" (DNS::Label::__parse_stage1::__cur)
+[debug/ast-declarations]                   - Parameter "__trim" (DNS::Label::__parse_stage1::__trim)
+[debug/ast-declarations]                   - Parameter "__lah" (DNS::Label::__parse_stage1::__lah)
+[debug/ast-declarations]                   - Parameter "__lahe" (DNS::Label::__parse_stage1::__lahe)
+[debug/ast-declarations]                 - Parameter "__dd" (DNS::Pointer::__on_name::__dd)
 [debug/ast-declarations]   - Function "DNS::Pointer::parse1" (DNS::Pointer::parse1)
 [debug/ast-declarations]         - Parameter "data" (DNS::Pointer::parse1::data)
 [debug/ast-declarations]         - Parameter "cur" (DNS::Pointer::parse1::cur)
@@ -489,6 +550,7 @@
 [debug/ast-declarations]                             - Parameter "data" (DNS::Pointer::__on_0x25_undelivered::data)
 [debug/ast-declarations]                         - Field "__parser" (DNS::Pointer::__parser)
 [debug/ast-declarations]                         - Field "__sink" (DNS::Pointer::__sink)
+[debug/ast-declarations]                         - Field "__filters" (DNS::Pointer::__filters)
 [debug/ast-declarations]                         - Field "__parse_stage1" (DNS::Pointer::__parse_stage1)
 [debug/ast-declarations]                             - Parameter "__data" (DNS::Pointer::__parse_stage1::__data)
 [debug/ast-declarations]                             - Parameter "__cur" (DNS::Pointer::__parse_stage1::__cur)
@@ -509,6 +571,12 @@
 [debug/ast-declarations]                             - Parameter "data" (DNS::Pointer::parse3::data)
 [debug/ast-declarations]                             - Parameter "cur" (DNS::Pointer::parse3::cur)
 [debug/ast-declarations]                             - Parameter "context" (DNS::Pointer::parse3::context)
+[debug/ast-declarations]                         - Field "__parse_DNS_Pointer_2_stage2" (DNS::Pointer::__parse_DNS_Pointer_2_stage2)
+[debug/ast-declarations]                             - Parameter "__data" (DNS::Pointer::__parse_DNS_Pointer_2_stage2::__data)
+[debug/ast-declarations]                             - Parameter "__cur" (DNS::Pointer::__parse_DNS_Pointer_2_stage2::__cur)
+[debug/ast-declarations]                             - Parameter "__trim" (DNS::Pointer::__parse_DNS_Pointer_2_stage2::__trim)
+[debug/ast-declarations]                             - Parameter "__lah" (DNS::Pointer::__parse_DNS_Pointer_2_stage2::__lah)
+[debug/ast-declarations]                             - Parameter "__lahe" (DNS::Pointer::__parse_DNS_Pointer_2_stage2::__lahe)
 [debug/ast-declarations]           - LocalVariable "ncur" (DNS::Pointer::parse3::ncur)
 [debug/ast-declarations]           - LocalVariable "lahead" (DNS::Pointer::parse3::lahead)
 [debug/ast-declarations]           - LocalVariable "lahead_end" (DNS::Pointer::parse3::lahead_end)