jade-lang 0.1.0

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

@@ -0,0 +1,79 @@
+require 'jade/frontend/type_checking/placeholder'
+require 'jade/frontend/type_checking/scheme'
+require 'jade/frontend/type_checking/var_gen'
+
+module Jade
+  module Frontend
+    module TypeChecking
+      Env = Data.define(
+        :entry_name, :bindings, :substitution,
+        :definitions, :var_gen, :node_types,
+      ) do
+        def self.empty(var_gen = VarGen.new)
+          Env[nil, {}, Substitution::EMPTY, {}, var_gen, {}]
+        end
+
+        def fresh
+          var_gen.fresh
+        end
+
+        def bind(key, value)
+          bindings
+            .merge(key => value)
+            .then { with(bindings: it) }
+        end
+
+        def pin_type(node_id, type)
+          with(node_types: node_types.merge(node_id => type))
+        end
+
+        # Post-finalize, apply the env's substitution to every pinned
+        # type so stored types are canonical (no leftover Type::Var that
+        # the substitution would resolve).
+        def canonicalize_node_types
+          node_types
+            .transform_values { substitution.apply(it) }
+            .then { with(node_types: it) }
+        end
+
+        def define(key, value)
+          definitions
+            .merge(key => value)
+            .then { with(definitions: it) }
+        end
+
+        def lookup(key)
+          binding = bindings[key]
+
+          type, constraints =
+            case bindings[key]
+            in Scheme => scheme
+              Instantiation.instantiate(scheme, var_gen)
+
+            in Placeholder => placeholder
+              Scheme[placeholder.free_vars, placeholder.type, placeholder.constraints]
+                .then { Instantiation.instantiate(it, var_gen) }
+            end
+
+          Result.init(type, constraints)
+        end
+
+        def lookup_def(key)
+          definitions[key]
+        end
+
+        def free_vars
+          bindings
+            .values
+            .flat_map(&:free_vars)
+            .flat_map { substitution.apply(it).unbound_vars }
+            .uniq(&:id)
+        end
+
+        def composose_substitution(sub)
+          with(substitution: substitution.compose(sub))
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/type_checking/error/case_of_branches_type_mismatch.rb

@@ -0,0 +1,19 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Error
+        class CaseOfBranchesTypeMismatch < Error::TypeMismatch
+          def initialize(entry, span, expected:, actual:, actual_index:)
+            super
+            @actual_index = actual_index
+          end
+
+          def message
+            "First branch of this case statement is #{@expected} " +
+              "but #{ordinal(@actual_index)} branch is #{@actual}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/type_checking/error/derivation_failed.rb

@@ -0,0 +1,21 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Error
+        class DerivationFailed < Jade::Error
+          attr_reader :constraint
+
+          def initialize(entry, span, constraint:, trace: [])
+            @constraint = constraint
+            @trace = trace
+            super(entry:, span:)
+          end
+
+          def message
+            "#{@constraint.interface} cannot be derived for #{@constraint.type}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/type_checking/error/function_body_type_mismatch.rb

@@ -0,0 +1,23 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Error
+        class FunctionBodyTypeMismatch < TypeMismatch
+          def initialize(entry, span, expected:, actual:, function_name:)
+            super
+            @function_name = function_name
+          end
+
+          def message
+            "There's a problem with the body of `#{@function_name}` definition: " ++
+              "it returns #{@actual} but its signature says it should be #{@expected}"
+          end
+
+          def label
+            "returns #{@actual}, expected #{@expected}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/type_checking/error/function_call_type_mismatch.rb

@@ -0,0 +1,37 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Error
+        class FunctionCallTypeMismatch < TypeMismatch
+          def initialize(entry, span, expected:, actual:, infix:)
+            super
+            @infix = infix
+          end
+
+          def message
+            case @infix
+            in AST::InfixOperator(value:)
+              infix_error(value)
+            else
+              "Function call mismatch, expected #{@expected} but found #{@actual}"
+            end
+          end
+
+          private
+
+          def infix_error(operator)
+            if @expected.args.first != @actual.args.first
+              return "Left side of (#{operator}) expects #{@expected.args.first} but found #{@actual.args.first}"
+            end
+
+            if @expected.args.last != @actual.args.last
+              return "Right side of (#{operator}) expects #{@expected.args.last} but found #{@actual.args.last}"
+            end
+
+            "Function call mismatch, expected #{@expected} but found #{@actual}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/type_checking/error/if_branch_type_mismatch.rb

@@ -0,0 +1,19 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Error
+        class IfBranchTypeMismatch < TypeMismatch
+          def initialize(entry, span, expected:, actual:, branch:)
+            super
+            @branch = branch == :then ? 'then' : 'else'
+          end
+
+          def message
+            "The #{@branch} branch of this if statement is expected to return" +
+              " #{@expected} but got #{@actual}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/type_checking/error/if_branches_type_mismatch.rb

