jade-lang 0.1.0

data/lib/jade/codegen/boundary/specialized/scalar.rb

@@ -0,0 +1,67 @@
+module Jade
+  module Codegen
+    module Boundary
+      module Specialized
+        # Int / Float / Bool / String. The runtime validators in
+        # `Jade::Interop::Boundary` do the check + conversion (e.g.
+        # `String#dup`, `Float#to_f`) in one call.
+        module Scalar
+          extend self
+
+          HELPER = {
+            'Basics.Int'    => 'integer',
+            'Basics.Float'  => 'float',
+            'Basics.Bool'   => 'bool',
+            'String.String' => 'string',
+          }.freeze
+
+          LABEL = {
+            'Basics.Int'    => 'Int',
+            'Basics.Float'  => 'Float',
+            'Basics.Bool'   => 'Bool',
+            'String.String' => 'String',
+          }.freeze
+
+          # Ruby class used by `List.decode` to validate a list of scalars
+          # in a single `Array#all?` C-loop.
+          LIST_ELEM_CLASS = {
+            'Basics.Int'    => '::Integer',
+            'Basics.Float'  => '::Numeric',
+            'Basics.Bool'   => '::TrueClass',
+            'String.String' => '::String',
+          }.freeze
+
+          def decode(type, input)
+            qname = qname_for(type) or return nil
+            label = LABEL[qname].inspect
+            "Jade::Interop::Boundary.#{HELPER[qname]}(#{label}, #{input})"
+          end
+
+          # Scalar encoders are identity (Ruby int IS the JSON int, etc.),
+          # so `encode` returns nil — callers handle that via
+          # `Specialized.identity_encoder?`.
+          def encode(_type, _value_expr, _registry)
+            nil
+          end
+
+          def identity_encoder?(type)
+            qname_for(type) ? true : false
+          end
+
+          def specializable?(type, _registry, _seen)
+            identity_encoder?(type)
+          end
+
+          # The scalar's qname (e.g. `"Basics.Int"`) if `type` is a 0-arg
+          # application of a known scalar constructor, else nil. Used by
+          # `List.decode` to pick `LIST_ELEM_CLASS` for the all? check.
+          def qname_for(type)
+            return nil unless Specialized.args_of(type) == []
+
+            Specialized.qname_of(type).then { HELPER.key?(it) ? it : nil }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/codegen/boundary/specialized.rb

