kumi 0.0.6 → 0.0.8

data/scripts/generate_function_docs.rb

@@ -9,7 +9,7 @@ require "kumi"
 
 # Helper to format the type information for display.
 def format_type(type)
-  Kumi::Types.type_to_s(type)
+  Kumi::Core::Types.type_to_s(type)
 end
 
 # Helper to generate a signature string for a function.
@@ -49,19 +49,19 @@ end
 
 def function_categories
   {
-    "Logical Functions" => Kumi::FunctionRegistry.logical_operations,
-    "Comparison Functions" => Kumi::FunctionRegistry.comparison_operators,
-    "Math Functions" => Kumi::FunctionRegistry.math_operations,
-    "String Functions" => Kumi::FunctionRegistry.string_operations,
-    "Collection Functions" => Kumi::FunctionRegistry.collection_operations,
-    "Conditional Functions" => Kumi::FunctionRegistry.conditional_operations,
-    "Type & Hash Functions" => Kumi::FunctionRegistry.type_operations
+    "Logical Functions" => Kumi::Registry.logical_operations,
+    "Comparison Functions" => Kumi::Registry.comparison_operators,
+    "Math Functions" => Kumi::Registry.math_operations,
+    "String Functions" => Kumi::Registry.string_operations,
+    "Collection Functions" => Kumi::Registry.collection_operations,
+    "Conditional Functions" => Kumi::Registry.conditional_operations,
+    "Type & Hash Functions" => Kumi::Registry.type_operations
   }
 end
 
 def add_functions_for_category(output, functions)
   functions.sort.each do |name|
-    signature = Kumi::FunctionRegistry.signature(name)
+    signature = Kumi::Registry.signature(name)
     output << "* **`#{name}`**: #{signature[:description]}"
     output << "  * **Usage**: #{generate_signature(name, signature)}"
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kumi
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.8
 platform: ruby
 authors:
 - André Muta
@@ -48,78 +48,101 @@ files:
 - docs/features/array-broadcasting.md
 - docs/features/input-declaration-system.md
 - docs/features/performance.md
+- docs/schema_metadata.md
+- docs/schema_metadata/broadcasts.md
+- docs/schema_metadata/cascades.md
+- docs/schema_metadata/declarations.md
+- docs/schema_metadata/dependencies.md
+- docs/schema_metadata/evaluation_order.md
+- docs/schema_metadata/examples.md
+- docs/schema_metadata/inferred_types.md
+- docs/schema_metadata/inputs.md
 - examples/deep_schema_compilation_and_evaluation_benchmark.rb
 - examples/federal_tax_calculator_2024.rb
 - examples/game_of_life.rb
 - examples/simple_rpg_game.rb
 - examples/static_analysis_errors.rb
 - examples/wide_schema_compilation_and_evaluation_benchmark.rb
-- lib/generators/trait_engine/templates/schema_spec.rb.erb
 - lib/kumi.rb
 - lib/kumi/analyzer.rb
-- lib/kumi/analyzer/analysis_state.rb
-- lib/kumi/analyzer/constant_evaluator.rb
-- lib/kumi/analyzer/passes/broadcast_detector.rb
-- lib/kumi/analyzer/passes/declaration_validator.rb
-- lib/kumi/analyzer/passes/dependency_resolver.rb
-- lib/kumi/analyzer/passes/input_collector.rb
-- lib/kumi/analyzer/passes/name_indexer.rb
-- lib/kumi/analyzer/passes/pass_base.rb
-- lib/kumi/analyzer/passes/semantic_constraint_validator.rb
-- lib/kumi/analyzer/passes/toposorter.rb
-- lib/kumi/analyzer/passes/type_checker.rb
-- lib/kumi/analyzer/passes/type_consistency_checker.rb
-- lib/kumi/analyzer/passes/type_inferencer.rb
-- lib/kumi/analyzer/passes/unsat_detector.rb
-- lib/kumi/analyzer/passes/visitor_pass.rb
-- lib/kumi/atom_unsat_solver.rb
 - lib/kumi/cli.rb
-- lib/kumi/compiled_schema.rb
 - lib/kumi/compiler.rb
