jade-lang 0.8.0 → 0.10.0

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

@@ -49,6 +49,24 @@ module Jade
           Result[results.map(&:node), results.flat_map(&:errors), scope]
         end
 
+        # A local alias is a `Symbol::Alias`; one that crossed a module arrives
+        # as a `TypeRef`, so both spellings have to be resolved before asking.
+        def resolved_alias(symbol, registry)
+          symbol
+            .then { it.is_a?(Symbol::TypeRef) ? registry.lookup(it) : it }
+            .then { it if it.is_a?(Symbol::Alias) }
+        end
+
+        private def lookup_applied_type(applied_type, entry)
+          case applied_type.constructor
+          in AST::TypeName(type:)
+            entry.lookup_type(type)
+          in AST::QualifiedTypeName(path:)
+            *module_parts, type_name = path
+            entry.lookup_qualified_type(module_parts.join('.'), type_name)
+          end
+        end
+
         def analyze_duplicate_fields(fields, entry)
           fields
             .group_by(&:key)
@@ -87,9 +105,28 @@ module Jade
 
           in Symbol::RecordType(row_var:)
             row_var.nil? ? [] : [row_var]
+
+          in Symbol::Alias(body:)
+            # Aliases are transparent — vars are whatever the body has.
+            # Skip if body unresolved (cycle / pre-deep-decl).
+            body ? collect_vars(body, registry) : []
           end
         end
 
+        def validate_inhabited(symbol_ref, registry, entry, kind:)
+          symbol = registry.lookup(symbol_ref)
+          return [] if Inhabitedness.inhabited?(symbol, registry)
+
+          [
+            Error::NoBaseCase.new(
+              entry.name,
+              symbol.decl_span,
+              name: symbol_ref.name,
+              kind:,
+            ),
+          ]
+        end
+
         def validate_type_symbol(symbol, registry, entry)
           case symbol
           in Symbol::Union(variants:, type_params:)
@@ -144,6 +181,10 @@ module Jade
           in Symbol::Struct(type_params:, record_type:)
             validate_type_symbol(record_type, registry, entry) +
               type_params.flat_map { validate_type_symbol(it, registry, entry) }
+
+          in Symbol::Alias(type_params:, body:)
+            (body ? validate_type_symbol(body, registry, entry) : []) +
+              type_params.flat_map { validate_type_symbol(it, registry, entry) }
           end
         end
       end

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

@@ -20,6 +20,19 @@ module Jade
           functions_r = analyze_in_parallel(functions, registry, scope, entry)
 
           make_error = ->(klass, **kw) { klass.new(entry.name, node.range, **kw) }
+
+          resolved_alias(type_sym, registry).then do |alias_sym|
+            if alias_sym
+              return make_error
+                .(
+                  Error::ImplementationOnAlias,
+                  interface: entry.lookup_type(interface).qname,
+                  alias_name: alias_sym.qname,
+                )
+                .then { Result[node, [it], scope] }
+            end
+          end
+
           type_is_local = entry.defined_types.key?(local_type_name(applied_type))
 
           unless entry.defined_types.key?(interface) || type_is_local
@@ -73,16 +86,6 @@ module Jade
 
         private
 
-        def lookup_applied_type(applied_type, entry)
-          case applied_type.constructor
-          in AST::TypeName(type:)
-            entry.lookup_type(type)
-          in AST::QualifiedTypeName(path:)
-            *module_parts, type_name = path
-            entry.lookup_qualified_type(module_parts.join('.'), type_name)
-          end
-        end
-
         def local_type_name(applied_type)
           case applied_type.constructor
           in AST::TypeName(type:) then type

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