@@ -0,0 +1,18 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Error
+        class IfBranchesTypeMismatch < TypeMismatch
+          def initialize(entry, span, expected:, actual:)
+            super
+          end
+
+          def message
+            "If branches must return the same type. The then branch produces " +
+              "#{@expected} but the else branch produces #{@actual}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/type_checking/error/if_condition_type_mismatch.rb

@@ -0,0 +1,17 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Error
+        class IfConditionTypeMismatch < TypeMismatch
+          def initialize(entry, span, expected: Type.bool, actual:)
+            super
+          end
+
+          def message
+            "If condition expects #{@expected} but found #{@actual}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/type_checking/error/implementation_type_mismatch.rb

@@ -0,0 +1,20 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Error
+        class ImplementationTypeMismatch < TypeMismatch
+          def initialize(entry, span, expected:, actual:, interface:, fn_name:)
+            super(entry, span, expected:, actual:)
+            @interface = interface
+            @fn_name   = fn_name
+          end
+
+          def message
+            "Implementation of #{@interface}.#{@fn_name}: " \
+              "expected #{@expected} but the provided function has type #{@actual}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/type_checking/error/list_item_type_mismatch.rb

@@ -0,0 +1,19 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Error
+        class ListItemTypeMismatch < TypeMismatch
+          def initialize(entry, span, expected:, actual:, actual_index:)
+            super
+            @actual_index = actual_index
+          end
+
+          def message
+            "The #{ordinal(@actual_index)} item does not match the previous items in the list, " +
+              "expected #{@expected} but found #{@actual}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/type_checking/error/missing_implementation.rb

@@ -0,0 +1,20 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Error
+        class MissingImplementation < Jade::Error
+          attr_reader :constraint
+
+          def initialize(entry, span, constraint:)
+            @constraint = constraint
+            super(entry:, span:)
+          end
+
+          def message
+            "No implementation of #{@constraint.interface} for #{@constraint.type}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/type_checking/error/missing_patterns.rb

@@ -0,0 +1,26 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Error
+        class MissingPatterns < Jade::Error
+          def initialize(entry, span, missing_patterns:)
+            @missing_patterns = missing_patterns
+            super(entry:, span:)
+          end
+
+          def message
+            patterns_str = @missing_patterns
+              .map { |row| row.map(&:to_s).join(', ') }
+              .map { "  #{it}" }
+              .join("\n")
+            "Pattern match is not exhaustive. Missing cases:\n#{patterns_str}"
+          end
+
+          def label
+            "non-exhaustive pattern match"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/type_checking/error/pattern_type_mismatch.rb

@@ -0,0 +1,13 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Error
+        class PatternTypeMismatch < TypeMismatch
+          def message
+            "Pattern is trying to match #{@expected} with #{@actual}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/type_checking/error/port_not_decodable.rb

@@ -0,0 +1,38 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Error
+        class PortNotDecodable < Jade::Error
+          attr_reader :port_name, :arm, :type
+
+          def initialize(entry, span, port_name:, arm:, type:)
+            @port_name = port_name
+            @arm = arm
+            @type = type
+            super(entry:, span:)
+          end
+
+          def message
+            "Port `#{@port_name}` cannot decode its #{@arm} arm (`#{@type}`): " \
+              "no Decodable instance"
+          end
+
+          def label
+            "no Decodable instance for `#{@type}`"
+          end
+
+          def notes
+            [
+              Jade::Diagnostics::Annotation[
+                :help,
+                "implement Decodable for `#{@type}` so it can be decoded " \
+                  "automatically, or declare the port with `Decode.Value` " \
+                  "to skip auto-decoding",
+              ],
+            ]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/type_checking/error/record_access_type_mismatch.rb

@@ -0,0 +1,14 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Error
+        class RecordAccessTypeMismatch  < TypeMismatch
+          def message
+            "Something is off with this record access, it expects #{@expected} " +
+              "but found #{@actual}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/type_checking/error/type_mismatch.rb

@@ -0,0 +1,23 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Error
+        class TypeMismatch < Jade::Error
+          def initialize(entry, span, expected:, actual:, **)
+            @expected = expected
+            @actual = actual
+            super(entry:, span:)
+          end
+
+          def message
+            "Expected #{@expected} but got #{@actual}"
+          end
+
+          def label
+            "expected #{@expected}, got #{@actual}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/type_checking/error/unresolved_constraint.rb

