jade-lang 0.1.0

data/lib/jade/frontend/forward_declaration/module.rb

@@ -0,0 +1,98 @@
+module Jade
+  module Frontend
+    module ForwardDeclaration
+      module Module
+        extend self
+        extend Helper
+
+        def shallow(node, registry, entry)
+          node => AST::Module(body:)
+
+          shallow_declare_node(body, registry, entry)
+        end
+
+        def deep(node, entry, registry)
+          node => AST::Module(exposing:, body:)
+
+          case exposing
+          in AST::ExposeList(items:)
+            items
+              .reduce(Result[entry, []]) do |acc, exposed|
+                case exposed
+                in AST::ExposeValue(name:, range:)
+                  lookup_and_expose_value(acc.entry, name, range)
+
+                in AST::ExposeType(name:, range:)
+                  lookup_and_expose_type(acc.entry, name, range)
+
+                in AST::ExposeTypeExpand(name:, range:)
+                  lookup_and_expose_type_with_variants(acc.entry, name, range)
+                end
+                  .add_errors(acc.errors)
+              end
+
+          in AST::ExposeAll
+            entry
+              .values
+              .merge(entry.types)
+              .reduce(entry) { |acc, (name, sym)| acc.expose(sym.to_ref) }
+              .then { Result[it, []] }
+
+          in AST::ExposeNone
+            Result[entry, []]
+          end
+            .then { deep_declare_node(body, it.entry, registry).add_errors(it.errors) }
+        end
+
+        private
+
+        def lookup_and_expose_type(entry, name, span)
+          symbol = entry.lookup_type(name)
+
+          if symbol
+            return entry
+              .expose(symbol.to_ref)
+              .then { Result[it, []] }
+          end
+
+          Result[
+            entry,
+            [Error::ExposedTypeNotFound.new(entry.name, span, name:)],
+          ]
+        end
+
+        def lookup_and_expose_type_with_variants(entry, name, span)
+          symbol = entry.lookup_type(name)
+
+          unless symbol
+            return Result[
+              entry,
+              [Error::ExposedTypeNotFound.new(entry.name, span, name:)],
+            ]
+          end
+
+          symbol
+            .constructor_refs
+            .reduce(entry) { |acc, ctor| acc.expose(ctor.to_ref) }
+            .expose(symbol.to_ref)
+            .then { Result[it, []] }
+        end
+
+        def lookup_and_expose_value(entry, name, span)
+          symbol = entry.lookup_value(name)
+
+          if symbol
+            return entry
+              .expose(symbol.to_ref)
+              .then { Result[it, []] }
+          end
+
+          Result[
+            entry,
+            [Error::ExposedValueNotFound.new(entry.name, span, name:)],
+          ]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module Jade
+  module Frontend
+    module ForwardDeclaration
+      module StructDeclaration
+        extend self
+        extend Helper
+
+        def shallow(node, registry, entry)
+          node => AST::StructDeclaration(name:, type_params:)
+
+          type_params
+            .map { Symbol.var(it.name, it.range) }
+            .then { Symbol.predeclared_struct(name, it, node.range) }
+            .then { entry.define(it) }
+            .then { Result[it, []] }
+        end
+
+        def deep(node, entry, _)
+          node => AST::StructDeclaration(name:, record_type:)
+
+          symbol = entry.lookup_type(name)
+
+          figure_out_type(entry, record_type)
+            .map do |record_type_symbol|
+              constructor_fn_symbol = Symbol.constructor(
+                name,
+                record_type_symbol.fields.values,
+                symbol.to_ref,
+                nil,
+              )
+
+              record_type_symbol
+                .then { symbol.with(record_type: it) }
+                .then { entry.define(it) }
+                .then { it.define(constructor_fn_symbol) }
+            end
+            .then { to_declaration_result(entry, it) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module Jade
+  module Frontend
+    module ForwardDeclaration
+      module TypeDeclaration
+        extend self
+        extend Helper
+
+        def shallow(node, registry, entry)
+          node => AST::TypeDeclaration(name:, type_params:, variants:)
+
+          predeclared_variants = variants
+            .map { |var| Symbol.predeclared_constructor(var.name, var.range) }
+
+          type_params.map { Symbol.var(it.name, it.range) }
+            .then { Symbol.union(name, it, predeclared_variants, node.range) }
+            .then { entry.define(it) }
+            .then { Result[it, []] }
+        end
+
+        def deep(node, entry, _)
+          node => AST::TypeDeclaration(name:, variants:)
+
+          symbol = entry.lookup_type(name)
+
+          variants
+            .map do |var|
+              var.args.map { figure_out_type(entry, it) }
+                .then { Results.sequence(it) }
+                .map { Symbol.constructor(var.name, it, symbol.to_ref, var.range) }
+            end
+            .then { Results.sequence(it) }
+            .map do |variant_symbols|
+              variant_symbols
+                .reduce(entry) { |acc_entry, sym| acc_entry.define(sym) }
+                .then { it.define(symbol.with(variants: variant_symbols.map(&:to_ref))) }
+            end
+            .then { to_declaration_result(entry, it) }
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/forward_declaration.rb

@@ -0,0 +1,71 @@
+require 'jade/frontend/forward_declaration/helper'
+require 'jade/frontend/forward_declaration/error'
+
+require 'jade/interop/lowering'
+
+require 'jade/frontend/forward_declaration/body'
+require 'jade/frontend/forward_declaration/function_declaration'
+require 'jade/frontend/forward_declaration/implementation'
+require 'jade/frontend/forward_declaration/implementation_function'
+require 'jade/frontend/forward_declaration/import_declaration'
+require 'jade/frontend/forward_declaration/interop_import_declaration'
+require 'jade/frontend/forward_declaration/module'
+require 'jade/frontend/forward_declaration/struct_declaration'
+require 'jade/frontend/forward_declaration/type_declaration'
+require 'jade/frontend/forward_declaration/interface_declaration'
+
+module Jade
+  module Frontend
+    module ForwardDeclaration
+      extend self
+
+      Result = Data.define(:entry, :errors) do
+        def add_errors(new_errors)
+          with(errors: errors + new_errors)
+        end
+
+        def to_result
+          errors.empty? ? Ok[entry] : Err[errors]
+        end
+      end
+
+      def declare(node, registry, entry)
+        shallow_declare_node(node, registry, entry)
+          .then { deep_declare_node(node, it.entry, registry).add_errors(it.errors) }
+          .to_result
+      end
+
+      def declare_entry(entry, registry)
+        declare(entry.ast, registry, entry)
+      end
+
+      def shallow_declare_node(node, registry, entry)
+        resolver(node, entry)
+          &.shallow(node, registry, entry) || Result[entry, []]
+      end
+
+      def deep_declare_node(node, entry, registry)
+        resolver(node, entry)
+          &.deep(node, entry, registry) || Result[entry, []]
+      end
+
+      private
+
+      def resolver(node, entry)
+        case node
+        in AST::Body then Body
+        in AST::FunctionDeclaration then FunctionDeclaration
+        in AST::Implementation then Implementation
+        in AST::ImportDeclaration then ImportDeclaration
+        in AST::InteropImportDeclaration then InteropImportDeclaration
+        in AST::Module then Module
+        in AST::StructDeclaration then StructDeclaration
+        in AST::TypeDeclaration then TypeDeclaration
+        in AST::InterfaceDeclaration then InterfaceDeclaration
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/pattern_analysis/exhaustiveness.rb

@@ -0,0 +1,65 @@
+module Jade
+  module Frontend
+    module PatternAnalysis
+      module Exhaustiveness
+        extend self
+
+        def assert(patterns, range, env, registry, expected)
+          Matrix[
+            patterns.map { [node_to_matrix_pattern(it)] },
+            [expected],
+          ]
+            .missing_patterns(env)
+            .then { to_errors(it, range, env) }
+        end
+
+        private
+
+        def to_errors(matrix, range, env)
+          return [] if matrix.empty?
+
+          TypeChecking::Error::MissingPatterns
+            .new(env.entry_name, range, missing_patterns: matrix.rows)
+            .then { [it] }
+        end
+
+        def node_to_matrix_pattern(pattern_node)
+          case pattern_node
+          in AST::Pattern::Record(fields:)
+            Record[
+              fields
+                .map(&:name)
+                .zip(fields.map(&:pattern))
+                .to_h
+                .transform_values { node_to_matrix_pattern(it) },
+            ]
+
+          in AST::Pattern::Constructor(constructor:, patterns:)
+            Constructor[
+              constructor.symbol.qualified_name,
+              patterns.map { node_to_matrix_pattern(it) },
+            ]
+
+          in AST::Pattern::List(patterns:, rest:)
+            # Rewrite [x, y | xs] / [x, y] into nested Cons/Nil constructors
+            tail = rest ? Wildcard[] : Constructor['List.Nil', []]
+            patterns
+              .map { node_to_matrix_pattern(it) }
+              .reverse
+              .reduce(tail) { |acc, head| Constructor['List.Cons', [head, acc]] }
+
+          in AST::Pattern::Binding | AST::Pattern::Wildcard
+            Wildcard[]
+
+          in AST::Pattern::Literal(literal: { value:, symbol: })
+            Literal[
+              value,
+              symbol.qualified_name,
+            ]
+
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/pattern_analysis/matrix.rb

@@ -0,0 +1,235 @@
+module Jade
+  module Frontend
+    module PatternAnalysis
+      Matrix = Data.define(:rows, :types) do
+        def self.wildcard(types)
+          types
+            .map { Wildcard[] }
+            .then { [it] }
+            .then { Matrix[it, types] }
+        end
+
+        def self.empty(types = [])
+          self.new([], types)
+        end
+
+        def map
+          rows
+            .map { yield it }
+            .then { with(rows: it) }
+        end
+
+        def include?(row)
+          rows.include?(row)
+        end
+
+        def size
+          rows.size
+        end
+
+        def empty?
+          rows.empty?
+        end
+
+        def any?
+          rows.any?
+        end
+
+        def concat(other)
+          with(rows: rows + other.rows)
+        end
+
+        def missing_patterns(env, seen_recursive_types = ::Set.new)
+          if types.empty?
+            return rows.empty? ? Matrix[[[]], types] : Matrix.empty
+          end
+
+          type = types.first
+
+          return Matrix.empty if never?(type)
+          return Matrix.wildcard(types) if rows.empty?
+
+          if infinite?(type) || type_var?(type) || seen_recursive_types.include?(type)
+            matrix = default
+              .missing_patterns(env, seen_recursive_types)
+
+            matrix
+              .map { [Wildcard[]] + it }
+
+          elsif expandable?(type, env)
+            expand(env).missing_patterns(env, seen_recursive_types)
+
+          else
+            new_seen = seen_recursive_types | ::Set[type]
+            constructors_of(type, env)
+              .reduce(Matrix.empty.with(types:)) do |acc, constructor|
+                missing = specialize(constructor)
+                  .missing_patterns(env, new_seen)
+
+                missing
+                  .map do |row|
+                    new_args = row.take(constructor.args.size)
+                    tail = row.drop(constructor.args.size)
+
+                  [Constructor[constructor.name, new_args]] + tail
+                end
+                .then { acc.concat(it) }
+              end
+          end
+        end
+
+        protected
+
+        def expandable?(type, env)
+          case type
+          in Type::AnonymousRecord
+            true
+
+          in Type::Application(constructor:)
+            env.lookup_def(constructor.name).is_a?(TypeChecking::StructDef)
+
+          else
+            false
+          end
+        end
+
+        def expand(env)
+          type_fields = 
+            case types.first
+            in Type::AnonymousRecord(fields:)
+              fields
+
+            in Type::Application(constructor:)
+              env.lookup_def(constructor.name).body.fields
+            end
+
+          map do |row|
+            case row.first
+            in Record(fields:)
+              type_fields
+                .map do |(k, v)|
+                  fields[k] || Wildcard[]
+                end + row.drop(1)
+
+            in Wildcard
+              type_fields.map { Wildcard[] } + row.drop(1)
+            end
+          end
+            .with(types: type_fields.values + types.drop(1))
+        end
+
+        def constructors_of(type, env)
+          case type
+          in Type::Application(constructor: Type::Constructor(name: 'Basics.Bool'))
+            [
+              TypeChecking::ConstructorDef['Basics.True', 'Basics.Bool', []],
+              TypeChecking::ConstructorDef['Basics.False', 'Basics.Bool', []],
+            ]
+          in Type::Application(constructor: Type::Constructor(name: /^Tuple\.Tuple([2-4])$/ => name))
+            n = name[-1].to_i
+            [TypeChecking::Definition.constructor(name, name, Array.new(n) { env.fresh })]
+
+          in Type::Application(constructor: Type::Constructor(name: 'List.List'), args: [elem_type])
+            [
+              TypeChecking::ConstructorDef['List.Nil',  'List.List', []],
+              TypeChecking::ConstructorDef['List.Cons', 'List.List', [elem_type, type]],
+            ]
+
+          else
+            type_def = env.lookup_def(type.constructor.name)
+
+            # Type the user can't destructure from here (transitively reached
+            # through an imported struct field, or opaque intrinsic) —
+            # any pattern they can write is trivially exhaustive.
+            return [] if type_def.nil? || type_def.opaque?
+
+            type_def
+              .constructors
+              .map do |con|
+                con
+                  .args
+                  .map do |arg|
+                    if type_var?(arg)
+                      type_def
+                        .type_params
+                        .find_index { arg.name == it.name }
+                        .then { type.args.at(it) }
+
+                    else
+                      arg
+                    end
+                  end
+                .then { con.with(args: it) }
+              end
+          end
+        end
+
+        def specialize(constructor)
+          rows
+            .filter_map do |cols|
+              case cols.first
+              in Literal(value:)
+                next [] + cols.drop(1) if value == false && "Basics.False" == constructor.name
+                next [] + cols.drop(1) if value == true && "Basics.True" == constructor.name
+
+              in Constructor(constructor: cons_name, args:)
+                args + cols.drop(1) if cons_name == constructor.name
+
+              in Wildcard
+                constructor.args.map { Wildcard[] } + cols.drop(1)
+
+              end
+            end
+            .then { with(rows: it) }
+            .then { it.with(types: constructor.args) }
+        end
+
+        def default
+          rows
+            .select { it.first.wildcard? }
+            .map { it.drop(1) }
+            .then { with(rows: it) }
+            .with(types: types.drop(1))
+        end
+
+        def add(columns)
+          with(rows: rows.concat(columns))
+        end
+
+        private
+
+        def never?(type)
+          case type
+          in Type::Application(constructor: Type::Constructor(name: 'Basics.Never'))
+            true
+          else
+            false
+          end
+        end
+
+        def type_var?(type)
+          type.is_a?(Type::Var)
+        end
+
+        def infinite?(type)
+          case type
+          in Type::Function
+            true
+
+          in Type::Application(constructor:)
+            case constructor
+            in Type::Constructor(name: 'Basics.Int') then true
+            in Type::Constructor(name: 'Basics.Float') then true
+            in Type::Constructor(name: 'String.String') then true
+            else
+              false
+            end
+
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/pattern_analysis.rb

@@ -0,0 +1,40 @@
+require 'jade/frontend/pattern_analysis/matrix'
+require 'jade/frontend/pattern_analysis/exhaustiveness'
+
+module Jade
+  module Frontend
+    module PatternAnalysis
+      Wildcard = Data.define do
+        def wildcard?; true; end
+        def to_s; '_'; end
+      end
+
+      Literal = Data.define(:value, :type) do
+        def wildcard?; false; end
+        def to_s; value.inspect; end
+      end
+
+      Constructor = Data.define(:constructor, :args) do
+        def wildcard?; false; end
+
+        def to_s
+          if constructor.start_with?('Tuple.')
+            "(#{args.map(&:to_s).join(', ')})"
+          else
+            name = constructor.split('.').last
+            args.empty? ? name : "#{name}(#{args.map(&:to_s).join(', ')})"
+          end
+        end
+      end
+
+      Record = Data.define(:fields) do
+        def wildcard?; false; end
+
+        def to_s
+          fields_str = fields.map { |k, v| "#{k}: #{v}" }.join(', ')
+          "{ #{fields_str} }"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module Assign
+        extend self
+        extend Helper
+
+        def analyze(node, registry, scope, entry)
+          node => AST::Assign(pattern:, expression:)
+
+          ptn_r = analyze_node(pattern, registry, scope, entry)
+          Result.combine(node, scope: ptn_r.scope,
+            pattern: ptn_r,
+            expression: analyze_node(expression, registry, scope, entry),
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module Body
+        extend self
+        extend Helper
+
+        def analyze(node, registry, scope, entry)
+          node => AST::Body(expressions:)
+
+          duplicate_errors = expressions
+            .select { it.is_a?(AST::FunctionDeclaration) }
+            .group_by(&:name)
+            .filter_map do |name, decls|
+              next nil if decls.size < 2
+
+              first, *rest = decls
+              Error::DuplicateFunctionDeclaration.new(
+                entry.name,
+                first.range,
+                name,
+                duplicate_spans: rest.map(&:range),
+              )
+            end
+
+          analyze_in_sequence(expressions, registry, scope, entry)
+            .add_errors(duplicate_errors)
+            .map_node { node.with(expressions: it) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module CaseOf
+        extend self
+        extend Helper
+
+        def analyze(node, registry, scope, entry)
+          node => AST::CaseOf(expression:, branches:)
+
+          Result.combine(node, scope:,
+            expression: analyze_node(expression, registry, scope, entry),
+            branches: analyze_in_parallel(branches, registry, scope, entry),
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module CaseOfBranch
+        extend self
+        extend Helper
+
+        def analyze(node, registry, scope, entry)
+          node => AST::CaseOfBranch(pattern:, body:)
+
+          ptn_r = analyze_node(pattern, registry, scope, entry)
+          Result.combine(node, scope:,
+            pattern: ptn_r,
+            body: analyze_node(body, registry, ptn_r.scope, entry),
+          )
+        end
+      end
+    end
+  end
+end