@@ -0,0 +1,106 @@
+require 'jade/codegen/boundary/specialized/scalar'
+require 'jade/codegen/boundary/specialized/list'
+require 'jade/codegen/boundary/specialized/maybe'
+require 'jade/codegen/boundary/specialized/record'
+
+module Jade
+  module Codegen
+    module Boundary
+      # Emits inline boundary code for known-shape types — scalars,
+      # `List(specializable)`, `Maybe(specializable)`, and structs whose
+      # fields are all specializable. Bypasses `Decode::Runner` and the
+      # descriptor cache.
+      #
+      # This module is the dispatcher: each shape (`Scalar`, `List`,
+      # `Maybe`, `Record`) lives in its own file under `specialized/`,
+      # exposing `decode` / `encode` / `specializable?` methods that the
+      # dispatcher tries in order. Shapes that contain other types
+      # (`List`, `Maybe`, `Record`) recurse back through the dispatcher.
+      module Specialized
+        extend self
+
+        # Ruby expression that validates `input` and yields the decoded
+        # value, or `nil` if `type` isn't specializable.
+        def decode_expr(type, input, registry)
+          Scalar.decode(type, input) ||
+            List.decode(type, input, registry) ||
+            Maybe.decode(type, input, registry) ||
+            Record.decode(type, input, registry)
+        end
+
+        # Ruby expression that encodes `value_expr` to the wire form, or
+        # `nil` if the encoder is identity (caller skips the wrap) or the
+        # type isn't specializable (caller falls back to the cache).
+        def encode_expr(type, value_expr, registry)
+          Record.encode(type, value_expr, registry) ||
+            List.encode(type, value_expr, registry) ||
+            Maybe.encode(type, value_expr, registry)
+        end
+
+        # True when the encoder for `type` produces output equal to the
+        # input — the boundary wrapper can skip the encode call entirely.
+        # Recursive: `List(t)` is identity iff `t` is.
+        def identity_encoder?(type)
+          Scalar.identity_encoder?(type) || List.identity_encoder?(type)
+        end
+
+        # Predicate used by `Record.specializable_struct` when checking
+        # field types. The `seen` set carries struct qnames we're already
+        # inside, threaded through container shapes for cycle detection.
+        def specializable_field?(type, registry, seen)
+          Scalar.specializable?(type, registry, seen) ||
+            List.specializable?(type, registry, seen) ||
+            Maybe.specializable?(type, registry, seen) ||
+            Record.specializable?(type, registry, seen)
+        end
+
+        def collect_helpers(body, registry)
+          Record.collect_helpers(body, registry)
+        end
+
+        def emit_helpers(structs, registry)
+          Record.emit_helpers(structs, registry)
+        end
+
+        # --- type-shape helpers shared across shape modules ---
+
+        # Both `Type::Application` (from inferred boundary types) and
+        # `Symbol::TypeApplication` (from struct field declarations) carry
+        # the same constructor/args shape; normalize to a qname string.
+        def qname_of(type)
+          case type
+          in Type::Application(constructor: Type::Constructor(name:))
+            name
+
+          in Symbol::TypeApplication(constructor: Symbol::TypeRef(module_name:, name: n))
+            "#{module_name}.#{n}"
+
+          else
+            nil
+          end
+        end
+
+        def args_of(type)
+          case type
+          in Type::Application(args:)         then args
+          in Symbol::TypeApplication(args:)   then args
+          else                                     nil
+          end
+        end
+
+        # Human-readable label for error messages on container types.
+        def type_label(type)
+          if (qname = Scalar.qname_for(type))
+            Scalar::LABEL[qname]
+          elsif (inner = List.inner_of(type))
+            "List(#{type_label(inner)})"
+          elsif (inner = Maybe.inner_of(type))
+            "Maybe(#{type_label(inner)})"
+          else
+            (qname_of(type) || 'value').split('.').last
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/codegen/boundary.rb

