kumi 0.0.5 → 0.0.6

data/lib/kumi/analyzer/passes/toposorter.rb

@@ -3,8 +3,8 @@
 module Kumi
   module Analyzer
     module Passes
-      # RESPONSIBILITY: Compute topological ordering of declarations from dependency graph
-      # DEPENDENCIES: :dependency_graph from DependencyResolver, :definitions from NameIndexer
+      # RESPONSIBILITY: Compute topological ordering of declarations, allowing safe conditional cycles
+      # DEPENDENCIES: :dependency_graph from DependencyResolver, :definitions from NameIndexer, :cascade_metadata from UnsatDetector
       # PRODUCES: :topo_order - Array of declaration names in evaluation order
       # INTERFACE: new(schema, state).run(errors)
       class Toposorter < PassBase
@@ -22,17 +22,26 @@ module Kumi
           temp_marks = Set.new
           perm_marks = Set.new
           order = []
+          cascade_metadata = get_state(:cascade_metadata) || {}
 
-          visit_node = lambda do |node|
+          visit_node = lambda do |node, path = []|
             return if perm_marks.include?(node)
 
             if temp_marks.include?(node)
-              report_unexpected_cycle(temp_marks, node, errors)
-              return
+              # Check if this is a safe conditional cycle
+              cycle_path = path + [node]
+              if safe_conditional_cycle?(cycle_path, graph, cascade_metadata)
+                # Allow this cycle - it's safe due to cascade mutual exclusion
+                return
+              else
+                report_unexpected_cycle(temp_marks, node, errors)
+                return
+              end
             end
 
             temp_marks << node
-            Array(graph[node]).each { |edge| visit_node.call(edge.to) }
+            current_path = path + [node]
+            Array(graph[node]).each { |edge| visit_node.call(edge.to, current_path) }
             temp_marks.delete(node)
             perm_marks << node
 
@@ -50,6 +59,33 @@ module Kumi
           order.freeze
         end
 
+        def safe_conditional_cycle?(cycle_path, graph, cascade_metadata)
+          return false if cycle_path.nil? || cycle_path.size < 2
+          
+          # Find where the cycle starts - look for the first occurrence of the repeated node
+          last_node = cycle_path.last
+          return false if last_node.nil?
+          
+          cycle_start = cycle_path.index(last_node)
+          return false unless cycle_start && cycle_start < cycle_path.size - 1
+          
+          cycle_nodes = cycle_path[cycle_start..-1]
+          
+          # Check if all edges in the cycle are conditional
+          cycle_nodes.each_cons(2) do |from, to|
+            edges = graph[from] || []
+            edge = edges.find { |e| e.to == to }
+            
+            return false unless edge&.conditional
+            
+            # Check if the cascade has mutually exclusive conditions
+            cascade_meta = cascade_metadata[edge.cascade_owner]
+            return false unless cascade_meta&.dig(:all_mutually_exclusive)
+          end
+          
+          true
+        end
+
         def report_unexpected_cycle(temp_marks, current_node, errors)
           cycle_path = temp_marks.to_a.join(" → ") + " → #{current_node}"
 

data/lib/kumi/analyzer/passes/type_checker.rb

@@ -9,7 +9,7 @@ module Kumi
       # INTERFACE: new(schema, state).run(errors)
       class TypeChecker < VisitorPass
         def run(errors)
-          visit_nodes_of_type(Expressions::CallExpression, errors: errors) do |node, _decl, errs|
+          visit_nodes_of_type(Kumi::Syntax::CallExpression, errors: errors) do |node, _decl, errs|
             validate_function_call(node, errs)
           end
           state
@@ -47,11 +47,33 @@ module Kumi
           types = signature[:param_types]
           return if types.nil? || (signature[:arity].negative? && node.args.empty?)
 
