jade-lang 0.1.0

data/lib/jade/frontend/forward_declaration/error/exposed_type_not_found.rb

@@ -0,0 +1,18 @@
+module Jade
+  module Frontend
+    module ForwardDeclaration
+      module Error
+        class ExposedTypeNotFound < Jade::Error
+          def initialize(entry, span, name:)
+            @name = name
+            super(entry:, span:)
+          end
+
+          def message
+            "Your are trying to expose a type named `#{@name}` but I cannot find its definition"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/forward_declaration/error/exposed_value_not_found.rb

@@ -0,0 +1,18 @@
+module Jade
+  module Frontend
+    module ForwardDeclaration
+      module Error
+        class ExposedValueNotFound < Jade::Error
+          def initialize(entry, span, name:)
+            @name = name
+            super(entry:, span:)
+          end
+
+          def message
+            "Your are trying to expose a value named `#{@name}` but I cannot find its definition"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/forward_declaration/error/module_not_found.rb

@@ -0,0 +1,18 @@
+module Jade
+  module Frontend
+    module ForwardDeclaration
+      module Error
+        class ModuleNotFound < Jade::Error
+          def initialize(entry, span, name:)
+            @name = name
+            super(entry:, span:)
+          end
+
+          def message
+            "Your are trying to import a module named `#{@name}` but I cannot find it"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/forward_declaration/error/private_type_expansion.rb

@@ -0,0 +1,19 @@
+module Jade
+  module Frontend
+    module ForwardDeclaration
+      module Error
+        class PrivateTypeExpansion < Jade::Error
+          def initialize(entry, span, name:, module_name:)
+            @name = name
+            @module_name = module_name
+            super(entry:, span:)
+          end
+
+          def message
+            "#{@module_name}'s `#{@name}` type does not allow `(..)` because its constructors are private"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/forward_declaration/error/tuple_arity_overflow.rb

@@ -0,0 +1,25 @@
+module Jade
+  module Frontend
+    module ForwardDeclaration
+      module Error
+        class TupleArityOverflow < Jade::Error
+          MAX_ARITY = 4
+
+          def initialize(entry, span, arity:)
+            super(entry:, span:)
+            @arity = arity
+          end
+
+          def message
+            "Tuple of #{@arity} items is too big — tuples cap at #{MAX_ARITY}. " \
+              "Use a record or a struct."
+          end
+
+          def label
+            "#{@arity}-tuple"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/forward_declaration/error/type_not_found.rb

@@ -0,0 +1,29 @@
+module Jade
+  module Frontend
+    module ForwardDeclaration
+      module Error
+        class TypeNotFound < Jade::Error
+          attr_reader :candidates
+
+          def initialize(entry, span, name:, candidates: [])
+            @name = name
+            @candidates = candidates
+            super(entry:, span:)
+          end
+
+          def message
+            "Type `#{@name}` is not defined"
+          end
+
+          def label
+            "not found"
+          end
+
+          def queried_name
+            @name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/forward_declaration/error/type_not_lowerable.rb

@@ -0,0 +1,16 @@
+module Jade
+  module Frontend
+    module ForwardDeclaration
+      module Error
+        class TypeNotLowerable < Jade::Error
+          attr_reader :message
+
+          def initialize(entry, span, message:)
+            super(entry:, span:)
+            @message = message
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/forward_declaration/error/unknown_extends_interface.rb

@@ -0,0 +1,18 @@
+module Jade
+  module Frontend
+    module ForwardDeclaration
+      module Error
+        class UnknownExtendsInterface < Jade::Error
+          def initialize(entry, span, interface:)
+            @interface = interface
+            super(entry:, span:)
+          end
+
+          def message
+            "I cannot find an interface named `#{@interface}`"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+require 'jade/error'
+
+require 'jade/frontend/forward_declaration/error/bad_import'
+require 'jade/frontend/forward_declaration/error/exposed_type_not_found'
+require 'jade/frontend/forward_declaration/error/exposed_value_not_found'
+require 'jade/frontend/forward_declaration/error/module_not_found'
+require 'jade/frontend/forward_declaration/error/private_type_expansion'
+require 'jade/frontend/forward_declaration/error/type_not_lowerable'
+require 'jade/frontend/forward_declaration/error/unknown_extends_interface'
+require 'jade/frontend/forward_declaration/error/type_not_found'
+require 'jade/frontend/forward_declaration/error/tuple_arity_overflow'

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