@@ -0,0 +1,189 @@
+require 'jade/frontend/type_checking/constraints'
+
+module Jade
+  module Codegen
+    module Boundary
+      extend self
+      extend Helpers
+
+      DECODABLE = 'Decode.Decodable'
+      ENCODABLE = 'Encode.Encodable'
+
+      VALUE_PASSTHROUGH_DECODER = 'Jade::Decode::Decoder[Jade::Decode::Desc::Pass[]]'
+      VALUE_IDENTITY_ENCODER    = '->(v) { v }'
+      NEVER_ENCODER             = '->(_) { fail "Never arm produced a value" }'
+
+      def decoder_for(type, registry)
+        case type
+        in Type::Application(constructor: Type::Constructor(name:), args:)
+          decode_app(name, args, registry)
+
+        else
+          nil
+        end
+      end
+
+      def encoder_for(type, registry)
+        case type
+        in Type::Application(constructor: Type::Constructor(name:), args:)
+          encode_app(name, args, registry)
+
+        else
+          nil
+        end
+      end
+
+      def eligible?(fn_type, registry)
+        args, return_type = Type.signature(fn_type)
+        args.all? { decoder_for(it, registry) } &&
+          return_eligible?(return_type, registry)
+      end
+
+      # Task in return position needs both arms encodable — the wrapper
+      # discriminates the outcome rather than producing an encoded Task.
+      # Everything else checks the type's own encoder directly.
+      def return_eligible?(type, registry)
+        case type
+        in Type::Application(constructor: Type::Constructor(name: 'Task.Task'), args: [ok_t, err_t])
+          !encoder_for(ok_t, registry).nil? && !encoder_for(err_t, registry).nil?
+
+        else
+          !encoder_for(type, registry).nil?
+        end
+      end
+
+      def task_arms(task_type, registry)
+        task_type => Type::Application(
+          constructor: Type::Constructor(name: 'Task.Task'),
+          args: [ok_t, err_t],
+        )
+        ok_enc  = encoder_for(ok_t, registry)
+        err_enc = encoder_for(err_t, registry)
+        [ok_enc, err_enc] if ok_enc && err_enc
+      end
+
+      private
+
+      def decode_app(name, args, registry)
+        case [name, args]
+        in ['Basics.Int', []]    then intr_call('Decode.int')
+        in ['Basics.Float', []]  then intr_call('Decode.float')
+        in ['Basics.Bool', []]   then intr_call('Decode.bool')
+        in ['String.String', []] then intr_call('Decode.string')
+        in ['Decode.Value', []]  then VALUE_PASSTHROUGH_DECODER
+
+        in ['List.List', [inner]]
+          decoder_for(inner, registry)
+            &.then { "#{intr('Decode.list')}.call(#{it})" }
+
+        in ['Maybe.Maybe', [inner]]
+          decoder_for(inner, registry)
+            &.then { "#{intr('Decode.nullable')}.call(#{it})" }
+
+        in ['Dict.Dict', [k_t, v_t]]
+          k_dec = decoder_for(k_t, registry)
+          v_dec = decoder_for(v_t, registry)
+          "#{intr('Decode.dict')}.curry[#{k_dec}][#{v_dec}]" if k_dec && v_dec
+
+        else
+          decoder_dispatch(name, args, registry)
+        end
+      end
+
+      def encode_app(name, args, registry)
+        case [name, args]
+        in ['Basics.Int', []]    then intr('Encode.int')
+        in ['Basics.Float', []]  then intr('Encode.float')
+        in ['Basics.Bool', []]   then intr('Encode.bool')
+        in ['String.String', []] then intr('Encode.string')
+        in ['Decode.Value', []]  then VALUE_IDENTITY_ENCODER
+
+        # Never is uninhabited — the encoder can never be called. Treat as
+        # eligible so Task(a, Never) boundaries work; raise loudly if the
+        # impossible happens.
+        in ['Basics.Never', []]  then NEVER_ENCODER
+
+        in ['List.List', [inner]]
+          encoder_for(inner, registry)
+            &.then { "#{intr('Encode.list')}.curry[#{it}]" }
+
+        in ['Maybe.Maybe', [inner]]
+          encoder_for(inner, registry)
+            &.then { "#{intr('Encode.nullable')}.curry[#{it}]" }
+
+        in ['Dict.Dict', [k_t, v_t]]
+          k_enc = encoder_for(k_t, registry)
+          v_enc = encoder_for(v_t, registry)
+          "#{intr('Encode.dict')}.curry[#{k_enc}][#{v_enc}]" if k_enc && v_enc
+
+        # Task isn't a value-encodable type. `return_eligible?` and
+        # `task_arms` handle Task in return position; here we just say
+        # "no encoder" so other places that ask for an encoder on a Task
+        # value get an honest nil.
+        in ['Task.Task', _]
+          nil
+
+        else
+          encoder_dispatch(name, args, registry)
+        end
+      end
+
+      def intr(qname)
+        "Jade::Runtime.intr(#{qname.inspect})"
+      end
+
+      def intr_call(qname)
+        "#{intr(qname)}.call"
+      end
+
+      # impl_fn_ref returns a Method ref; callers `.call(...)` it. For
+      # 0-arg decoder methods that means `decoder.call()` → the Decoder
+      # value. For 1-arg encoder methods that's `encoder.call(value)`.
+      def decoder_dispatch(name, args, registry)
+        if ref = impl_fn_ref(DECODABLE, name, 'decoder', registry)
+          "#{ref}.call"
+        else
+          derived_dispatch(DECODABLE, name, args, registry)&.dig('decoder')
+        end
+      end
+
+      def encoder_dispatch(name, args, registry)
+        impl_fn_ref(ENCODABLE, name, 'encoder', registry) ||
+          derived_dispatch(ENCODABLE, name, args, registry)&.dig('encoder')
+      end
+
+      def derived_dispatch(interface_qname, type_qname, args, registry)
+        type       = Type.constructor(type_qname).apply(args)
+        constraint = Type.constraint(interface_qname, type, nil)
+
+        case Frontend::TypeChecking::Constraints.resolve(constraint, registry, nil)
+        in Ok[impl] then Codegen::FunctionCall.generate_impl_dispatch(impl, registry)
+        in Err      then nil
+        end
+      rescue NoMethodError, NoMatchingPatternError
+        # Deriver assumes derivability (type-check-time invariant); boundary
+        # synthesis may probe types whose deps fail — treat as ineligible.
+        nil
+      end
+
+      def impl_fn_ref(interface_qname, type_qname, fn_name, registry)
+        impl = registry.implementations[[interface_qname, type_qname]]
+        return nil unless impl
+        return nil unless impl.functions[fn_name].is_a?(Symbol::ValueRef)
+
+        fn_sym = registry.lookup(impl.functions[fn_name])
+
+        case fn_sym
+        in Symbol::Function
+          "#{to_qualified(fn_sym.module_name)}::Internal.method(:#{fn_sym.name})"
+
+        in Symbol::StdlibFunction(codegen:) if codegen.is_a?(String)
+          codegen
+
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/jade/codegen/constructor_reference.rb