+          # Skip type checking for vectorized operations
+          broadcast_meta = get_state(:broadcast_metadata, required: false)
+          if broadcast_meta && is_part_of_vectorized_operation?(node, broadcast_meta)
+            return
+          end
+
           node.args.each_with_index do |arg, i|
             validate_argument_type(arg, i, types[i], node.fn_name, errors)
           end
         end
 
+        def is_part_of_vectorized_operation?(node, broadcast_meta)
+          # Check if this node is part of a vectorized or reduction operation
+          # This is a simplified check - in a real implementation we'd need to track context
+          node.args.any? do |arg|
+            case arg
+            when Kumi::Syntax::DeclarationReference
+              broadcast_meta[:vectorized_operations]&.key?(arg.name) ||
+              broadcast_meta[:reduction_operations]&.key?(arg.name)
+            when Kumi::Syntax::InputElementReference
+              broadcast_meta[:array_fields]&.key?(arg.path.first)
+            else
+              false
+            end
+          end
+        end
+
         def validate_argument_type(arg, index, expected_type, fn_name, errors)
           return if expected_type.nil? || expected_type == Kumi::Types::ANY
 
@@ -67,15 +89,15 @@ module Kumi
 
         def get_expression_type(expr)
           case expr
-          when TerminalExpressions::Literal
+          when Kumi::Syntax::Literal
             # Inferred type from literal value
             Kumi::Types.infer_from_value(expr.value)
 
-          when TerminalExpressions::FieldRef
+          when Kumi::Syntax::InputReference
             # Declared type from input block (user-specified)
             get_declared_field_type(expr.name)
 
-          when TerminalExpressions::Binding
+          when Kumi::Syntax::DeclarationReference
             # Inferred type from type inference results
             get_inferred_declaration_type(expr.name)
 
@@ -101,10 +123,10 @@ module Kumi
 
         def describe_expression_type(expr, type)
           case expr
-          when TerminalExpressions::Literal
+          when Kumi::Syntax::Literal
             "`#{expr.value}` of type #{type} (literal value)"
 
-          when TerminalExpressions::FieldRef
+          when Kumi::Syntax::InputReference
             input_meta = get_state(:input_meta, required: false) || {}
             field_meta = input_meta[expr.name]
 
@@ -117,17 +139,17 @@ module Kumi
               "undeclared input field `#{expr.name}` (inferred as #{type})"
             end
 
-          when TerminalExpressions::Binding
+          when Kumi::Syntax::DeclarationReference
             # This type was inferred from the declaration's expression
             "reference to declaration `#{expr.name}` of inferred type #{type}"
 
-          when Expressions::CallExpression
+          when Kumi::Syntax::CallExpression
             "result of function `#{expr.fn_name}` returning #{type}"
 
-          when Expressions::ListExpression
+          when Kumi::Syntax::ArrayExpression
             "list expression of type #{type}"
 
-          when Expressions::CascadeExpression
+          when Kumi::Syntax::CascadeExpression
             "cascade expression of type #{type}"
 
           else

data/lib/kumi/analyzer/passes/type_inferencer.rb

@@ -4,7 +4,7 @@ module Kumi
   module Analyzer
     module Passes
       # RESPONSIBILITY: Infer types for all declarations based on expression analysis
-      # DEPENDENCIES: Toposorter (needs topo_order), DefinitionValidator (needs definitions)
+      # DEPENDENCIES: Toposorter (needs topo_order), DeclarationValidator (needs definitions)
       # PRODUCES: decl_types hash mapping declaration names to inferred types
       # INTERFACE: new(schema, state).run(errors)
       class TypeInferencer < PassBase
@@ -12,6 +12,9 @@ module Kumi
           types = {}
           topo_order = get_state(:topo_order)
           definitions = get_state(:definitions)
+          
+          # Get broadcast metadata from broadcast detector
+          broadcast_meta = get_state(:broadcast_metadata, required: false) || {}
 
           # Process declarations in topological order to ensure dependencies are resolved
           topo_order.each do |name|
@@ -19,8 +22,16 @@ module Kumi
             next unless decl
 
             begin