@@ -0,0 +1,90 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      # Least fixed point over "can a value of this type be built at all".
+      # A type currently being asked about counts as uninhabited, so a shape
+      # that needs itself to exist bottoms out at false rather than looping.
+      module Inhabitedness
+        extend self
+
+        DECLARATIONS = [Symbol::Union, Symbol::Struct, Symbol::Alias].freeze
+
+        def inhabited?(symbol, registry)
+          reachable?(symbol, registry, ::Set[], {})
+        end
+
+        private
+
+        def reachable?(sym, registry, visiting, subst)
+          case sym
+          in Symbol::Variable(name:)
+            subst.fetch(name, true)
+
+          in Symbol::RecordType(fields:)
+            fields.values.all? { reachable?(it, registry, visiting, subst) }
+
+          in Symbol::TypeRef
+            declaration(registry.lookup(sym), [], registry, visiting)
+
+          in Symbol::TypeApplication(constructor:, args:)
+            args
+              .map { reachable?(it, registry, visiting, subst) }
+              .then { declaration(resolve(constructor, registry), it, registry, visiting) }
+
+          in Symbol::Union | Symbol::Struct | Symbol::Alias
+            declaration(sym, [], registry, visiting)
+
+          else
+            true
+          end
+        end
+
+        def resolve(constructor, registry)
+          constructor.is_a?(Symbol::TypeRef) ? registry.lookup(constructor) : constructor
+        end
+
+        def declaration(head, arg_values, registry, visiting)
+          return true unless DECLARATIONS.any? { head.is_a?(it) }
+
+          # A declaration asked about on its own has no arguments to speak of,
+          # and a parameter stands for whatever a caller supplies, so it
+          # counts as something that exists.
+          values = head.type_params.each_index.map { arg_values.fetch(it, true) }
+          key = [head.qualified_name, values]
+          return false if visiting.include?(key)
+
+          seen = visiting + [key]
+          subst = head.type_params.map(&:name).zip(values).to_h
+
+          case head
+          in Symbol::Alias(body:)
+            body.nil? || reachable?(body, registry, seen, subst)
+
+          in Symbol::Struct(record_type:)
+            record_type.nil? || reachable?(record_type, registry, seen, subst)
+
+          in Symbol::Union(variants:) if tuple?(head)
+            values.all?
+
+          in Symbol::Union(variants:)
+            variants.empty? || variants.any? { buildable?(it, registry, seen, subst) }
+          end
+        end
+
+        # A tuple carries no variants to read, and unlike the other natives
+        # written that way it is a product: there is no empty one to fall back
+        # on the way a `List` has `[]`.
+        def tuple?(head)
+          head.qualified_name.start_with?('Tuple.Tuple')
+        end
+
+        def buildable?(variant_ref, registry, visiting, subst)
+          registry
+            .lookup(variant_ref)
+            .args
+            .all? { reachable?(it, registry, visiting, subst) }
+        end
+      end
+    end
+  end
+end

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

@@ -18,7 +18,7 @@ module Jade
             .flat_map { validate_type_symbol(it.symbol, registry, entry) }
 
           task_errors = functions_with_symbols
-            .flat_map { |fn| task_shape_errors(fn, entry) }
+            .flat_map { |fn| task_shape_errors(fn, registry, entry) }
 
           Result
             .init(node.with(functions: functions_with_symbols), scope)
@@ -27,38 +27,50 @@ module Jade
 
         private
 
-        def task_shape_errors(fn, entry)
-          unless task_type?(fn.symbol.return_type)
+        TASK = 'Task.Task'
+
+        # Asked of the expanded type rather than the written symbol: an alias
+        # is its body, and both questions here are about the shape.
+        def task_shape_errors(fn, registry, entry)
+          return_type = expand(fn.symbol.return_type, registry)
+
+          unless task_type?(return_type)
             Error::NonTaskPort
               .new(entry.name, fn.range, fn_name: fn.name)
               .then { return [it] }
           end
 
-          fn.symbol.return_type => Symbol::TypeApplication(args: [ok_arm, err_arm])
+          return_type => Type::Application(args: [ok_arm, err_arm])
 
           [ok_arm, err_arm]
             .any? { contains_task?(it) }
             .then { it ? [Error::NestedTaskPort.new(entry.name, fn.range, fn_name: fn.name)] : [] }
         end
 
-        def task_type?(symbol)
-          case symbol
-          in Symbol::TypeApplication(constructor: Symbol::TypeRef['Task', 'Task'])
-            true
+        def expand(symbol, registry)
+          Type
+            .from_symbol(symbol, registry, TypeChecking::VarGen.new)
+            .first
+        end
 
-          else
-            false
-          end
+        def task_type?(type)
+          type in Type::Application(constructor: Type::Constructor(name: TASK))
         end
 
-        def contains_task?(symbol)
-          case symbol
-          in Symbol::TypeApplication(constructor: Symbol::TypeRef['Task', 'Task'])
-             true
+        def contains_task?(type)
+          case type
+          in Type::Application(constructor: Type::Constructor(name: TASK))
+            true
 
-          in Symbol::TypeApplication(args:)
+          in Type::Application(args:)
             args.any? { contains_task?(it) }
 
+          in Type::Function(args:, return_type:)
+            (args + [return_type]).any? { contains_task?(it) }
+
+          in Type::AnonymousRecord(fields:)
+            fields.values.any? { contains_task?(it) }
+
           else
             false
           end

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

