jade-lang 0.1.0

data/lib/jade/codegen/pattern/constructor.rb

@@ -0,0 +1,57 @@
+module Jade
+  module Codegen
+    module Pattern
+      module Constructor
+        extend self
+        extend Helpers
+
+        def generate(node, registry)
+          node => AST::Pattern::Constructor(symbol:, patterns:)
+          constructor = registry.lookup(symbol)
+          qualified = to_qualified(constructor.qualified_name)
+
+          if keyed_variant?(constructor)
+            generate_keyed(qualified, patterns.first, registry)
+          else
+            generate_positional(qualified, patterns, registry)
+          end
+        end
+
+        private
+
+        def keyed_variant?(constructor)
+          constructor.args in [Symbol::RecordType]
+        end
+
+        def generate_positional(qualified, patterns, registry)
+          patterns
+            .map { generate_node(it, registry) }
+            .join(', ')
+            .then { it.empty? ? it : "(#{it})" }
+            .then { "#{qualified}#{it}" }
+        end
+
+        # Keyed variants have a single inner pattern that conceptually matches
+        # the record-shaped payload. The runtime class itself carries the
+        # record's fields, so we project the pattern onto the variant directly:
+        # binding/wildcard captures the whole instance; record patterns
+        # destructure via Ruby's Data deconstruct_keys.
+        def generate_keyed(qualified, pattern, registry)
+          case pattern
+          in AST::Pattern::Binding(name:)
+            "#{qualified} => #{name}"
+
+          in AST::Pattern::Wildcard
+            qualified
+
+          in AST::Pattern::Record(fields:)
+            fields
+              .map { generate_node(it, registry) }
+              .join(', ')
+              .then { "#{qualified}(#{it})" }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/codegen/port_decoder.rb

@@ -0,0 +1,77 @@
+module Jade
+  module Codegen
+    module PortDecoder
+      extend self
+
+      PASS = "Jade::Decode::Decoder[Jade::Decode::Desc::Pass[]]"
+
+      # `dictionaries` is the call site's constraint-attachment list; only
+      # used when an arm is a Dict marker.
+      def task_call(interop_fn, registry, dictionaries = [])
+        [
+          interop_fn.interop_module_name,
+          ":#{interop_fn.name}",
+          decoder(interop_fn, :ok, registry, dictionaries),
+          decoder(interop_fn, :err, registry, dictionaries),
+        ]
+          .join(', ')
+          .then { "Jade::Runtime.task_call(#{it})" }
+      end
+
+      private
+
+      # Per-arm decoder. PortResolution stamps one of:
+      # - :pass — Decode.Value or Never arm, no decoder needed
+      # - Symbol::Implementation — concrete OR partial impl (with marker
+      #   deps for free vars). We push a synthetic dict_env mapping the
+      #   port's vars to the call-site dictionaries so generate_impl_dispatch
+      #   can resolve markers uniformly.
+      # - Symbol::InteropFunction::Dict — bare-var arm, decoder comes
+      #   from the caller's threaded dictionary at the given constraint index
+      def decoder(interop_fn, arm, registry, dictionaries)
+        case interop_fn.decoders.fetch(arm)
+        in Symbol::InteropFunction::PASS
+          PASS
+
+        in Symbol::Implementation => impl
+          emit_impl_decoder(impl, interop_fn, dictionaries, registry)
+
+        in Symbol::InteropFunction::Dict(constraint_index:)
+          "#{FunctionCall.dispatch_value(dictionaries.fetch(constraint_index), registry)}[\"decoder\"]"
+        end
+      end
+
+      def emit_impl_decoder(impl, interop_fn, dictionaries, registry)
+        synthetic_env = build_synthetic_dict_env(impl, interop_fn, dictionaries, registry)
+
+        Codegen.with_dict_env(synthetic_env) {
+          FunctionCall.generate_impl_dispatch(impl, registry).fetch('decoder')
+        }
+      end
+
+      # Maps [iface, port_var_id] → ruby expression for the call-site dict.
+      # For concrete impls (no markers) this is empty — generate_impl_dispatch
+      # never reads dict_env. For partial impls, each marker dep's Type::Var
+      # gets resolved to the dictionaries[i] corresponding to its name.
+      def build_synthetic_dict_env(impl, interop_fn, dictionaries, registry)
+        collect_marker_vars(impl).to_h do |iface, var|
+          idx = interop_fn.constraints.index { |i, n| i == iface && n == var.name }
+          [[iface, var.id], FunctionCall.dispatch_value(dictionaries.fetch(idx), registry)]
+        end
+      end
+
+      def collect_marker_vars(impl, acc = [])
+        impl.deps.each do |dep|
+          case dep
+          in Symbol::Implementation
+            collect_marker_vars(dep, acc)
+
+          in Type::Constraint(interface:, type: Type::Var => var)
+            acc << [interface, var]
+          end
+        end
+        acc.uniq { |iface, var| [iface, var.id] }
+      end
+    end
+  end
+end