@@ -0,0 +1,32 @@
+module Jade
+  module Frontend
+    module ForwardDeclaration
+      module FunctionDeclaration
+        extend self
+        extend Helper
+
+        def shallow(node, registry, entry)
+          node => AST::FunctionDeclaration(name:, range:)
+
+          Symbol
+            .predeclared_function(name, range)
+            .then { entry.define(it) }
+            .then { Result[it, []] }
+        end
+
+        def deep(node, entry, _)
+          node => AST::FunctionDeclaration(name:, params:, return_type:, range:)
+
+          params
+            .map { |param| param.type.then { figure_out_type(entry, it) }.map { [param.name, it] } }
+            .then { Results.sequence(it) }
+            .map(&:to_h)
+            .and_then { |params_types| figure_out_type(entry, return_type).map { [params_types, it] } }
+            .map { |params_types, return_type_type| Symbol.function(name, params_types, return_type_type, range) }
+            .map { entry.define(it) }
+            .then { to_declaration_result(entry, it) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+module Jade
+  module Frontend
+    module ForwardDeclaration
+      module Helper
+        def shallow_declare_node(ast, registry, entry)
+          ForwardDeclaration.shallow_declare_node(ast, registry, entry)
+        end
+
+        def deep_declare_node(ast, entry, registry)
+          ForwardDeclaration.deep_declare_node(ast, entry, registry)
+        end
+
+        def figure_out_type(entry, node)
+          case node
+          in AST::TypeVar(type:)
+            Ok[Symbol.var(type, node.range)]
+
+          in AST::TypeName(type:)
+            require_type(entry, type, node.range)
+              .map { Symbol.type_application(it.to_ref, []) }
+
+          in AST::TypeApplication(constructor:, args:)
+            constructor_r =
+              case constructor
+              in AST::TypeName
+                require_type(entry, constructor.type, constructor.range)
+
+              in AST::QualifiedTypeName(path:)
+                *module_parts, type_name = path
+                require_qualified_type(entry, module_parts.join('.'), type_name, constructor.range)
+              end
+
+            args
+              .map { figure_out_type(entry, it) }
+              .then { Results.sequence(it) }
+              .and_then { |resolved_args| constructor_r.map { Symbol.type_application(it.to_ref, resolved_args, node.range) } }
+
+          in AST::TypeFunction(params:, return_type:)
+            params
+              .map { figure_out_type(entry, it) }
+              .then { Results.sequence(it) }
+              .and_then { |resolved_params| figure_out_type(entry, return_type).map { Symbol.function_type(resolved_params, it) } }
+
+          in AST::TypeTuple(items:) if items.length > Error::TupleArityOverflow::MAX_ARITY
+            Err[Error::TupleArityOverflow.new(entry&.name, node.range, arity: items.length)]
+
+          in AST::TypeTuple(items:)
+            type_name = Stdlib::Tuple.constructor_by_arity(items.length)
+
+            items
+              .map { figure_out_type(entry, it) }
+              .then { Results.sequence(it) }
+              .map { Symbol.type_application(Symbol.type_ref(*type_name.split('.')), it, node.range) }
+
+          in AST::TypeRecord(fields:, row_var:)
+            row = row_var&.then { |row| Symbol.var(row.name, row.range) }
+
+            fields
+              .map { |k, v| figure_out_type(entry, v).map { [k, it] } }
+              .then { Results.sequence(it) }
+              .map { Symbol.record_type(it.to_h, row) }
+          end
+        end
+
+        private
+
+        def require_type(entry, name, span)
+          entry.lookup_type(name)
+            &.then { Ok[it] } ||
+            Err[Error::TypeNotFound.new(
+              entry.name, span, name:,
+              candidates: entry.types.keys,
+            )]
+        end
+
+        def require_qualified_type(entry, module_path, type_name, span)
+          entry.lookup_qualified_type(module_path, type_name)
+            &.then { Ok[it] } ||
+            Err[Error::TypeNotFound.new(entry.name, span, name: "#{module_path}.#{type_name}")]
+        end
+
+        def to_declaration_result(entry, r)
+          case r
+          in Ok[sym] then Result[sym, []]
+          in Err[e]  then Result[entry, [e]]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+module Jade
+  module Frontend
+    module ForwardDeclaration
+      module Implementation
+        extend self
+        extend Helper
+
+        def shallow(_node, _registry, entry)
+          Result[entry, []]
+        end
+
+        def deep(node, entry, _registry)
+          node => AST::Implementation(interface:, applied_type:, extends:, functions:)
+
+          interface_r = require_type(entry, interface, node.range)
+
+          extends_errors = extends
+            .filter_map do |iface_name|
+              next if entry.lookup_type(iface_name)
+
+              Error::UnknownExtendsInterface.new(entry.name, node.range, interface: iface_name)
+            end
+
+          return Result[entry, extends_errors] if extends_errors.any?
+
+          interface_r
+            .and_then do |interface_sym|
+              figure_out_type(entry, applied_type).map { [interface_sym, it] }
+            end
+            .map do |interface_sym, applied_type_sym|
+              type_name =
+                case applied_type.constructor
+                in AST::TypeName(type:) then type
+                in AST::QualifiedTypeName(path:) then path.last
+                end
+              extends_refs = extends.map { entry.lookup_type(it).to_ref }
+
+              entry_with_fns, fn_map = functions
+                .reduce([entry, {}]) do |(acc_entry, acc_map), impl_fn|
+                  ImplementationFunction
+                    .declare(impl_fn, acc_entry, interface, type_name)
+                    .then { |e, ref| [e, acc_map.merge(impl_fn.name => ref)] }
+                end
+
+              Symbol
+                .implementation(
+                  interface_sym.to_ref,
+                  applied_type_sym.constructor,
+                  [],
+                  [],
+                  fn_map,
+                  [],
+                  node.range,
+                  extends: extends_refs,
+                )
+                .then { entry_with_fns.define(it) }
+            end
+            .then { to_declaration_result(entry, it) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+require 'jade/codegen/helpers'
+
+module Jade
+  module Frontend
+    module ForwardDeclaration
+      module ImplementationFunction
+        extend self
+        extend Codegen::Helpers
+
+        def declare(impl_fn, entry, interface, type_name)
+          impl_fn => AST::ImplementationFunction(name: fn_name, fn:)
+
+          case fn
+          in AST::Lambda(params: lambda_params)
+            synth_name = impl_synthetic_name(interface, type_name, fn_name)
+
+            stub_params, stub_return = [
+              lambda_params
+                .zip(0..)
+                .to_h { |_, i| [param_synthetic_name(i), Symbol.var(param_synthetic_name(i), nil)] },
+              Symbol.var("r", nil),
+            ]
+
+            Symbol
+              .function(synth_name, stub_params, stub_return)
+              .then { [entry.define(it), Symbol.value_ref(entry.name, synth_name)] }
+
+
+          in AST::VariableReference
+            [
+              entry,
+              Symbol.value_ref(entry.name, fn.name),
+            ]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+module Jade
+  module Frontend
+    module ForwardDeclaration
+      module ImportDeclaration
+        extend self
+
+        # TODO: This does a lot, so It could just be import registration.
+        #  everything else doesn't need the registry at all
+        def shallow(ast, registry, entry)
+          ast => AST::ImportDeclaration(module_name:, as:, exposing:)
+
+          importing_module = registry.get(module_name)
+
+          unless importing_module
+            return [
+              entry,
+              [ModuleNotFound.new(entry, ast.range, name: module_name)],
+            ]
+          end
+
+          exposing_to_symbol(exposing, entry, importing_module)
+            .map { ImportEntry[module_name, as&.as || module_name, it, importing_module.exposes] }
+            .on_err { return Result[entry, it] } => Ok(import_entry)
+
+          Result[entry.import(import_entry), []]
+        end
+
+        def deep(_, entry, _)
+          Result[entry, []]
+        end
+
+        private
+
+        def exposing_to_symbol(exposing, current_entry, importing_module)
+          case exposing
+          in AST::ExposeNone then Ok[[]]
+          in AST::ExposeAll then Ok[importing_module.exposed]
+          in AST::ExposeList(items:) then handle_exposing_list(items, current_entry, importing_module)
+          end
+        end
+
+        def bad_import(current_entry, span, module_name, name)
+          Err[Error::BadImport.new(current_entry.name, span, module_name:, name:)]
+        end
+
+        def handle_exposing_list(items, current_entry, importing_module)
+          items
+            .map do |item|
+              case item
+              in AST::ExposeValue(name:, range:)
+                handle_exposing_value(name, range, current_entry, importing_module)
+
+              in AST::ExposeType(name:, range:)
+                handle_exposing_type(name, range, current_entry, importing_module)
+
+              in AST::ExposeTypeExpand(name:, range:)
+                handle_exposing_type(name, range, current_entry, importing_module)
+                  .and_then do |type|
+                    handling_exposing_type_expansion(
+                      type, name, range, current_entry, importing_module
+                    )
+                  end
+              end
+            end
+            .then { combine_results(it) }
+            .map(&:flatten)
+        end
+
+        def handle_exposing_value(name, span, current_entry, importing_module)
+          importing_module
+            .exposed_value(name)
+            .then do
+              it ? Ok[it] : bad_import(current_entry, span, importing_module.name, name)
+            end
+        end
+
+        def handle_exposing_type(name, span, current_entry, importing_module)
+          importing_module
+            .exposed_type(name)
+            .then do
+              it ? Ok[it] : bad_import(current_entry, span, importing_module.name, name)
+            end
+        end
+
+        def handling_exposing_type_expansion(type, name, span, current_entry, importing_module)
+          importing_module
+            .exposed_type_variants(name)
+            .then  do |variants|
+              if variants
+                Ok[variants + [type]]
+              else
+                Error::PrivateTypeExpansion
+                  .new(current_entry.name, span, name:, module_name: importing_module.name)
+                  .then { Err[it] }
+              end
+            end
+        end
+
+        def combine_results(results)
+          oks, errs = results.partition(&:ok?)
+
+          if errs.empty?
+            oks
+              .map { it => Ok(ok); ok }
+              .then { Ok[it] }
+          else
+            errs
+              .map { it => Err(err); err }
+              .then { Err[it] }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+module Jade
+  module Frontend
+    module ForwardDeclaration
+      module InterfaceDeclaration
+        extend self
+        extend Helper
+
+        def shallow(node, _registry, entry)
+          node => AST::InterfaceDeclaration(name:, type_param:, functions:)
+
+          interface_ref = Symbol.type_ref(entry.name, name)
+          type_var = Symbol.var(type_param.name, type_param.range)
+
+          functions
+            .map do |fn|
+              Symbol
+                .interface_function(fn.name, interface_ref, [], nil, fn.range)
+            end
+            .then do |fn_symbols|
+              Symbol.interface(name, type_var, fn_symbols, {}, node.range)
+                .then { entry.define(it) }
+                .then { fn_symbols.reduce(it) { |acc, fn| acc.define(fn) } }
+            end
+            .then { Result[it, []] }
+        end
+
+        def deep(node, entry, _registry)
+          node => AST::InterfaceDeclaration(name:, functions:)
+
+          symbol = entry.lookup_type(name)
+          interface_ref = symbol.to_ref
+
+          functions
+            .map { build_interface_function(entry, interface_ref, it) }
+            .then { Results.sequence(it) }
+            .map do |fn_symbols|
+              fn_symbols
+                .reduce(entry) { |acc, fn| acc.define(fn) }
+                .then { it.define(symbol.with(functions: fn_symbols)) }
+            end
+            .then { to_declaration_result(entry, it) }
+        end
+
+        private
+
+        def build_interface_function(entry, interface_ref, fn_decl)
+          fn_decl => AST::InterfaceFunctionDecl(name:, type:, range:)
+
+          figure_out_type(entry, type)
+            .map do |type_symbol|
+              params, return_type =
+                case type_symbol
+                in Symbol::FunctionType(params:, return_type:)
+                  [params, return_type]
+                else
+                  [[], type_symbol]
+                end
+
+              Symbol
+                .interface_function(name, interface_ref, params, return_type, range)
+            end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+module Jade
+  module Frontend
+    module ForwardDeclaration
+      module InteropImportDeclaration
+        extend self
+        extend Helper
+
+        def shallow(node, registry, entry)
+          node => AST::InteropImportDeclaration(functions:)
+
+          functions
+            .reduce(entry) do |acc, fn|
+              Symbol
+                .predeclared_interop_function(fn.name)
+                .then { entry.define(it) }
+            end
+            .then { Result[it, []] }
+        end
+
+        def deep(node, entry, registry)
+          node => AST::InteropImportDeclaration(module: mod_name, functions:)
+
+          functions
+            .reduce([entry, []]) do |(acc, errors), fn|
+              case figure_out_type(entry, fn.type)
+              in Err[e]
+                [acc, errors + [e]]
+
+              in Ok[type_sym]
+                wrap_in_fn_type(type_sym)
+                  .then { fn_type_to_interop(mod_name, fn, it, entry, registry) }
+                  .then { |(sym, interop_errors)| [acc.define(sym), errors + interop_errors] }
+              end
+            end
+            .then { Result[*it] }
+        end
+
+        private
+
+        def wrap_in_fn_type(symbol)
+          case symbol
+          in Symbol::Function | Symbol::FunctionType
+            symbol
+          else
+            Symbol.function_type([], symbol)
+          end
+        end
+
+        def fn_type_to_interop(interop_mod_name, function_node, symbol, entry, registry)
+          lifted_errors = Interop::Lowering
+            .validate(symbol.return_type, registry, entry)
+            .map { Error::TypeNotLowerable.new(entry, function_node.range, message: it.message) }
+
+          Symbol
+            .interop_function(
+              function_node.name,
+              symbol.params,
+              symbol.return_type,
+              interop_mod_name.name,
+              constraints: implicit_decodable_constraints(symbol.return_type),
+            )
+            .then { [it, lifted_errors] }
+        end
+
+        # Free type variables anywhere under the return TypeApplication's
+        # arms get an implicit Decodable constraint. Ports resolve these
+        # to dict markers (bare arms) or partial impls (nested arms) in
+        # port_resolution.rb. Non-port shapes yield [].
+        def implicit_decodable_constraints(return_type)
+          case return_type
+          in Symbol::TypeApplication(args:)
+            args
+              .flat_map { collect_var_names(it) }
+              .uniq
+              .map { ['Decode.Decodable', it] }
+          else
+            []
+          end
+        end
+
+        def collect_var_names(type_sym)
+          case type_sym
+          in Symbol::Variable(name:)
+            [name]
+
+          in Symbol::TypeApplication(args:)
+            args.flat_map { collect_var_names(it) }
+
+          in Symbol::RecordType(fields:)
+            fields.values.flat_map { collect_var_names(it) }
+
+          else
+            []
+          end
+        end
+      end
+    end
+  end
+end