kumi 0.0.15 → 0.0.17

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

@@ -6,7 +6,6 @@ module Kumi
       module Passes
         # RESPONSIBILITY: Detect unsatisfiable constraints and analyze cascade mutual exclusion
         # DEPENDENCIES: :declarations from NameIndexer, :input_metadata from InputCollector
-        # PRODUCES: :cascades - Hash of cascade mutual exclusion analysis results
         # INTERFACE: new(schema, state).run(errors)
         class UnsatDetector < VisitorPass
           include Syntax
@@ -20,142 +19,31 @@ module Kumi
             @definitions = definitions
             @evaluator = ConstantEvaluator.new(definitions)
 
-            # First pass: analyze cascade conditions for mutual exclusion
-            cascades = {}
             each_decl do |decl|
-              cascades[decl.name] = analyze_cascade_mutual_exclusion(decl, definitions) if decl.expression.is_a?(CascadeExpression)
-
-              # Store cascade metadata for later passes
-
-              # Second pass: check for unsatisfiable constraints
               if decl.expression.is_a?(CascadeExpression)
-                # Special handling for cascade expressions
                 check_cascade_expression(decl, definitions, errors)
               elsif decl.expression.is_a?(CallExpression) && decl.expression.fn_name == :or
-                # Check for OR expressions which need special disjunctive handling
                 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?
 
-                # DEBUG: Add detailed logging for hierarchical broadcasting debugging
-                if ENV["DEBUG_UNSAT"] || decl.loc&.to_s&.include?("hierarchical_broadcasting_spec.rb:257")
-                  puts "DEBUG UNSAT: Checking declaration '#{decl.name}' at #{decl.loc}"
-                  puts "  Expression: #{decl.expression.inspect}"
-                  puts "  Gathered atoms: #{atoms.map(&:inspect)}"
-                  puts "  Input meta: #{@input_meta.keys.inspect}" if @input_meta
-                end
-
-                # Use enhanced solver that can detect cross-variable mathematical constraints
-                if definitions && !definitions.empty?
-                  result = Kumi::Core::ConstraintRelationshipSolver.unsat?(atoms, definitions, input_meta: @input_meta)
-                  if ENV["DEBUG_UNSAT"] || decl.loc&.to_s&.include?("hierarchical_broadcasting_spec.rb:257")
-                    puts "  Enhanced solver result: #{result}"
-                  end
-                else
-                  result = Kumi::Core::AtomUnsatSolver.unsat?(atoms)
-                  if ENV["DEBUG_UNSAT"] || decl.loc&.to_s&.include?("hierarchical_broadcasting_spec.rb:257")
-                    puts "  Basic solver result: #{result}"
-                  end
-                end
+                result = if definitions && !definitions.empty?
+                           Kumi::Core::ConstraintRelationshipSolver.unsat?(atoms, definitions, input_meta: @input_meta)
+                         else
+                           Kumi::Core::AtomUnsatSolver.unsat?(atoms)
+                         end
                 impossible = result
 
-                if impossible && (ENV["DEBUG_UNSAT"] || decl.loc&.to_s&.include?("hierarchical_broadcasting_spec.rb:257"))
-                  puts "  -> FLAGGING AS IMPOSSIBLE: #{decl.name}"
-                end
-
                 report_error(errors, "conjunction `#{decl.name}` is impossible", location: decl.loc) if impossible
               end
             end