@@ -44,8 +44,10 @@ module Jade
         # still bare AST and `Placeholder.lift` can turn the call into a
         # lambda — the same route a positional partial application takes.
         def partially_applied(node, callee, fields, parent, constructor, registry, scope, entry, callee_r)
-          errors = Validation.errors(node, fields, parent, constructor, registry, entry) +
-            placeholder_errors(fields, parent, entry)
+          # A positional variant has no field names, so every key is also
+          # an unknown field. The placeholder error is the one that says why.
+          errors = placeholder_errors(fields, parent, constructor, entry)
+            .then { it.any? ? it : Validation.errors(node, fields, parent, constructor, registry, entry) }
 
           return Result[node, callee_r.errors + errors, scope] if errors.any?
 
@@ -81,12 +83,26 @@ module Jade
             end
         end
 
-        def placeholder_errors(fields, parent, entry)
-          return [] if parent.is_a?(Symbol::Struct)
+        # Validation already reports a keyed call on a plain function. A
+        # keyed variant lowers to a record literal, which takes holes.
+        def placeholder_errors(fields, parent, constructor, entry)
+          return [] if constructor.nil? || parent.is_a?(Symbol::Struct)
+          return [] if keyed_variant?(constructor)
 
           fields
             .select { it.value.is_a?(AST::Placeholder) }
-            .map { Error::PlaceholderNotAllowed.new(entry.name, it.range, field: it.key) }
+            .map do
+              Error::PlaceholderNotAllowed.new(
+                entry.name,
+                it.range,
+                field: it.key,
+                name: constructor.name,
+              )
+            end
+        end
+
+        def keyed_variant?(constructor)
+          constructor in Symbol::Constructor(args: [Symbol::RecordType])
         end
 
         def lower(node, callee, fields, parent, constructor, registry)

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

@@ -0,0 +1,16 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module PatternRange
+        extend self
+        extend Helper
+
+        # Both bounds are integer literals, so there is no name to resolve and
+        # nothing to bind.
+        def analyze(node, _registry, scope, _entry)
+          Result.init(node, scope)
+        end
+      end
+    end
+  end
+end

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

@@ -14,6 +14,7 @@ module Jade
             .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))
+            .add_errors(validate_inhabited(symbol_ref, registry, entry, kind: 'struct'))
         end
 
         private

data/lib/jade/frontend/semantic_analysis/type_alias_declaration/cycle_detection.rb