@@ -0,0 +1,20 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Error
+        class UnresolvedConstraint < Jade::Error
+          attr_reader :constraint
+
+          def initialize(entry, span, constraint:)
+            @constraint = constraint
+            super(entry:, span:)
+          end
+
+          def message
+            "Unresolved constraint: #{@constraint.interface} #{@constraint.type}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+require 'jade/error'
+
+require 'jade/frontend/type_checking/error/type_mismatch'
+
+require 'jade/frontend/type_checking/error/case_of_branches_type_mismatch'
+require 'jade/frontend/type_checking/error/derivation_failed'
+require 'jade/frontend/type_checking/error/function_body_type_mismatch'
+require 'jade/frontend/type_checking/error/function_call_type_mismatch'
+require 'jade/frontend/type_checking/error/if_branch_type_mismatch'
+require 'jade/frontend/type_checking/error/if_branches_type_mismatch'
+require 'jade/frontend/type_checking/error/if_condition_type_mismatch'
+require 'jade/frontend/type_checking/error/missing_patterns'
+require 'jade/frontend/type_checking/error/list_item_type_mismatch'
+require 'jade/frontend/type_checking/error/pattern_type_mismatch'
+require 'jade/frontend/type_checking/error/record_access_type_mismatch'
+require 'jade/frontend/type_checking/error/unresolved_constraint'
+require 'jade/frontend/type_checking/error/implementation_type_mismatch'
+require 'jade/frontend/type_checking/error/missing_implementation'

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

@@ -0,0 +1,23 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      Expected = Data.define(:type, :authoritative) do
+        def check?
+          authoritative == true
+        end
+
+        def self.check(type)
+          self[type, true]
+        end
+
+        def self.infer(type)
+          self[type, false]
+        end
+
+        def rigid_vars
+          check? ? type.unbound_vars : []
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Generalization
+        extend self
+
+        def generalize(env, type, constraints = [])
+          (type.unbound_vars + constraints.flat_map(&:unbound_vars))
+            .uniq(&:id)
+            .then { it - env.free_vars }
+            .then { Scheme[it, type, constraints] }
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,38 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Generalizer
+        extend self
+        include Inference::Helpers
+
+        def generalize(env)
+          env
+            .bindings
+            .reduce(env) do |e, (k, binding)|
+              case binding
+              in Placeholder(type:, constraints:)
+                unbound_cs = constraints
+                  .map { e.substitution.apply(it) }
+                  .uniq
+                  .select { it.unbound_vars.any? }
+
+                Generalization.
+                  generalize(
+                    # Remove the current placeholder and all Scheme bindings (local
+                    # params/variables) so they don't pollute free_vars during
+                    # generalization. Only other Placeholders contribute free_vars.
+                    e.with(bindings: e.bindings.except(k).select { |_, v| v.is_a?(Placeholder) }),
+                    e.substitution.apply(type),
+                    unbound_cs,
+                  )
+                  .then { e.bind(k, it) }
+              else
+
+                next e
+              end
+            end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+require 'jade/frontend/pattern_analysis'
+
+module Jade
+  module Frontend
+    module TypeChecking
+      module Inference
+        module Assign
+          extend Helpers
+          extend self
+
+          def infer(node, registry, state, expected)
+            node => AST::Assign(pattern:, expression:)
+
+            expr_state, expr_result = check(
+              expression,
+              registry,
+              state,
+              Expected.infer(state.fresh),
+            )
+
+            pattern_state, _ = Pattern.infer(
+              pattern,
+              registry,
+              expr_state,
+              Expected.check(expr_result.type),
+            )
+
+            final_state, residual_cs =
+              case pattern
+              in AST::Pattern::Binding(name:)
+                bind_with_residual(pattern_state, expr_state, expr_result, name)
+              else
+                [pattern_state, expr_result.constraints]
+              end
+
+            PatternAnalysis::Exhaustiveness
+              .assert([pattern], pattern.range, final_state.env, registry, expr_result.type)
+              .then { final_state.add_errors(it) }
+              .unify_result(expr_result.with(constraints: residual_cs), expected.type)
+          end
+
+          private
+
+          # Constraints whose vars are quantified into the new binding's scheme
+          # are captured by it; the rest propagate to the enclosing scope.
+          def bind_with_residual(pattern_state, expr_state, expr_result, name)
+            result = expr_result.apply(pattern_state.env.substitution)
+            scheme = generalize(expr_state.env, result.type, result.constraints)
+
+            result.constraints
+              .reject { |c| c.unbound_vars.any? { |v| scheme.quantified.any? { it.id == v.id } } }
+              .then { [pattern_state.bind(name, scheme), it] }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Inference
+        module Body
+          extend Helpers
+          extend self
+
+          def infer(node, registry, state, expected)
+            node => AST::Body(expressions:)
+
+            *first_expressions, last_expression = expressions
+
+            first_state, first_cs = first_expressions
+              .reduce([state, []]) do |(acc, cs), expr|
+                new_state, result = check(
+                  expr,
+                  registry,
+                  acc,
+                  Expected.infer(state.fresh),
+                )
+                [new_state, cs + result.constraints]
+              end
+
+            last_state, last_result = check(
+              last_expression,
+              registry,
+              first_state,
+              expected,
+            )
+
+            first_cs
+              .map { last_state.env.substitution.apply(it) }
+              .then do
+                last_result
+                  .with(constraints: it + last_result.constraints)
+                  .then { |result| [last_state, result] }
+              end
+          end
+        end
+      end
+    end
+  end
+end
+