-- lib/kumi/constraint_relationship_solver.rb
-- lib/kumi/domain/enum_analyzer.rb
-- lib/kumi/domain/range_analyzer.rb
-- lib/kumi/domain/validator.rb
-- lib/kumi/domain/violation_formatter.rb
-- lib/kumi/error_reporter.rb
-- lib/kumi/error_reporting.rb
+- lib/kumi/core/analyzer/analysis_state.rb
+- lib/kumi/core/analyzer/constant_evaluator.rb
+- lib/kumi/core/analyzer/passes/broadcast_detector.rb
+- lib/kumi/core/analyzer/passes/declaration_validator.rb
+- lib/kumi/core/analyzer/passes/dependency_resolver.rb
+- lib/kumi/core/analyzer/passes/input_collector.rb
+- lib/kumi/core/analyzer/passes/name_indexer.rb
+- lib/kumi/core/analyzer/passes/pass_base.rb
+- lib/kumi/core/analyzer/passes/semantic_constraint_validator.rb
+- lib/kumi/core/analyzer/passes/toposorter.rb
+- lib/kumi/core/analyzer/passes/type_checker.rb
+- lib/kumi/core/analyzer/passes/type_consistency_checker.rb
+- lib/kumi/core/analyzer/passes/type_inferencer.rb
+- lib/kumi/core/analyzer/passes/unsat_detector.rb
+- lib/kumi/core/analyzer/passes/visitor_pass.rb
+- lib/kumi/core/atom_unsat_solver.rb
+- lib/kumi/core/compiled_schema.rb
+- lib/kumi/core/constraint_relationship_solver.rb
+- lib/kumi/core/domain/enum_analyzer.rb
+- lib/kumi/core/domain/range_analyzer.rb
+- lib/kumi/core/domain/validator.rb
+- lib/kumi/core/domain/violation_formatter.rb
+- lib/kumi/core/error_reporter.rb
+- lib/kumi/core/error_reporting.rb
+- lib/kumi/core/errors.rb
+- lib/kumi/core/evaluation_wrapper.rb
+- lib/kumi/core/explain.rb
+- lib/kumi/core/export.rb
+- lib/kumi/core/export/deserializer.rb
+- lib/kumi/core/export/errors.rb
+- lib/kumi/core/export/node_builders.rb
+- lib/kumi/core/export/node_registry.rb
+- lib/kumi/core/export/node_serializers.rb
+- lib/kumi/core/export/serializer.rb
+- lib/kumi/core/function_registry.rb
+- lib/kumi/core/function_registry/collection_functions.rb
+- lib/kumi/core/function_registry/comparison_functions.rb
+- lib/kumi/core/function_registry/conditional_functions.rb
+- lib/kumi/core/function_registry/function_builder.rb
+- lib/kumi/core/function_registry/logical_functions.rb
+- lib/kumi/core/function_registry/math_functions.rb
+- lib/kumi/core/function_registry/string_functions.rb
+- lib/kumi/core/function_registry/type_functions.rb
+- lib/kumi/core/input/type_matcher.rb
+- lib/kumi/core/input/validator.rb
+- lib/kumi/core/input/violation_creator.rb
+- lib/kumi/core/json_schema.rb
+- lib/kumi/core/json_schema/generator.rb
+- lib/kumi/core/json_schema/validator.rb
+- lib/kumi/core/ruby_parser.rb
+- lib/kumi/core/ruby_parser/build_context.rb
+- lib/kumi/core/ruby_parser/declaration_reference_proxy.rb
+- lib/kumi/core/ruby_parser/dsl.rb
+- lib/kumi/core/ruby_parser/dsl_cascade_builder.rb
+- lib/kumi/core/ruby_parser/expression_converter.rb
+- lib/kumi/core/ruby_parser/guard_rails.rb
+- lib/kumi/core/ruby_parser/input_builder.rb
+- lib/kumi/core/ruby_parser/input_field_proxy.rb
+- lib/kumi/core/ruby_parser/input_proxy.rb
+- lib/kumi/core/ruby_parser/nested_input.rb
+- lib/kumi/core/ruby_parser/parser.rb
+- lib/kumi/core/ruby_parser/schema_builder.rb
+- lib/kumi/core/ruby_parser/sugar.rb
+- lib/kumi/core/schema_instance.rb
+- lib/kumi/core/types.rb
+- lib/kumi/core/types/builder.rb
+- lib/kumi/core/types/compatibility.rb
+- lib/kumi/core/types/formatter.rb
+- lib/kumi/core/types/inference.rb
+- lib/kumi/core/types/normalizer.rb
+- lib/kumi/core/types/validator.rb
+- lib/kumi/core/vectorization_metadata.rb
 - lib/kumi/errors.rb
