jade-lang 0.1.0

data/lib/jade/frontend/semantic_analysis/record_update.rb

@@ -0,0 +1,21 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module RecordUpdate
+        extend self
+        extend Helper
+
+        def analyze(node, registry, scope, entry)
+          node => AST::RecordUpdate(base:, fields:)
+
+          Result
+            .combine(node, scope:,
+              base: analyze_node(base, registry, scope, entry),
+              fields: analyze_in_parallel(fields, registry, scope, entry),
+            )
+            .add_errors(analyze_duplicate_fields(fields, entry))
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/semantic_analysis/struct_declaration.rb

@@ -0,0 +1,44 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module StructDeclaration
+        extend self
+        extend Helper
+
+        def analyze(node, registry, scope, entry)
+          node => AST::StructDeclaration(name:)
+
+          symbol_ref = entry.lookup_type(name).to_ref
+
+          Result
+            .init(node.with(symbol: symbol_ref), scope)
+            .add_errors(validate_no_unbound_vars(symbol_ref, registry, entry))
+            .add_errors(validate_type_symbol(symbol_ref, registry, entry))
+        end
+
+        private
+
+        def validate_no_unbound_vars(symbol, registry, entry)
+          actual_symbol = registry.lookup(symbol)
+
+          missing_vars = collect_vars(actual_symbol.record_type, registry)
+            .group_by(&:name)
+            .reject { |(k, _)| actual_symbol.type_params.map(&:name).include? k }
+            .values
+            .flatten
+
+          return [] if missing_vars.empty?
+
+          [
+            Error::UnboundTypeVariable.new(
+              entry.name,
+              missing_vars.size == 1 ? missing_vars.first.decl_span : actual_symbol.decl_span,
+              type_name: symbol.name,
+              variables: missing_vars.map(&:name),
+            )
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/semantic_analysis/tuple.rb

@@ -0,0 +1,17 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module Tuple
+        extend self
+        extend Helper
+
+        def analyze(node, registry, scope, entry)
+          node => AST::Tuple(items:)
+
+          analyze_in_sequence(items, registry, scope, entry)
+            .with(scope:)
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/semantic_analysis/type_declaration.rb

@@ -0,0 +1,69 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module TypeDeclaration
+        extend self
+        extend Helper
+
+        def analyze(node, registry, scope, entry)
+          node => AST::TypeDeclaration(name:, variants:)
+
+          symbol_ref = entry.lookup_type(name).to_ref
+
+          analyze_in_parallel(variants, registry, scope, entry)
+            .then { Result.combine(node, scope:, variants: it) }
+            .map_node { it.with(symbol: symbol_ref) }
+            .add_errors(validate_no_unbound_vars(symbol_ref, registry, entry))
+            .add_errors(validate_type_symbol(symbol_ref, registry, entry))
+        end
+
+        private
+
+        def validate_no_unbound_vars(symbol, registry, entry)
+          actual_symbol = registry.lookup(symbol)
+
+          vars = actual_symbol
+            .variants
+            .flat_map { collect_vars(it, registry) }
+            .group_by(&:name)
+
+          missing_vars = vars
+            .reject { |(k, _)| actual_symbol.type_params.map(&:name).include? k }
+            .values
+            .flatten
+
+          return [] if missing_vars.empty?
+
+          [
+            Error::UnboundTypeVariable.new(
+              entry.name,
+              missing_vars.size == 1 ? missing_vars.first.decl_span : actual_symbol.decl_span,
+              type_name: symbol.name,
+              variables: missing_vars.map(&:name),
+            )
+          ]
+        end
+
+        def collect_vars(symbol, registry)
+          case symbol
+          in Symbol::TypeRef | Symbol::ValueRef
+            registry.lookup(symbol)
+              .then { collect_vars(it, registry) }
+
+          in Symbol::Constructor(args:)
+            args.flat_map { collect_vars(it, registry) }
+
+          in Symbol::Variable
+            [symbol]
+
+          in Symbol::TypeApplication(args:)
+            args.flat_map { collect_vars(it, registry) }
+
+          in Symbol::RecordType(row_var:)
+            row_var.nil? ? [] : [row_var]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/semantic_analysis/variable_reference.rb

@@ -0,0 +1,27 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module VariableReference
+        extend self
+        extend Helper
+
+        def analyze(node, _registry, scope, entry)
+          node => AST::VariableReference(name:)
+
+          case scope.lookup(name)
+          in nil
+            Result
+              .init(node.with(symbol: Symbol.var(name, node.range)), scope)
+              .add_errors([Error::UndefinedVariable.new(
+                entry.name, node.range, var_ref: name,
+                candidates: scope.bindings.keys,
+              )])
+
+          in symbol
+            Result.init(node.with(symbol:), scope)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/semantic_analysis/variant_declaration.rb

@@ -0,0 +1,18 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module VariantDeclaration
+        extend self
+        extend Helper
+
+        def analyze(node, _registry, scope, entry)
+          node => AST::VariantDeclaration(name:)
+
+          node
+            .with(symbol: entry.lookup_value(name).to_ref)
+            .then { Result.init(it, scope) }
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/semantic_analysis.rb

@@ -0,0 +1,161 @@
+require 'jade/frontend/semantic_analysis/error'
+
+require 'jade/frontend/semantic_analysis/helper'
+require 'jade/frontend/semantic_analysis/module_node'
+require 'jade/frontend/semantic_analysis/import_declaration'
+require 'jade/frontend/semantic_analysis/literal'
+require 'jade/frontend/semantic_analysis/char_literal'
+require 'jade/frontend/semantic_analysis/assign'
+require 'jade/frontend/semantic_analysis/variable_reference'
+require 'jade/frontend/semantic_analysis/constructor_reference'
+require 'jade/frontend/semantic_analysis/body'
+require 'jade/frontend/semantic_analysis/function_declaration'
+require 'jade/frontend/semantic_analysis/function_call'
+require 'jade/frontend/semantic_analysis/keyed_call/validation'
+require 'jade/frontend/semantic_analysis/keyed_call'
+require 'jade/frontend/semantic_analysis/type_declaration'
+require 'jade/frontend/semantic_analysis/variant_declaration'
+require 'jade/frontend/semantic_analysis/interop_import_declaration'
+require 'jade/frontend/semantic_analysis/implementation'
+require 'jade/frontend/semantic_analysis/implementation_function'
+require 'jade/frontend/semantic_analysis/struct_declaration'
+require 'jade/frontend/semantic_analysis/interface_declaration'
+require 'jade/frontend/semantic_analysis/if_then_else'
+require 'jade/frontend/semantic_analysis/member_access'
+require 'jade/frontend/semantic_analysis/qualified_access'
+require 'jade/frontend/semantic_analysis/record_access'
+require 'jade/frontend/semantic_analysis/case_of'
+require 'jade/frontend/semantic_analysis/case_of_branch'
+require 'jade/frontend/semantic_analysis/pattern_wildcard'
+require 'jade/frontend/semantic_analysis/pattern_literal'
+require 'jade/frontend/semantic_analysis/pattern_binding'
+require 'jade/frontend/semantic_analysis/pattern_constructor'
+require 'jade/frontend/semantic_analysis/pattern_record'
+require 'jade/frontend/semantic_analysis/pattern_list'
+require 'jade/frontend/semantic_analysis/lambda'
+require 'jade/frontend/semantic_analysis/grouping'
+require 'jade/frontend/semantic_analysis/list'
+require 'jade/frontend/semantic_analysis/record_literal'
+require 'jade/frontend/semantic_analysis/record_update'
+require 'jade/frontend/semantic_analysis/record_field'
+
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      extend self
+
+      def analyze(entry, registry)
+        initialize_scope(entry)
+          .then { analyze_node(entry.ast, registry, it, entry) }
+          .then { it.errors.any? ? Err[it.errors] : Ok[entry.with(ast: it.node)] }
+      end
+
+      def analyze_repl(ast, registry, scope, entry)
+        analyze_node(ast, registry, scope, entry)
+          .then { it.errors.any? ? Err[it.errors] : Ok[[it.node, it.scope]] }
+      end
+
+      def analyze_entry(entry, registry)
+        analyze(entry, registry)
+      end
+
+      private
+
+      def initialize_scope(entry)
+        entry
+          .values
+          .reduce(Scope.new) { |acc, (unq_name, sym)| acc.bind(unq_name, sym) }
+      end
+
+      def analyze_node(ast, registry, scope, entry)
+        case ast
+        in AST::Module then ModuleNode
+        in AST::ImportDeclaration then ImportDeclaration
+        in AST::InteropImportDeclaration then InteropImportDeclaration
+        in AST::Literal then Literal
+        in AST::CharLiteral then CharLiteral
+        in AST::Assign then Assign
+        in AST::VariableReference then VariableReference
+        in AST::ConstructorReference then ConstructorReference
+        in AST::Body then Body
+        in AST::FunctionDeclaration then FunctionDeclaration
+        in AST::FunctionCall then FunctionCall
+        in AST::KeyedCall then KeyedCall
+        in AST::TypeDeclaration then TypeDeclaration
+        in AST::VariantDeclaration then VariantDeclaration
+        in AST::Implementation then Implementation
+        in AST::ImplementationFunction then ImplementationFunction
+        in AST::StructDeclaration then StructDeclaration
+        in AST::InterfaceDeclaration then InterfaceDeclaration
+        in AST::IfThenElse then IfThenElse
+        in AST::MemberAccess then MemberAccess
+        in AST::QualifiedAccess then QualifiedAccess
+        in AST::RecordAccess then RecordAccess
+        in AST::CaseOf then CaseOf
+        in AST::CaseOfBranch then CaseOfBranch
+        in AST::Pattern::Wildcard then PatternWildcard
+        in AST::Pattern::Literal then PatternLiteral
+        in AST::Pattern::Binding then PatternBinding
+        in AST::Pattern::Constructor then PatternConstructor
+        in AST::Pattern::Record then PatternRecord
+        in AST::Pattern::List then PatternList
+        in AST::Lambda then Lambda
+        in AST::Grouping then Grouping
+        in AST::List then List
+        in AST::RecordLiteral then RecordLiteral
+        in AST::RecordUpdate then RecordUpdate
+        in AST::RecordField then RecordField
+        end
+          .analyze(ast, registry, scope, entry)
+      end
+
+      Result = Data.define(:node, :errors, :scope) do
+        def self.init(node, scope)
+          new(node:, errors: [], scope:)
+        end
+
+        # Combine a fixed set of child Results into a parent Result.
+        # `children` keys must match the parent node's `with` field
+        # names. Errors are unioned; the parent's `scope:` is whatever
+        # the caller decides (usually the input scope or a child's).
+        def self.combine(node, scope:, **children)
+          new(
+            node: node.with(**children.transform_values(&:node)),
+            errors: children.values.flat_map(&:errors),
+            scope:,
+          )
+        end
+
+        def add_errors(more)
+          with(errors: errors + more)
+        end
+
+        def map_node
+          with(node: yield(node))
+        end
+
+        def with_scope(s)
+          with(scope: s)
+        end
+
+        def to_result
+          errors.any? ? Err[errors] : Ok[node]
+        end
+      end
+
+      Scope = Data.define(:bindings) do
+        def initialize(bindings: {})
+          super
+        end
+
+        def bind(name, symbol)
+          with(bindings: bindings.merge(name => symbol))
+        end
+
+        def lookup(name)
+          bindings[name]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      # Finalize-time pass that rewrites attached dictionary markers in place
+      # through the final substitution. Codegen then reads marker.type.id
+      # directly — dict_env keys (built from scheme.constraints) and marker
+      # ids both pass through the same final substitution, so they match.
+      #
+      # We do NOT pre-substitute scheme.type/constraints: substitution can map
+      # one quantified var to another (e.g. `b → c'` via body unification),
+      # which would leave the scheme's `quantified` list and type out of sync
+      # for downstream instantiations.
+      module Canonicalize
+        extend self
+
+        def run(ast, env, registry)
+          walk(ast, env.substitution, registry, env.entry_name)
+          env
+        end
+
+        private
+
+        def walk(node, sub, registry, entry_name)
+          case node
+          in AST::FunctionCall(callee:, args:)
+            canonicalize_dictionaries(node, sub, registry, entry_name)
+            walk(callee, sub, registry, entry_name)
+            args.each { walk(it, sub, registry, entry_name) }
+
+          in AST::QualifiedAccess | AST::VariableReference
+            canonicalize_dictionaries(node, sub, registry, entry_name)
+
+          in AST::Module(body:)             then walk(body, sub, registry, entry_name)
+          in AST::Body(expressions:)        then expressions.each { walk(it, sub, registry, entry_name) }
+          in AST::FunctionDeclaration(body:) then walk(body, sub, registry, entry_name)
+          in AST::Implementation(functions:) then functions.each { walk(it, sub, registry, entry_name) }
+          in AST::ImplementationFunction(fn:) then walk(fn, sub, registry, entry_name)
+          in AST::Assign(expression:)       then walk(expression, sub, registry, entry_name)
+          in AST::Lambda(body:)             then walk(body, sub, registry, entry_name)
+          in AST::Grouping(expression:)     then walk(expression, sub, registry, entry_name)
+          in AST::List(items:)              then items.each { walk(it, sub, registry, entry_name) }
+          in AST::RecordLiteral(fields:)    then fields.each { walk(it, sub, registry, entry_name) }
+          in AST::RecordField(value:)       then walk(value, sub, registry, entry_name)
+          in AST::RecordUpdate(base:, fields:)
+            walk(base, sub, registry, entry_name)
+            fields.each { walk(it, sub, registry, entry_name) }
+          in AST::RecordAccess(target:)     then walk(target, sub, registry, entry_name)
+          in AST::IfThenElse(condition:, if_branch:, else_branch:)
+            walk(condition, sub, registry, entry_name)
+            walk(if_branch, sub, registry, entry_name)
+            walk(else_branch, sub, registry, entry_name)
+          in AST::CaseOf(expression:, branches:)
+            walk(expression, sub, registry, entry_name)
+            branches.each { walk(it, sub, registry, entry_name) }
+          in AST::CaseOfBranch(body:)       then walk(body, sub, registry, entry_name)
+
+          # Leaves: cannot contain a FunctionCall. Listed explicitly so
+          # adding a new node type forces a decision here rather than
+          # silently skipping a subtree.
+          in AST::Literal |
+             AST::CharLiteral |
+             AST::ConstructorReference |
+             AST::ImportDeclaration |
+             AST::InteropImportDeclaration |
+             AST::TypeDeclaration |
+             AST::StructDeclaration |
+             AST::InterfaceDeclaration |
+             AST::Placeholder
+            nil
+          end
+        end
+
+        # Rewrite var-typed dictionary markers through the final substitution.
+        # If the var resolved to a concrete type (e.g. `Decodable α` where a
+        # pattern-binding unified α with Int), resolve the impl now so codegen
+        # can dispatch directly — previously this only handled var-stayed-var
+        # and the substituted-to-concrete case crashed codegen's dict lookup.
+        def canonicalize_dictionaries(node, sub, registry, entry_name)
+          node.dictionaries.each_with_index do |entry, i|
+            next unless entry.is_a?(Type::Constraint)
+
+            applied = sub.apply(entry.type)
+            resolved = entry.with(type: applied)
+
+            if applied.is_a?(Type::Var)
+              node.dictionaries[i] = resolved
+            else
+              Constraints
+                .resolve(resolved, registry, entry_name)
+                .map { node.dictionaries[i] = it }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/type_checking/constraints/deriving/decodable.rb

@@ -0,0 +1,144 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Constraints
+        module Deriving
+          module Decodable
+            extend self
+            include Helpers
+
+            INTERFACE = 'Decode.Decodable'
+
+            def supports?(interface) = interface == INTERFACE
+
+            def derive(constraint, registry, entry_name, &lookup)
+              case constraint.type
+              in Type::Application(constructor: Type::Constructor(name: 'List.List'), args: [inner])
+                derive_unary(constraint, inner, 'Decode.list', lookup, entry_name)
+
+              in Type::Application(constructor: Type::Constructor(name: 'Maybe.Maybe'), args: [inner])
+                derive_unary(constraint, inner, 'Decode.nullable', lookup, entry_name)
+
+              in Type::Application(constructor: Type::Constructor(name:), args:)
+                resolved_sym = Symbol
+                  .type_ref_from_qualified_name(name)
+                  .then { registry.lookup(it) }
+
+                case resolved_sym
+                in Symbol::Struct
+                  derive_struct(constraint, resolved_sym, args, registry, lookup, entry_name)
+
+                else
+                  failed(constraint, entry_name)
+                end
+
+              in Type::AnonymousRecord(fields:)
+                derive_anonymous_record(constraint, fields, lookup, entry_name)
+
+              else
+                failed(constraint, entry_name)
+              end
+            end
+
+            private
+
+            def failed(constraint, entry_name)
+              Err[
+                Error::DerivationFailed.new(
+                  entry_name,
+                  constraint.origin&.range,
+                  constraint:,
+                  trace: [],
+                )
+              ]
+            end
+
+            def derive_unary(constraint, inner_type, stdlib_fn, lookup, entry_name)
+              dep = Type.constraint(INTERFACE, inner_type, nil)
+
+              resolve_dep(dep, lookup, entry_name).and_then do |dep_impl|
+                body = [:call,
+                  [:stdlib_fn, stdlib_fn],
+                  [
+                    [:impl_arg, 0, 'decoder'],
+                  ],
+                ]
+
+                Ok[implementation(constraint, body, [dep_impl])]
+              end
+            end
+
+            def derive_struct(constraint, struct_sym, type_args, registry, lookup, entry_name)
+              fields = struct_fields(struct_sym, type_args, registry)
+
+              [:struct_constructor, struct_sym.qualified_name, fields.size]
+                .then { derive_record(constraint, fields, it, lookup, entry_name) }
+            end
+
+            def derive_anonymous_record(constraint, fields, lookup, entry_name)
+              keys = fields.keys.map(&:to_s)
+
+              [:anon_record_constructor, keys]
+                .then { derive_record(constraint, fields.to_a, it, lookup, entry_name) }
+            end
+
+            def derive_record(constraint, fields, constructor_ref, lookup, entry_name)
+              field_deps = fields.map do |_, field_type|
+                Type.constraint(INTERFACE, field_type, nil)
+              end
+
+              resolved_deps = field_deps.map do |dep|
+                resolve_dep(dep, lookup, entry_name) => Ok[impl]
+                impl
+              end
+
+              seed = [:call, [:stdlib_fn, 'Decode.succeed'], [constructor_ref]]
+
+              body = fields.each_with_index.reduce(seed) do |acc, ((field_name, _), idx)|
+                field_decoder = [:call,
+                  [:stdlib_fn, 'Decode.field'],
+                  [
+                    field_name.to_s,
+                    [:impl_arg, idx, 'decoder'],
+                  ],
+                ]
+
+                [:call, [:stdlib_fn, 'Decode.and_map'], [acc, field_decoder]]
+              end
+
+              Ok[implementation(constraint, body, resolved_deps)]
+            end
+
+            # Free-var inner constraints fall back to the constraint marker
+            # itself — codegen later resolves it from the caller's dict env.
+            # Without this, `Decodable(List(a))` with `a` free would bail
+            # with UnresolvedConstraint.
+            def resolve_dep(dep, lookup, entry_name)
+              lookup
+                .call(dep)
+                .on_err(Error::UnresolvedConstraint) {
+                  dep.type.is_a?(Type::Var) ? Ok[dep] : Err[it]
+                }
+            end
+
+            def implementation(constraint, body, deps)
+              decoder_fn = Symbol::DerivedFunction.new(params: [], body:)
+
+              Symbol::Implementation.new(
+                module_name: nil,
+                interface: Symbol.type_ref_from_qualified_name(constraint.interface),
+                type: constraint.type,
+                type_params: [],
+                constraints: [],
+                functions: { 'decoder' => decoder_fn },
+                deps:,
+                extends: [],
+                decl_span: nil,
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end