data/lib/jade/codegen/pretty.rb

@@ -0,0 +1,53 @@
+module Jade
+  module Codegen
+    module Pretty
+      extend self
+
+      INDENT = "  "
+
+      def newline(count = 1)
+        "\n" * count
+      end
+
+      def indent(str, levels = 1)
+        str.gsub(/^(?!$)/, INDENT * levels)
+      end
+
+      def block(header, body, footer = "end")
+        body.empty? ? "#{header}\n#{footer}" : "#{header}\n#{indent(body)}\n#{footer}"
+      end
+
+      def lambda(params, body)
+        multiline?(body) ? block("->(#{params}) {", body, "}") : "->(#{params}) { #{body} }"
+      end
+
+      def hash(pairs)
+        pairs
+          .map { |k, v| "#{k.inspect} => #{v}" }
+          .join(', ')
+          .then { "{ #{it} }" }
+      end
+
+      def array(items)
+        "[#{items.join(', ')}]"
+      end
+
+      # `callee(a, b, c)` on one line when it fits, multi-line with trailing
+      # comma when it doesn't or when an arg is already multi-line. Pass
+      # `open:`/`close:` to emit `Struct[a, b, c]`-shaped construction.
+      def call(callee, args, width: 80, open: '(', close: ')')
+        "#{callee}#{open}#{args.join(', ')}#{close}".then do |oneline|
+          if oneline.length <= width && args.none? { multiline?(it) }
+            oneline
+          else
+            "#{callee}#{open}\n#{indent(args.join(",\n"))},\n#{close}"
+          end
+        end
+      end
+
+      def multiline?(str)
+        str.include?("\n")
+      end
+    end
+  end
+end

data/lib/jade/codegen/transforms/fold_shape.rb