-            state.with(:cascades, cascades)
-          end
-
-          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 == :cascade_and
-
-              when_case.condition.args.each do |arg|
-                if arg.is_a?(ArrayExpression)
-                  # Handle array elements (for array broadcasting)
-                  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
-                elsif arg.is_a?(DeclarationReference)
-                  # Handle direct trait references (simple case)
-                  trait_name = arg.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
-
-            all_mutually_exclusive = total_pairs.positive? && (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
-
-          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
+            state
           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
+          private
 
           def check_or_expression(or_expr, definitions, _errors)
             # For OR expressions: A | B is impossible only if BOTH A AND B are impossible
@@ -199,23 +87,16 @@ module Kumi
               if current.is_a?(CallExpression) && COMPARATORS.include?(current.fn_name)
                 lhs, rhs = current.args
 
-                # Check for domain constraint violations before creating atom
                 list << if impossible_constraint?(lhs, rhs, current.fn_name)
-                          # Create a special impossible atom that will always trigger unsat
                           Atom.new(:==, :__impossible__, true)
                         else
                           Atom.new(current.fn_name, term(lhs, defs), term(rhs, defs))
                         end
               elsif current.is_a?(CallExpression) && current.fn_name == :or
-                # Special handling for OR expressions - they are disjunctive, not conjunctive
-                # We should NOT add OR children to the stack as they would be treated as AND
-                # OR expressions need separate analysis in the main run() method
                 next
               elsif current.is_a?(CallExpression) && current.fn_name == :cascade_and
-                # cascade_and takes individual arguments (not wrapped in array)
                 current.args.each { |arg| stack << arg }
               elsif current.is_a?(ArrayExpression)
-                # For ArrayExpression, add all elements to the stack
                 current.elements.each { |elem| stack << elem }
               elsif current.is_a?(DeclarationReference)
                 name = current.name
@@ -225,10 +106,6 @@ module Kumi
                 end
               end
 
-              # Add children to stack for processing
-              # IMPORTANT: Skip CascadeExpression children to avoid false positives
-              # Cascades are handled separately by check_cascade_expression() and are disjunctive,
-              # but gather_atoms() treats all collected atoms as conjunctive
               current.children.each { |child| stack << child } if current.respond_to?(:children) && !current.is_a?(CascadeExpression)
             end
 
@@ -247,32 +124,24 @@ module Kumi
             end
 
             decl.expression.cases.each_with_index do |when_case, index|
-              # DEBUG: Log each case
               if ENV["DEBUG_UNSAT"] || decl.loc&.to_s&.include?("hierarchical_broadcasting_spec.rb:257")
                 puts "  Case #{index}: condition=#{when_case.condition.inspect}"
               end
 
-              # Skip the base case (it's typically a literal true condition)
               next if when_case.condition.is_a?(Literal) && when_case.condition.value == true
 
-              # Skip non-conjunctive conditions (any?, none?) as they are disjunctive
               next if when_case.condition.is_a?(CallExpression) && %i[any? none?].include?(when_case.condition.fn_name)
 
-              # Skip single-trait 'on' branches: trait-level unsat detection covers these
               if when_case.condition.is_a?(CallExpression) && when_case.condition.fn_name == :cascade_and && (when_case.condition.args.size == 1)
-                # cascade_and uses individual arguments - skip if only one trait
                 next
               end
 
-              # Gather atoms from this individual condition only
               condition_atoms = gather_atoms(when_case.condition, definitions, Set.new, [])
 
-              # DEBUG: Add detailed logging for hierarchical broadcasting debugging
               if ENV["DEBUG_UNSAT"] || decl.loc&.to_s&.include?("hierarchical_broadcasting_spec.rb:257")
                 puts "    Condition atoms: #{condition_atoms.map(&:inspect)}"
               end
 
-              # Use enhanced solver for cascade conditions too
               if definitions && !definitions.empty?
                 result = Kumi::Core::ConstraintRelationshipSolver.unsat?(condition_atoms, definitions, input_meta: @input_meta)
                 if ENV["DEBUG_UNSAT"] || decl.loc&.to_s&.include?("hierarchical_broadcasting_spec.rb:257")
@@ -287,9 +156,7 @@ module Kumi
               impossible = result
               next unless !condition_atoms.empty? && impossible
 
-              # 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 == :cascade_and
-                # cascade_and uses individual arguments
                 trait_bindings = when_case.condition.args
 
                 if trait_bindings.all?(DeclarationReference)
@@ -314,9 +181,6 @@ module Kumi
               val = @evaluator.evaluate(node)
               val == :unknown ? node.name : val
             when InputElementReference
-              # For hierarchical paths like input.companies.regions.offices.teams.department,
-              # create a unique identifier that represents the specific path
-              # This prevents false positives where different paths are treated as the same :unknown
               path_identifier = node.path.join(".").to_s
               path_identifier.to_sym
             when Literal
@@ -326,51 +190,10 @@ module Kumi
             end
           end
 
-          def check_domain_constraints(node, definitions, errors)
-            case node
-            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 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
-
-              if definition.expression.is_a?(Literal)
-                literal_value = definition.expression.value
-                check_value_against_domains(node.name, literal_value, errors, definition.loc)
-              end
-            end
-          end
-
-          def check_value_against_domains(_var_name, value, _errors, _location)
-            # Check if this value violates any input domain constraints
-            @input_meta.each_value do |field_meta|
-              domain = field_meta[:domain]
-              next unless domain
-
-              if violates_domain?(value, domain)
-                # This indicates a constraint that can never be satisfied
-                # Rather than flagging the cascade, flag the impossible condition
-                return true
-              end
-            end
-            false
-          end
-
           def violates_domain?(value, domain)
             case domain
-            when Range
-              !domain.include?(value)
-            when Array
+            when Range, Array
               !domain.include?(value)
-            when Proc
-              # For Proc domains, we can't statically analyze
-              false
             else
               false
             end
@@ -381,7 +204,6 @@ module Kumi
             if lhs.is_a?(InputReference) && rhs.is_a?(Literal)
               return field_literal_impossible?(lhs, rhs, operator)
             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
 
@@ -404,13 +226,10 @@ module Kumi
 
             case operator
             when :==
-              # field == value where value is not in domain
               violates_domain?(literal_value, domain)
             when :!=
-              # field != value where value is not in domain is always true (not impossible)
               false
             else
-              # For other operators, we'd need more sophisticated analysis
               false
             end
           end
@@ -424,10 +243,8 @@ module Kumi
 
             case operator
             when :==
-              # binding == value where binding evaluates to different value
               evaluated_value != literal_value
             else
-              # For other operators, we could add more sophisticated checking
               false
             end
           end

data/lib/kumi/core/compiler/access_builder.rb

@@ -2,18 +2,29 @@ module Kumi
   module Core
     module Compiler
       class AccessBuilder
-        def self.build(plans)
+        class << self
+          attr_accessor :yjit
+        end
+        self.yjit = defined?(RubyVM::YJIT) && RubyVM::YJIT.enabled?
+
+        def self.build(plans, strategy: nil)
+          strategy ||= yjit ? :interp : :codegen
           accessors = {}
+
           plans.each_value do |variants|
             variants.each do |plan|
-              key = plan.respond_to?(:accessor_key) ? plan.accessor_key : "#{plan.path}:#{mode}"
-              accessors[key] = build_proc_for(
-                mode: plan.mode,
-                path_key: plan.path,
-                missing: (plan.on_missing || :error).to_sym,
-                key_policy: (plan.key_policy || :indifferent).to_sym,
-                operations: plan.operations
-              )
+              accessors[plan.accessor_key] =
+                case strategy
+                when :codegen then AccessCodegen.fetch_or_compile(plan)
+                else
+                  build_proc_for(
+                    mode: plan.mode,
+                    path_key: plan.path,
+                    missing: (plan.on_missing || :error).to_sym,
+                    key_policy: (plan.key_policy || :indifferent).to_sym,
+                    operations: plan.operations
+                  )
+                end
             end
           end
           accessors.freeze
@@ -25,7 +36,6 @@ module Kumi
           when :materialize then Accessors::MaterializeAccessor.build(operations, path_key, missing, key_policy)
           when :ravel       then Accessors::RavelAccessor.build(operations, path_key, missing, key_policy)
           when :each_indexed then Accessors::EachIndexedAccessor.build(operations, path_key, missing, key_policy, true)
-          when :each then Accessors::EachAccessor.build(operations, path_key, missing, key_policy)
           else
             raise "Unknown accessor mode: #{mode.inspect}"
           end

data/lib/kumi/core/compiler/access_codegen.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "digest/sha1"
+
+module Kumi
+  module Core
+    module Compiler
+      class AccessCodegen
+        CACHE = {}
+        CACHE_MUTEX = Mutex.new
+
+        def self.fetch_or_compile(plan)
+          key = Digest::SHA1.hexdigest(Marshal.dump([plan.mode, plan.operations, plan.on_missing, plan.key_policy, plan.path]))
+          CACHE_MUTEX.synchronize do
+            CACHE[key] ||= compile(plan).tap(&:freeze)
+          end
+        end
+
+        def self.compile(plan)
+          case plan.mode
+          when :read         then gen_read(plan)
+          when :materialize  then gen_materialize(plan)
+          when :ravel        then gen_ravel(plan)
+          when :each_indexed then gen_each_indexed(plan)
+          else
+            raise "Unknown accessor mode: #{plan.mode.inspect}"
+          end
+        end
+
+        private_class_method def self.gen_read(plan)
+          code = AccessEmit::Read.build(plan)
+          debug_code(code, plan, "READ") if ENV["DEBUG_CODEGEN"]
+          eval(code, TOPLEVEL_BINDING)
+        end
+
+        private_class_method def self.gen_materialize(plan)
+          code = AccessEmit::Materialize.build(plan)
+          debug_code(code, plan, "MATERIALIZE") if ENV["DEBUG_CODEGEN"]
+          eval(code, TOPLEVEL_BINDING)
+        end
+
+        private_class_method def self.gen_ravel(plan)
+          code = AccessEmit::Ravel.build(plan)
+          debug_code(code, plan, "RAVEL") if ENV["DEBUG_CODEGEN"]
+          eval(code, TOPLEVEL_BINDING)
+        end
+
+        private_class_method def self.gen_each_indexed(plan)
+          code = AccessEmit::EachIndexed.build(plan)
+          debug_code(code, plan, "EACH_INDEXED") if ENV["DEBUG_CODEGEN"]
+          eval(code, TOPLEVEL_BINDING)
+        end
+
+        private_class_method def self.debug_code(code, plan, mode_name)
+          puts "=== Generated #{mode_name} code for #{plan.path}:#{plan.mode} ==="
+          puts code
+        end
+      end
+    end
+  end
+end

data/lib/kumi/core/compiler/access_emit/base.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+module Kumi
+  module Core
+    module Compiler
+      module AccessEmit
+        module Base
+          module_function
+
+          # ---------- IR segmentation ----------
+          def segment_ops(ops)
+            segs, cur = [], []
+            i = 0
+            while i < ops.length
+              case ops[i][:type]
+              when :enter_hash
+                preview = (i + 1 < ops.length) && ops[i + 1][:type] == :enter_array
+                cur << [:enter_hash, ops[i][:key].to_s, preview]
+              when :enter_array
+                segs << cur unless cur.empty?
+                segs << :array
+                cur = []
+              else
+                raise "Unknown operation: #{ops[i].inspect}"
+              end
+              i += 1
+            end
+            segs << cur unless cur.empty?
+            segs
+          end
+
+          # ---------- codegen helpers ----------
+          def fetch_hash_code(node_var:, key:, key_policy:, preview_array:, mode:, policy:, path_key:, map_depth:)
+            effective_policy = preview_array ? :indifferent : (key_policy || :indifferent)
+            str = key.to_s.inspect
+            sym = key.to_sym.inspect
+
+            fetch =
+              case effective_policy
+              when :string
+                %(next_node = #{node_var}.key?(#{str}) ? #{node_var}[#{str}] : :__missing__)
+              when :symbol
+                %(next_node = #{node_var}.key?(#{sym}) ? #{node_var}[#{sym}] : :__missing__)
+              else # :indifferent
+                <<~RB.chomp
+                  next_node =
+                    if #{node_var}.key?(#{str}); #{node_var}[#{str}]
+                    elsif #{node_var}.key?(#{sym}); #{node_var}[#{sym}]
+                    elsif #{node_var}.key?(#{str}); #{node_var}[#{str}] # (string twice ok / predictable)
+                    else :__missing__
+                    end
+                RB
+              end
+
+            miss_action = build_miss_action(policy, mode, map_depth, preview_array, key: key, path_key: path_key)
+
+            <<~RB.chomp
+              raise TypeError, "Expected Hash at '#{path_key}' (#{mode})" unless #{node_var}.is_a?(Hash)
+              #{fetch}
+              if next_node == :__missing__
+                #{miss_action}
+              end
+              #{node_var} = next_node
+            RB
+          end
+
+          def array_guard_code(node_var:, mode:, policy:, path_key:, map_depth:)
+            miss_action = build_array_miss_action(policy, mode, map_depth, path_key)
+            <<~RB.chomp
+              if #{node_var}.nil?
+                #{miss_action}
+              end
+              unless #{node_var}.is_a?(Array)
+                raise TypeError, "Expected Array at '#{path_key}' (#{mode}); got \#{#{node_var}.class}"
+              end
+            RB
+          end
+
+          # ---------- missing behaviors ----------
+          def build_miss_action(policy, mode, map_depth, preview_array, key:, path_key:)
+            case policy
+            when :nil
+              if mode == :ravel
+                base = "out << nil"
+                cont = map_depth.positive? ? "next" : "return out"
+                "#{base}\n#{cont}"
+              elsif mode == :each_indexed
+                if map_depth.positive?
+                  <<~RB.chomp
+                    if block
+                      block.call(nil, idx_vec.dup)
+                      next
+                    else
+                      out << [nil, idx_vec.dup]
+                      next
+                    end
+                  RB
+                else
+                  <<~RB.chomp
+                    if block
+                      block.call(nil, idx_vec.dup)
+                      return nil
+                    else
+                      out << [nil, idx_vec.dup]
+                      return out
+                    end
+                  RB
+                end
+              else # :materialize, :read
+                # Important: for :materialize this is ALWAYS nil (never [])
+                return_val = 'nil'
+                map_depth.positive? ? "next #{return_val}" : "return #{return_val}"
+              end
+            when :skip
+              if mode == :materialize
+                return_val = preview_array ? '[]' : 'nil'
+                map_depth.positive? ? "next #{return_val}" : "return #{return_val}"
+              else
+                map_depth.positive? ? "next" : (mode == :each_indexed ? "if block; return nil; else; return out; end" : "return out")
+              end
+            else # :error
+              %(raise KeyError, "Missing key '#{key}' at '#{path_key}' (#{mode})")
+            end
+          end
+
+          def build_array_miss_action(policy, mode, map_depth, path_key)
+            case policy
+            when :nil
+              if mode == :materialize
+                map_depth.positive? ? "next nil" : "return nil"
+              elsif mode == :each_indexed
+                if map_depth.positive?
+                  <<~RB.chomp
+                    if block
+                      block.call(nil, idx_vec.dup)
+                      next
+                    else
+                      out << [nil, idx_vec.dup]
+                      next
+                    end
+                  RB
+                else
+                  <<~RB.chomp
+                    if block
+                      block.call(nil, idx_vec.dup)
+                      return nil
+                    else
+                      out << [nil, idx_vec.dup]
+                      return out
+                    end
+                  RB
+                end
+              else # :ravel / others
+                base = "out << nil"
+                cont = map_depth.positive? ? "next" : "return out"
+                "#{base}\n#{cont}"
+              end
+            when :skip
+              if mode == :materialize
+                map_depth.positive? ? "next []" : "return []"
+              elsif mode == :each_indexed
+                map_depth.positive? ? "next" : "if block; return nil; else; return out; end"
+              else # :ravel
+                map_depth.positive? ? "next" : "return out"
+              end
+            else
+              %(raise TypeError, "Missing array at '#{path_key}' (#{mode})")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kumi/core/compiler/access_emit/each_indexed.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+module Kumi::Core::Compiler::AccessEmit
+  module EachIndexed
+    extend Base
+    module_function
+    def build(plan)
+      policy     = plan.on_missing || :error
+      key_policy = plan.key_policy || :indifferent
+      path_key   = plan.path
+      segs       = segment_ops(plan.operations)
+
+      code = +"lambda do |data, &block|\n"
+      code << "  out = []\n"
+      code << "  node0 = data\n"
+      code << "  idx_vec = []\n"
+      nodev, depth, loop_depth = "node0", 0, 0
+
+      segs.each do |seg|
+        if seg == :array
+          code << "  #{array_guard_code(node_var: nodev, mode: :each_indexed, policy: policy, path_key: path_key, map_depth: loop_depth)}\n"
+          code << "  ary#{loop_depth} = #{nodev}\n"
+          code << "  len#{loop_depth} = ary#{loop_depth}.length\n"
+          code << "  i#{loop_depth} = -1\n"
+          code << "  while (i#{loop_depth} += 1) < len#{loop_depth}\n"
+          code << "    idx_vec[#{loop_depth}] = i#{loop_depth}\n"
+          child = "node#{depth + 1}"
+          code << "    #{child} = ary#{loop_depth}[i#{loop_depth}]\n"
+          nodev = child; depth += 1; loop_depth += 1
+        else
+          seg.each do |(_, key, preview)|
+            code << fetch_hash_code(node_var: nodev, key: key, key_policy: key_policy,
+                                    preview_array: preview, mode: :each_indexed, policy: policy,
+                                    path_key: path_key, map_depth: loop_depth)
+            code << "\n"
+          end
+        end
+      end
+
+      code << "  if block\n"
+      code << "    block.call(#{nodev}, idx_vec.dup)\n"
+      code << "  else\n"
+      code << "    out << [#{nodev}, idx_vec.dup]\n"
+      code << "  end\n"
+
+      while loop_depth.positive?
+        code << "  end\n"
+        loop_depth -= 1
+        nodev = "node#{depth - 1}"
+        depth -= 1
+      end
+
+      code << "  block ? nil : out\nend\n"
+      code
+    end
+  end
+end