jade-lang 0.1.0

data/lib/jade/frontend/type_checking/inference/case_of.rb

@@ -0,0 +1,102 @@
+require 'jade/frontend/pattern_analysis'
+
+module Jade
+  module Frontend
+    module TypeChecking
+      module Inference
+        module CaseOf
+          extend Helpers
+          extend self
+
+          def infer(node, registry, state, expected)
+            node => AST::CaseOf(expression:, branches:)
+
+            new_state, expr_result = check(
+              expression,
+              registry,
+              state,
+              Expected.infer(state.fresh),
+            )
+
+            first_branch, *rest_branches = branches
+            after_first_state, first_result = infer_branch(
+              first_branch,
+              registry,
+              new_state,
+              expected,
+              expr_result,
+            )
+
+            seed = [
+              after_first_state,
+              expr_result.constraints + first_result.constraints
+            ]
+
+            rest_branches
+              .each_with_index
+              .reduce(seed) do |(acc, cs), (branch, i)|
+                unify_branch(
+                  branch,
+                  i,
+                  acc,
+                  first_result,
+                  cs,
+                  registry,
+                  expected,
+                  expr_result,
+                )
+              end
+              .then { |st, cs| [check_exhaustiveness(node, st, registry, expr_result), cs] }
+              .then do |st, cs|
+                first_result
+                  .with(constraints: cs)
+                  .apply(st.env.substitution)
+                  .then { |result| [st, result] }
+              end
+          end
+
+          private
+
+          def unify_branch(branch, i, state, first_result, cs, registry, expected, expr_result)
+            new_state, body = infer_branch(branch, registry, state, expected, expr_result)
+
+            new_state
+              .unify(body.type, first_result.type) { branch_mismatch(new_state, branch, it, i) }
+              .then { [it, cs + body.constraints] }
+          end
+
+          def branch_mismatch(state, branch, error, index)
+            Error::CaseOfBranchesTypeMismatch.new(
+              state.env.entry_name,
+              branch.range,
+              actual: error.actual,
+              expected: error.expected,
+              actual_index: index + 2,
+            )
+          end
+
+          def check_exhaustiveness(node, state, registry, result)
+            node => AST::CaseOf(branches:)
+
+            patterns = branches.map(&:pattern)
+            type     = result.apply(state.env.substitution).type
+
+            PatternAnalysis::Exhaustiveness
+              .assert(patterns, node.range, state.env, registry, type)
+              .then { state.add_errors(it) }
+          end
+
+          def infer_branch(node, registry, env, expected, expression_result)
+            node => AST::CaseOfBranch(pattern:, body:)
+
+            pattern_state, _pattern_result = Pattern.infer(
+              pattern, registry, env, Expected.infer(expression_result.type)
+            )
+
+            check(body, registry, pattern_state, expected)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/type_checking/inference/constructor_reference.rb