-- lib/kumi/evaluation_wrapper.rb
-- lib/kumi/explain.rb
-- lib/kumi/export.rb
-- lib/kumi/export/deserializer.rb
-- lib/kumi/export/errors.rb
-- lib/kumi/export/node_builders.rb
-- lib/kumi/export/node_registry.rb
-- lib/kumi/export/node_serializers.rb
-- lib/kumi/export/serializer.rb
-- lib/kumi/function_registry.rb
-- lib/kumi/function_registry/collection_functions.rb
-- lib/kumi/function_registry/comparison_functions.rb
-- lib/kumi/function_registry/conditional_functions.rb
-- lib/kumi/function_registry/function_builder.rb
-- lib/kumi/function_registry/logical_functions.rb
-- lib/kumi/function_registry/math_functions.rb
-- lib/kumi/function_registry/string_functions.rb
-- lib/kumi/function_registry/type_functions.rb
-- lib/kumi/input/type_matcher.rb
-- lib/kumi/input/validator.rb
-- lib/kumi/input/violation_creator.rb
-- lib/kumi/parser/build_context.rb
-- lib/kumi/parser/declaration_reference_proxy.rb
-- lib/kumi/parser/dsl.rb
-- lib/kumi/parser/dsl_cascade_builder.rb
-- lib/kumi/parser/expression_converter.rb
-- lib/kumi/parser/guard_rails.rb
-- lib/kumi/parser/input_builder.rb
-- lib/kumi/parser/input_field_proxy.rb
-- lib/kumi/parser/input_proxy.rb
-- lib/kumi/parser/nested_input.rb
-- lib/kumi/parser/parser.rb
-- lib/kumi/parser/schema_builder.rb
-- lib/kumi/parser/sugar.rb
+- lib/kumi/registry.rb
 - lib/kumi/schema.rb
-- lib/kumi/schema_instance.rb
+- lib/kumi/schema_metadata.rb
 - lib/kumi/syntax/array_expression.rb
 - lib/kumi/syntax/call_expression.rb
 - lib/kumi/syntax/cascade_expression.rb
@@ -134,15 +157,8 @@ files:
 - lib/kumi/syntax/root.rb
 - lib/kumi/syntax/trait_declaration.rb
 - lib/kumi/syntax/value_declaration.rb
-- lib/kumi/types.rb
-- lib/kumi/types/builder.rb
-- lib/kumi/types/compatibility.rb
-- lib/kumi/types/formatter.rb
-- lib/kumi/types/inference.rb
-- lib/kumi/types/normalizer.rb
-- lib/kumi/types/validator.rb
-- lib/kumi/vectorization_metadata.rb
 - lib/kumi/version.rb
+- migrate_to_core_iterative.rb
 - scripts/generate_function_docs.rb
 homepage: https://github.com/amuta/kumi
 licenses:

data/lib/generators/trait_engine/templates/schema_spec.rb.erb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-require "rails_helper"
-
-RSpec.describe <%= schema_constant %> do
-  # Single shared instance for every example
-  let(:schema) { described_class }
-
-  # Minimal dummy context so every binding can run
-  let(:ctx) do
-    {
-<% leaf_keys.each do |k| -%>
-      <%= "#{k}:" %> nil,
-<% end -%>
-    }
-  end
-
-<% expose_names.each do |name| -%>
-  describe "<%= name %>" do
-    it "evaluates without raising" do
-      expect {
-        schema.evaluate_binding(:<%= name %>, ctx)
-      }.not_to raise_error
-    end
-  end
-
-<% end -%>
-end