-              inferred_type = infer_expression_type(decl.expression, types)
-              types[name] = inferred_type
+              # Check if this declaration is marked as vectorized
+              if broadcast_meta[:vectorized_operations]&.key?(name)
+                # Infer the element type and wrap in array
+                element_type = infer_vectorized_element_type(decl.expression, types, broadcast_meta)
+                types[name] = decl.is_a?(Kumi::Syntax::TraitDeclaration) ? { array: :boolean } : { array: element_type }
+              else
+                # Normal type inference
+                inferred_type = infer_expression_type(decl.expression, types, broadcast_meta, name)
+                types[name] = inferred_type
+              end
             rescue StandardError => e
               report_type_error(errors, "Type inference failed: #{e.message}", location: decl&.loc)
             end
@@ -31,32 +42,47 @@ module Kumi
 
         private
 
-        def infer_expression_type(expr, type_context = {})
+        def infer_expression_type(expr, type_context = {}, broadcast_metadata = {}, current_decl_name = nil)
           case expr
           when Literal
             Types.infer_from_value(expr.value)
-          when FieldRef
+          when InputReference
             # Look up type from field metadata
             input_meta = get_state(:input_meta, required: false) || {}
             meta = input_meta[expr.name]
             meta&.dig(:type) || :any
-          when Binding
+          when DeclarationReference
             type_context[expr.name] || :any
           when CallExpression
-            infer_call_type(expr, type_context)
-          when ListExpression
-            infer_list_type(expr, type_context)
+            infer_call_type(expr, type_context, broadcast_metadata, current_decl_name)
+          when ArrayExpression
+            infer_list_type(expr, type_context, broadcast_metadata, current_decl_name)
           when CascadeExpression
-            infer_cascade_type(expr, type_context)
+            infer_cascade_type(expr, type_context, broadcast_metadata, current_decl_name)
+          when InputElementReference
+            # Element reference returns the field type
+            infer_element_reference_type(expr)
           else
             :any
           end
         end
 
-        def infer_call_type(call_expr, type_context)
-          fn_name = call_expr.fn_name
+        def infer_call_type(call_expr, type_context, broadcast_metadata = {}, current_decl_name = nil)
+          fn_name = call_expr.fn_name  
           args = call_expr.args
 
+          # Check broadcast metadata first
+          if current_decl_name && broadcast_metadata[:vectorized_values]&.key?(current_decl_name)
+            # This declaration is marked as vectorized, so it produces an array
+            element_type = infer_vectorized_element_type(call_expr, type_context, broadcast_metadata)
+            return { array: element_type }
+          end
+
+          if current_decl_name && broadcast_metadata[:reducer_values]&.key?(current_decl_name)
+            # This declaration is marked as a reducer, get the result from the function
+            return infer_function_return_type(fn_name, args, type_context, broadcast_metadata)
+          end
+
           # Check if function exists in registry
           unless FunctionRegistry.supported?(fn_name)
             # Don't push error here - let existing TypeChecker handle it
@@ -72,7 +98,7 @@ module Kumi
           end
 
           # Infer argument types
-          arg_types = args.map { |arg| infer_expression_type(arg, type_context) }
+          arg_types = args.map { |arg| infer_expression_type(arg, type_context, broadcast_metadata, current_decl_name) }
 
           # Validate parameter types (warn but don't fail)
           param_types = signature[:param_types] || []
@@ -90,10 +116,29 @@ module Kumi
           signature[:return_type] || :any
         end
 
-        def infer_list_type(list_expr, type_context)
+        def infer_vectorized_element_type(call_expr, type_context, broadcast_metadata)
+          # For vectorized arithmetic operations, infer the element type
+          # For now, assume arithmetic operations on floats produce floats
+          case call_expr.fn_name
+          when :multiply, :add, :subtract, :divide
+            :float
+          else
+            :any
+          end
+        end
+
+        def infer_function_return_type(fn_name, args, type_context, broadcast_metadata)
+          # Get the function signature
+          return :any unless FunctionRegistry.supported?(fn_name)
+          
+          signature = FunctionRegistry.signature(fn_name)
+          signature[:return_type] || :any
+        end
+
+        def infer_list_type(list_expr, type_context, broadcast_metadata = {}, current_decl_name = nil)
           return Types.array(:any) if list_expr.elements.empty?
 