@@ -0,0 +1,21 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Inference
+        module ConstructorReference
+          extend Helpers
+          extend self
+
+          def infer(node, registry, state, expected)
+            node => AST::ConstructorReference(symbol:)
+
+            state
+              .env
+              .lookup(symbol.qualified_name)
+              .then { state.unify_result(it, expected.type) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/type_checking/inference/function_call.rb

@@ -0,0 +1,132 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Inference
+        module FunctionCall
+          extend Helpers
+          extend self
+
+          def infer(node, registry, state, expected)
+            node => AST::FunctionCall(callee:, args:)
+
+            callee_state, callee_result = check(
+              callee,
+              registry,
+              state,
+              Expected.infer(state.fresh),
+            )
+              .then { |st, rs| [st, rs.attach_origin(node)] }
+
+            args_state, args_acc = args
+              .reduce([callee_state, Result.accumulator]) do |(state_acc, acc), arg|
+                check(
+                  arg,
+                  registry,
+                  state_acc,
+                  Expected.infer(state_acc.fresh),
+                )
+                .then { |(new_state, result)| [new_state, acc.add(result)] }
+              end
+
+            after_callee_state, result_type = unify_callee(
+              args_state,
+              callee_result,
+              args_acc,
+              node,
+              state,
+            )
+
+            after_callee_state.unify_result(
+              callee_result.map { result_type },
+              expected.type,
+              &type_error(state, node)
+            )
+            .then do |st, rs|
+              # When expected is authoritative and this unification failed,
+              # adopt expected.type so the enclosing body-level unify doesn't
+              # re-report the same mismatch.
+              adopted = expected.check? && st.errors.size > after_callee_state.errors.size
+              base_rs = adopted ? rs.with(type: expected.type) : rs
+
+              callee_subst = base_rs
+                .constraints
+                .map { st.env.substitution.apply(it) }
+
+              args_subst = args_acc
+                .constraints
+                .map { st.env.substitution.apply(it) }
+
+              propagated = (callee_subst + args_subst)
+                .select { it.type.is_a?(Type::Var) }
+
+              # Pass 1 still needs propagation so constraints from inner calls
+              # bubble up through outer constructor calls and reach the function
+              # binding before generalization. Skip only the mutating dictionary
+              # attachment, which would otherwise emit double dispatch code.
+              next [st, base_rs.with(constraints: propagated)] if st.skip_constraints
+
+              # Attach a resolution per callee constraint, in callee order, so codegen
+              # can pass dicts positionally. Concrete constraints attach a resolved
+              # Implementation; var-typed ones attach themselves as a marker meaning
+              # "use the enclosing function's local dict".
+              callee_errors = callee_subst
+                .flat_map do |c|
+                  case c.type
+                  in Type::Var
+                    Constraints.attach_dictionary(c, c)
+                    []
+                  else
+                    Constraints.solve_at_call_site(c, registry, st.env.entry_name)
+                  end
+                end
+
+              # Args' constraints dispatch at their own origins (inner call sites,
+              # or a QualifiedAccess/VariableReference when a polymorphic fn is
+              # passed as a value). Var-typed ones attach themselves as a marker,
+              # mirroring the callee path, so reference-as-value codegen can
+              # resolve via the enclosing function's dict_env.
+              args_errors = args_subst
+                .flat_map do |c|
+                  case c.type
+                  in Type::Var
+                    Constraints.attach_dictionary(c, c)
+                    []
+                  else
+                    Constraints.solve_at_call_site(c, registry, st.env.entry_name)
+                  end
+                end
+
+              st
+                .add_errors(callee_errors + args_errors)
+                .then { [it, base_rs.with(constraints: propagated)] }
+            end
+          end
+
+          private
+
+          def unify_callee(state, callee_result, args_acc, node, outer)
+            return_type = state.fresh
+            fn_type = Type.function(args_acc.types, return_type)
+
+            state
+              .unify_result(Result.init(fn_type), callee_result.type, &type_error(outer, node))
+              .first
+              .then { [it, return_type] }
+          end
+
+          def type_error(state, node)
+            ->(e) do
+              Error::FunctionCallTypeMismatch.new(
+                state.env.entry_name,
+                node.range,
+                expected: e.expected,
+                actual: e.actual,
+                infix: node.infix,
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/type_checking/inference/function_declaration.rb

@@ -0,0 +1,70 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Inference
+        module FunctionDeclaration
+          extend Helpers
+          extend self
+
+          def infer(node, registry, state, _)
+            node => AST::FunctionDeclaration(symbol:, body:, params:)
+
+            # Use the binding directly instead of env.lookup, which would
+            # instantiate fresh vars and detach body call sites' dict markers
+            # from the binding's stored constraints.
+            state
+              .env
+              .bindings[symbol.qualified_name] => {
+                type: fn_type, constraints: fn_constraints,
+              }
+
+            arg_types, return_type = Type.signature(fn_type)
+
+            new_state, body_result = arg_types
+              .zip(params)
+              .reduce(state) do |acc, (t, p)|
+                acc.bind(p.name, Scheme.mono(t))
+              end
+              .then { check(body, registry, it, Expected.check(return_type)) }
+
+            new_state
+              .unify(
+                body_result.type,
+                return_type,
+                fn_type.unbound_vars
+              ) do
+                Error::FunctionBodyTypeMismatch.new(
+                  state.env.entry_name,
+                  node.range,
+                  expected: it.expected,
+                  actual: it.actual,
+                  function_name: node.name,
+                )
+              end
+              .then do |st|
+                next st if st.env.bindings[symbol.qualified_name].is_a?(Scheme)
+
+                updated_constraints = (fn_constraints + body_result.constraints)
+                  .map { st.env.substitution.apply(it) }
+                  .uniq
+
+                # TODO: for impl function declarations, unresolved constraints here
+                # (e.g. Eq(a) when the body calls == on a field of type a) should
+                # be stored as impl-level constraints, not function-level ones.
+                # The impl finalization pass (see TypeChecking.finalize) should then
+                # promote them into deps when the impl is instantiated for a concrete type.
+                st.bind(
+                  symbol.qualified_name,
+                  Placeholder[
+                    st.env.substitution.apply(fn_type),
+                    updated_constraints,
+                  ]
+                )
+              end
+              .then { [it, Result.init(Type.unit)] }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/type_checking/inference/grouping.rb

@@ -0,0 +1,18 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Inference
+        module Grouping
+          extend Helpers
+          extend self
+
+          def infer(node, registry, env, expected_type)
+            node => AST::Grouping(expression:)
+
+            check(expression, registry, env, expected_type)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/type_checking/inference/helpers.rb

@@ -0,0 +1,34 @@
+require 'jade/frontend/type_checking/generalization'
+require 'jade/frontend/type_checking/instantiation'
+
+module Jade
+  module Frontend
+    module TypeChecking
+      module Inference
+        module Helpers
+          extend self
+
+          def unify(actual, expected)
+            Unification.unify(actual, expected)
+          end
+
+          def instantiate(scheme, var_gen)
+            Instantiation.instantiate(scheme, var_gen)
+          end
+
+          def generalize(env, type, constraints = [])
+            Generalization.generalize(env, type, constraints)
+          end
+
+          def check(node, registry, env, expected_type)
+            TypeChecking.check_node(node, registry, env, expected_type)
+          end
+
+          def type_from_symbol(symbol, registry, var_gen)
+            Type.from_symbol(symbol, registry, var_gen)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/type_checking/inference/if_then_else.rb

@@ -0,0 +1,46 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Inference
+        module IfThenElse
+          extend Helpers
+          extend self
+
+          def infer(node, registry, state, expected)
+            node => AST::IfThenElse(condition:, if_branch:, else_branch:)
+
+            cond_state, cond_result = check(condition, registry, state, Expected.check(Type.bool))
+            after_cond_state, _ = cond_state.unify_result(cond_result, Type.bool) do
+              Error::IfConditionTypeMismatch.new(
+                state.env.entry_name,
+                condition.range,
+                actual: it.actual,
+              )
+            end
+
+            if_state, if_result = check(if_branch, registry, after_cond_state, expected)
+            else_state, else_result = check(else_branch, registry, if_state, expected)
+
+            constraints = cond_result.constraints +
+              if_result.constraints +
+              else_result.constraints
+
+            else_state
+              .unify_result(
+                else_result.with(constraints:),
+                if_result.type,
+                expected.rigid_vars
+              ) do
+                Error::IfBranchesTypeMismatch.new(
+                  state.env.entry_name,
+                  else_branch.range,
+                  expected: it.expected,
+                  actual: it.actual,
+                )
+              end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/type_checking/inference/implementation.rb

@@ -0,0 +1,150 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Inference
+        module Implementation
+          extend Helpers
+          extend self
+
+          def infer(node, registry, state, _expected)
+            node => AST::Implementation(functions:)
+
+            impl = node.symbol
+
+            interface_sym   = registry.lookup(impl.interface)
+            interface_qname = impl.interface.qualified_name
+
+            # Build the concrete type for the constructor, respecting its type params
+            concrete_type, = type_from_symbol(impl.type, registry, state.env.var_gen)
+
+            functions
+              .reduce(state) do |st, impl_fn|
+                impl_fn => AST::ImplementationFunction(name:)
+
+                iface_fn = interface_sym
+                  .functions
+                  .find { |f| f.name == name }
+
+                # Instantiate the interface function with fresh vars
+                iface_fn_type, iface_fn_constraints =
+                  type_from_symbol(iface_fn, registry, st.env.var_gen)
+
+                # The type var standing for the interface's type param
+                t_var = iface_fn_constraints
+                  .find { |c| c.interface == interface_qname }
+                  .type
+
+                # When the interface uses t_var as a constructor (e.g. f(a) -> f(b)),
+                # bind it to a partial application so that f(a) beta-reduces correctly.
+                # For 1-param types (Maybe): tail = [] → constructor
+                # For 2-param types (Result): tail = [e] → PartialApplication[Constructor, [e]]
+                binding_type =
+                  case [constructor_var_in?(iface_fn_type, t_var.id), concrete_type]
+                  in [true, Type::Application(constructor:, args:)]
+                    tail = args.drop(1)
+                    tail.empty? ? constructor : Type::PartialApplication[constructor, tail]
+                  else
+                    concrete_type
+                  end
+
+                # Bind the interface type var to the concrete type
+                st_after_bind = st.unify(t_var, binding_type) { nil }
+                expected_type = st_after_bind.env.substitution.apply(iface_fn_type)
+
+                infer_fn(
+                  impl_fn,
+                  registry,
+                  st_after_bind,
+                  Expected.check(expected_type),
+                  interface_qname,
+                )
+              end
+              .then { [it, Result.init(Type.unit)] }
+          end
+
+          private
+
+          def infer_fn(impl_fn, registry, state, expected, interface_qname)
+            impl_fn => AST::ImplementationFunction(name:, fn:)
+
+            case fn
+            in AST::Lambda(params: [])
+              # 0-arg lambda for a non-function field (e.g. `decoder: () -> { ... }`
+              # against `decoder: Decoder(a)`) acts as a thunk: type the body and
+              # unify with expected. Mirrors `from_symbol_r`'s 0-arg collapse for
+              # named `def f() -> T`. Codegen emits a `->()` either way; the
+              # runtime always `.call`s the impl entry.
+              if expected.type.is_a?(Type::Function)
+                check(fn, registry, state, expected).first
+              else
+                body_state, body_result = check(
+                  fn.body,
+                  registry,
+                  state,
+                  Expected.infer(state.fresh),
+                )
+                body_state.unify(
+                  body_result.type,
+                  expected.type,
+                  &mismatch_error(state.env.entry_name, impl_fn, interface_qname, name)
+                )
+              end
+
+            in AST::Lambda
+              check(fn, registry, state, expected).first
+
+            in AST::VariableReference
+              ref_state, ref_result = check(fn, registry, state, expected)
+
+              ref_state.unify(
+                ref_result.type,
+                expected.type,
+                &mismatch_error(
+                  state.env.entry_name,
+                  impl_fn,
+                  interface_qname,
+                  name
+                )
+              )
+
+            # `decoder: zero_arg_fn` becomes `FunctionCall(zero_arg_fn, [])`
+            # after ZeroArgRewrite. Type the call; its result must match the
+            # interface field's type.
+            in AST::FunctionCall
+              check(fn, registry, state, expected).first
+            end
+          end
+
+          def constructor_var_in?(type, var_id)
+            case type
+            in Type::Application(constructor: Type::Var(id:)) if id == var_id
+              true
+
+            in Type::Application(constructor:, args:)
+              [constructor, *args].any? { constructor_var_in?(it, var_id) }
+
+            in Type::Function(args:, return_type:)
+              [*args, return_type].any? { constructor_var_in?(it, var_id) }
+
+            else
+              false
+            end
+          end
+
+          def mismatch_error(entry_name, impl_fn, interface_qname, fn_name)
+            ->(e) do
+              Error::ImplementationTypeMismatch.new(
+                entry_name,
+                impl_fn.range,
+                expected: e.expected,
+                actual:   e.actual,
+                interface: interface_qname,
+                fn_name:,
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/type_checking/inference/import_declaration.rb

@@ -0,0 +1,19 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Inference
+        module ImportDeclaration
+          extend Helpers
+          extend self
+
+          def infer(node, _, state, _)
+            node => AST::ImportDeclaration
+            Type.unit
+              .then { Result.init(it) }
+              .then { [state, it] }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/type_checking/inference/interface_declaration.rb

@@ -0,0 +1,18 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Inference
+        module InterfaceDeclaration
+          extend Helpers
+          extend self
+
+          def infer(node, _, state, _)
+            node => AST::InterfaceDeclaration
+
+            [state, Result.init(Type.unit)]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/type_checking/inference/interop_import_declaration.rb

@@ -0,0 +1,18 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Inference
+        module InteropImportDeclaration
+          extend Helpers
+          extend self
+
+          def infer(node, _, state, _)
+            node => AST::InteropImportDeclaration
+
+            [state, Result.init(Type.unit)]
+          end
+        end
+      end
+    end
+  end
+end