data/lib/kumi/analyzer/analysis_state.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  module Analyzer
-    # Simple immutable state wrapper to prevent accidental mutations between passes
-    class AnalysisState
-      def initialize(data = {})
-        @data = data.dup.freeze
-      end
-
-      # Get a value (same as hash access)
-      def [](key)
-        @data[key]
-      end
-
-      # Check if key exists (same as hash)
-      def key?(key)
-        @data.key?(key)
-      end
-
-      # Get all keys (same as hash)
-      def keys
-        @data.keys
-      end
-
-      # Create new state with additional data (simple and clean)
-      def with(key, value)
-        AnalysisState.new(@data.merge(key => value))
-      end
-
-      # Convert back to hash for final result
-      def to_h
-        @data.dup
-      end
-    end
-  end
-end

data/lib/kumi/analyzer/constant_evaluator.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  module Analyzer
-    class ConstantEvaluator
-      include Syntax
-
-      def initialize(definitions)
-        @definitions = definitions
-        @memo = {}
-      end
-
-      OPERATORS = {
-        add: :+,
-        subtract: :-,
-        multiply: :*,
-        divide: :/
-      }.freeze
-
-      def evaluate(node, visited = Set.new)
-        return :unknown unless node
-        return @memo[node] if @memo.key?(node)
-        return node.value if node.is_a?(Literal)
-
-        result = case node
-                 when DeclarationReference then evaluate_binding(node, visited)
-                 when CallExpression then evaluate_call_expression(node, visited)
-                 else :unknown
-                 end
-
-        @memo[node] = result unless result == :unknown
-        result
-      end
-
-      private
-
-      def evaluate_binding(node, visited)
-        return :unknown if visited.include?(node.name)
-
-        visited << node.name
-        definition = @definitions[node.name]
-        return :unknown unless definition
-
-        evaluate(definition.expression, visited)
-      end
-
-      def evaluate_call_expression(node, visited)
-        return :unknown unless OPERATORS.key?(node.fn_name)
-
-        args = node.args.map { |arg| evaluate(arg, visited) }
-        return :unknown if args.any?(:unknown)
-
-        args.reduce(OPERATORS[node.fn_name])
-      end
-    end
-  end
-end

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