@@ -0,0 +1,18 @@
+module Jade
+  module Codegen
+    module ConstructorReference
+      extend self
+      extend Helpers
+
+      def generate(node, registry)
+        node => AST::ConstructorReference(symbol:)
+        from_symbol(registry.lookup(symbol))
+      end
+
+      def from_symbol(symbol)
+        qualified = to_qualified(symbol.qualified_name)
+        symbol.args.empty? ? "#{qualified}[]" : "#{qualified}.method(:[])"
+      end
+    end
+  end
+end

data/lib/jade/codegen/context.rb

@@ -0,0 +1,96 @@
+module Jade
+  module Codegen
+    # Dynamically-scoped emission state. Each `with_X` wraps a block so the
+    # state is visible to the recursive `generate` call tree, then restored
+    # on exit. Stored on the Codegen singleton because threading these as
+    # parameters through every AST branch would pollute the API.
+    module Context
+      extend self
+
+      # Maps [interface_qname, type_var_id] => ruby parameter name. Set by
+      # FunctionDeclaration around its body so nested calls can resolve the
+      # caller's dict for var-typed constraints. Empty outside any function.
+      def dict_env
+        @dict_env ||= {}
+      end
+
+      def with_dict_env(env)
+        prev = @dict_env
+        @dict_env = env
+        yield
+      ensure
+        @dict_env = prev
+      end
+
+      # When set, references with this name emit as `self` (and field accesses
+      # on them as bare method calls). Used to rewrite operator-impl lambda
+      # bodies — `(a, b) -> { a.amount == b.amount }` becomes
+      # `def ==(b); amount == b.amount; end`, no `a = self` shim.
+      #
+      # Name-based, not symbol-identity-based, because Pattern::Binding doesn't
+      # carry the resolved Symbol::Variable.
+      def self_var_name
+        @self_var_name
+      end
+
+      def with_self_var_name(name)
+        prev = @self_var_name
+        @self_var_name = name
+        yield
+      ensure
+        @self_var_name = prev
+      end
+
+      # False outside a Module so bare expressions (REPL) get the runtime
+      # fallback — no constants exist to reference.
+      def hoist_records?
+        @hoist_records
+      end
+
+      def with_hoisted_records
+        prev = @hoist_records
+        @hoist_records = true
+        yield
+      ensure
+        @hoist_records = prev
+      end
+
+      # Methods (def strings) to inline into each type's `Data.define do ... end`
+      # block. Populated once at the start of module emission by walking impls
+      # of dispatched interfaces; consumed by StructDeclaration /
+      # VariantDeclaration. Indexed by the fully-qualified Ruby class string
+      # (e.g. `"::Sample::Money"`).
+      def dispatched_methods
+        @dispatched_methods || {}
+      end
+
+      def with_dispatched_methods(map)
+        prev = @dispatched_methods
+        @dispatched_methods = map
+        yield
+      ensure
+        @dispatched_methods = prev
+      end
+
+      # Maps boundary decoder/encoder expression strings to module-level
+      # const names that hold the same value, precomputed once at module
+      # load. Populated by `Boundary.collect_cache` at the start of module
+      # emission; consumed by `Boundary.cached_decoder_for` /
+      # `cached_encoder_for` from wrapper codegen.
+      #
+      # Shape: `{ decoders: { spec => const }, encoders: { spec => const } }`.
+      # Empty outside a Module — `cached_*` falls through to the raw spec.
+      def boundary_cache
+        @boundary_cache || { decoders: {}, encoders: {} }
+      end
+
+      def with_boundary_cache(cache)
+        prev = @boundary_cache
+        @boundary_cache = cache
+        yield
+      ensure
+        @boundary_cache = prev
+      end
+    end
+  end
+end