@@ -0,0 +1,95 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module TypeAliasDeclaration
+        # An alias is replaced by its body, so one that reaches itself would
+        # expand forever. This finds the path back, or nothing.
+        module CycleDetection
+          extend self
+
+          def call(symbol_ref, registry, entry)
+            symbol = registry.lookup(symbol_ref)
+            return [] unless symbol.body
+
+            qname = symbol.qualified_name
+            cycle = find(qname, symbol.body, registry, [qname], ::Set[])
+
+            return [] unless cycle
+            return [] unless reports_for?(qname, cycle, registry)
+
+            [
+              Error::RecursiveTypeAlias.new(
+                entry.name,
+                symbol.decl_span,
+                name: symbol_ref.name,
+                cycle: cycle.map { Symbol.unqualified_name(it) },
+              ),
+            ]
+          end
+
+          private
+
+          # Every alias in a cycle finds it, so `A = B, B = A` would be
+          # reported twice for one mistake. The first by declaration reports
+          # and the rest stay quiet, which needs no state shared between
+          # declarations since each walk already knows the whole cycle.
+          def reports_for?(qname, cycle, registry)
+            qname == cycle.min_by { declaration_order(it, registry) }
+          end
+
+          def declaration_order(qname, registry)
+            Symbol
+              .type_ref_from_qualified_name(qname)
+              .then { registry.lookup(it) }
+              .then { [it.decl_span&.begin || 0, qname] }
+          end
+
+          # Returns the qname-path back to `start_qname` if found, nil
+          # otherwise. Whether an alias reaches `start_qname` does not depend
+          # on the path taken to it, so `explored` is shared across the whole
+          # walk and an alias that came up clean once is never walked again.
+          # Without it an alias naming another one twice doubles the work per
+          # level.
+          def find(start_qname, sym, registry, visited, explored)
+            case sym
+            in Symbol::TypeRef
+              resolved = registry.lookup(sym)
+              return nil unless resolved.is_a?(Symbol::Alias)
+
+              qname = resolved.qualified_name
+              return visited + [qname] if qname == start_qname
+              return nil unless explored.add?(qname)
+
+              resolved.body &&
+                find(start_qname, resolved.body, registry, visited + [qname], explored)
+
+            in Symbol::TypeApplication(constructor:, args:)
+              first(start_qname, [constructor, *args], registry, visited, explored)
+
+            in Symbol::PartialApplication(constructor:, args:)
+              first(start_qname, [constructor, *args], registry, visited, explored)
+
+            in Symbol::FunctionType(params:, return_type:)
+              first(start_qname, params + [return_type], registry, visited, explored)
+
+            in Symbol::RecordType(fields:)
+              first(start_qname, fields.values, registry, visited, explored)
+
+            # Leaves (Variable, primitives, etc.) — can't transitively
+            # contain an alias reference, so no cycle through them.
+            else
+              nil
+            end
+          end
+
+          def first(start_qname, syms, registry, visited, explored)
+            syms
+              .lazy
+              .filter_map { find(start_qname, it, registry, visited, explored) }
+              .first
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+require 'jade/frontend/semantic_analysis/type_alias_declaration/cycle_detection'
+
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module TypeAliasDeclaration
+        extend self
+        extend Helper
+
+        def analyze(node, registry, scope, entry)
+          node => AST::TypeAliasDeclaration(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))
+            .add_errors(CycleDetection.call(symbol_ref, registry, entry))
+        end
+
+        private
+
+        def validate_no_unbound_vars(symbol_ref, registry, entry)
+          actual_symbol = registry.lookup(symbol_ref)
+          return [] unless actual_symbol.body
+
+          missing = collect_vars(actual_symbol.body, registry)
+            .group_by(&:name)
+            .reject { |name, _| actual_symbol.type_params.map(&:name).include?(name) }
+            .values
+            .flatten
+
+          return [] if missing.empty?
+
+          [
+            Error::UnboundTypeVariable.new(
+              entry.name,
+              missing.size == 1 ? missing.first.decl_span : actual_symbol.decl_span,
+              type_name: symbol_ref.name,
+              variables: missing.map(&:name).uniq,
+            ),
+          ]
+        end
+      end
+    end
+  end
+end

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

@@ -15,6 +15,7 @@ module Jade
             .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))
+            .add_errors(validate_inhabited(symbol_ref, registry, entry, kind: 'type'))
         end
 
         private

data/lib/jade/frontend/semantic_analysis.rb

@@ -1,5 +1,6 @@
 require 'jade/frontend/semantic_analysis/error'
 
+require 'jade/frontend/semantic_analysis/inhabitedness'
 require 'jade/frontend/semantic_analysis/helper'
 require 'jade/frontend/semantic_analysis/module_node'
 require 'jade/frontend/semantic_analysis/import_declaration'
@@ -19,6 +20,7 @@ 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/type_alias_declaration'
 require 'jade/frontend/semantic_analysis/interface_declaration'
 require 'jade/frontend/semantic_analysis/if_then_else'
 require 'jade/frontend/semantic_analysis/member_access'
@@ -28,6 +30,7 @@ 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_range'
 require 'jade/frontend/semantic_analysis/pattern_binding'
 require 'jade/frontend/semantic_analysis/pattern_constructor'
 require 'jade/frontend/semantic_analysis/pattern_record'
@@ -86,6 +89,7 @@ module Jade
         in AST::Implementation then Implementation
         in AST::ImplementationFunction then ImplementationFunction
         in AST::StructDeclaration then StructDeclaration
+        in AST::TypeAliasDeclaration then TypeAliasDeclaration
         in AST::InterfaceDeclaration then InterfaceDeclaration
         in AST::IfThenElse then IfThenElse
         in AST::MemberAccess then MemberAccess
@@ -95,6 +99,7 @@ module Jade
         in AST::CaseOfBranch then CaseOfBranch
         in AST::Pattern::Wildcard then PatternWildcard
         in AST::Pattern::Literal then PatternLiteral
+        in AST::Pattern::Range then PatternRange
         in AST::Pattern::Binding then PatternBinding
         in AST::Pattern::Constructor then PatternConstructor
         in AST::Pattern::Record then PatternRecord

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

@@ -64,6 +64,7 @@ module Jade
              AST::InteropImportDeclaration |
              AST::TypeDeclaration |
              AST::StructDeclaration |
+             AST::TypeAliasDeclaration |
              AST::InterfaceDeclaration |
              AST::Placeholder
             nil

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