@@ -1,251 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  module Analyzer
-    module Passes
-      # Detects which operations should be broadcast over arrays
-      # DEPENDENCIES: :input_meta, :definitions
-      # PRODUCES: :broadcast_metadata
-      class BroadcastDetector < PassBase
-        def run(errors)
-          input_meta = get_state(:input_meta) || {}
-          definitions = get_state(:definitions) || {}
-          
-          # Find array fields with their element types
-          array_fields = find_array_fields(input_meta)
-          
-          # Build compiler metadata
-          compiler_metadata = {
-            array_fields: array_fields,
-            vectorized_operations: {},
-            reduction_operations: {}
-          }
-          
-          # Track which values are vectorized for type inference
-          vectorized_values = {}
-          
-          # Analyze traits first, then values (to handle dependencies)
-          traits = definitions.select { |name, decl| decl.is_a?(Kumi::Syntax::TraitDeclaration) }
-          values = definitions.select { |name, decl| decl.is_a?(Kumi::Syntax::ValueDeclaration) }
-          
-          (traits.to_a + values.to_a).each do |name, decl|
-            result = analyze_value_vectorization(name, decl.expression, array_fields, vectorized_values, errors)
-            
-            
-            case result[:type]
-            when :vectorized
-              compiler_metadata[:vectorized_operations][name] = result[:info]
-              # Store array source information for dimension checking
-              array_source = extract_array_source(result[:info], array_fields)
-              vectorized_values[name] = { vectorized: true, array_source: array_source }
-            when :reduction
-              compiler_metadata[:reduction_operations][name] = result[:info]
-              # Reduction produces scalar, not vectorized
-              vectorized_values[name] = { vectorized: false }
-            end
-          end
-          
-          state.with(:broadcast_metadata, compiler_metadata.freeze)
-        end
-
-        private
-
-        def find_array_fields(input_meta)
-          result = {}
-          input_meta.each do |name, meta|
-            if meta[:type] == :array && meta[:children]
-              result[name] = {
-                element_fields: meta[:children].keys,
-                element_types: meta[:children].transform_values { |v| v[:type] || :any }
-              }
-            end
-          end
-          result
-        end
-
-        def analyze_value_vectorization(name, expr, array_fields, vectorized_values, errors)
-          case expr
-          when Kumi::Syntax::InputElementReference
-            if array_fields.key?(expr.path.first)
-              { type: :vectorized, info: { source: :array_field_access, path: expr.path } }
-            else
-              { type: :scalar }
-            end
-            
-          when Kumi::Syntax::DeclarationReference
-            # Check if this references a vectorized value
-            vector_info = vectorized_values[expr.name]
-            if vector_info && vector_info[:vectorized]
-              { type: :vectorized, info: { source: :vectorized_declaration, name: expr.name } }
-            else
-              { type: :scalar }
-            end
-            
-          when Kumi::Syntax::CallExpression
-            analyze_call_vectorization(name, expr, array_fields, vectorized_values, errors)
-            
-          when Kumi::Syntax::CascadeExpression
-            analyze_cascade_vectorization(name, expr, array_fields, vectorized_values, errors)
-            
-          else
-            { type: :scalar }
-          end
-        end
-
-        def analyze_call_vectorization(name, expr, array_fields, vectorized_values, errors)
-          # Check if this is a reduction function using function registry metadata
-          if FunctionRegistry.reducer?(expr.fn_name)
-            # Only treat as reduction if the argument is actually vectorized
-            arg_info = analyze_argument_vectorization(expr.args.first, array_fields, vectorized_values)
-            if arg_info[:vectorized]
-              { type: :reduction, info: { function: expr.fn_name, source: arg_info[:source] } }
-            else
-              # Not a vectorized reduction - just a regular function call
-              { type: :scalar }
-            end
-            
-          else
-            # Special case: all?, any?, none? functions with vectorized trait arguments should be treated as vectorized
-            # for cascade condition purposes (they get transformed during compilation)
-            if [:all?, :any?, :none?].include?(expr.fn_name) && expr.args.length == 1
-              arg = expr.args.first
-              if arg.is_a?(Kumi::Syntax::ArrayExpression) && arg.elements.length == 1
-                trait_ref = arg.elements.first
-                if trait_ref.is_a?(Kumi::Syntax::DeclarationReference) && vectorized_values[trait_ref.name]&.[](:vectorized)
-                  return { type: :vectorized, info: { source: :cascade_condition_with_vectorized_trait, trait: trait_ref.name } }
-                end
-              end
-            end
-            
-            # ANY function with vectorized arguments becomes vectorized (with broadcasting)
-            arg_infos = expr.args.map { |arg| analyze_argument_vectorization(arg, array_fields, vectorized_values) }
-            
-            if arg_infos.any? { |info| info[:vectorized] }
-              # Check for dimension mismatches when multiple arguments are vectorized
-              vectorized_sources = arg_infos.select { |info| info[:vectorized] }.map { |info| info[:array_source] }.compact.uniq
-              
-              if vectorized_sources.length > 1
-                # Multiple different array sources - this is a dimension mismatch
-                # Generate enhanced error message with type information
-                enhanced_message = build_dimension_mismatch_error(expr, arg_infos, array_fields, vectorized_sources)
-                
-                report_error(errors, enhanced_message, location: expr.loc, type: :semantic)
-                return { type: :scalar }  # Treat as scalar to prevent further errors
-              end
-              
-              # This is a vectorized operation - ANY function supports broadcasting
-              { type: :vectorized, info: { 
-                operation: expr.fn_name, 
-                vectorized_args: arg_infos.map.with_index { |info, i| [i, info[:vectorized]] }.to_h 
-              }}
-            else
-              { type: :scalar }
-            end
-          end
-        end
-
-        def analyze_argument_vectorization(arg, array_fields, vectorized_values)
-          case arg
-          when Kumi::Syntax::InputElementReference
-            if array_fields.key?(arg.path.first)
-              { vectorized: true, source: :array_field, array_source: arg.path.first }
-            else
-              { vectorized: false }
-            end
-            
-          when Kumi::Syntax::DeclarationReference
-            # Check if this references a vectorized value
-            vector_info = vectorized_values[arg.name]
-            if vector_info && vector_info[:vectorized]
-              array_source = vector_info[:array_source]
-              { vectorized: true, source: :vectorized_value, array_source: array_source }
-            else
-              { vectorized: false }
-            end
-            
-          when Kumi::Syntax::CallExpression
-            # Recursively check
-            result = analyze_value_vectorization(nil, arg, array_fields, vectorized_values, [])
-            { vectorized: result[:type] == :vectorized, source: :expression }
-            
-          else
-            { vectorized: false }
-          end
-        end
-
-        def extract_array_source(info, array_fields)
-          case info[:source]
-          when :array_field_access
-            info[:path]&.first
-          when :cascade_condition_with_vectorized_trait
-            # For cascades, we'd need to trace back to the original source
-            nil  # TODO: Could be enhanced to trace through trait dependencies
-          else
-            nil
-          end
-        end
-
-        def analyze_cascade_vectorization(name, expr, array_fields, vectorized_values, errors)
-          # A cascade is vectorized if:
-          # 1. Any of its result expressions are vectorized, OR
-          # 2. Any of its conditions reference vectorized values (traits or arrays)
-          vectorized_results = []
-          vectorized_conditions = []
-          
-          expr.cases.each do |case_expr|
-            # Check if result is vectorized
-            result_info = analyze_value_vectorization(nil, case_expr.result, array_fields, vectorized_values, errors)
-            vectorized_results << (result_info[:type] == :vectorized)
-            
-            # Check if condition is vectorized
-            condition_info = analyze_value_vectorization(nil, case_expr.condition, array_fields, vectorized_values, errors)
-            vectorized_conditions << (condition_info[:type] == :vectorized)
-            
-          end
-          
-          if vectorized_results.any? || vectorized_conditions.any?
-            { type: :vectorized, info: { source: :cascade_with_vectorized_conditions_or_results } }
-          else
-            { type: :scalar }
-          end
-        end
-
-        def build_dimension_mismatch_error(_expr, arg_infos, array_fields, vectorized_sources)
-          # Build detailed error message with type information
-          summary = "Cannot broadcast operation across arrays from different sources: #{vectorized_sources.join(', ')}. "
-          
-          problem_desc = "Problem: Multiple operands are arrays from different sources:\n"
-          
-          vectorized_args = arg_infos.select { |info| info[:vectorized] }
-          vectorized_args.each_with_index do |arg_info, index|
-            array_source = arg_info[:array_source]
-            next unless array_source && array_fields[array_source]
-
-            # Determine the type based on array field metadata
-            type_desc = determine_array_type(array_source, array_fields)
-            problem_desc += "  - Operand #{index + 1} resolves to #{type_desc} from array '#{array_source}'\n"
-          end
-          
-          explanation = "Direct operations on arrays from different sources is ambiguous and not supported. " \
-                        "Vectorized operations can only work on fields from the same array input."
-          
-          "#{summary}#{problem_desc}#{explanation}"
-        end
-
-        def determine_array_type(array_source, array_fields)
-          field_info = array_fields[array_source]
-          return "array(any)" unless field_info[:element_types]
-
-          # For nested arrays (like items.name where items is an array), this represents array(element_type)
-          element_types = field_info[:element_types].values.uniq
-          if element_types.length == 1
-            "array(#{element_types.first})"
-          else
-            "array(mixed)"
-          end
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  module Analyzer
-    module Passes
-      # RESPONSIBILITY: Perform local structural validation on each declaration
-      # DEPENDENCIES: :definitions
-      # PRODUCES: None (validation only)
-      # INTERFACE: new(schema, state).run(errors)
-      class DeclarationValidator < VisitorPass
-        def run(errors)
-          each_decl do |decl|
-            visit(decl) { |node| validate_node(node, errors) }
-          end
-          state
-        end
-
-        private
-
-        def validate_node(node, errors)
-          case node
-          when Kumi::Syntax::ValueDeclaration
-            validate_attribute(node, errors)
-          when Kumi::Syntax::TraitDeclaration
-            validate_trait(node, errors)
-          end
-        end
-
-        def validate_attribute(node, errors)
-          return unless node.expression.nil?
-
-          report_error(errors, "attribute `#{node.name}` requires an expression", location: node.loc)
-        end
-
-        def validate_trait(node, errors)
-          return if node.expression.is_a?(Kumi::Syntax::CallExpression)
-
-          report_error(errors, "trait `#{node.name}` must wrap a CallExpression", location: node.loc)
-        end
-      end
-    end
-  end
-end