jade-lang 0.1.0

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

@@ -0,0 +1,87 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Inference
+        module Lambda
+          extend Helpers
+          extend self
+
+          def infer(node, registry, state, expected)
+            node => AST::Lambda(body:, params:)
+
+            params_types = params.map { state.fresh }
+
+            pre_state = state
+              .unify_result(
+                Result.init(Type.function(params_types, state.fresh)),
+                expected.type,
+                &type_error(state, node)
+              )
+              .first
+
+            params_state = params
+              .zip(params_types)
+              .reduce(pre_state) do |acc, (p, t)|
+                case p
+                in AST::Pattern::Binding(name:)
+                  pre_state.env.substitution.apply(t)
+                    .then do |concrete_t|
+                      acc.bind(name, Scheme.mono(concrete_t))
+                        .then { it.with(env: it.env.pin_type(p.id, concrete_t)) }
+                    end
+
+                in AST::Pattern::Wildcard
+                  acc
+
+                else
+                  pre_state.env.substitution.apply(t)
+                    .then { Pattern.infer(p, registry, acc, Expected.check(it)) }
+                    .first
+                end
+              end
+
+            body_state, body_result = check(
+              body,
+              registry,
+              params_state,
+              Expected.infer(params_state.fresh),
+            )
+
+            exhaustiveness_state = params
+              .zip(params_types)
+              .reduce(body_state) do |acc, (p, t)|
+                case p
+                in AST::Pattern::Binding | AST::Pattern::Wildcard
+                  acc
+                else
+                  concrete_t = body_state.env.substitution.apply(t)
+                  PatternAnalysis::Exhaustiveness
+                    .assert([p], p.range, acc.env, registry, concrete_t)
+                    .then { acc.add_errors(it) }
+                end
+              end
+
+            Type
+              .function(params_types, body_result.type)
+              .then { Result.init(it, body_result.constraints) }
+              .apply(exhaustiveness_state.env.substitution)
+              .then { exhaustiveness_state.unify_result(it, expected.type, &type_error(exhaustiveness_state, node)) }
+          end
+
+          private
+
+          def type_error(state, node)
+            ->(e) do
+              Error::TypeMismatch.new(
+                state.env.entry_name,
+                node.range,
+                expected: e.expected,
+                actual: e.actual,
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Inference
+        module List
+          extend Helpers
+          extend self
+
+          def infer(node, registry, state, expected)
+            node => AST::List(items:)
+
+            if items.empty?
+              Type.list.apply([state.fresh])
+                .then { Result.init(it) }
+                .then { return state.unify_result(it, expected.type, expected.rigid_vars) }
+            end
+
+            head, *rest = items
+            head_state, head_result = check(head, registry, state, Expected.infer(state.fresh))
+
+            items_state, items_result = rest
+              .each_with_index
+              .reduce([head_state, head_result]) do |(state_acc, result_acc), (item, i)|
+                new_state, result = check(item, registry, state_acc, Expected.infer(state_acc.fresh))
+                new_state
+                  .unify_result(result, result_acc.type, &type_error(new_state, item, i))
+                  .then { |st, rs| [st, rs.with(constraints: result_acc.constraints + rs.constraints)] }
+              end
+
+            Result
+              .init(Type.list.apply([items_result.type]), items_result.constraints)
+              .then { items_state.unify_result(it, expected.type, expected.rigid_vars) }
+          end
+
+          private
+
+          def type_error(state, item, index)
+            ->(error) do
+              Error::ListItemTypeMismatch.new(
+                state.env.entry_name,
+                item.range,
+                expected: error.expected,
+                actual: error.actual,
+                actual_index: index + 2,
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Inference
+        module Literal
+          extend Helpers
+          extend self
+
+          def infer(node, registry, state, _)
+            symbol =
+              case node
+              in AST::Literal | AST::CharLiteral
+                node.symbol
+              end
+
+            type_from_symbol(symbol, registry, state.env.var_gen)
+              .then { [state, Result.init(*it)] }
+          end
+        end
+      end
+    end
+  end
+end
+

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

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

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

@@ -0,0 +1,135 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Inference
+        module Pattern
+          extend Helpers
+          extend self
+
+          def infer(pattern, registry, state, expected)
+            infer_(pattern, registry, state, expected)
+              .then { |s, r| [s.with(env: s.env.pin_type(pattern.id, r.type)), r] }
+          end
+
+          def infer_(pattern, registry, state, expected)
+            case pattern
+            in AST::Pattern::Record(fields:, symbol:)
+              fields_state, fields_result = fields
+                .reduce([state, Result.accumulator]) do |(state_acc, result_acc), field|
+                  st, rs = Expected
+                    .infer(state_acc.fresh)
+                    .then { infer(field.pattern, registry, state_acc, it) }
+
+                  [st, result_acc.add(rs)]
+                end
+
+              fields
+                .map(&:name)
+                .zip(fields_result.types)
+                .to_h
+                .then { Type.anonymous_record(it, state.fresh) }
+                .then { Result.init(it) }
+                .then do
+                  fields_state
+                    .unify_result(it, expected.type, &type_error(state, pattern))
+                end
+
+            in AST::Pattern::Literal(literal:)
+              new_state, literal_result = check(literal, registry, state, expected)
+              new_state.unify_result(literal_result, expected.type, &type_error(state, pattern))
+
+            in AST::Pattern::Wildcard
+              Result
+                .init(state.fresh)
+                .then { state.unify_result(it, expected.type) }
+
+            in AST::Pattern::Binding(name:)
+              state
+                .bind(name, Scheme.mono(expected.type))
+                .then { it.unify_result(Result.init(it.fresh), expected.type) }
+
+            in AST::Pattern::List(patterns:, rest:)
+              elem_type = state.fresh
+              list_type = Type.list.apply([elem_type])
+
+              heads_state = patterns
+                .reduce(state) do |acc, pat|
+                  infer(pat, registry, acc, Expected.check(elem_type)).first
+                end
+
+              after_rest_state =
+                case rest
+                in AST::Pattern::Binding(name:)
+                  generalize(heads_state.env, list_type, [])
+                    .then { heads_state.bind(name, it) }
+
+                in AST::Pattern::Wildcard | nil
+                  heads_state
+                end
+
+              Result
+                .init(list_type)
+                .then do
+                  after_rest_state
+                    .unify_result(
+                      it,
+                      expected.type,
+                      &type_error(after_rest_state, pattern)
+                    )
+                end
+
+            in AST::Pattern::Constructor(symbol:, patterns: [])
+              state.env.lookup(symbol.qualified_name) => { type: constructor_type }
+
+              state.unify_result(
+                Result.init(constructor_type),
+                expected.type,
+                &type_error(state, pattern)
+              )
+
+            in AST::Pattern::Constructor(symbol:, patterns:)
+              state.env.lookup(symbol.qualified_name) => { type: constructor_type }
+
+              patterns_state, patterns_result = constructor_type
+                .args
+                .zip(patterns)
+                .reduce([state, Result.accumulator]) do |(acc_state, acc_result), (inner_expected, pat)|
+                  new_state, result = Expected
+                    .check(inner_expected)
+                    .then { infer(pat, registry, acc_state, it) }
+
+                  [new_state, acc_result.add(result)]
+                end
+
+              patterns_result.types
+                .then { Type.function(it, expected.type) }
+                .then { Result.init(it) }
+                .then do
+                  patterns_state
+                    .unify_result(it, constructor_type) do |error|
+                      Error::PatternTypeMismatch.new(
+                        state.env.entry_name, pattern.range,
+                        expected: error.expected.return_type,
+                        actual:   error.actual.return_type,
+                      )
+                    end
+                end
+                .then { |(state, result)| [state, result.map(&:return_type)] }
+            end
+          end
+
+          private
+
+          def type_error(state, pattern)
+            ->(error) do
+              Error::PatternTypeMismatch.new(
+                state.env.entry_name, pattern.range,
+                expected: error.expected, actual: error.actual,
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,35 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Inference
+        module RecordAccess
+          extend Helpers
+          extend self
+
+          def infer(node, registry, state, expected_)
+            node => AST::RecordAccess(target:, name:)
+
+            record_expected = Type.anonymous_record(
+              { name.name => expected_.type },
+              state.fresh.with(name: 'a'),
+            )
+
+            target_state, target_result = check(target, registry, state, Expected.infer(state.fresh))
+            after_state, _ = target_state.unify_result(target_result, record_expected) do
+              Error::RecordAccessTypeMismatch.new(
+                state.env.entry_name,
+                name.range,
+                expected: it.expected,
+                actual: it.actual,
+              )
+            end
+
+            Result.init(expected_.type)
+              .then { it.apply(after_state.env.substitution) }
+              .then { [after_state, it] }
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,24 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Inference
+        module RecordLiteral
+          extend Helpers
+          extend self
+
+          def infer(node, registry, state, expected)
+            node => AST::RecordLiteral(fields:)
+
+            fields_state, fields_types, fields_constraints = fields
+              .reduce([state, {}, []]) do |(state_acc, types_acc, c_acc), field|
+                new_state, result = check(field, registry, state_acc, Expected.infer(state_acc.fresh))
+                [new_state, types_acc.merge(field.key => result.type), c_acc + result.constraints]
+              end
+
+            [fields_state, Result.init(Type.anonymous_record(fields_types, nil), fields_constraints)]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Inference
+        module RecordUpdate
+          extend Helpers
+          extend self
+
+          def infer(node, registry, state, expected)
+            node => AST::RecordUpdate(base:, fields:)
+
+            base_state, base_result = check(base, registry, state, Expected.infer(state.fresh))
+
+            fields_state, fields_types = fields
+              .reduce([base_state, {}]) do |(state_acc, types_acc), field|
+                new_state, result = check(field, registry, state_acc, Expected.infer(state_acc.fresh))
+                [new_state, types_acc.merge(field.key => result.type)]
+              end
+
+            update_record = Type.anonymous_record(fields_types, fields_state.fresh)
+
+            after_state, result = fields_state.unify_result(base_result, update_record) do
+              Error::RecordAccessTypeMismatch.new(
+                state.env.entry_name,
+                node.range,
+                expected: it.expected,
+                actual: it.actual,
+              )
+            end
+
+            after_state.unify_result(result, expected.type)
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

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

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

@@ -0,0 +1,27 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Inference
+        module VariableReference
+          extend Helpers
+          extend self
+
+          def infer(node, registry, state, _)
+            node => AST::VariableReference(symbol:)
+
+            case symbol
+            in Symbol::Variable
+              symbol.name
+            else
+              symbol.qualified_name
+            end
+              .then { state.env.lookup(it) }
+              .then { it.attach_origin(node) }
+              .then { [state, it] }
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,27 @@
+require 'jade/frontend/type_checking/inference/helpers'
+
+require 'jade/frontend/type_checking/inference/body'
+require 'jade/frontend/type_checking/inference/case_of'
+require 'jade/frontend/type_checking/inference/constructor_reference'
+require 'jade/frontend/type_checking/inference/function_call'
+require 'jade/frontend/type_checking/inference/function_declaration'
+require 'jade/frontend/type_checking/inference/implementation'
+require 'jade/frontend/type_checking/inference/grouping'
+require 'jade/frontend/type_checking/inference/if_then_else'
+require 'jade/frontend/type_checking/inference/import_declaration'
+require 'jade/frontend/type_checking/inference/interop_import_declaration'
+require 'jade/frontend/type_checking/inference/lambda'
+require 'jade/frontend/type_checking/inference/list'
+require 'jade/frontend/type_checking/inference/literal'
+require 'jade/frontend/type_checking/inference/module'
+require 'jade/frontend/type_checking/inference/pattern'
+require 'jade/frontend/type_checking/inference/qualified_access'
+require 'jade/frontend/type_checking/inference/record_access'
+require 'jade/frontend/type_checking/inference/record_field'
+require 'jade/frontend/type_checking/inference/record_literal'
+require 'jade/frontend/type_checking/inference/record_update'
+require 'jade/frontend/type_checking/inference/struct_declaration'
+require 'jade/frontend/type_checking/inference/interface_declaration'
+require 'jade/frontend/type_checking/inference/type_declaration'
+require 'jade/frontend/type_checking/inference/assign'
+require 'jade/frontend/type_checking/inference/variable_reference'

data/lib/jade/frontend/type_checking/instantiation.rb

@@ -0,0 +1,24 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Instantiation
+        extend self
+
+        # Index = position in scheme.constraints. Lets attach_dictionary write
+        # positionally so sibling same-iface markers don't collide on one origin.
+        def instantiate(scheme, var_gen)
+          sub = scheme
+            .quantified.reduce(Substitution::EMPTY) do |subs, var|
+              subs.bind(var.id, var_gen.fresh(var.name))
+            end
+
+          scheme
+            .constraints
+            .each_with_index
+            .map { |c, i| sub.apply(c.with(index: i)) }
+            .then { [sub.apply(scheme.type), it] }
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/type_checking/loader.rb

@@ -0,0 +1,80 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Loader
+        extend self
+
+        def load(entry, registry, env: Env.empty)
+          env
+            .with(entry_name: entry.name)
+            .then { load_local_bindings(it, entry, registry) }
+            .then { load_local_definitions(it, entry, registry) }
+            .then { load_imports(it, entry, registry) }
+        end
+
+        def load_local_bindings(env, entry, registry)
+          entry
+            .defined_values
+            .reduce(env) do |e, (_, sym)|
+              case sym
+              in Symbol::Function
+                Type
+                  .from_symbol(sym, registry, e.var_gen)
+                  .then { Placeholder[*it] }
+
+              else
+                Type
+                  .from_symbol(sym, registry, e.var_gen)
+                  .then { Inference::Helpers.generalize(e, *it) }
+              end
+                .then { e.bind(sym.qualified_name, it) }
+            end
+        end
+
+        def load_local_definitions(env, entry, registry)
+          entry
+            .types
+            .reduce(env) do |e, (_, sym)|
+              Definition
+                .from_symbol(sym, registry)
+                .then { e.define(sym.qualified_name, it) }
+            end
+        end
+
+        def load_imports(env, entry, registry)
+          entry
+            .imports
+            .reduce(env) do |e, import_entry|
+              import_entry.qualified_symbols.reduce(e) do |acc, sym|
+                add_imported_symbol(acc, sym, registry)
+              end
+            end
+        end
+
+        def add_imported_symbol(env, sym, registry)
+          case sym
+          in Symbol::ValueRef
+            return env if env.bindings[sym.qualified_name]
+
+            upstream_env = registry.get(sym.module_name)&.env
+            return env unless upstream_env
+
+            upstream_env
+              .bindings[sym.qualified_name]
+              &.then { env.bind(sym.qualified_name, it) } || env
+
+          in Symbol::TypeRef
+            return env if env.lookup_def(sym.qualified_name)
+
+            Definition
+              .from_symbol(sym, registry)
+              .then { env.define(sym.qualified_name, it) }
+
+          else
+            env
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/type_checking/placeholder.rb

@@ -0,0 +1,12 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      Placeholder = Data.define(:type, :constraints) do
+        def free_vars
+          type.unbound_vars + constraints.flat_map(&:unbound_vars)
+        end
+      end
+    end
+  end
+end
+