@@ -0,0 +1,90 @@
+require 'set'
+
+module Jade
+  module Frontend
+    module TypeChecking
+      # One mistake is met by every node above it, each reporting it in
+      # whatever type the one below left behind. Only the first is news.
+      module Cascade
+        extend self
+
+        def prune(errors)
+          errors
+            .then { one_view_per_span(it) }
+            .then { drop_enclosing(it) }
+            .then { drop_downstream(it) }
+        end
+
+        private
+
+        # Parent and child, reporting one unification failure. A subclass
+        # of TypeMismatch exists to say more, so it is the one to keep.
+        def one_view_per_span(errors)
+          errors
+            .chunk_while { |a, b| a.span && a.span == b.span }
+            .flat_map { |group| mismatches?(group) ? [most_specific(group)] : group }
+        end
+
+        def mismatches?(group)
+          group.size > 1 && group.all? { it.is_a?(Error::TypeMismatch) }
+        end
+
+        def most_specific(group)
+          group
+            .each_with_index
+            .min_by { |error, i| [-depth(error.class), i] }
+            .first
+        end
+
+        def depth(klass)
+          klass.ancestors.take_while { it != Jade::Error }.size
+        end
+
+        # A mismatch spanning a mismatch already reported is the node above
+        # it complaining about what the one below produced.
+        def drop_enclosing(errors)
+          errors.reject do |error|
+            error.is_a?(Error::TypeMismatch) &&
+              errors.any? { encloses?(error, it) }
+          end
+        end
+
+        def encloses?(outer, inner)
+          return false unless inner.is_a?(Error::TypeMismatch)
+          return false if outer.equal?(inner) || outer.span.nil? || inner.span.nil?
+
+          outer.span.begin <= inner.span.begin &&
+            inner.span.end <= outer.span.end &&
+            outer.span != inner.span
+        end
+
+        # That variable is the hole the first failure left, so anything
+        # naming it fails for the same reason.
+        def drop_downstream(errors)
+          errors
+            .reduce([[], ::Set.new]) do |(kept, seen), error|
+              vars = inference_vars(error)
+
+              next [kept, seen] if vars.any? { seen.include?(it) }
+
+              [kept + [error], seen | vars]
+            end
+            .first
+        end
+
+        # Two errors mentioning the author's `a` are not thereby the same
+        # error; only inference's own variables mark a shared failure.
+        def inference_vars(error)
+          return ::Set.new unless error.is_a?(Error::TypeMismatch)
+
+          [error.expected, error.actual]
+            .compact
+            .flat_map(&:unbound_vars)
+            .select { it.name.nil? }
+            .map(&:id)
+            .to_set
+        end
+      end
+    end
+  end
+end

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

@@ -47,6 +47,9 @@ module Jade
                   failed(constraint, entry_name)
                 end
 
+              in Type::AnonymousRecord(fields:)
+                derive_anonymous_record(constraint, fields, lookup, entry_name)
+
               else
                 failed(constraint, entry_name)
               end
@@ -93,7 +96,14 @@ module Jade
 
             def derive_struct(constraint, struct_sym, type_args, registry, lookup, entry_name)
               fields = struct_fields(struct_sym, type_args, registry)
+              derive_record(constraint, fields, lookup, entry_name)
+            end
+
+            def derive_anonymous_record(constraint, fields, lookup, entry_name)
+              derive_record(constraint, fields.to_a, lookup, entry_name)
+            end
 
+            def derive_record(constraint, fields, lookup, entry_name)
               field_deps = fields
                 .map { |_, field_type| Type.constraint(INTERFACE, field_type, nil) }
 

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

@@ -2,7 +2,6 @@ require_relative './deriving/helpers.rb'
 require_relative './deriving/eq.rb'
 require_relative './deriving/decodable.rb'
 require_relative './deriving/encodable.rb'
-require_relative './deriving/assignable.rb'
 require_relative './deriving/show.rb'
 
 module Jade
@@ -12,14 +11,16 @@ module Jade
         module Deriving
           extend self
 
-          DERIVERS = [Eq, Show, Decodable, Encodable, Assignable]
+          BUILTIN = [Eq, Show, Decodable, Encodable].freeze
+
+          def derivers = BUILTIN + Extensions.derivers
 
           def derivable?(interface)
-            DERIVERS.any? { it.supports?(interface) }
+            derivers.any? { it.supports?(interface) }
           end
 
           def derive(constraint, registry, entry_name, &lookup)
-            DERIVERS
+            derivers
               .find { it.supports?(constraint.interface) }
               .then { it.derive(constraint, registry, entry_name, &lookup) }
           end