diff --git a/tools/hls-fuzzer/AST.cpp b/tools/hls-fuzzer/AST.cpp
index 3820c5302..be499e76e 100644
--- a/tools/hls-fuzzer/AST.cpp
+++ b/tools/hls-fuzzer/AST.cpp
@@ -379,6 +379,11 @@ llvm::raw_ostream &ast::operator<<(llvm::raw_ostream &os,
             << parameter.getDimension() << ']';
 }
 
+llvm::raw_ostream &ast::operator<<(llvm::raw_ostream &os,
+                                   const ReturnType &returnType) {
+  return os << returnType.variant;
+}
+
 llvm::raw_ostream &ast::operator<<(llvm::raw_ostream &os,
                                    const Function &function) {
   os << function.returnType << ' ' << function.name << '(';
@@ -391,10 +396,10 @@ llvm::raw_ostream &ast::operator<<(llvm::raw_ostream &os,
   mlir::raw_indented_ostream indentedOstream(os);
   indentedOstream.indent();
   for (auto &iter : function.statements)
-    indentedOstream << iter;
+    indentedOstream << iter << '\n';
   if (function.returnStatement)
-    indentedOstream << *function.returnStatement;
+    indentedOstream << *function.returnStatement << '\n';
 
-  os << "\n}\n";
+  os << "}\n";
   return os;
 }
diff --git a/tools/hls-fuzzer/AST.h b/tools/hls-fuzzer/AST.h
index 449f8e31a..8b0be2814 100644
--- a/tools/hls-fuzzer/AST.h
+++ b/tools/hls-fuzzer/AST.h
@@ -192,6 +192,8 @@ class ScalarType {
   template <typename From>
   friend struct llvm::simplify_type;
 
+  using SubElements = std::tuple<>;
+
 private:
   std::shared_ptr<const Variant> datatype;
 };
@@ -234,16 +236,22 @@ struct Constant {
           return PrimitiveType::Double;
         });
   }
+
+  using SubElements = std::tuple<>;
 };
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const Constant &constant);
 