data/lib/jade/codegen/emitter.rb

@@ -0,0 +1,81 @@
+require 'jade/codegen/helpers'
+
+module Jade
+  module Codegen
+    module Emitter
+      extend self
+      extend Helpers
+
+      def emit(ir)
+        case ir
+        in [:var, expr]
+          expr
+
+        in [:!, expr]
+          "!(#{emit(expr)})"
+
+        in [:and, expr1, expr2]
+          "#{emit(expr1)} && #{emit(expr2)}"
+
+        in Integer | TrueClass | FalseClass | Float
+          ir.to_s
+
+        in String
+          ir.inspect
+
+        in [:case, subject, branches]
+          branches
+            .map { [:case_branch, *it] }
+            .map { emit(it) }
+            .join("\n")
+            .then { "case #{emit(subject)}\n#{it}\nend" }
+
+        in [:case_branch, pattern, body]
+          body
+            .map { emit(it) }.join('; ')
+            .then { "in #{emit(pattern)} then #{it}" }
+
+        in [:call, callee, args]
+          args
+            .map { emit(it) }
+            .join(', ')
+            .then { "#{emit(callee)}.call(#{it})"}
+
+        in [:impl_arg, index, fn]
+          "impl_arg[#{index}]['#{fn}']"
+
+        in [:stdlib_fn, name]
+          "Jade::Runtime.intr(#{name.inspect})"
+
+        in [:struct_constructor, qualified_name, arity]
+          "#{to_qualified(qualified_name)}.method(:[]).curry(#{arity})"
+
+        in [:anon_record_constructor, keys]
+          "#{data_define(keys)}.method(:[]).curry(#{keys.size})"
+
+        in [:list, exprs]
+          exprs
+            .map { emit(it) }
+            .join(', ')
+            .then { "[#{it}]" }
+
+        in [:access, expr, key]
+          "#{emit(expr)}.#{key}"
+
+        # patterns
+
+        in [:constructor, name, args]
+          args
+            .map { "#{it}" }
+            .join(',')
+            .then { "#{to_qualified(name)}(#{it})" }
+
+        in [:_]
+          '_'
+
+        end
+      end
+
+    end
+  end
+end