-          element_types = list_expr.elements.map { |elem| infer_expression_type(elem, type_context) }
+          element_types = list_expr.elements.map { |elem| infer_expression_type(elem, type_context, broadcast_metadata, current_decl_name) }
 
           # Try to unify all element types
           unified_type = element_types.reduce { |acc, type| Types.unify(acc, type) }
@@ -103,11 +148,75 @@ module Kumi
           Types.array(:any)
         end
 
-        def infer_cascade_type(cascade_expr, type_context)
+        def infer_vectorized_element_type(expr, type_context, vectorization_meta)
+          # For vectorized operations, we need to infer the element type
+          case expr
+          when InputElementReference
+            # Get the field type from metadata
+            input_meta = get_state(:input_meta, required: false) || {}
+            array_name = expr.path.first
+            field_name = expr.path[1]
+            
+            array_meta = input_meta[array_name]
+            return :any unless array_meta&.dig(:type) == :array
+            
+            array_meta.dig(:children, field_name, :type) || :any
+            
+          when CallExpression
+            # For arithmetic operations, infer from operands
+            if %i[add subtract multiply divide].include?(expr.fn_name)
+              # Get types of operands
+              arg_types = expr.args.map do |arg|
+                if arg.is_a?(InputElementReference)
+                  infer_vectorized_element_type(arg, type_context, vectorization_meta)
+                elsif arg.is_a?(DeclarationReference)
+                  # Get the element type if it's vectorized
+                  ref_type = type_context[arg.name]
+                  if ref_type.is_a?(Hash) && ref_type.key?(:array)
+                    ref_type[:array]
+                  else
+                    ref_type || :any
+                  end
+                else
+                  infer_expression_type(arg, type_context, vectorization_meta)
+                end
+              end
+              
+              # Unify types for arithmetic
+              Types.unify(*arg_types) || :float
+            else
+              :any
+            end
+            
+          else
+            :any
+          end
+        end
+
+        def infer_element_reference_type(expr)
+          # Get array field metadata
+          input_meta = get_state(:input_meta, required: false) || {}
+          
+          return :any unless expr.path.size >= 2
+          
+          array_name = expr.path.first
+          field_name = expr.path[1]
+          
+          array_meta = input_meta[array_name]
+          return :any unless array_meta&.dig(:type) == :array
+          
+          # Get the field type from children metadata
+          field_type = array_meta.dig(:children, field_name, :type) || :any
+          
+          # Return array of field type (vectorized)
+          { array: field_type }
+        end
+
+        def infer_cascade_type(cascade_expr, type_context, broadcast_metadata = {}, current_decl_name = nil)
           return :any if cascade_expr.cases.empty?
 
           result_types = cascade_expr.cases.map do |case_stmt|
-            infer_expression_type(case_stmt.result, type_context)
+            infer_expression_type(case_stmt.result, type_context, broadcast_metadata, current_decl_name)
           end
 
           # Reduce all possible types into a single unified type

data/lib/kumi/analyzer/passes/unsat_detector.rb

@@ -3,6 +3,10 @@
 module Kumi
   module Analyzer
     module Passes
+      # RESPONSIBILITY: Detect unsatisfiable constraints and analyze cascade mutual exclusion
+      # DEPENDENCIES: :definitions from NameIndexer, :input_meta from InputCollector
+      # PRODUCES: :cascade_metadata - Hash of cascade mutual exclusion analysis results
+      # INTERFACE: new(schema, state).run(errors)
       class UnsatDetector < VisitorPass
         include Syntax
 
@@ -15,35 +19,116 @@ module Kumi
           @definitions = definitions
           @evaluator = ConstantEvaluator.new(definitions)
 