+class ScalarParameter;
+
 /// AST-node representing a reference to a variable in C.
 struct Variable {
   const ScalarType datatype;
   const std::string name;
 
   const ScalarType &getType() const { return datatype; }
+
+  using SubElements = std::tuple<ScalarParameter>;
 };
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const Variable &variable);
@@ -324,6 +332,9 @@ class BinaryExpression {
 
   using SubElements = std::tuple<Expression, Expression>;
 
+  constexpr static std::size_t LHS = 0;
+  constexpr static std::size_t RHS = 1;
+
 private:
   Expression lhs;
   Op op;
@@ -344,6 +355,11 @@ class CastExpression {
   /// Returns the type of this expression, i.e., the type being cast to.
   const ScalarType &getType() const { return targetType; }
 
+  using SubElements = std::tuple<ScalarType, Expression>;
+
+  constexpr static std::size_t TARGET_TYPE = 0;
+  constexpr static std::size_t OPERAND = 1;
+
 private:
   ScalarType targetType;
   Expression expression;
@@ -374,6 +390,8 @@ class UnaryExpression {
 
   static bool isLegalOperandType(Op op, const ScalarType &type);
 
+  using SubElements = std::tuple<Expression>;
+
 private:
   Op op;
   Expression expression;
@@ -398,6 +416,11 @@ class ConditionalExpression {
 
   ScalarType getType() const;
 
+  using SubElements = std::tuple<Expression, Expression, Expression>;
+  constexpr static std::size_t CONDITION = 0;
+  constexpr static std::size_t TRUE_VAL = 1;
+  constexpr static std::size_t FALSE_VAL = 2;
+
 private:
   Expression condition;
   Expression trueVal;
@@ -452,6 +475,8 @@ class ReturnStatement {
 
   const Expression &getReturnValue() const { return returnValue; }
 
+  using SubElements = std::tuple<Expression>;
+
 private:
   Expression returnValue;
 };
@@ -478,6 +503,11 @@ class ArrayAssignmentStatement {
   /// Returns the value that will be assigned to the element.
   const Expression &getValueExpression() const { return valueExpression; }
 
+  using SubElements = std::tuple<ArrayParameter, Expression, Expression>;
+  constexpr static std::size_t ARRAY = 0;
+  constexpr static std::size_t INDEX = 1;
+  constexpr static std::size_t VALUE = 2;
+
 private:
   std::string arrayParameter;
   Expression indexingExpression;
@@ -507,6 +537,40 @@ class Statement {
   std::shared_ptr<const Variant> statement;
 };
 
+/// Class representing a list of statements in a body.
+class StatementList {
+public:
+  StatementList() = default;
+
+  explicit StatementList(std::vector<Statement> statements)
+      : statements(std::move(statements)) {}
+
+  /// Returns the number of statements.
+  std::size_t size() const { return statements.size(); }
+
+  const Statement &operator[](std::size_t index) const {
+    return statements[index];
+  }
+
+  auto begin() { return statements.begin(); }
+
+  auto begin() const { return statements.begin(); }
+
+  auto end() { return statements.end(); }
+
+  auto end() const { return statements.end(); }
+
+  std::vector<Statement> takeVector() { return std::move(statements); }
+
+  // Recursive statement list representation.
+  // The definition is left recursive, meaning the statement is always the tail
+  // statement after the list.
+  using SubElements = std::tuple<StatementList, Statement>;
+
+private:
+  std::vector<Statement> statements;
+};
+
 /// AST-Node representing a scalar function parameter in C.
 class ScalarParameter {
 public:
@@ -519,6 +583,8 @@ class ScalarParameter {
 
   const ScalarType &getDataType() const { return dataType; }
 
+  using SubElements = std::tuple<ScalarType>;
+
 private:
   ScalarType dataType;
   std::string name;
@@ -545,6 +611,8 @@ class ArrayParameter {
 
   std::size_t getDimension() const { return dimension; }
 
+  using SubElements = std::tuple<ScalarType>;
+
 private:
   ScalarType dataType;
   std::string name;
@@ -555,13 +623,50 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &os,
                               const ArrayParameter &parameter);
 
 /// Tag type representing the 'void' type from C.
-struct VoidType {};
+struct VoidType {
+  friend bool operator==(const VoidType &lhs, const VoidType &rhs) {
+    return true;
+  }
+
+  friend bool operator!=(const VoidType &lhs, const VoidType &rhs) {
+    return !(lhs == rhs);
+  }
+};
 
 inline llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const VoidType &) {
   return os << "void";
 }
 
-using ReturnType = std::variant<VoidType, ScalarType>;
+class ReturnType {
+  using Variant = std::variant<VoidType, ScalarType>;
+
+public:
+  ReturnType() = default;
+
+  template <class T, std::enable_if_t<std::is_constructible_v<Variant, T> &&
+                                      !std::is_same_v<std::decay_t<Variant>, T>>
+                         * = nullptr>
+  /*implicit*/ ReturnType(T &&arg) : variant(std::forward<T>(arg)) {}
+
+  friend bool operator==(const ReturnType &lhs, const ReturnType &rhs) {
+    return lhs.variant == rhs.variant;
+  }
+
+  friend bool operator!=(const ReturnType &lhs, const ReturnType &rhs) {
+    return !(lhs == rhs);
+  }
+
+  template <typename From>
+  friend struct llvm::simplify_type;
+
+  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &os,
+                                       const ReturnType &returnType);
+
+  using SubElements = std::tuple<>;
+
+private:
+  Variant variant;
+};
 
 /// AST-Node representing a function in C.
 /// Functions are currently limited to just a return statement.
@@ -576,6 +681,11 @@ struct Function {
   /// The return statement at the end of a function iff it does not have a void
   /// return type.
   const std::optional<ReturnStatement> returnStatement;
+
+  using SubElements = std::tuple<ReturnType, StatementList, ReturnStatement>;
+  constexpr static std::size_t RETURN_TYPE = 0;
+  constexpr static std::size_t STATEMENTS = 1;
+  constexpr static std::size_t RETURN_STATEMENT = 2;
 };
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const Function &function);
@@ -628,6 +738,7 @@ auto enumRange() {
 
 // Enable 'dyn_cast' and friends on 'ScalarType' by delegating to 'dyn_cast' on
 // the variant.
+// E.g. 'ast::PrimitiveType* prim = dyn_cast<ast::PrimitiveType>(scalarType);'
 template <>
 struct llvm::simplify_type<dynamatic::ast::ScalarType> {
   using SimpleType = const dynamatic::ast::ScalarType::Variant;
@@ -638,4 +749,14 @@ struct llvm::simplify_type<dynamatic::ast::ScalarType> {
   }
 };
 
+template <>
+struct llvm::simplify_type<dynamatic::ast::ReturnType> {
+  using SimpleType = const dynamatic::ast::ReturnType::Variant;
+
+  static SimpleType &
+  getSimplifiedValue(const dynamatic::ast::ReturnType &datatype) {
+    return datatype.variant;
+  }
+};
+
 #endif
diff --git a/tools/hls-fuzzer/BasicCGenerator.cpp b/tools/hls-fuzzer/BasicCGenerator.cpp
index 416a91fca..2e7024f5b 100644
--- a/tools/hls-fuzzer/BasicCGenerator.cpp
+++ b/tools/hls-fuzzer/BasicCGenerator.cpp
@@ -49,19 +49,23 @@ static ast::Expression safeCastAsNeeded(const ast::ScalarType &to,
       outputPrim->getMinValue());
 }
 
-auto gen::BasicCGenerator::generateFreshScalarParameter(
-    ast::ScalarType datatype, const OpaqueContext &context)
-    -> PendingParameter {
-  scalarParameters.push_back(
-      {{std::move(datatype), generateFreshVarName()}, context});
-  return PendingParameter(*this, scalarParameters.back().first);
-}
-
 ast::ReturnStatement
 gen::BasicCGenerator::generateReturnStatement(const OpaqueContext &context) {
-  ast::Expression expression = generateExpression(context, 0);
-  return ast::ReturnStatement{safeCastAsNeeded(
-      llvm::cast<ast::ScalarType>(returnType), std::move(expression))};
+  return *generateWithDependencies<ast::ReturnStatement>(
+      context, typeSystem.getReturnStatementTransferFns(),
+      /*return value=*/
+      [&](const OpaqueContext &context) {
+        ast::Expression expression = generateExpression(context, 0);
+        if (maybeReturnType && llvm::isa<ast::ScalarType>(*maybeReturnType))
+          expression =
+              safeCastAsNeeded(llvm::cast<ast::ScalarType>(*maybeReturnType),
+                               std::move(expression));
+        return expression;
+      },
+      /*constructor=*/
+      [&](ast::Expression &&expression) {
+        return ast::ReturnStatement{std::move(expression)};
+      });
 }
 
 constexpr std::size_t MAX_DEPTH = 4;
@@ -127,7 +131,7 @@ gen::BasicCGenerator::generateBinaryExpression(ast::BinaryExpression::Op op,
     return std::nullopt;
 
   return generateWithDependencies<ast::BinaryExpression>(
-      context, typeSystem.getBinaryExpressionContextDependencies(op),
+      context, typeSystem.getBinaryExpressionTransferFns(op),
       /*lhs=*/
       [&](const OpaqueContext &context) -> ast::Expression {
         return generateExpression(context, depth + 1);
@@ -211,102 +215,127 @@ std::optional<ast::Expression>
 gen::BasicCGenerator::generateUnaryExpression(ast::UnaryExpression::Op op,
                                               const OpaqueContext &context,
                                               std::size_t depth) {
-  auto conclusion = typeSystem.checkUnaryExpressionOpaque(op, context);
-  if (!conclusion)
+  if (typeSystem.discardUnaryExpressionOpaque(op, context))
     return std::nullopt;
 
-  ast::Expression operand = generateExpression(*conclusion, depth + 1);
-
-  // Perform explicit casts to a legal operand type if the operand type is not
-  // legal for the given operation.
-  // This would e.g. cast 'double's that are meant to be applied to '~' to a
-  // random type that can be legally used with '~'.
-  if (!ast::UnaryExpression::isLegalOperandType(op, operand.getType())) {
-    std::optional<ast::ScalarType> scalarType = generateScalarType(
-        context, /*toExclude=*/[&](const ast::ScalarType &value) {
-          return !ast::UnaryExpression::isLegalOperandType(op, value);
-        });
-    if (!scalarType)
-      return std::nullopt;
-
-    operand = safeCastAsNeeded(*scalarType, std::move(operand));
-  }
+  return generateWithDependencies<ast::UnaryExpression>(
+      context, typeSystem.getUnaryExpressionTransferFns(op),
+      /*operand=*/
+      [&](const OpaqueContext &context) {
+        return generateExpression(context, depth + 1);
+      },
+      /*constructor=*/
+      [&](ast::Expression &&operand) -> std::optional<ast::UnaryExpression> {
+        // Perform explicit casts to a legal operand type if the operand type is
+        // not legal for the given operation. This would e.g. cast 'double's
+        // that are meant to be applied to '~' to a random type that can be
+        // legally used with '~'.
+        if (!ast::UnaryExpression::isLegalOperandType(op, operand.getType())) {
+          std::optional<ast::ScalarType> scalarType = generateScalarType(
+              context, /*toExclude=*/[&](const ast::ScalarType &value) {
+                return !ast::UnaryExpression::isLegalOperandType(op, value);
+              });
+          if (!scalarType)
+            return std::nullopt;
 
-  return ast::UnaryExpression{op, std::move(operand)};
+          operand = safeCastAsNeeded(*scalarType, std::move(operand));
+        }
+
+        return ast::UnaryExpression{op, std::move(operand)};
+      });
 }
 
 std::optional<ast::ConditionalExpression>
 gen::BasicCGenerator::generateConditionalExpression(
     const OpaqueContext &context, std::size_t depth) {
-  auto subcontext = typeSystem.checkConditionalExpressionOpaque(context);
-  if (!subcontext)
+  if (typeSystem.discardConditionalExpressionOpaque(context))
     return std::nullopt;
-  auto &&[cond, trueExpr, falseExpr] = *subcontext;
 
-  return ast::ConditionalExpression{generateExpression(cond, depth + 1),
-                                    generateExpression(trueExpr, depth + 1),
-                                    generateExpression(falseExpr, depth + 1)};
+  return generateWithDependencies<ast::ConditionalExpression>(
+      context, typeSystem.getConditionalExpressionTransferFns(),
+      /*condition=*/
+      [&](const OpaqueContext &context) {
+        return generateExpression(context, depth + 1);
+      },
+      /*true value=*/
+      [&](const OpaqueContext &context) {
+        return generateExpression(context, depth + 1);
+      },
+      /*false value=*/
+      [&](const OpaqueContext &context) {
+        return generateExpression(context, depth + 1);
+      },
+      /*constructor=*/
+      [&](ast::Expression &&cond, ast::Expression &&trueExpr,
+          ast::Expression &&falseExpr) {
+        return ast::ConditionalExpression{std::move(cond), std::move(trueExpr),
+                                          std::move(falseExpr)};
+      });
 }
 
 std::optional<ast::CastExpression>
 gen::BasicCGenerator::generateCastExpression(const OpaqueContext &context,
                                              std::size_t depth) {
-  auto subcontext = typeSystem.checkCastExpressionOpaque(context);
-  if (!subcontext)
+  if (typeSystem.discardCastExpressionOpaque(context))
     return std::nullopt;
-  auto &&[typeCon, exprCon] = *subcontext;
 
-  ast::Expression expression = generateExpression(exprCon, depth + 1);
-  ast::ScalarType expressionType = expression.getType();
-
-  // Keep it interesting by not performing noop-casts!
-  std::optional<ast::ScalarType> datatype =
-      generateScalarType(typeCon, /*toExclude=*/[&](auto &&value) {
-        return value == expressionType;
+  return generateWithDependencies<ast::CastExpression>(
+      context, typeSystem.getCastExpressionTransferFns(),
+      /*data type=*/
+      [&](const OpaqueContext &context) { return generateScalarType(context); },
+      /*operand=*/
+      [&](const OpaqueContext &context) {
+        return generateExpression(context, depth + 1);
+      },
+      /*constructor=*/
+      [](ast::ScalarType &&datatype, ast::Expression &&expression) {
+        return ast::CastExpression{std::move(datatype), std::move(expression)};
       });
-  if (!datatype)
-    return std::nullopt;
-
-  return ast::CastExpression{std::move(*datatype), std::move(expression)};
 }
 
-std::optional<ast::Constant>
-gen::BasicCGenerator::generateConstant(const OpaqueContext &context,
-                                       std::size_t) const {
-  auto candidates = ast::PrimitiveType::ALL_PRIMITIVES;
-  random.shuffle(candidates);
+ast::Constant gen::BasicCGenerator::getConstantForType(
+    const ast::ScalarType &scalarType) const {
+  return llvm::TypeSwitch<ast::ScalarType, ast::Constant>(scalarType)
+      .Case([&](const ast::PrimitiveType *primitive) {
+        switch (primitive->getType()) {
+        case ast::PrimitiveType::Int8:
+          return ast::Constant{random.getInterestingInteger<std::int8_t>()};
+        case ast::PrimitiveType::UInt8:
+          return ast::Constant{random.getInterestingInteger<std::uint8_t>()};
 
-  for (ast::PrimitiveType::Type iter : candidates) {
-    std::optional constant = [&] {
-      switch (iter) {
-      case ast::PrimitiveType::Int8:
-        return ast::Constant{random.getInterestingInteger<std::int8_t>()};
-      case ast::PrimitiveType::UInt8:
-        return ast::Constant{random.getInterestingInteger<std::uint8_t>()};
+        case ast::PrimitiveType::Int16:
+          return ast::Constant{random.getInterestingInteger<std::int16_t>()};
 
-      case ast::PrimitiveType::Int16:
-        return ast::Constant{random.getInterestingInteger<std::int16_t>()};
+        case ast::PrimitiveType::UInt16:
+          return ast::Constant{random.getInterestingInteger<std::uint16_t>()};
 
-      case ast::PrimitiveType::UInt16:
-        return ast::Constant{random.getInterestingInteger<std::uint16_t>()};
+        case ast::PrimitiveType::Int32:
+          return ast::Constant{random.getInterestingInteger<std::int32_t>()};
 
-      case ast::PrimitiveType::Int32:
-        return ast::Constant{random.getInterestingInteger<std::int32_t>()};
+        case ast::PrimitiveType::UInt32:
+          return ast::Constant{random.getInterestingInteger<std::uint32_t>()};
 
-      case ast::PrimitiveType::UInt32:
-        return ast::Constant{random.getInterestingInteger<std::uint32_t>()};
+        case ast::PrimitiveType::Float:
+          return ast::Constant{random.getInterestingFloat()};
 
-      case ast::PrimitiveType::Float:
-        return ast::Constant{random.getInterestingFloat()};
+        case ast::PrimitiveType::Double:
+          return ast::Constant{random.getInterestingDouble()};
+        }
+        llvm_unreachable("all enum cases handled");
+      });
+}
 
-      case ast::PrimitiveType::Double:
-        return ast::Constant{random.getInterestingDouble()};
-      }
-      llvm_unreachable("all enum cases handled");
-    }();
-    if (constant = typeSystem.checkConstantOpaque(*constant, context); constant)
+std::optional<ast::Constant>
+gen::BasicCGenerator::generateConstant(const OpaqueContext &context,
+                                       std::size_t) const {
+  auto candidates = ast::PrimitiveType::ALL_PRIMITIVES;
+  random.shuffle(candidates);
+
+  for (ast::PrimitiveType::Type iter : candidates)
+    if (std::optional constant =
+            typeSystem.discardConstantOpaque(getConstantForType(iter), context))
       return constant;
-  }
+
   return std::nullopt;
 }
 
@@ -317,7 +346,7 @@ gen::BasicCGenerator::generateArrayReadExpression(const OpaqueContext &context,
     return std::nullopt;
 
   return generateWithDependencies<ast::ArrayReadExpression>(
-      context, typeSystem.getArrayReadExpressionContextDependencies(),
+      context, typeSystem.getArrayReadExpressionTransferFns(),
       /*array parameter=*/
       [&](const OpaqueContext &context) -> std::optional<ast::ArrayParameter> {
         return generateArrayParameter(context);
@@ -360,68 +389,88 @@ gen::BasicCGenerator::generateArrayParameter(const OpaqueContext &context,
   if (!random.getRatherLowProbabilityBool()) {
     // Randomly shuffle the parameter ordering and find the first parameter
     // that passes type checking.
-    std::vector<ast::ArrayParameter> copy(arrayParameters.size());
-    llvm::copy(llvm::make_first_range(arrayParameters), copy.begin());
+    std::vector<ast::ArrayParameter> copy = arrayParameters;
     random.shuffle(copy);
 
     for (const ast::ArrayParameter &candidateParam : copy)
-      if (typeSystem.checkArrayParameterOpaque(candidateParam, context))
+      if (!typeSystem.discardExistingArrayParameterOpaque(candidateParam,
+                                                          context))
         return candidateParam;
   }
 
-  std::optional<ast::ScalarType> elementType = generateScalarType(context);
-  if (!elementType)
+  if (typeSystem.discardFreshArrayParameterOpaque(context))
     return std::nullopt;
 
-  arrayParameters.push_back(
-      {{std::move(*elementType), generateFreshVarName(),
-        // Generate a power-of-2 dimension to make the modulo operator fast and
-        // easy to implement.
-        // We choose an arbitrary upper-bound of 32 for the dimension for now.
-        static_cast<std::size_t>(1 << random.getInteger(0, 5))},
-       context});
-  if (!typeSystem.checkArrayParameterOpaque(arrayParameters.back().first,
-                                            context)) {
-    arrayParameters.pop_back();
-    varCounter--;
-    return std::nullopt;
-  }
-  return arrayParameters.back().first;
+  return generateWithDependencies<ast::ArrayParameter>(
+      context, typeSystem.getArrayParameterTransferFns(),
+      /*element type=*/
+      [&](const OpaqueContext &context) { return generateScalarType(context); },
+      /*constructor=*/
+      [&](ast::ScalarType &&elementType) {
+        return arrayParameters.emplace_back(
+            std::move(elementType), generateFreshVarName(),
+            // Generate a power-of-2 dimension to make the modulo operator
+            // fast and easy to implement. We choose an arbitrary upper-bound
+            // of 32 for the dimension for now.
+            static_cast<std::size_t>(1 << random.getInteger(0, 5)));
+      });
 }
 
 std::optional<ast::Variable>
 gen::BasicCGenerator::generateScalarParameter(const OpaqueContext &context,
                                               std::size_t) {
-  auto conclusion = typeSystem.checkVariableOpaque(context);
-  if (!conclusion)
+  if (typeSystem.discardVariableOpaque(context))
     return std::nullopt;
 
-  // With a low chance, skip picking an existing parameter and try to generate
-  // a new one.
-  if (!random.getRatherLowProbabilityBool()) {
-    // Randomly shuffle the parameter ordering and find the first parameter
-    // that passes type checking.
-    std::vector<ast::ScalarParameter> copy(scalarParameters.size());
-    llvm::copy(llvm::make_first_range(scalarParameters), copy.begin());
-    random.shuffle(copy);
+  return generateWithDependencies<ast::Variable>(
+      context, typeSystem.getVariableTransferFns(),
+      /*parameter=*/
+      [&](const OpaqueContext &context) -> std::optional<ast::ScalarParameter> {
+        std::array<std::function<std::optional<ast::ScalarParameter>()>, 2>
+            generators;
+        generators[0] = [&]() -> std::optional<ast::ScalarParameter> {
+          // Randomly shuffle the parameter ordering and find the first
+          // parameter that passes type checking.
+          std::vector<ast::ScalarParameter> copy = scalarParameters;
+          random.shuffle(copy);
+
+          for (const ast::ScalarParameter &iter : copy)
+            if (!typeSystem.discardExistingScalarParameterOpaque(iter, context))
+              return iter;
+
+          return std::nullopt;
+        };
+        generators[1] = [&]() -> std::optional<ast::ScalarParameter> {
+          if (typeSystem.discardFreshScalarParameterOpaque(context))
+            return std::nullopt;
 
-    for (ast::ScalarParameter &iter : copy)
-      if (typeSystem.checkScalarParameterOpaque(iter, *conclusion))
-        return ast::Variable{iter.getDataType(), iter.getName().str()};
-  }
+          return generateWithDependencies<ast::ScalarParameter>(
+              context, typeSystem.getScalarParameterTransferFns(),
+              /*datatype=*/
+              [&](const OpaqueContext &context) {
+                return generateScalarType(context);
+              },
+              /*constructor=*/
+              [&](ast::ScalarType &&datatype) {
+                return scalarParameters.emplace_back(std::move(datatype),
+                                                     generateFreshVarName());
+              });
+        };
 
-  std::optional<ast::ScalarType> datatype = generateScalarType(*conclusion);
-  if (!datatype)
-    return std::nullopt;
+        if (random.getRatherLowProbabilityBool())
+          std::swap(generators[0], generators[1]);
 
-  PendingParameter pendingParam =
-      generateFreshScalarParameter(*datatype, context);
-  if (typeSystem.checkScalarParameterOpaque(pendingParam.getParameter(),
-                                            *conclusion)) {
-    ast::ScalarParameter parameter = pendingParam.commit();
-    return ast::Variable{parameter.getDataType(), parameter.getName().str()};
-  }
-  return std::nullopt;
+        for (auto &iter : generators)
+          if (std::optional<ast::ScalarParameter> result = iter())
+            return result;
+
+        return std::nullopt;
+      },
+      /*constructor=*/
+      [&](ast::ScalarParameter &&parameter) {
+        return ast::Variable{parameter.getDataType(),
+                             parameter.getName().str()};
+      });
 }
 
 std::optional<ast::ScalarType> gen::BasicCGenerator::generateScalarType(
@@ -434,7 +483,7 @@ std::optional<ast::ScalarType> gen::BasicCGenerator::generateScalarType(
     if (toExclude && toExclude(iter))
       continue;
 
-    if (typeSystem.checkScalarTypeOpaque(iter, context))
+    if (!typeSystem.discardScalarTypeOpaque(iter, context))
       return iter;
   }
 
@@ -451,7 +500,7 @@ gen::BasicCGenerator::generateReturnType(const OpaqueContext &context) const {
   candidates.back() = ast::VoidType{};
   random.shuffle(candidates);
   for (const ast::ReturnType &iter : candidates)
-    if (typeSystem.checkReturnTypeOpaque(iter, context))
+    if (!typeSystem.discardReturnTypeOpaque(iter, context))
       return iter;
 
   llvm::report_fatal_error(
@@ -460,23 +509,29 @@ gen::BasicCGenerator::generateReturnType(const OpaqueContext &context) const {
 
 constexpr std::size_t MAX_STATEMENTS = 10;
 
-std::vector<ast::Statement>
-gen::BasicCGenerator::generateStatementList(const OpaqueContext &context) {
-  std::vector<ast::Statement> result;
-  // TODO: Type systems should have better control over the number of
-  //       statements and in what order they are generated.
-  //       Right now they are always generated last statement to first.
-  std::size_t numStatements = random.getInteger<std::size_t>(0, MAX_STATEMENTS);
-  result.reserve(numStatements);
-  for (std::size_t i = 0; i < numStatements; i++) {
-    std::optional<ast::Statement> maybeStat = generateStatement(context);
-    if (!maybeStat)
-      break;
-
-    result.push_back(std::move(*maybeStat));
-  }
-  std::reverse(result.begin(), result.end());
-  return result;
+ast::StatementList
+gen::BasicCGenerator::generateStatementList(const OpaqueContext &context,
+                                            size_t depth) {
+  if (depth > MAX_STATEMENTS)
+    return ast::StatementList();
+
+  return generateWithDependencies<ast::StatementList>(
+             context, typeSystem.getStatementListTransferFns(),
+             /*statement list=*/
+             [&](const OpaqueContext &context) {
+               return generateStatementList(context, depth + 1);
+             },
+             /*statement=*/
+             [&](const OpaqueContext &context) {
+               return generateStatement(context);
+             },
+             /*constructor=*/
+             [&](ast::StatementList &&statements, ast::Statement &&statement) {
+               std::vector<ast::Statement> result = statements.takeVector();
+               result.push_back(std::move(statement));
+               return ast::StatementList(std::move(result));
+             })
+      .value_or(ast::StatementList());
 }
 
 std::optional<ast::Statement>
@@ -487,48 +542,68 @@ gen::BasicCGenerator::generateStatement(const OpaqueContext &context) {
 std::optional<ast::ArrayAssignmentStatement>
 gen::BasicCGenerator::generateArrayAssignmentStatement(
     const OpaqueContext &context) {
-  auto conclusion = typeSystem.checkArrayAssignmentStatementOpaque(context);
-  if (!conclusion)
+  if (typeSystem.discardArrayAssignmentStatementOpaque(context))
     return std::nullopt;
 
-  auto &&[param, index, value] = *conclusion;
-  std::optional<ast::ArrayParameter> parameter = generateArrayParameter(param);
-  if (!parameter)
-    return std::nullopt;
-
-  ast::Expression castAsNeeded = safeCastAsNeeded(
-      /*to=*/ast::PrimitiveType::UInt32,
-      generateExpression(/*context=*/index, /*depth=*/0));
-  castAsNeeded = ast::BinaryExpression{
-      std::move(castAsNeeded), ast::BinaryExpression::BitAnd,
-      ast::Constant{static_cast<std::uint32_t>(parameter->getDimension() - 1)}};
-  return ast::ArrayAssignmentStatement{
-      parameter->getName().str(),
-      castAsNeeded,
-      generateExpression(value, 0),
-  };
+  return generateWithDependencies<ast::ArrayAssignmentStatement>(
+      context, typeSystem.getArrayAssignmentStatementTransferFns(),
+      /*array parameter=*/
+      [&](const OpaqueContext &context) {
+        return generateArrayParameter(context);
+      },
+      /*index=*/
+      [&](const OpaqueContext &context) {
+        return safeCastAsNeeded(
+            /*to=*/ast::PrimitiveType::UInt32,
+            generateExpression(context, /*depth=*/0));
+      },
+      /*value=*/
+      [&](const OpaqueContext &context) {
+        return generateExpression(context, 0);
+      },
+      /*constructor=*/
+      [&](ast::ArrayParameter &&param, ast::Expression &&index,
+          ast::Expression &&value) {
+        index = ast::BinaryExpression{std::move(index),
+                                      ast::BinaryExpression::BitAnd,
+                                      ast::Constant{static_cast<std::uint32_t>(
+                                          param.getDimension() - 1)}};
+        return ast::ArrayAssignmentStatement{
+            param.getName().str(),
+            std::move(index),
+            std::move(value),
+        };
+      });
 }
 
 ast::Function gen::BasicCGenerator::generate(std::string_view functionName) {
-  auto conclusion = typeSystem.checkFunctionOpaque(entryContext);
-  returnType = generateReturnType(conclusion.returnType);
-  std::optional<ast::ReturnStatement> returnStatement;
-  if (!std::holds_alternative<ast::VoidType>(returnType))
-    returnStatement = generateReturnStatement(conclusion.returnStatement);
-
-  std::vector<ast::Statement> statementList =
-      generateStatementList(conclusion.returnStatement);
-
-  auto scalarRange = llvm::make_first_range(scalarParameters);
-  auto arrayRange = llvm::make_first_range(arrayParameters);
-  return ast::Function{
-      returnType,
-      std::string(functionName),
-      std::vector(scalarRange.begin(), scalarRange.end()),
-      std::vector(arrayRange.begin(), arrayRange.end()),
-      statementList,
-      std::move(returnStatement),
-  };
+  return *generateWithDependencies<ast::Function>(
+      entryContext, typeSystem.getFunctionTransferFns(),
+      /*return type=*/
+      [&](const OpaqueContext &context) {
+        return maybeReturnType = generateReturnType(context);
+      },
+      /*statement list=*/
+      [&](const OpaqueContext &context) {
+        return generateStatementList(context, 0);
+      },
+      /*return statement=*/
+      [&](const OpaqueContext &context) {
+        return generateReturnStatement(context);
+      },
+      /*constructor=*/
+      [&](ast::ReturnType &&returnType, ast::StatementList &&statements,
+          ast::ReturnStatement &&returnStatement) {
+        std::optional maybeReturnStatement = std::move(returnStatement);
+        if (returnType == ast::VoidType{})
+          maybeReturnStatement.reset();
+
+        return ast::Function{
+            std::move(returnType),   std::string(functionName),
+            scalarParameters,        arrayParameters,
+            statements.takeVector(), std::move(maybeReturnStatement),
+        };
+      });
 }
 
 std::string
@@ -538,30 +613,19 @@ gen::BasicCGenerator::generateTestBench(const ast::Function &kernel) const {
   ss << "\nint main() {\n";
   mlir::raw_indented_ostream os(ss);
   os.indent();
-  for (const auto &[parameter, context] : scalarParameters) {
-    std::optional<ast::Constant> constant;
-    while (!constant) {
-      constant = generateConstant(context);
-    }
-
+  for (const ast::ScalarParameter &parameter : scalarParameters) {
     os << parameter.getDataType() << ' ' << parameter.getName() << " = "
-       << *constant << ";\n";
+       << getConstantForType(parameter.getDataType()) << ";\n";
   }
 
-  for (const auto &[parameter, context] : arrayParameters) {
+  for (const ast::ArrayParameter &parameter : arrayParameters) {
     os << parameter.getElementType() << ' ' << parameter.getName() << "["
        << parameter.getDimension() << "] = {";
-    llvm::interleaveComma(
-        llvm::seq<std::size_t>(0, parameter.getDimension()), os,
-        [&, &context = context, &parameter = parameter](auto &&) {
-          std::optional<ast::Constant> constant;
-          while (!constant) {
-            constant = generateConstant(context);
-          }
-          // C++ does not allow implicit casts in array constructors, so we
-          // must cast the constant explicitly.
-          os << safeCastAsNeeded(parameter.getElementType(), *constant);
-        });
+    llvm::interleaveComma(llvm::seq<std::size_t>(0, parameter.getDimension()),
+                          os, [&, &parameter = parameter](auto &&) {
+                            os << getConstantForType(
+                                parameter.getElementType());
+                          });
     os << "};\n";
   }
 
diff --git a/tools/hls-fuzzer/BasicCGenerator.h b/tools/hls-fuzzer/BasicCGenerator.h
index 8a3dd44cf..02567239b 100644
--- a/tools/hls-fuzzer/BasicCGenerator.h
+++ b/tools/hls-fuzzer/BasicCGenerator.h
@@ -77,9 +77,6 @@ class BasicCGenerator {
     std::optional<ast::ScalarParameter> parameter;
   };
 
-  PendingParameter generateFreshScalarParameter(ast::ScalarType datatype,
-                                                const OpaqueContext &context);
-
   ast::ReturnStatement
   generateReturnStatement(const OpaqueContext &constraints);
 
@@ -101,6 +98,8 @@ class BasicCGenerator {
   std::optional<ast::CastExpression>
   generateCastExpression(const OpaqueContext &constraint, std::size_t depth);
 
+  ast::Constant getConstantForType(const ast::ScalarType &scalarType) const;
+
   std::optional<ast::Constant> generateConstant(const OpaqueContext &constraint,
                                                 std::size_t depth = 0) const;
 
@@ -126,8 +125,8 @@ class BasicCGenerator {
 
   ast::ReturnType generateReturnType(const OpaqueContext &context) const;
 
-  std::vector<ast::Statement>
-  generateStatementList(const OpaqueContext &context);
+  ast::StatementList generateStatementList(const OpaqueContext &context,
+                                           size_t depth);
 
   std::optional<ast::Statement> generateStatement(const OpaqueContext &context);
 
@@ -135,9 +134,9 @@ class BasicCGenerator {
   generateArrayAssignmentStatement(const OpaqueContext &context);
 
   Randomly &random;
-  ast::ReturnType returnType;
-  std::vector<std::pair<ast::ScalarParameter, OpaqueContext>> scalarParameters;
-  std::vector<std::pair<ast::ArrayParameter, OpaqueContext>> arrayParameters;
+  std::optional<ast::ReturnType> maybeReturnType;
+  std::vector<ast::ScalarParameter> scalarParameters;
+  std::vector<ast::ArrayParameter> arrayParameters;
   std::size_t varCounter = 0;
   AbstractTypeSystem &typeSystem;
   OpaqueContext entryContext;
diff --git a/tools/hls-fuzzer/TypeSystem.h b/tools/hls-fuzzer/TypeSystem.h
index 5786efd2d..8609184bb 100644
--- a/tools/hls-fuzzer/TypeSystem.h
+++ b/tools/hls-fuzzer/TypeSystem.h
@@ -1,9 +1,10 @@
 #ifndef DYNAMATIC_HLS_FUZZER_TYPE_SYSTEM_GUIDED_GENERATOR
 #define DYNAMATIC_HLS_FUZZER_TYPE_SYSTEM_GUIDED_GENERATOR
 
+#include "AST.h"
 #include "Randomly.h"
-#include "TypeSystemTraits.h"
 
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/FunctionExtras.h"
 
 #include <any>
@@ -84,6 +85,18 @@ class TransferFn {
         remaining...>::type;
   };
 
+  // Special case required to still allow parent dependencies when 'ASTNode'
+  // does not have any subelements.
+  template <typename Tuple>
+  struct CalcCompFn<Tuple, PARENT_DEPENDENCY, 0> {
+    // Recursive case.
+    using type = typename CalcCompFn<
+        decltype(std::tuple_cat(
+            std::declval<Tuple>(),
+            std::declval<std::tuple<const TypingContext &>>())),
+        0>::type;
+  };
+
   // Terminating end-case
   template <class... Args, std::size_t current>
   struct CalcCompFn<std::tuple<Args...>, current> {
@@ -272,78 +285,170 @@ using TransferFnArray =
 /// and 'discard*' methods.
 class AbstractTypeSystem {
 protected:
-  /// Returns an instance of 'TransferFn' which simply forwards the context from
-  /// the parent to the subelement.
+  /// Returns an instance of 'TransferFn' which simply forwards the context
+  /// from the parent to the subelement.
   template <typename ASTNode>
   static auto copyFromParent() {
-    return TransferFn<OpaqueContext, ASTNode, PARENT_DEPENDENCY>(
-        [](const OpaqueContext &context) { return context; });
+    return copyFrom<ASTNode, PARENT_DEPENDENCY>();
+  }
+
+  /// Returns an instance of 'TransferFn' which forwards the context
+  /// from the given index to the subelement.
+  template <typename ASTNode, std::size_t index>
+  static auto copyFrom() {
+    return TransferFn<OpaqueContext, ASTNode, index>(
+        [](const OpaqueContext &context, auto &&...) { return context; });
   }
 
 public:
   virtual ~AbstractTypeSystem();
 
-  virtual ConclusionOf<ast::Function, OpaqueContext>
-  checkFunctionOpaque(const OpaqueContext &context) = 0;
+  virtual TransferFnArray<ast::Function> getFunctionTransferFns() {
+    return {
+        /*return type=*/copyFromParent<ast::Function>(),
+        /*statement list=*/copyFromParent<ast::Function>(),
+        /*return statement=*/copyFromParent<ast::Function>(),
+        /*output=*/copyFromParent<ast::Function>(),
+    };
+  }
+
+  virtual TransferFnArray<ast::ReturnStatement>
+  getReturnStatementTransferFns() {
+    return {
+        /*return value=*/copyFromParent<ast::ReturnStatement>(),
+        /*output=*/copyFromParent<ast::ReturnStatement>(),
+    };
+  }
 
-  /// Returns true if the generator should discard this binary expression based
-  /// on the given input context.
+  /// Returns true if the generator should discard this binary expression
+  /// based on the given input context.
   virtual bool discardBinaryExpressionOpaque(ast::BinaryExpression::Op op,
                                              const OpaqueContext &context) = 0;
 
-  virtual std::optional<ConclusionOf<ast::UnaryExpression, OpaqueContext>>
-  checkUnaryExpressionOpaque(ast::UnaryExpression::Op op,
-                             const OpaqueContext &context) = 0;
-
   virtual TransferFnArray<ast::BinaryExpression>
-  getBinaryExpressionContextDependencies(ast::BinaryExpression::Op op) {
+  getBinaryExpressionTransferFns(ast::BinaryExpression::Op op) {
     // Default implementation: Simply propagates the context to the subelements.
     return {/*lhs=*/copyFromParent<ast::BinaryExpression>(),
             /*rhs=*/copyFromParent<ast::BinaryExpression>(),
             /*output=*/copyFromParent<ast::BinaryExpression>()};
   }
 
-  virtual std::optional<ConclusionOf<ast::Variable, OpaqueContext>>
-  checkVariableOpaque(const OpaqueContext &context) = 0;
+  virtual bool discardUnaryExpressionOpaque(ast::UnaryExpression::Op op,
+                                            const OpaqueContext &context) = 0;
 
-  virtual std::optional<ConclusionOf<ast::CastExpression, OpaqueContext>>
-  checkCastExpressionOpaque(const OpaqueContext &context) = 0;
+  virtual TransferFnArray<ast::UnaryExpression>
+  getUnaryExpressionTransferFns(ast::UnaryExpression::Op op) {
+    return {
+        /*operand=*/copyFromParent<ast::UnaryExpression>(),
+        /*output=*/copyFromParent<ast::UnaryExpression>(),
+    };
+  }
 
-  virtual std::optional<ConclusionOf<ast::ConditionalExpression, OpaqueContext>>
-  checkConditionalExpressionOpaque(const OpaqueContext &context) = 0;
+  virtual bool discardVariableOpaque(const OpaqueContext &context) = 0;
 
-  virtual std::optional<ConclusionOf<ast::ScalarType, OpaqueContext>>
-  checkScalarTypeOpaque(const ast::ScalarType &,
-                        const OpaqueContext &context) = 0;
+  virtual TransferFnArray<ast::Variable> getVariableTransferFns() {
+    return {
+        /*parameter=*/copyFromParent<ast::Variable>(),
+        /*output=*/copyFromParent<ast::Variable>(),
+    };
+  }
+
+  virtual bool discardCastExpressionOpaque(const OpaqueContext &context) = 0;
 
-  virtual std::optional<ConclusionOf<ast::ReturnType, OpaqueContext>>
-  checkReturnTypeOpaque(const ast::ReturnType &,
+  virtual TransferFnArray<ast::CastExpression> getCastExpressionTransferFns() {
+    return {
+        /*target type=*/copyFromParent<ast::CastExpression>(),
+        /*operand=*/copyFromParent<ast::CastExpression>(),
+        /*output=*/copyFromParent<ast::CastExpression>(),
+    };
+  }
+
+  virtual bool
+  discardConditionalExpressionOpaque(const OpaqueContext &context) = 0;
+
+  virtual TransferFnArray<ast::ConditionalExpression>
+  getConditionalExpressionTransferFns() {
+    // Default implementation: Simply propagates the context to the
+    // subelements.
+    return {
+        /*condition=*/copyFromParent<ast::ConditionalExpression>(),
+        /*true value=*/copyFromParent<ast::ConditionalExpression>(),
+        /*false value=*/copyFromParent<ast::ConditionalExpression>(),
+        /*output=*/copyFromParent<ast::ConditionalExpression>(),
+    };
+  }
+
+  virtual bool discardScalarTypeOpaque(const ast::ScalarType &scalarType,
+                                       const OpaqueContext &context) = 0;
+
+  virtual bool discardReturnTypeOpaque(const ast::ReturnType &,
+                                       const OpaqueContext &context) = 0;
+
+  virtual std::optional<ast::Constant>
+  discardConstantOpaque(const ast::Constant &,
                         const OpaqueContext &context) = 0;
 
-  virtual std::optional<ConclusionOf<ast::Constant, OpaqueContext>>
-  checkConstantOpaque(const ast::Constant &, const OpaqueContext &context) = 0;
+  virtual bool
+  discardExistingScalarParameterOpaque(const ast::ScalarParameter &,
+                                       const OpaqueContext &context) = 0;
+
+  virtual bool
+  discardFreshScalarParameterOpaque(const OpaqueContext &context) = 0;
 
-  virtual std::optional<ConclusionOf<ast::ScalarParameter, OpaqueContext>>
-  checkScalarParameterOpaque(const ast::ScalarParameter &,
-                             const OpaqueContext &context) = 0;
+  virtual TransferFnArray<ast::ScalarParameter>
+  getScalarParameterTransferFns() {
+    return {
+        /*data type=*/copyFromParent<ast::ScalarParameter>(),
+        /*output=*/copyFromParent<ast::ScalarParameter>(),
+    };
+  }
 
   virtual bool
   discardArrayReadExpressionOpaque(const OpaqueContext &context) = 0;
 
   virtual TransferFnArray<ast::ArrayReadExpression>
-  getArrayReadExpressionContextDependencies() {
+  getArrayReadExpressionTransferFns() {
     return {/*array parameter=*/copyFromParent<ast::ArrayReadExpression>(),
             /*index=*/copyFromParent<ast::ArrayReadExpression>(),
             /*output=*/copyFromParent<ast::ArrayReadExpression>()};
   }
 
-  virtual std::optional<ConclusionOf<ast::ArrayParameter, OpaqueContext>>
-  checkArrayParameterOpaque(const ast::ArrayParameter &,
-                            const OpaqueContext &context) = 0;
+  virtual bool
+  discardExistingArrayParameterOpaque(const ast::ArrayParameter &,
+                                      const OpaqueContext &context) = 0;
+
+  virtual bool
+  discardFreshArrayParameterOpaque(const OpaqueContext &context) = 0;
+
+  virtual TransferFnArray<ast::ArrayParameter> getArrayParameterTransferFns() {
+    return {
+        /*element type=*/copyFromParent<ast::ArrayParameter>(),
+        /*output=*/copyFromParent<ast::ArrayParameter>(),
+    };
+  }
+
+  virtual bool
+  discardArrayAssignmentStatementOpaque(const OpaqueContext &context) = 0;
+
+  virtual TransferFnArray<ast::ArrayAssignmentStatement>
+  getArrayAssignmentStatementTransferFns() {
+    return TransferFnArray<ast::ArrayAssignmentStatement>{
+        /*array parameter=*/copyFromParent<ast::ArrayAssignmentStatement>(),
+        /*index=*/copyFromParent<ast::ArrayAssignmentStatement>(),
+        /*value=*/copyFromParent<ast::ArrayAssignmentStatement>(),
+        /*output=*/copyFromParent<ast::ArrayAssignmentStatement>(),
+    };
+  }
+
+  virtual bool discardStatementListOpaque(const OpaqueContext &context) = 0;
 
-  virtual std::optional<
-      ConclusionOf<ast::ArrayAssignmentStatement, OpaqueContext>>
-  checkArrayAssignmentStatementOpaque(const OpaqueContext &context) = 0;
+  virtual TransferFnArray<ast::StatementList> getStatementListTransferFns() {
+    return TransferFnArray<ast::StatementList>{
+        /*statement list=*/copyFromParent<ast::StatementList>(),
+        /*statement=*/copyFromParent<ast::StatementList>(),
+        /*output=*/copyFromParent<ast::StatementList>(),
+    };
+  }
 };
 
 /// CRTP-Base class for all implementations of a type system.
@@ -356,20 +461,13 @@ class AbstractTypeSystem {
 /// used when generating sub-elements of an AST-node or 2) rejecting AST-nodes
 /// entirely based on the current type context.
 ///
-/// There are currently two APIs to achieve this:
-/// 1) The transfer functions API
-/// 2) the 'check*' API.
-/// The latter is considered deprecated and implements a subset of
-/// functionality of the transfer functions API.
-///
-/// Regardless of API, all type checking is performed under a given context
-/// specified as the 'TypingContext' template parameter.
-/// Every AST node is initially generated using an input context
-/// passed into the 'check*' method or 'discard*' method of the AST node which
-/// may discard the AST node.
-/// Otherwise, new contexts for the subelements of the AST node can be derived.
+/// All type checking is performed under a given context specified as the
+/// 'TypingContext' template parameter. Every AST node is initially generated
+/// using an input context passed into the 'discard*' method of the AST node
+/// which may discard the AST node. Otherwise, new contexts for the subelements
+/// of the AST node can be derived.
 ///
-/// The transfer functions API allows specifying how input contexts for AST
+/// The transfer functions allow specifying how input contexts for AST
 /// elements should be calculated.
 /// Specifically, an instance of 'TransferFn' can specify that it depends on the
 /// context and AST node of a sibling subelement in addition to, or instead of
@@ -380,20 +478,14 @@ class AbstractTypeSystem {
 /// 'a'.
 /// The generator uses this knowledge to generate the AST node of 'a' before
 /// 'i'.
-/// 'check*' methods in contrast only implement deriving subelement contexts
-/// from the parent input context.
-/// They return a tuple of 'TypingContext's for every subelement of 'ASTNode',
-/// the so-called conclusion type.
 ///
 /// Note: We call it contexts rather than constraints to match literature, and
 /// as it more generally informs an AST-node generation about the type-system
 /// state rather than necessarily putting requirements on an AST-node
-/// generation. In the future, it'll likely be possible to also output contexts
-/// from sub-expressions to parent-expressions.
-/// An example of such a context would e.g. be the set of all variables used.
+/// generation.
 ///
-/// The logic that should be implemented in the 'check*' methods can be thought
-/// of as inversions of the usual type checking rules seen in literature.
+/// The logic that should be implemented can be thought of as inversions of the
+/// usual type checking rules seen in literature.
 /// E.g. assuming a type system where the context is a two-state variable that
 /// requires the expression to either be an integer type or a floating point
 /// type, then a typing rule for conditional expressions might look as follows:
@@ -406,17 +498,11 @@ class AbstractTypeSystem {
 /// ({integer} |- cond) -> ({A} |- lhs) -> ({A} |- rhs) -> ({A} |- cond ? lhs :
 /// rhs)
 ///
-/// The corresponding 'checkConditionalExpression' method instead implements:
+/// The corresponding 'getConditionalExpressionTransferFns' method
+/// instead implements:
 /// ({A} |- cond ? lhs : rhs) -> ({integer} |- cond) -> ({A} |- lhs) -> ({A} |-
-/// rhs) where 'A' is the context passed into the function and the three clauses
-/// correspond to the conclusion type of conditional expressions.
-///
-/// Check methods for terminals are slightly special: They take as input an
-/// already generated terminal node and are always discardable.
-/// All check methods have a default implementation that forwards the current
-/// constraint to all sub-elements.
-/// See the 'TypeSystemTraits' specializations to find the documentation for
-/// various AST-Node's conclusion types.
+/// rhs) where 'A' is the input context and the three clauses correspond to the
+/// input contexts of the sub elements.
 ///
 /// The current implementation how a type system is used in the base generator
 /// has a few constraints:
@@ -426,12 +512,7 @@ class AbstractTypeSystem {
 ///   return type.
 template <typename TypingContext, typename Self>
 class TypeSystem : public AbstractTypeSystem {
-
 public:
-  /// The conclusion type of 'ASTNode' with the given context.
-  template <typename ASTNode>
-  using ConclusionOf = ConclusionOf<ASTNode, TypingContext>;
-
   template <typename ASTNode, std::size_t... inputIndices>
   using TransferFn = TransferFn<TypingContext, ASTNode, inputIndices...>;
 
@@ -443,240 +524,157 @@ class TypeSystem : public AbstractTypeSystem {
   // since we use CRTP-techniques to call these. They may be but are not
   // required to be static.
 
-  static ConclusionOf<ast::Function>
-  checkFunction(const TypingContext &context) {
-    return {context, context};
-  }
-
   static bool discardBinaryExpression(ast::BinaryExpression::Op,
                                       const TypingContext &) {
     return false;
   }
 
-  static ConclusionOf<ast::UnaryExpression>
-  checkUnaryExpression(ast::UnaryExpression::Op, const TypingContext &context) {
-    return {context};
+  static bool discardUnaryExpression(ast::UnaryExpression::Op,
+                                     const TypingContext &) {
+    return false;
   }
 
-  static ConclusionOf<ast::Variable>
-  checkVariable(const TypingContext &context) {
-    return {context};
-  }
+  static bool discardVariable(const TypingContext &) { return false; }
 
-  static ConclusionOf<ast::CastExpression>
-  checkCastExpression(const TypingContext &context) {
-    return {context, context};
-  }
+  static bool discardCastExpression(const TypingContext &) { return false; }
 
-  static ConclusionOf<ast::ConditionalExpression>
-  checkConditionalExpression(const TypingContext &context) {
-    return {context, context, context};
+  static bool discardConditionalExpression(const TypingContext &) {
+    return false;
   }
 
-  static ConclusionOf<ast::ScalarType> checkScalarType(const ast::ScalarType &,
-                                                       const TypingContext &) {
-    return {};
+  static bool discardScalarType(const ast::ScalarType &,
+                                const TypingContext &) {
+    return false;
   }
 
-  std::optional<ConclusionOf<ast::ReturnType>>
-  checkReturnType(const ast::ReturnType &returnType,
-                  const TypingContext &context) {
+  bool discardReturnType(const ast::ReturnType &returnType,
+                         const TypingContext &context) {
     // Default implementation dispatches to 'checkScalarType'.
-    return llvm::TypeSwitch<ast::ReturnType,
-                            std::optional<ConclusionOf<ast::ReturnType>>>(
-               returnType)
-        .Case([](const ast::VoidType *) {
-          return ConclusionOf<ast::ReturnType>{};
-        })
-        .Case([&](const ast::ScalarType *scalar)
-                  -> std::optional<ConclusionOf<ast::ReturnType>> {
-          if (std::optional optional = self().checkScalarType(*scalar, context);
-              !optional)
-            return std::nullopt;
-
-          return ConclusionOf<ast::ReturnType>{};
+    return llvm::TypeSwitch<ast::ReturnType, bool>(returnType)
+        .Case([](const ast::VoidType *) { return false; })
+        .Case([&](const ast::ScalarType *scalar) {
+          return self().discardScalarType(*scalar, context);
         });
   }
 
-  std::optional<ConclusionOf<ast::Constant>>
-  checkConstant(const ast::Constant &constant, const TypingContext &context) {
-    if (std::optional optional =
-            self().checkScalarType(constant.getType(), context);
-        !optional)
+  std::optional<ast::Constant> discardConstant(const ast::Constant &constant,
+                                               const TypingContext &context) {
+    if (self().discardScalarType(constant.getType(), context))
       return std::nullopt;
 
     return constant;
   }
 
-  std::optional<ConclusionOf<ast::ScalarParameter>>
-  checkScalarParameter(const ast::ScalarParameter &parameter,
-                       const TypingContext &context) {
-    if (std::optional optional =
-            self().checkScalarType(parameter.getDataType(), context);
-        !optional)
-      return std::nullopt;
+  bool discardExistingScalarParameter(const ast::ScalarParameter &parameter,
+                                      const TypingContext &context) {
+    return self().discardScalarType(parameter.getDataType(), context);
+  }
 
-    return context;
+  static bool discardFreshScalarParameter(const TypingContext &) {
+    return false;
   }
 
   static bool discardArrayReadExpression(const TypingContext &) {
     return false;
   }
 
-  std::optional<ConclusionOf<ast::ArrayParameter>>
-  checkArrayParameter(const ast::ArrayParameter &parameter,
-                      const TypingContext &context) {
-    if (std::optional optional =
-            self().checkScalarType(parameter.getElementType(), context);
-        !optional)
-      return std::nullopt;
+  bool discardExistingArrayParameter(const ast::ArrayParameter &parameter,
+                                     const TypingContext &context) {
+    return self().discardScalarType(parameter.getElementType(), context);
+  }
 
-    return context;
+  static bool discardFreshArrayParameter(const TypingContext &) {
+    return false;
   }
 
-  static ConclusionOf<ast::ArrayAssignmentStatement>
-  checkArrayAssignmentStatement(const TypingContext &context) {
-    return {context, context, context};
+  static bool discardArrayAssignmentStatement(const TypingContext &) {
+    return false;
   }
 
+  static bool discardStatementList(const TypingContext &) { return false; }
+
   // Implementations of the virtual methods in 'AbstractTypeSystem'.
   // These are automatically implemented to unbox the 'TypingContext's out of
   // the opaque contexts, calling the corresponding non-opaque 'check*' method
   // and boxing the result into an opaque context again.
 
-  dynamatic::ConclusionOf<ast::Function, OpaqueContext>
-  checkFunctionOpaque(const OpaqueContext &context) final {
-    return convert(self().checkFunction(context.cast<TypingContext>()));
-  }
-
   bool discardBinaryExpressionOpaque(ast::BinaryExpression::Op op,
                                      const OpaqueContext &context) final {
     return self().discardBinaryExpression(op, context.cast<TypingContext>());
   }
 
-  std::optional<dynamatic::ConclusionOf<ast::UnaryExpression, OpaqueContext>>
-  checkUnaryExpressionOpaque(ast::UnaryExpression::Op op,
-                             const OpaqueContext &context) final {
-    return convert(
-        self().checkUnaryExpression(op, context.cast<TypingContext>()));
+  bool discardUnaryExpressionOpaque(ast::UnaryExpression::Op op,
+                                    const OpaqueContext &context) final {
+    return self().discardUnaryExpression(op, context.cast<TypingContext>());
   }
 
-  std::optional<dynamatic::ConclusionOf<ast::Variable, OpaqueContext>>
-  checkVariableOpaque(const OpaqueContext &context) final {
-    return convert(self().checkVariable(context.cast<TypingContext>()));
+  bool discardVariableOpaque(const OpaqueContext &context) final {
+    return self().discardVariable(context.cast<TypingContext>());
   }
 
-  std::optional<dynamatic::ConclusionOf<ast::CastExpression, OpaqueContext>>
-  checkCastExpressionOpaque(const OpaqueContext &context) final {
-    return convert(self().checkCastExpression(context.cast<TypingContext>()));
+  bool discardCastExpressionOpaque(const OpaqueContext &context) final {
+    return self().discardCastExpression(context.cast<TypingContext>());
   }
 
-  std::optional<
-      dynamatic::ConclusionOf<ast::ConditionalExpression, OpaqueContext>>
-  checkConditionalExpressionOpaque(const OpaqueContext &context) final {
-    return convert(
-        self().checkConditionalExpression(context.cast<TypingContext>()));
+  bool discardConditionalExpressionOpaque(const OpaqueContext &context) final {
+    return self().discardConditionalExpression(context.cast<TypingContext>());
   }
 
-  std::optional<dynamatic::ConclusionOf<ast::ScalarType, OpaqueContext>>
-  checkScalarTypeOpaque(const ast::ScalarType &node,
-                        const OpaqueContext &context) final {
-    return convert(self().checkScalarType(node, context.cast<TypingContext>()));
+  bool discardScalarTypeOpaque(const ast::ScalarType &node,
+                               const OpaqueContext &context) final {
+    return self().discardScalarType(node, context.cast<TypingContext>());
+  }
+
+  bool discardReturnTypeOpaque(const ast::ReturnType &node,
+                               const OpaqueContext &context) final {
+    return self().discardReturnType(node, context.cast<TypingContext>());
   }
 
-  std::optional<dynamatic::ConclusionOf<ast::ReturnType, OpaqueContext>>
-  checkReturnTypeOpaque(const ast::ReturnType &node,
+  std::optional<ast::Constant>
+  discardConstantOpaque(const ast::Constant &node,
                         const OpaqueContext &context) final {
-    return convert(self().checkReturnType(node, context.cast<TypingContext>()));
+    return self().discardConstant(node, context.cast<TypingContext>());
   }
 
-  std::optional<dynamatic::ConclusionOf<ast::Constant, OpaqueContext>>
-  checkConstantOpaque(const ast::Constant &node,
-                      const OpaqueContext &context) final {
-    return convert(self().checkConstant(node, context.cast<TypingContext>()));
+  bool
+  discardExistingScalarParameterOpaque(const ast::ScalarParameter &node,
+                                       const OpaqueContext &context) final {
+    return self().discardExistingScalarParameter(node,
+                                                 context.cast<TypingContext>());
   }
 
-  std::optional<dynamatic::ConclusionOf<ast::ScalarParameter, OpaqueContext>>
-  checkScalarParameterOpaque(const ast::ScalarParameter &node,
-                             const OpaqueContext &context) final {
-    return convert(
-        self().checkScalarParameter(node, context.cast<TypingContext>()));
+  bool discardFreshScalarParameterOpaque(const OpaqueContext &context) final {
+    return self().discardFreshScalarParameter(context.cast<TypingContext>());
   }
 
   bool discardArrayReadExpressionOpaque(const OpaqueContext &context) final {
     return self().discardArrayReadExpression(context.cast<TypingContext>());
   }
 
-  std::optional<dynamatic::ConclusionOf<ast::ArrayParameter, OpaqueContext>>
-  checkArrayParameterOpaque(const ast::ArrayParameter &node,
-                            const OpaqueContext &context) final {
-    return convert(
-        self().checkArrayParameter(node, context.cast<TypingContext>()));
+  bool discardExistingArrayParameterOpaque(const ast::ArrayParameter &node,
+                                           const OpaqueContext &context) final {
+    return self().discardExistingArrayParameter(node,
+                                                context.cast<TypingContext>());
   }
 
-  std::optional<
-      dynamatic::ConclusionOf<ast::ArrayAssignmentStatement, OpaqueContext>>
-  checkArrayAssignmentStatementOpaque(const OpaqueContext &context) final {
-    return convert(
-        self().checkArrayAssignmentStatement(context.cast<TypingContext>()));
+  bool discardFreshArrayParameterOpaque(const OpaqueContext &context) final {
+    return self().discardFreshArrayParameter(context.cast<TypingContext>());
   }
 
-private:
-  Self &self() { return static_cast<Self &>(*this); }
-
-  const Self &self() const { return static_cast<const Self &>(*this); }
-
-  static OpaqueContext convert(const TypingContext &context) {
-    return OpaqueContext(context);
-  }
-
-  static OpaqueContext convert(TypingContext &&context) {
-    return OpaqueContext(context);
+  bool
+  discardArrayAssignmentStatementOpaque(const OpaqueContext &context) final {
+    return self().discardArrayAssignmentStatement(
+        context.cast<TypingContext>());
   }
 
-  template <class T>
-  static auto convert(const T &value) {
-    return value;
+  bool discardStatementListOpaque(const OpaqueContext &context) final {
+    return self().discardStatementList(context.cast<TypingContext>());
   }
 
-  template <class T>
-  static auto convert(std::optional<T> &&value) {
-    using Ret = decltype(convert(std::move(*value)));
-    if (!value)
-      return std::optional<Ret>{};
-
-    return std::optional<Ret>(convert(std::move(*value)));
-  }
-
-  /// Converts all instances of 'TypingContext' of a tuple-like struct into
-  /// 'OpaqueContext'.
-  /// Tuple-like structs are structs that specialize 'std::tuple_size' and
-  /// implement 'get<size_t>' methods.
-  template <template <typename> typename TupleLike,
-            class Indices = std::make_index_sequence<
-                std::tuple_size<std::decay_t<TupleLike<TypingContext>>>::value>>
-  decltype(auto) convert(TupleLike<TypingContext> &&tuple) {
-    return convertTupleLikeImpl(std::forward<TupleLike<TypingContext>>(tuple),
-                                Indices{});
-  }
-
-  /// Converts all instances of 'TypingContext' in the tuple into
-  /// 'OpaqueContext's.
-  template <class... Args>
-  static decltype(auto) convert(std::tuple<Args...> &&tuple) {
-    return std::apply(
-        [](auto &&...args) {
-          return std::make_tuple(
-              convert(std::forward<decltype(args)>(args))...);
-        },
-        std::move(tuple));
-  }
+private:
+  Self &self() { return static_cast<Self &>(*this); }
 
-  template <template <typename> typename TupleLike, std::size_t... indices>
-  static decltype(auto) convertTupleLikeImpl(TupleLike<TypingContext> &&tuple,
-                                             std::index_sequence<indices...>) {
-    return TupleLike<OpaqueContext>{convert(get<indices>(tuple))...};
-  }
+  const Self &self() const { return static_cast<const Self &>(*this); }
 };
 
 /// A noop-system which uses all the default implementations in 'TypeSystem'.
@@ -697,58 +695,57 @@ class DisallowByDefaultTypeSystem : public TypeSystem<TypingContext, Self> {
     return true;
   }
 
-  static std::optional<ConclusionOf<ast::UnaryExpression, TypingContext>>
-  checkUnaryExpression(ast::UnaryExpression::Op, const TypingContext &) {
-    return std::nullopt;
+  static bool discardUnaryExpression(ast::UnaryExpression::Op,
+                                     const TypingContext &) {
+    return true;
   }
 
-  static std::optional<ConclusionOf<ast::Variable, TypingContext>>
-  checkVariable(const TypingContext &) {
-    return std::nullopt;
-  }
+  static bool discardVariable(const TypingContext &) { return true; }
 
-  static std::optional<ConclusionOf<ast::CastExpression, TypingContext>>
-  checkCastExpression(const TypingContext &) {
-    return std::nullopt;
+  static bool discardCastExpression(const TypingContext &) { return true; }
+
+  static bool discardConditionalExpression(const TypingContext &) {
+    return true;
   }
 
-  static std::optional<ConclusionOf<ast::ConditionalExpression, TypingContext>>
-  checkConditionalExpression(const TypingContext &) {
-    return std::nullopt;
+  static bool discardScalarType(const ast::ScalarType &,
+                                const TypingContext &) {
+    return true;
   }
 
-  static std::optional<ConclusionOf<ast::ScalarType, TypingContext>>
-  checkScalarType(const ast::ScalarType &, const TypingContext &) {
-    return std::nullopt;
+  static bool discardReturnType(const ast::ReturnType &,
+                                const TypingContext &) {
+    return true;
   }
 
-  static std::optional<ConclusionOf<ast::ReturnType, TypingContext>>
-  checkScalarType(const ast::ReturnType &, const TypingContext &) {
+  std::optional<ast::Constant> discardConstant(const ast::Constant &,
+                                               const TypingContext &) {
     return std::nullopt;
   }
 
-  std::optional<ConclusionOf<ast::Constant, TypingContext>>
-  checkConstant(const ast::Constant &, const TypingContext &) {
-    return std::nullopt;
+  static bool discardExistingScalarParameter(const ast::ScalarParameter &,
+                                             const TypingContext &) {
+    return true;
   }
 
-  std::optional<ConclusionOf<ast::ScalarParameter, TypingContext>>
-  checkScalarParameter(const ast::ScalarParameter &, const TypingContext &) {
-    return std::nullopt;
+  static bool discardFreshScalarParameter(const TypingContext &) {
+    return true;
   }
 
   static bool discardArrayReadExpression(const TypingContext &) { return true; }
 
-  std::optional<ConclusionOf<ast::ArrayParameter, TypingContext>>
-  checkArrayParameter(const ast::ArrayParameter &, const TypingContext &) {
-    return std::nullopt;
+  static bool discardExistingArrayParameter(const ast::ArrayParameter &,
+                                            const TypingContext &) {
+    return true;
   }
 
-  static std::optional<
-      ConclusionOf<ast::ArrayAssignmentStatement, TypingContext>>
-  checkArrayAssignmentStatement(const TypingContext &) {
-    return std::nullopt;
+  static bool discardFreshArrayParameter(const TypingContext &) { return true; }
+
+  static bool discardArrayAssignmentStatement(const TypingContext &) {
+    return true;
   }
+
+  static bool discardStatementList(const TypingContext &) { return true; }
 };
 
 } // namespace dynamatic::gen
diff --git a/tools/hls-fuzzer/TypeSystemTraits.h b/tools/hls-fuzzer/TypeSystemTraits.h
deleted file mode 100644
index e251b97ea..000000000
--- a/tools/hls-fuzzer/TypeSystemTraits.h
+++ /dev/null
@@ -1,169 +0,0 @@
-#ifndef DYNAMATIC_HLS_FUZZER_TYPE_SYSTEM_TRAITS
-#define DYNAMATIC_HLS_FUZZER_TYPE_SYSTEM_TRAITS
-
-#include "AST.h"
-
-#include <tuple>
-
-namespace dynamatic {
-
-/// Class that provides meta-information about how 'ASTNode' is used in the type
-/// system.
-/// Specializations should provide the following definitions:
-///
-/// * template <typename TypingContext> ... Conclusion:
-///   The conclusion type of the 'ASTNode' that can be instantiated with any
-///   typing contexts.
-///
-///   The conclusion type is the return type of the corresponding 'check*'
-///   method of 'ASTNode' within 'TypeSystem' and usually contains contexts
-///   that are used to generate the sub-elements of the 'ASTNode' and are
-///   derived from the input context.
-///
-///   Templating the type allows it to be used for 'OpaqueContext's in the
-///   'AbstractTypeSystem' as well as for any custom typing context type used
-///   in a subclass of 'TypeSystem'.
-///
-///   The conclusion type of conditional expressions is e.g.
-///   'std::tuple<TypingContext, TypingContext, TypingContext>' which are the
-///   contexts used to type check the condition, true-expression and
-///   false-expression respectively.
-///
-///   If this is a struct, it should be a tuple-like struct, i.e., specialize
-///   'std::tuple_size' and implement a 'get<std::size_t>' method.
-template <typename ASTNode>
-struct TypeSystemTraits {
-  // Always false.
-  constexpr static bool NO_SPECIALIZATION = sizeof(ASTNode) == 0;
-
-  static_assert(
-      NO_SPECIALIZATION,
-      "Missing specialization of 'TypeSystemTraits' for ASTNode"
-      "Please add a specialization of 'TypeSystemTraits' for the given"
-      " ASTNode");
-};
-
-/// Concrete conclusion type of 'ASTNode' with the given typing context.
-/// Allows the C++ code to use a consistent typename to refer to conclusion
-/// types, regardless of the 'ASTNode' used.
-/// See the documentation of 'TypeSystemTraits::Conclusion'.
-template <typename ASTNode, typename TypingContext>
-using ConclusionOf =
-    typename TypeSystemTraits<ASTNode>::template Conclusions<TypingContext>;
-
-/// Struct implementing common defaults.
-struct TypeSystemTraitsDefaults {
-  /// No conclusion values forwarded. This is common for terminal nodes.
-  template <typename>
-  using Conclusions = std::tuple<>;
-};
-
-template <>
-struct TypeSystemTraits<ast::Function> : TypeSystemTraitsDefaults {
-  template <typename TypingContext>
-  struct Conclusions {
-    TypingContext returnType;
-    TypingContext returnStatement;
-  };
-};
-
-template <>
-struct TypeSystemTraits<ast::Variable> : TypeSystemTraitsDefaults {
-
-  /// Type constraint for the parameter this variable references or scalar
-  /// types of fresh parameters created.
-  template <typename TypingContext>
-  using Conclusions = TypingContext;
-};
-
-template <>
-struct TypeSystemTraits<ast::UnaryExpression> : TypeSystemTraitsDefaults {
-
-  /// Type constraint for the expression the operation is applied on.
-  template <typename TypingContext>
-  using Conclusions = TypingContext;
-};
-
-template <>
-struct TypeSystemTraits<ast::CastExpression> : TypeSystemTraitsDefaults {
-
-  /// Type constraints for the target type followed
-  /// by the expression.
-  template <typename TypingContext>
-  using Conclusions =
-      std::tuple</*type=*/TypingContext, /*expr=*/TypingContext>;
-};
-
-template <>
-struct TypeSystemTraits<ast::ConditionalExpression> : TypeSystemTraitsDefaults {
-
-  /// Type constraints for the condition followed by the true-expression
-  /// followed by the false expression.
-  template <typename TypingContext>
-  using Conclusions =
-      std::tuple</*condExpr=*/TypingContext, /*trueExpr=*/TypingContext,
-                 /*falseExpr=*/TypingContext>;
-};
-
-template <>
-struct TypeSystemTraits<ast::ScalarType> : TypeSystemTraitsDefaults {};
-
-template <>
-struct TypeSystemTraits<ast::ReturnType> : TypeSystemTraitsDefaults {};
-
-template <>
-struct TypeSystemTraits<ast::Constant> : TypeSystemTraitsDefaults {
-
-  /// A possibly-modified constant that should be used instead by the generator.
-  template <typename TypingContext>
-  using Conclusions = ast::Constant;
-};
-
-template <>
-struct TypeSystemTraits<ast::ScalarParameter> {
-
-  /// Type constraint for constants that this parameter is initialized to during
-  /// test bench generation.
-  template <typename TypingContext>
-  using Conclusions = TypingContext;
-};
-
-template <>
-struct TypeSystemTraits<ast::ArrayParameter> {
-
-  /// Type constraint for constants that this parameter is initialized to during
-  /// test bench generation.
-  template <typename TypingContext>
-  using Conclusions = TypingContext;
-};
-
-template <>
-struct TypeSystemTraits<ast::ArrayAssignmentStatement> {
-
-  template <typename TypingContext>
-  using Conclusions =
-      std::tuple</*parameter=*/TypingContext, /*index=*/TypingContext,
-                 /*value=*/TypingContext>;
-};
-
-} // namespace dynamatic
-
-template <typename TypingContext>
-struct std::tuple_size<dynamatic::TypeSystemTraits<
-    dynamatic::ast::Function>::Conclusions<TypingContext>>
-    : std::integral_constant<std::size_t, 2> {};
-
-namespace dynamatic {
-template <std::size_t i, typename TypingContext>
-const TypingContext &
-get(const ConclusionOf<ast::Function, TypingContext> &con) {
-  static_assert(i < 2);
-  if constexpr (i == 0) {
-    return con.returnType;
-  } else {
-    return con.returnStatement;
-  }
-}
-} // namespace dynamatic
-
-#endif
diff --git a/tools/hls-fuzzer/targets/BitwidthTypeSystem.cpp b/tools/hls-fuzzer/targets/BitwidthTypeSystem.cpp
index 42370d7da..bb78215da 100644
--- a/tools/hls-fuzzer/targets/BitwidthTypeSystem.cpp
+++ b/tools/hls-fuzzer/targets/BitwidthTypeSystem.cpp
@@ -4,34 +4,33 @@
 
 #define DEBUG_TYPE "bitwidth-type-system"
 
-auto dynamatic::gen::BitwidthTypeSystem::checkScalarType(
-    const ast::ScalarType &scalarType, const BitwidthTypingContext &context)
-    -> std::optional<ConclusionOf<ast::ScalarType>> {
+bool dynamatic::gen::BitwidthTypeSystem::discardScalarType(
+    const ast::ScalarType &scalarType, const BitwidthTypingContext &context) {
   if (scalarType == ast::PrimitiveType::Double ||
       scalarType == ast::PrimitiveType::Float)
-    return std::nullopt;
+    return true;
 
   // Only allow a datatype if either: We have no bitwidth requirement OR
   // the type restricts it to fit in the given bitwidth.
   if (std::optional<std::uint8_t> req = context.bitwidthRequirementOrNone();
       !req || *req >= scalarType.getBitwidth())
-    return ConclusionOf<ast::ScalarType>{};
+    return false;
 
-  return std::nullopt;
+  return true;
 }
 
-auto dynamatic::gen::BitwidthTypeSystem::checkConstant(
+auto dynamatic::gen::BitwidthTypeSystem::discardConstant(
     const ast::Constant &constant, const BitwidthTypingContext &context) const
-    -> std::optional<ConclusionOf<ast::Constant>> {
+    -> std::optional<ast::Constant> {
   // Allow all integer constants as we manually truncate them
   // (regardless of their C++ type).
-  if (!checkScalarType(constant.getType(), ResultIsTruncated{}))
+  if (!discardScalarType(constant.getType(), ResultIsTruncated{}))
     return std::nullopt;
 
   // Any integer constant is okay.
   std::optional<std::uint8_t> req = context.bitwidthRequirementOrNone();
   if (!req)
-    return ConclusionOf<ast::Constant>{};
+    return constant;
 
   // Otherwise restrain it to our bitwidth.
   return std::visit(
@@ -88,7 +87,7 @@ bool dynamatic::gen::BitwidthTypeSystem::discardBinaryExpression(
   llvm_unreachable("all enum cases handled");
 }
 
-auto dynamatic::gen::BitwidthTypeSystem::getBinaryExpressionContextDependencies(
+auto dynamatic::gen::BitwidthTypeSystem::getBinaryExpressionTransferFns(
     ast::BinaryExpression::Op op) -> TransferFnArray<ast::BinaryExpression> {
   switch (op) {
   case ast::BinaryExpression::BitAnd:
@@ -150,32 +149,37 @@ auto dynamatic::gen::BitwidthTypeSystem::getBinaryExpressionContextDependencies(
   case ast::BinaryExpression::BitXor:
   case ast::BinaryExpression::ShiftLeft:
   case ast::BinaryExpression::ShiftRight:
-    return TypeSystem::getBinaryExpressionContextDependencies(op);
+    return TypeSystem::getBinaryExpressionTransferFns(op);
   }
   llvm_unreachable("all enum cases handled");
 }
 
-auto dynamatic::gen::BitwidthTypeSystem::checkConditionalExpression(
-    const BitwidthTypingContext &context) const
-    -> ConclusionOf<ast::ConditionalExpression> {
-  // The condition must be constrained to fit within the global max bitwidth.
-  return {{getInterestingBitWidthInRange(globalMaxBitwidth)}, context, context};
+dynamatic::gen::TransferFnArray<dynamatic::ast::ConditionalExpression>
+dynamatic::gen::BitwidthTypeSystem::getConditionalExpressionTransferFns() {
+  return {
+      /*condition=*/TransferFn<ast::ConditionalExpression>(
+          BitwidthTypingContext(globalMaxBitwidth)),
+      /*true value=*/copyFromParent<ast::ConditionalExpression>(),
+      /*false value=*/copyFromParent<ast::ConditionalExpression>(),
+      /*output=*/copyFromParent<ast::ConditionalExpression>(),
+  };
 }
 
-auto dynamatic::gen::BitwidthTypeSystem::checkFunction(
-    const BitwidthTypingContext &context) -> ConclusionOf<ast::Function> {
+dynamatic::gen::TransferFnArray<dynamatic::ast::Function>
+dynamatic::gen::BitwidthTypeSystem::getFunctionTransferFns() {
   // Return types are exempt from the bitwidth rules as they're an interface
   // type.
   // Any integer type is allowed in that case.
-  return ConclusionOf<ast::Function>{
-      /*returnType=*/ResultIsTruncated{},
-      /*returnStatement=*/context,
+  return {
+      /*return type=*/TransferFn<ast::Function>(ResultIsTruncated{}),
+      /*statement list=*/copyFromParent<ast::Function>(),
+      /*return statement=*/copyFromParent<ast::Function>(),
+      /*output=*/copyFromParent<ast::Function>(),
   };
 }
 
-auto dynamatic::gen::BitwidthTypeSystem::
-    getArrayReadExpressionContextDependencies()
-        -> TransferFnArray<ast::ArrayReadExpression> {
+auto dynamatic::gen::BitwidthTypeSystem::getArrayReadExpressionTransferFns()
+    -> TransferFnArray<ast::ArrayReadExpression> {
   return {
       /*array parameter=*/copyFromParent<ast::ArrayReadExpression>(),
       /*index=*/
diff --git a/tools/hls-fuzzer/targets/BitwidthTypeSystem.h b/tools/hls-fuzzer/targets/BitwidthTypeSystem.h
index 6675cd654..1fec95452 100644
--- a/tools/hls-fuzzer/targets/BitwidthTypeSystem.h
+++ b/tools/hls-fuzzer/targets/BitwidthTypeSystem.h
@@ -60,55 +60,50 @@ class BitwidthTypeSystem
       : globalMaxBitwidth(globalMaxBitwidth), random(random) {}
 
   /// Disallows floats and doubles.
-  static std::optional<ConclusionOf<ast::ScalarType>>
-  checkScalarType(const ast::ScalarType &scalarType,
-                  const BitwidthTypingContext &);
+  static bool discardScalarType(const ast::ScalarType &scalarType,
+                                const BitwidthTypingContext &);
 
-  std::optional<ConclusionOf<ast::ReturnType>>
-  checkReturnType(const ast::ReturnType &returnType,
-                  const BitwidthTypingContext &context) {
+  bool discardReturnType(const ast::ReturnType &returnType,
+                         const BitwidthTypingContext &context) {
     // Disallow void.
     if (llvm::isa<ast::VoidType>(returnType))
-      return std::nullopt;
+      return true;
 
-    return Super::checkReturnType(returnType, context);
+    return Super::discardReturnType(returnType, context);
   }
 
   /// Disallow array-assignment statements.
   /// There is no rationale for doing so beyond the fact that we don't need
   /// them, since we can just generate expression trees, and that it makes
   /// synthesis faster.
-  static std::optional<ConclusionOf<ast::ArrayAssignmentStatement>>
-  checkArrayAssignmentStatement(const BitwidthTypingContext &) {
-    return std::nullopt;
+  static bool discardArrayAssignmentStatement(const BitwidthTypingContext &) {
+    return true;
   }
 
   /// Forces constants to fit in the given bitwidth requirement.
-  std::optional<ConclusionOf<ast::Constant>>
-  checkConstant(const ast::Constant &constant,
-                const BitwidthTypingContext &context) const;
+  std::optional<ast::Constant>
+  discardConstant(const ast::Constant &constant,
+                  const BitwidthTypingContext &context) const;
 
   bool discardBinaryExpression(ast::BinaryExpression::Op op,
                                const BitwidthTypingContext &context) const;
 
-  static std::optional<ConclusionOf<ast::UnaryExpression>>
-  checkUnaryExpression(ast::UnaryExpression::Op,
-                       const BitwidthTypingContext &) {
+  static bool discardUnaryExpression(ast::UnaryExpression::Op,
+                                     const BitwidthTypingContext &) {
     // TODO: Figure out and implement logic here.
-    return std::nullopt;
+    return true;
   }
 
   TransferFnArray<ast::BinaryExpression>
-  getBinaryExpressionContextDependencies(ast::BinaryExpression::Op op) final;
+  getBinaryExpressionTransferFns(ast::BinaryExpression::Op op) final;
 
-  ConclusionOf<ast::ConditionalExpression>
-  checkConditionalExpression(const BitwidthTypingContext &context) const;
+  TransferFnArray<ast::ConditionalExpression>
+  getConditionalExpressionTransferFns() override;
 
-  static ConclusionOf<ast::Function>
-  checkFunction(const BitwidthTypingContext &context);
+  TransferFnArray<ast::Function> getFunctionTransferFns() override;
 
   TransferFnArray<ast::ArrayReadExpression>
-  getArrayReadExpressionContextDependencies() override;
+  getArrayReadExpressionTransferFns() override;
 
 private:
   /// Returns either 'bitWidth' or with a low probability, a value in the range
diff --git a/tools/hls-fuzzer/targets/DynamaticTypeSystem.cpp b/tools/hls-fuzzer/targets/DynamaticTypeSystem.cpp
index ca6bc670b..766e28a79 100644
--- a/tools/hls-fuzzer/targets/DynamaticTypeSystem.cpp
+++ b/tools/hls-fuzzer/targets/DynamaticTypeSystem.cpp
@@ -1,20 +1,15 @@
 #include "DynamaticTypeSystem.h"
 
-auto dynamatic::gen::DynamaticTypeSystem::checkScalarType(
-    const ast::ScalarType &scalarType, DynamaticTypingContext context)
-    -> std::optional<ConclusionOf<ast::ScalarType>> {
+bool dynamatic::gen::DynamaticTypeSystem::discardScalarType(
+    const ast::ScalarType &scalarType, DynamaticTypingContext context) {
   switch (context.constraint) {
   case DynamaticTypingContext::FloatRequired:
-    if (scalarType != ast::PrimitiveType::Float &&
-        scalarType != ast::PrimitiveType::Double)
-      return std::nullopt;
-    return ConclusionOf<ast::ScalarType>{};
+    return scalarType != ast::PrimitiveType::Float &&
+           scalarType != ast::PrimitiveType::Double;
 
   case DynamaticTypingContext::IntegerRequired:
-    if (scalarType == ast::PrimitiveType::Float ||
-        scalarType == ast::PrimitiveType::Double)
-      return std::nullopt;
-    return ConclusionOf<ast::ScalarType>{};
+    return scalarType == ast::PrimitiveType::Float ||
+           scalarType == ast::PrimitiveType::Double;
   }
   llvm_unreachable("all enum cases handled");
 }
@@ -47,7 +42,7 @@ bool dynamatic::gen::DynamaticTypeSystem::discardBinaryExpression(
 }
 
 dynamatic::gen::TransferFnArray<dynamatic::ast::BinaryExpression>
-dynamatic::gen::DynamaticTypeSystem::getBinaryExpressionContextDependencies(
+dynamatic::gen::DynamaticTypeSystem::getBinaryExpressionTransferFns(
     ast::BinaryExpression::Op op) {
   switch (op) {
   case ast::BinaryExpression::BitAnd:
@@ -64,31 +59,44 @@ dynamatic::gen::DynamaticTypeSystem::getBinaryExpressionContextDependencies(
             TransferFn<ast::BinaryExpression>(DynamaticTypingContext{
                 DynamaticTypingContext::IntegerRequired})};
   default:
-    return Super::getBinaryExpressionContextDependencies(op);
+    return Super::getBinaryExpressionTransferFns(op);
   }
 }
 
-auto dynamatic::gen::DynamaticTypeSystem::checkUnaryExpression(
-    ast::UnaryExpression::Op op, DynamaticTypingContext context) const
-    -> std::optional<ConclusionOf<ast::UnaryExpression>> {
+dynamatic::gen::TransferFnArray<dynamatic::ast::UnaryExpression>
+dynamatic::gen::DynamaticTypeSystem::getUnaryExpressionTransferFns(
+    ast::UnaryExpression::Op op) {
   switch (op) {
   case ast::UnaryExpression::BitwiseNot:
-    // Requires an integer, produces an integer.
-    if (context.constraint != DynamaticTypingContext::IntegerRequired)
-      return std::nullopt;
-
-    return context;
+    return {
+        /*operand=*/TransferFn<ast::UnaryExpression>(
+            DynamaticTypingContext{DynamaticTypingContext::IntegerRequired}),
+        /*output=*/copyFromParent<ast::UnaryExpression>(),
+    };
   case ast::UnaryExpression::BoolNot:
-    // Can only be generated if an integer is required.
-    if (context.constraint != DynamaticTypingContext::IntegerRequired)
-      return std::nullopt;
+    return {
+        /*operand=*/TransferFn<ast::UnaryExpression>(DynamaticTypingContext{
+            random.fromEnum<DynamaticTypingContext::Constraint>()}),
+        /*output=*/copyFromParent<ast::UnaryExpression>(),
+    };
+  case ast::UnaryExpression::Minus:
+    return {
+        /*operand=*/copyFromParent<ast::UnaryExpression>(),
+        /*output=*/copyFromParent<ast::UnaryExpression>(),
+    };
+  }
+  llvm_unreachable("all enum cases handled");
+}
 
-    // However, the operand itself may be of any type since boolean conversions
-    // are supported.
-    return DynamaticTypingContext{
-        random.fromEnum<DynamaticTypingContext::Constraint>()};
+bool dynamatic::gen::DynamaticTypeSystem::discardUnaryExpression(
+    ast::UnaryExpression::Op op, DynamaticTypingContext context) {
+  switch (op) {
+  case ast::UnaryExpression::BitwiseNot:
+  case ast::UnaryExpression::BoolNot:
+    // Can't apply to float.
+    return context.constraint == DynamaticTypingContext::FloatRequired;
   case ast::UnaryExpression::Minus:
-    return {context};
+    return false;
   }
   llvm_unreachable("all enum values handled");
 }
diff --git a/tools/hls-fuzzer/targets/DynamaticTypeSystem.h b/tools/hls-fuzzer/targets/DynamaticTypeSystem.h
index 551baf089..c405728bb 100644
--- a/tools/hls-fuzzer/targets/DynamaticTypeSystem.h
+++ b/tools/hls-fuzzer/targets/DynamaticTypeSystem.h
@@ -28,35 +28,37 @@ class DynamaticTypeSystem
   explicit DynamaticTypeSystem(Randomly &random) : random(random) {}
 
   /// Discard 'scalarType' based on the mode in 'context'.
-  static std::optional<ConclusionOf<ast::ScalarType>>
-  checkScalarType(const ast::ScalarType &scalarType,
-                  DynamaticTypingContext context);
+  static bool discardScalarType(const ast::ScalarType &scalarType,
+                                DynamaticTypingContext context);
 
   /// Discard 'op' based on the mode in 'context' and forward constraint to
   /// the operands as required.
   static bool discardBinaryExpression(ast::BinaryExpression::Op op,
                                       DynamaticTypingContext context);
 
-  std::optional<ConclusionOf<ast::UnaryExpression>>
-  checkUnaryExpression(ast::UnaryExpression::Op op,
-                       DynamaticTypingContext context) const;
+  static bool discardUnaryExpression(ast::UnaryExpression::Op op,
+                                     DynamaticTypingContext context);
+
+  TransferFnArray<ast::UnaryExpression>
+  getUnaryExpressionTransferFns(ast::UnaryExpression::Op op) override;
 
   TransferFnArray<ast::BinaryExpression>
-  getBinaryExpressionContextDependencies(ast::BinaryExpression::Op op) final;
+  getBinaryExpressionTransferFns(ast::BinaryExpression::Op op) final;
 
-  ConclusionOf<ast::ConditionalExpression>
-  checkConditionalExpression(DynamaticTypingContext context) const {
-    // Condition can be either a floating point type or integer type.
-    // Either converts to a bool type without issues.
-    return ConclusionOf<ast::ConditionalExpression>{
-        {random.fromEnum<DynamaticTypingContext::Constraint>()},
-        context,
-        context,
+  TransferFnArray<ast::ConditionalExpression>
+  getConditionalExpressionTransferFns() override {
+    return {
+        /*condition=*/TransferFn<ast::ConditionalExpression>(
+            DynamaticTypingContext{
+                random.fromEnum<DynamaticTypingContext::Constraint>()}),
+        /*true value=*/copyFromParent<ast::ConditionalExpression>(),
+        /*false value=*/copyFromParent<ast::ConditionalExpression>(),
+        /*output=*/copyFromParent<ast::ConditionalExpression>(),
     };
   }
 
   TransferFnArray<ast::ArrayReadExpression>
-  getArrayReadExpressionContextDependencies() final {
+  getArrayReadExpressionTransferFns() final {
     return {/*array parameter=*/copyFromParent<ast::ArrayReadExpression>(),
             /*index=*/
             TransferFn<ast::ArrayReadExpression>(DynamaticTypingContext{
@@ -64,15 +66,15 @@ class DynamaticTypeSystem
             /*output=*/copyFromParent<ast::ArrayReadExpression>()};
   }
 
-  static std::optional<ConclusionOf<ast::ArrayAssignmentStatement>>
-  checkArrayAssignmentStatement(DynamaticTypingContext context) {
-    return ConclusionOf<ast::ArrayAssignmentStatement>{
-        // Forward the context to the array parameter as is.
-        /*parameter=*/context,
-        // Indexing expression must be an integer.
+  TransferFnArray<ast::ArrayAssignmentStatement>
+  getArrayAssignmentStatementTransferFns() override {
+    return {
+        /*array parameter=*/copyFromParent<ast::ArrayAssignmentStatement>(),
         /*index=*/
-        DynamaticTypingContext{DynamaticTypingContext::IntegerRequired},
-        /*value=*/context,
+        TransferFn<ast::ArrayAssignmentStatement>(
+            DynamaticTypingContext{DynamaticTypingContext::IntegerRequired}),
+        /*value=*/copyFromParent<ast::ArrayAssignmentStatement>(),
+        /*output=*/copyFromParent<ast::ArrayAssignmentStatement>(),
     };
   }
 
diff --git a/unittests/tools/hls-fuzzer/TEST_SUITE.cpp b/unittests/tools/hls-fuzzer/TEST_SUITE.cpp
index 2261d7854..6017f2933 100644
--- a/unittests/tools/hls-fuzzer/TEST_SUITE.cpp
+++ b/unittests/tools/hls-fuzzer/TEST_SUITE.cpp
@@ -25,48 +25,61 @@ TYPED_TEST_P(TypeSystemTest, OutputCheck) {
 REGISTER_TYPED_TEST_SUITE_P(TypeSystemTest, OutputCheck);
 
 namespace {
-// Bool representing whether a parameter is required.
+
+enum class PlusOfTwoState {
+  PlusNeeded,
+  FreshParamNeeded,
+  ExistingParamNeeded,
+};
+
 class PlusOfTwoParamOnlyTypeSystem final
-    : public gen::DisallowByDefaultTypeSystem<bool,
+    : public gen::DisallowByDefaultTypeSystem<PlusOfTwoState,
                                               PlusOfTwoParamOnlyTypeSystem> {
 public:
   using DisallowByDefaultTypeSystem::DisallowByDefaultTypeSystem;
 
   static bool discardBinaryExpression(ast::BinaryExpression::Op op,
-                                      bool mustBeParameter) {
-    return mustBeParameter || op != ast::BinaryExpression::Plus;
+                                      PlusOfTwoState state) {
+    return op != ast::BinaryExpression::Plus ||
+           state != PlusOfTwoState::PlusNeeded;
   }
 
   gen::TransferFnArray<ast::BinaryExpression>
-  getBinaryExpressionContextDependencies(ast::BinaryExpression::Op) override {
+  getBinaryExpressionTransferFns(ast::BinaryExpression::Op) override {
     return {
-        TransferFn<ast::BinaryExpression>(true),
-        TransferFn<ast::BinaryExpression>(true),
-        TransferFn<ast::BinaryExpression>(true),
+        /*lhs=*/TransferFn<ast::BinaryExpression>(
+            PlusOfTwoState::FreshParamNeeded),
+        /*rhs=*/
+        TransferFn<ast::BinaryExpression, ast::BinaryExpression::LHS>(
+            PlusOfTwoState::ExistingParamNeeded),
+        /*output=*/copyFromParent<ast::BinaryExpression>(),
     };
   }
 
-  static std::optional<ConclusionOf<ast::ScalarParameter>>
-  checkScalarParameter(const ast::ScalarParameter &, bool mustBeParameter) {
-    if (!mustBeParameter)
-      return std::nullopt;
+  static bool discardFreshScalarParameter(PlusOfTwoState state) {
+    return state != PlusOfTwoState::FreshParamNeeded;
+  }
 
-    return mustBeParameter;
+  static bool discardExistingScalarParameter(const ast::ScalarParameter &,
+                                             PlusOfTwoState state) {
+    return false;
   }
 
-  static std::optional<ConclusionOf<ast::Variable>>
-  checkVariable(bool mustBeParameter) {
-    if (mustBeParameter)
-      return mustBeParameter;
-    return std::nullopt;
+  static bool discardVariable(PlusOfTwoState state) {
+    return state == PlusOfTwoState::PlusNeeded;
   }
 
-  static std::optional<ConclusionOf<ast::ScalarType>>
-  checkScalarType(const ast::ScalarType &scalarType, bool) {
-    if (scalarType != ast::PrimitiveType::Double)
-      return std::nullopt;
+  static bool discardScalarType(const ast::ScalarType &scalarType,
+                                PlusOfTwoState) {
+    return scalarType != ast::PrimitiveType::Double;
+  }
+
+  bool discardReturnType(const ast::ReturnType &returnType,
+                         PlusOfTwoState state) {
+    if (llvm::isa<ast::VoidType>(returnType))
+      return true;
 
-    return ConclusionOf<ast::ScalarType>{};
+    return TypeSystem::discardReturnType(returnType, state);
   }
 
   constexpr static std::string_view result =
@@ -75,7 +88,7 @@ class PlusOfTwoParamOnlyTypeSystem final
 }
 )";
 
-  constexpr static auto entryContext = false;
+  constexpr static auto entryContext = PlusOfTwoState::PlusNeeded;
 };
 
 // Bool representing whether an array read expression is required.
@@ -91,35 +104,27 @@ class ReturnArrayConstantOnlyTypeSystem final
   }
 
   gen::TransferFnArray<ast::ArrayReadExpression>
-  getArrayReadExpressionContextDependencies() override {
+  getArrayReadExpressionTransferFns() override {
     return {
-        TransferFn<ast::ArrayReadExpression>(false),
-        TransferFn<ast::ArrayReadExpression>(false),
-        copyFromParent<ast::ArrayReadExpression>(),
+        /*array parameter=*/TransferFn<ast::ArrayReadExpression>(false),
+        /*index=*/TransferFn<ast::ArrayReadExpression>(false),
+        /*output=*/copyFromParent<ast::ArrayReadExpression>(),
     };
   }
 
-  std::optional<ConclusionOf<ast::ArrayParameter>>
-  checkArrayParameter(const ast::ArrayParameter &param, bool createArrayRead) {
-    // TODO: The array dimension is currently random making the test below
-    //       susceptible to internal implementation changes.
-    //       Array parameters (like constants) are terminators with a large
-    //       combination of possible values.
-    //       We probably want to allow the type system to return an array
-    //       parameter to use instead for that reason.
-    return TypeSystem::checkArrayParameter(param, createArrayRead);
-  }
+  static bool discardFreshArrayParameter(bool createArrayRead) { return false; }
 
-  static std::optional<ConclusionOf<ast::ScalarType>>
-  checkScalarType(const ast::ScalarType &scalarType, bool /*createArrayRead*/) {
-    if (scalarType != ast::PrimitiveType::Double)
-      return std::nullopt;
+  static bool discardScalarType(const ast::ScalarType &scalarType,
+                                bool /*createArrayRead*/) {
+    return scalarType != ast::PrimitiveType::Double;
+  }
 
-    return ConclusionOf<ast::ScalarType>{};
+  bool discardReturnType(const ast::ReturnType &returnType, bool state) {
+    return TypeSystem::discardReturnType(returnType, state);
   }
 
-  static std::optional<ConclusionOf<ast::Constant>>
-  checkConstant(const ast::Constant &, bool createArrayRead) {
+  static std::optional<ast::Constant> discardConstant(const ast::Constant &,
+                                                      bool createArrayRead) {
     if (createArrayRead)
       return std::nullopt;
 
@@ -127,8 +132,8 @@ class ReturnArrayConstantOnlyTypeSystem final
   }
 
   constexpr static std::string_view result =
-      R"(double test(double var0[1]) {
-  return var0[((uint32_t)((0)) & (0u))];
+      R"(double test(double var0[32]) {
+  return var0[((uint32_t)((0)) & (31u))];
 }
 )";