@@ -0,0 +1,222 @@
+module Jade
+  module Codegen
+    module Transforms
+      module FoldShape
+        extend self
+        extend Helpers
+
+        ACC_NAME = '__fold_acc__'
+
+        # The right-fold shape:
+        #
+        #   def f(xs) ->
+        #     case xs
+        #       of []          -> BASE          (no self-call)
+        #       of [h | rest]  -> COMBINE       (exactly one f(rest), strict)
+        #
+        # Returns a shape hash, or nil if the body doesn't match.
+        def shape_for(body, self_sym, param_names, registry)
+          return nil unless param_names.size == 1
+
+          sig = [self_sym, 1]
+          expr = unwrap_body(body)
+          return nil unless expr.is_a?(AST::CaseOf)
+          return nil unless expr.branches.size == 2
+
+          list_arg = param_names.first
+          return nil unless subject_is_arg?(expr.expression, list_arg)
+
+          empty_branch = expr.branches.find { empty_list_pattern?(it.pattern) }
+          cons_branch = expr.branches.find { cons_pattern?(it.pattern) }
+          return nil unless empty_branch && cons_branch
+          return nil if SelfCall.contains_self_call?(
+            empty_branch.body, sig, registry
+          )
+
+          head_name = head_binding_name(cons_branch.pattern)
+          rest_name = rest_binding_name(cons_branch.pattern)
+          return nil unless head_name && rest_name
+
+          calls = strict_self_calls(cons_branch.body, sig, registry)
+          return nil unless calls&.size == 1
+
+          call = calls.first
+          return nil unless call.args.size == 1
+
+          arg = call.args.first
+          return nil unless arg in AST::VariableReference(name: ^rest_name)
+          return nil unless rest_used_only?(cons_branch.body, rest_name, call)
+
+          {
+            list_arg: list_arg,
+            base: empty_branch.body,
+            head_name: head_name,
+            combine: cons_branch.body,
+            self_call: call,
+          }
+        end
+
+        # Emits `xs.reverse.reduce(BASE) { |acc, head| COMBINE' }`. The
+        # `reverse` gives right-associative combine order regardless of the
+        # combiner's algebraic properties. Task effects are unaffected by
+        # build order — only the final Task chain shape determines run-time
+        # behavior.
+        def generate_body(shape, registry)
+          shape => { list_arg:, base:, head_name:, combine:, self_call: }
+
+          base_code = generate_node(base, registry)
+          combine_code = substitute(combine, self_call)
+            .then { generate_node(it, registry) }
+
+          "#{list_arg}.reverse.reduce(#{base_code}) " \
+            "{ |#{ACC_NAME}, #{head_name}| #{combine_code} }"
+        end
+
+        private
+
+        def unwrap_body(node)
+          case node
+          in AST::Body(expressions: [single]) then unwrap_body(single)
+          in AST::Grouping(expression:) then unwrap_body(expression)
+          else node
+          end
+        end
+
+        def subject_is_arg?(expression, arg_name)
+          expression in AST::VariableReference(name: ^arg_name)
+        end
+
+        def empty_list_pattern?(pattern)
+          pattern in AST::Pattern::List(patterns: [], rest: nil)
+        end
+
+        # Only binding/wildcard heads qualify. Literal or constructor heads
+        # (`[True | rest]`, `[1 | rest]`) make the source function partial
+        # over the head; folding it would silently widen it to total.
+        def cons_pattern?(pattern)
+          case pattern
+          in AST::Pattern::List(
+            patterns: [AST::Pattern::Binding | AST::Pattern::Wildcard],
+            rest: AST::Pattern::Binding
+          ) then true
+          else false
+          end
+        end
+
+        def rest_binding_name(pattern)
+          case pattern
+          in AST::Pattern::List(rest: AST::Pattern::Binding(name:)) then name
+          else nil
+          end
+        end
+
+        def head_binding_name(pattern)
+          case pattern
+          in AST::Pattern::List(patterns: [AST::Pattern::Binding(name:)])
+            name
+
+          in AST::Pattern::List(patterns: [AST::Pattern::Wildcard])
+            '_'
+
+          else
+            nil
+          end
+        end
+
+        # The emitted block binds only `head` and `acc` — not `rest`. Any
+        # reference to `rest` in COMBINE outside the chosen self-call's
+        # argument would emit unbound Ruby.
+        def rest_used_only?(node, rest_name, call)
+          return true if node.equal?(call)
+          return false if node in AST::VariableReference(name: ^rest_name)
+
+          SelfCall.child_values(node)
+            .all? { rest_check_value(it, rest_name, call) }
+        end
+
+        def rest_check_value(value, rest_name, call)
+          case value
+          when Array then value.all? { rest_check_value(it, rest_name, call) }
+          when AST::Node then rest_used_only?(value, rest_name, call)
+          else true
+          end
+        end
+
+        # Collects self-calls in strict (always-evaluated) positions. Returns
+        # nil when any self-call sits in a lazy position — a Lambda body,
+        # an If branch, or a Case branch body — because `reduce` walks every
+        # element unconditionally and can't skip or duplicate the recursive
+        # step the way the source might.
+        def strict_self_calls(node, sig, registry)
+          deep = ->(n) {
+            SelfCall.contains_self_call_anywhere?(n, sig, registry)
+          }
+
+          case node
+          in AST::FunctionCall if SelfCall.self_call?(node, sig, registry)
+            return nil if node.args.any? { deep.call(it) }
+            [node]
+
+          in AST::Lambda
+            deep.call(node) ? nil : []
+
+          in AST::IfThenElse(condition:, if_branch:, else_branch:)
+            return nil if deep.call(if_branch)
+            return nil if deep.call(else_branch)
+            strict_self_calls(condition, sig, registry)
+
+          in AST::CaseOf(expression:, branches:)
+            return nil if branches.any? { deep.call(it.body) }
+            strict_self_calls(expression, sig, registry)
+
+          else
+            SelfCall.child_values(node)
+              .map { collect_strict_value(it, sig, registry) }
+              .then { it.any?(&:nil?) ? nil : it.flatten(1) }
+          end
+        end
+
+        def collect_strict_value(value, sig, registry)
+          case value
+          when Array
+            value
+              .map { collect_strict_value(it, sig, registry) }
+              .then { it.any?(&:nil?) ? nil : it.flatten(1) }
+          when AST::Node
+            strict_self_calls(value, sig, registry)
+          else
+            []
+          end
+        end
+
+        # AST nodes are immutable Data; rebuilds the tree with `target`
+        # replaced by a fresh `__fold_acc__` reference.
+        def substitute(node, target)
+          return acc_var_ref if node.equal?(target)
+          return node unless node.is_a?(AST::Node)
+
+          node
+            .to_h
+            .transform_values { substitute_value(it, target) }
+            .then { node.class.new(**it) }
+        end
+
+        def substitute_value(value, target)
+          case value
+          when Array then value.map { substitute_value(it, target) }
+          when AST::Node then substitute(value, target)
+          else value
+          end
+        end
+
+        def acc_var_ref
+          AST::VariableReference.new(
+            name: ACC_NAME,
+            symbol: Symbol::Variable.new(name: ACC_NAME, decl_span: nil),
+            range: nil,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/jade/codegen/transforms/self_call.rb

@@ -0,0 +1,80 @@
+module Jade
+  module Codegen
+    module Transforms
+      # AST-walking primitives for recognizing self-recursive calls. A
+      # "self-call signature" is the pair `[self_sym, arity]`: a ValueRef
+      # carrying module_name + name, paired with the function's user-declared
+      # arity (partial applications never qualify).
+      module SelfCall
+        extend self
+
+        METADATA_KEYS = %i[
+          range symbol id
+          leading_comments trailing_comments dangling_comments
+          trailing_comma
+        ].freeze
+
+        # Defensive on `node` — anything that isn't a FunctionCall returns
+        # false, so callers don't need to type-check before calling.
+        def self_call?(node, sig, registry)
+          return false unless node.is_a?(AST::FunctionCall)
+
+          self_sym, arity = sig
+          resolved = resolve(node.callee.symbol, registry)
+
+          resolved.is_a?(Symbol::Function) &&
+            resolved.module_name == self_sym.module_name &&
+            resolved.name == self_sym.name &&
+            node.args.size == arity
+        end
+
+        # Scope-aware: stops at Lambda boundaries. A self-call inside a
+        # lambda body belongs to that lambda, not to the enclosing function.
+        def contains_self_call?(node, sig, registry)
+          return true if self_call?(node, sig, registry)
+          return false if node.is_a?(AST::Lambda)
+
+          child_descendants(node)
+            .any? { contains_self_call?(it, sig, registry) }
+        end
+
+        # Scope-blind: descends into Lambda bodies. For disqualifying any
+        # subtree that textually mentions a self-call at any depth.
+        def contains_self_call_anywhere?(node, sig, registry)
+          return true if self_call?(node, sig, registry)
+
+          child_descendants(node)
+            .any? { contains_self_call_anywhere?(it, sig, registry) }
+        end
+
+        def child_values(node)
+          node
+            .to_h
+            .reject { |k, _| METADATA_KEYS.include?(k) }
+            .values
+        end
+
+        private
+
+        def resolve(symbol, registry)
+          case symbol
+          in Symbol::ValueRef => ref then registry.lookup(ref)
+          in s then s
+          end
+        end
+
+        # Flat list of direct AST::Node descendants, dipping into array
+        # fields (e.g. FunctionCall#args) but skipping scalars.
+        def child_descendants(node)
+          child_values(node).flat_map do |v|
+            case v
+            when Array then v.grep(AST::Node)
+            when AST::Node then [v]
+            else []
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/codegen/transforms/tail_call.rb

@@ -0,0 +1,120 @@
+module Jade
+  module Codegen
+    module Transforms
+      module TailCall
+        extend self
+        extend Helpers
+
+        def tail_recursive?(body, self_sym, arity, registry)
+          classify(body, [self_sym, arity], registry) == :tail
+        end
+
+        def generate_body(body, registry, self_sym, param_names)
+          [self_sym, param_names.size]
+            .then { emit_tail(body, registry, it, param_names) }
+            .then { Pretty.block("loop do", it) }
+        end
+
+        private
+
+        def classify(node, sig, registry)
+          has_self = ->(n) { SelfCall.contains_self_call?(n, sig, registry) }
+
+          case node
+          in AST::FunctionCall if SelfCall.self_call?(node, sig, registry)
+            node.args.any? { has_self.call(it) } ? :non_tail : :tail
+
+          in AST::Body(expressions:)
+            *leading, last = expressions
+            if leading.any? { has_self.call(it) }
+              :non_tail
+            else
+              classify(last, sig, registry)
+            end
+
+          in AST::IfThenElse(condition:, if_branch:, else_branch:)
+            if has_self.call(condition)
+              :non_tail
+            else
+              combine(
+                classify(if_branch, sig, registry),
+                classify(else_branch, sig, registry),
+              )
+            end
+
+          in AST::CaseOf(expression:, branches:)
+            if has_self.call(expression)
+              :non_tail
+            else
+              branches
+                .map { classify(it.body, sig, registry) }
+                .reduce(:none) { |acc, c| combine(acc, c) }
+            end
+
+          in AST::Grouping(expression:)
+            classify(expression, sig, registry)
+
+          else
+            has_self.call(node) ? :non_tail : :none
+          end
+        end
+
+        def combine(a, b)
+          return :non_tail if a == :non_tail || b == :non_tail
+          return :tail if a == :tail || b == :tail
+          :none
+        end
+
+        def emit_tail(node, registry, sig, params)
+          case node
+          in AST::FunctionCall if SelfCall.self_call?(node, sig, registry)
+            node.args
+              .map { generate_node(it, registry) }
+              .join(', ')
+              .then { "#{params.join(', ')} = #{it}" }
+
+          in AST::Body(expressions:)
+            *leading, last = expressions
+            [
+              *leading.map { generate_node(it, registry) },
+              emit_tail(last, registry, sig, params),
+            ].join("\n")
+
+          in AST::IfThenElse(condition:, if_branch:, else_branch:)
+            [
+              "if (#{generate_node(condition, registry)})",
+              Pretty.indent(emit_tail(if_branch, registry, sig, params)),
+              "else",
+              Pretty.indent(emit_tail(else_branch, registry, sig, params)),
+              "end",
+            ].join("\n")
+
+          in AST::CaseOf(expression:, branches:)
+            subject = generate_node(expression, registry)
+            branches
+              .map { emit_tail_branch(it, registry, sig, params) }
+              .join("\n")
+              .then { "case #{subject}\n#{it}\nend" }
+
+          in AST::Grouping(expression:)
+            emit_tail(expression, registry, sig, params)
+
+          else
+            "break #{generate_node(node, registry)}"
+          end
+        end
+
+        def emit_tail_branch(branch, registry, sig, params)
+          pat = generate_node(branch.pattern, registry)
+          body = emit_tail(branch.body, registry, sig, params)
+
+          if Pretty.multiline?(body)
+            "in #{pat} then\n#{Pretty.indent(body)}"
+          else
+            "in #{pat} then #{body}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/codegen/variant_declaration.rb

@@ -0,0 +1,41 @@
+module Jade
+  module Codegen
+    module VariantDeclaration
+      extend self
+      extend Helpers
+
+      def generate(node, sibling_names)
+        node => AST::VariantDeclaration(name:, args:, symbol:)
+
+        impls = symbol.qualified_name
+          .then { "::#{to_qualified(it)}" }
+          .then { Codegen.dispatched_methods[it] || [] }
+
+        sibling_names
+          .map { |s| "def #{predicate_name(s)}; #{s == name}; end" }
+          .then { [it.join(Pretty.newline), *impls] }
+          .reject(&:empty?)
+          .join(Pretty.newline(2))
+          .then { Pretty.block("#{name} = #{data_define(fields_for(args))} do", it) }
+      end
+
+      private
+
+      def fields_for(args)
+        case args
+        in [AST::TypeRecord(fields:)]
+          fields.keys
+        else
+          args.map.with_index { |_, i| "_#{i + 1}" }
+        end
+      end
+
+      def predicate_name(variant_name)
+        variant_name
+          .gsub(/([a-z])([A-Z])/, '\1_\2')
+          .downcase
+          .then { "#{it}?" }
+      end
+    end
+  end
+end