+          # First pass: analyze cascade conditions for mutual exclusion
+          cascade_metadata = {}
+          each_decl do |decl|
+            cascade_metadata[decl.name] = analyze_cascade_mutual_exclusion(decl, definitions) if decl.expression.is_a?(CascadeExpression)
+          end
+
+          # Store cascade metadata for later passes
+
+          # Second pass: check for unsatisfiable constraints
           each_decl do |decl|
             if decl.expression.is_a?(CascadeExpression)
               # Special handling for cascade expressions
               check_cascade_expression(decl, definitions, errors)
-            else
+            elsif decl.expression.is_a?(CallExpression) && decl.expression.fn_name == :or
               # Check for OR expressions which need special disjunctive handling
-              if decl.expression.is_a?(CallExpression) && decl.expression.fn_name == :or
-                impossible = check_or_expression(decl.expression, definitions, errors)
-                report_error(errors, "conjunction `#{decl.name}` is impossible", location: decl.loc) if impossible
-              else
-                # Normal handling for non-cascade expressions
-                atoms = gather_atoms(decl.expression, definitions, Set.new)
-                next if atoms.empty?
-
-                # Use enhanced solver that can detect cross-variable mathematical constraints
-                impossible = if definitions && !definitions.empty?
-                               Kumi::ConstraintRelationshipSolver.unsat?(atoms, definitions, input_meta: @input_meta)
-                             else
-                               Kumi::AtomUnsatSolver.unsat?(atoms)
-                             end
+              impossible = check_or_expression(decl.expression, definitions, errors)
+              report_error(errors, "conjunction `#{decl.name}` is impossible", location: decl.loc) if impossible
+            else
+              # Normal handling for non-cascade expressions
+              atoms = gather_atoms(decl.expression, definitions, Set.new)
+              next if atoms.empty?
+
+              # Use enhanced solver that can detect cross-variable mathematical constraints
+              impossible = if definitions && !definitions.empty?
+                             Kumi::ConstraintRelationshipSolver.unsat?(atoms, definitions, input_meta: @input_meta)
+                           else
+                             Kumi::AtomUnsatSolver.unsat?(atoms)
+                           end
+
+              report_error(errors, "conjunction `#{decl.name}` is impossible", location: decl.loc) if impossible
+            end
+          end
+          state.with(:cascade_metadata, cascade_metadata)
+        end
 
-                report_error(errors, "conjunction `#{decl.name}` is impossible", location: decl.loc) if impossible
+        private
+
+        def analyze_cascade_mutual_exclusion(decl, definitions)
+          conditions = []
+          condition_traits = []
+
+          # Extract all cascade conditions (except base case)
+          decl.expression.cases[0...-1].each do |when_case|
+            next unless when_case.condition
+
+            next unless when_case.condition.fn_name == :all?
+
+            when_case.condition.args.each do |arg|
+              next unless arg.is_a?(ArrayExpression)
+
+              arg.elements.each do |element|
+                next unless element.is_a?(DeclarationReference)
+
+                trait_name = element.name
+                trait = definitions[trait_name]
+                if trait
+                  conditions << trait.expression
+                  condition_traits << trait_name
+                end
               end
             end
+            # end
+          end
+
+          # Check mutual exclusion for all pairs
+          total_pairs = conditions.size * (conditions.size - 1) / 2
+          exclusive_pairs = 0
+
+          if conditions.size >= 2
+            conditions.combination(2).each do |cond1, cond2|
+              exclusive_pairs += 1 if conditions_mutually_exclusive?(cond1, cond2)
+            end
           end
-          state
+
+          all_mutually_exclusive = (total_pairs > 0) && (exclusive_pairs == total_pairs)
+
+          {
+            condition_traits: condition_traits,
+            condition_count: conditions.size,
+            all_mutually_exclusive: all_mutually_exclusive,
+            exclusive_pairs: exclusive_pairs,
+            total_pairs: total_pairs
+          }
         end
 
-        private
+        def conditions_mutually_exclusive?(cond1, cond2)
+          if cond1.is_a?(CallExpression) && cond1.fn_name == :== &&
+             cond2.is_a?(CallExpression) && cond2.fn_name == :==
+
+            c1_field, c1_value = cond1.args
+            c2_field, c2_value = cond2.args
+
+            # Same field, different values = mutually exclusive
+            return true if same_field?(c1_field, c2_field) && different_values?(c1_value, c2_value)
+          end
+
+          false
+        end
+
+        def same_field?(field1, field2)
+          return false unless field1.is_a?(InputReference) && field2.is_a?(InputReference)
+
+          field1.name == field2.name
+        end
+
+        def different_values?(val1, val2)
+          return false unless val1.is_a?(Literal) && val2.is_a?(Literal)
+
+          val1.value != val2.value
+        end
 
         def check_or_expression(or_expr, definitions, errors)
           # For OR expressions: A | B is impossible only if BOTH A AND B are impossible
@@ -52,26 +137,22 @@ module Kumi
 
           # Check if left side is impossible
           left_atoms = gather_atoms(left_side, definitions, Set.new)
-          left_impossible = if !left_atoms.empty?
-                              if definitions && !definitions.empty?
-                                Kumi::ConstraintRelationshipSolver.unsat?(left_atoms, definitions, input_meta: @input_meta)
-                              else
-                                Kumi::AtomUnsatSolver.unsat?(left_atoms)
-                              end
-                            else
+          left_impossible = if left_atoms.empty?
                               false
+                            elsif definitions && !definitions.empty?
+                              Kumi::ConstraintRelationshipSolver.unsat?(left_atoms, definitions, input_meta: @input_meta)
+                            else
+                              Kumi::AtomUnsatSolver.unsat?(left_atoms)
                             end
 
           # Check if right side is impossible
           right_atoms = gather_atoms(right_side, definitions, Set.new)
-          right_impossible = if !right_atoms.empty?
-                               if definitions && !definitions.empty?
-                                 Kumi::ConstraintRelationshipSolver.unsat?(right_atoms, definitions, input_meta: @input_meta)
-                               else
-                                 Kumi::AtomUnsatSolver.unsat?(right_atoms)
-                               end
-                             else
+          right_impossible = if right_atoms.empty?
                                false
+                             elsif definitions && !definitions.empty?
+                               Kumi::ConstraintRelationshipSolver.unsat?(right_atoms, definitions, input_meta: @input_meta)
+                             else
+                               Kumi::AtomUnsatSolver.unsat?(right_atoms)
                              end
 
           # OR is impossible only if BOTH sides are impossible
@@ -106,10 +187,10 @@ module Kumi
             elsif current.is_a?(CallExpression) && current.fn_name == :all?
               # For all? function, add all trait arguments to the stack
               current.args.each { |arg| stack << arg }
-            elsif current.is_a?(ListExpression)
-              # For ListExpression, add all elements to the stack
+            elsif current.is_a?(ArrayExpression)
+              # For ArrayExpression, add all elements to the stack
               current.elements.each { |elem| stack << elem }
-            elsif current.is_a?(Binding)
+            elsif current.is_a?(DeclarationReference)
               name = current.name
               unless visited.include?(name)
                 visited << name
@@ -141,8 +222,8 @@ module Kumi
 
             # Skip single-trait 'on' branches: trait-level unsat detection covers these
             if when_case.condition.is_a?(CallExpression) && when_case.condition.fn_name == :all?
-              # Handle both ListExpression (old format) and multiple args (new format)
-              if when_case.condition.args.size == 1 && when_case.condition.args.first.is_a?(ListExpression)
+              # Handle both ArrayExpression (old format) and multiple args (new format)
+              if when_case.condition.args.size == 1 && when_case.condition.args.first.is_a?(ArrayExpression)
                 list = when_case.condition.args.first
                 next if list.elements.size == 1
               elsif when_case.condition.args.size == 1
@@ -154,7 +235,6 @@ module Kumi
             condition_atoms = gather_atoms(when_case.condition, definitions, Set.new, [])
             # DEBUG
             # if when_case.condition.is_a?(CallExpression) && [:all?, :any?, :none?].include?(when_case.condition.fn_name)
-            #   puts "DEBUG: Processing #{when_case.condition.fn_name} condition"
             #   puts "  Args: #{when_case.condition.args.inspect}"
             #   puts "  Atoms found: #{condition_atoms.inspect}"
             # end
@@ -174,14 +254,14 @@ module Kumi
 
             # For multi-trait on-clauses, report the trait names rather than the value name
             if when_case.condition.is_a?(CallExpression) && when_case.condition.fn_name == :all?
-              # Handle both ListExpression (old format) and multiple args (new format)
-              trait_bindings = if when_case.condition.args.size == 1 && when_case.condition.args.first.is_a?(ListExpression)
+              # Handle both ArrayExpression (old format) and multiple args (new format)
+              trait_bindings = if when_case.condition.args.size == 1 && when_case.condition.args.first.is_a?(ArrayExpression)
                                  when_case.condition.args.first.elements
                                else
                                  when_case.condition.args
                                end
 
-              if trait_bindings.all?(Binding)
+              if trait_bindings.all?(DeclarationReference)
                 traits = trait_bindings.map(&:name).join(" AND ")
                 report_error(errors, "conjunction `#{traits}` is impossible", location: decl.loc)
                 next
@@ -193,7 +273,7 @@ module Kumi
 
         def term(node, _defs)
           case node
-          when FieldRef, Binding
+          when InputReference, DeclarationReference
             val = @evaluator.evaluate(node)
             val == :unknown ? node.name : val
           when Literal
@@ -205,14 +285,14 @@ module Kumi
 
         def check_domain_constraints(node, definitions, errors)
           case node
-          when FieldRef
-            # Check if FieldRef points to a field with domain constraints
+          when InputReference
+            # Check if InputReference points to a field with domain constraints
             field_meta = @input_meta[node.name]
             nil unless field_meta&.dig(:domain)
 
-            # For FieldRef, the constraint comes from trait conditions
-            # We don't flag here since the FieldRef itself is valid
-          when Binding
+            # For InputReference, the constraint comes from trait conditions
+            # We don't flag here since the InputReference itself is valid
+          when DeclarationReference
             # Check if this binding evaluates to a value that violates domain constraints
             definition = definitions[node.name]
             return unless definition
@@ -254,18 +334,18 @@ module Kumi
         end
 
         def impossible_constraint?(lhs, rhs, operator)
-          # Case 1: FieldRef compared against value outside its domain
-          if lhs.is_a?(FieldRef) && rhs.is_a?(Literal)
+          # Case 1: InputReference compared against value outside its domain
+          if lhs.is_a?(InputReference) && rhs.is_a?(Literal)
             return field_literal_impossible?(lhs, rhs, operator)
-          elsif rhs.is_a?(FieldRef) && lhs.is_a?(Literal)
+          elsif rhs.is_a?(InputReference) && lhs.is_a?(Literal)
             # Reverse case: literal compared to field
             return field_literal_impossible?(rhs, lhs, flip_operator(operator))
           end
 
-          # Case 2: Binding that evaluates to literal compared against impossible value
-          if lhs.is_a?(Binding) && rhs.is_a?(Literal)
+          # Case 2: DeclarationReference that evaluates to literal compared against impossible value
+          if lhs.is_a?(DeclarationReference) && rhs.is_a?(Literal)
             return binding_literal_impossible?(lhs, rhs, operator)
-          elsif rhs.is_a?(Binding) && lhs.is_a?(Literal)
+          elsif rhs.is_a?(DeclarationReference) && lhs.is_a?(Literal)
             return binding_literal_impossible?(rhs, lhs, flip_operator(operator))
           end