jade-lang 0.9.0 → 0.10.0

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.rb

@@ -6,7 +6,19 @@ module Jade
       module Constraints
         extend self
 
-        def resolve(constraint, registry, entry_name)
+        # A derived instance is built by asking for its components' instances,
+        # so a type that contains itself asks for the one being built. Nothing
+        # ties that knot yet, so the walk is cut here rather than left to run
+        # out of stack.
+        def resolve(constraint, registry, entry_name, in_progress = ::Set[])
+          key = [constraint.interface, constraint.type.to_s]
+
+          if in_progress.include?(key)
+            Error::RecursiveDerivation
+              .new(entry_name, constraint.origin&.range, constraint:)
+              .then { return Err[it] }
+          end
+
           if constraint.type in Type::Var
             Error::UnresolvedConstraint
               .new(entry_name, constraint.origin&.range, constraint:)
@@ -23,7 +35,7 @@ module Jade
                     constraint.type,
                     constraint.origin,
                   )
-                .then { resolve(it, registry, entry_name) } => Ok[resolved]
+                .then { resolve(it, registry, entry_name, in_progress) } => Ok[resolved]
 
                 resolved
               end
@@ -34,7 +46,9 @@ module Jade
 
           if Deriving.derivable?(constraint.interface)
             Deriving
-              .derive(constraint, registry, entry_name) { resolve(it, registry, entry_name) }
+              .derive(constraint, registry, entry_name) do
+                resolve(it, registry, entry_name, in_progress + [key])
+              end
               .then { return it }
           end
 
@@ -87,6 +101,7 @@ module Jade
             in Type::Application(constructor:) then constructor.name
             in Type::PartialApplication(constructor:) then constructor.name
             in Type::Constructor(name:) then name
+            in Type::Displayable => t then t.render
             else constraint.type.to_s
             end
 

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

@@ -0,0 +1,49 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Error
+        # Inference ids (`t8894`) are counters: they change between
+        # compiles, and two occurrences of one variable look unrelated
+        # unless you notice the digits match. Read out as `a`, `b`, `c`;
+        # the ids themselves stay internal.
+        module Display
+          extend self
+
+          LETTERS = ('a'..'z').to_a.freeze
+
+          Naming = Data.define(:substitution) do
+            def [](type)
+              substitution.apply(type).to_s
+            end
+
+            # Spells out the body of an alias, for the one type a message is
+            # about. Nested positions keep the short name.
+            def annotated(type)
+              substitution.apply(type).then do |applied|
+                applied.is_a?(Type::Displayable) ? applied.annotated : applied.to_s
+              end
+            end
+          end
+
+          # Every type in one message at once, so a variable is the same
+          # letter on both sides of it.
+          def naming(*types)
+            types
+              .flat_map(&:unbound_vars)
+              .uniq(&:id)
+              .select { it.name.nil? }
+              .each_with_index
+              .to_h { |var, i| [var.id, Type.var(var.id, letter(i))] }
+              .then { Naming[Substitution.new(it)] }
+          end
+
+          private
+
+          def letter(index)
+            LETTERS[index] || "t#{index - LETTERS.size + 1}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Error
+        class DivisionByZero < Jade::Error
+          def initialize(entry, span)
+            super(entry:, span:)
+          end
+
+          def message
+            'Cannot divide by zero.'
+          end
+
+          def label
+            'this divisor is zero'
+          end
+
+          def notes
+            [
+              Jade::Diagnostics::Annotation[
+                :help,
+                'division takes a `NonZero`. A literal other than zero is one; ' \
+                  'for a value, `non_zero(n)` gives a `Maybe(NonZero(a))`',
+              ],
+            ]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Error
+        class EmptyRangePattern < Jade::Error
+          include PatternProblem
+          def initialize(entry, span, from:, to:)
+            @from = from
+            @to = to
+            super(entry:, span:)
+          end
+
+          def message
+            "#{@from}..#{@to} matches nothing, because #{@from} is greater " \
+              "than #{@to}."
+          end
+
+          def label
+            'empty range'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -9,12 +9,13 @@ module Jade
           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}"
+            "There\u0027s a problem with the body of `#{@function_name}` definition: " \
+              "it returns #{naming.annotated(@actual)} but its signature says it should be " \
+              "#{naming.annotated(@expected)}"
           end
 
           def label
-            "returns #{@actual}, expected #{@expected}"
+            "returns #{naming[@actual]}, expected #{naming[@expected]}"
           end
         end
       end

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

@@ -3,9 +3,15 @@ module Jade
     module TypeChecking
       module Error
         class FunctionCallTypeMismatch < TypeMismatch
-          def initialize(entry, span, expected:, actual:, infix:)
+          def initialize(
+            entry, span, expected:, actual:, infix:, lifted_placeholder:,
+            callee_name:, arg_names:
+          )
             super
             @infix = infix
+            @lifted_placeholder = lifted_placeholder
+            @callee_name = callee_name
+            @arg_names = arg_names
           end
 
           def message
@@ -13,22 +19,119 @@ module Jade
             in AST::InfixOperator(value:)
               infix_error(value)
             else
-              "Function call mismatch, expected #{@expected} but found #{@actual}"
+              "Function call mismatch, expected #{naming[@expected]} but found #{naming[@actual]}"
             end
           end
 
+          def notes
+            return non_zero_note if wanted_non_zero?
+            return placeholder_note if one_too_many_for_the_placeholder?
+            return arity_note if wrong_arity?
+            return under_applied_note if under_applied
+
+            []
+          end
+
           private
 
+          # The only type nobody can construct directly, so saying what was
+          # expected is not enough to act on.
+          def wanted_non_zero?
+            @expected in Type::Function(
+              args: [*, Type::Application(constructor: Type::Constructor(name: 'Basics.NonZero'))]
+            )
+          end
+
+          def non_zero_note
+            help(
+              'a divisor has to be known not to be zero. A literal other than ' \
+                'zero is; for a value, `non_zero(n)` gives a `Maybe(NonZero(a))`',
+            )
+          end
+
+          def placeholder_note
+            ('a `_` makes this a function waiting for that argument, and the ' \
+              'call has one argument too many for that. If you piped into it, ' \
+              '`|>` already supplies the first argument, so drop the `_`')
+              .then { help(it) }
+          end
+
+          def arity_note
+            "#{subject(@callee_name, 'this')} takes #{count(@expected.args.size)}, " \
+              "#{@actual.args.size} given"
+              .then { help(it) }
+          end
+
+          # An argument that arrives as a function returning what was wanted
+          # is a constructor or function that has not been given everything
+          # it needs.
+          def under_applied_note
+            @actual
+              .args[under_applied]
+              .args
+              .size
+              .then { count(it) }
+              .then { "#{under_applied_subject} needs #{it}" }
+              .then { help(it) }
+          end
+
+          def under_applied_subject
+            subject(@arg_names[under_applied], "argument #{under_applied + 1}")
+          end
+
+          def under_applied
+            return nil unless comparable_calls?
+            return nil unless @expected.args.size == @actual.args.size
+
+            @expected.args.zip(@actual.args).index do |want, got|
+              got.is_a?(Type::Function) &&
+                !want.is_a?(Type::Function) &&
+                got.return_type == want
+            end
+          end
+
+          def wrong_arity?
+            comparable_calls? && @expected.args.size != @actual.args.size
+          end
+
+          def comparable_calls?
+            !@infix && (@expected in Type::Function) && (@actual in Type::Function)
+          end
+
+          def subject(name, fallback)
+            name ? "`#{name}`" : fallback
+          end
+
+          def count(n)
+            "#{n} #{n == 1 ? 'argument' : 'arguments'}"
+          end
+
+          def help(text)
+            [Jade::Diagnostics::Annotation[:help, text]]
+          end
+
+          # `xs |> f(_, y)` reads as though the `_` marks where the piped
+          # value goes, but `|>` has already put it in front of it.
+          def one_too_many_for_the_placeholder?
+            return false unless @lifted_placeholder
+            return false unless @expected in Type::Function
+            return false unless @actual in Type::Function
+
+            @actual.args.size == @expected.args.size + 1
+          end
+
           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}"
+              return "Left side of (#{operator}) expects #{naming[@expected.args.first]} " \
+                "but found #{naming[@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}"
+              return "Right side of (#{operator}) expects #{naming[@expected.args.last]} " \
+                "but found #{naming[@actual.args.last]}"
             end
 
-            "Function call mismatch, expected #{@expected} but found #{@actual}"
+            "Function call mismatch, expected #{naming[@expected]} but found #{naming[@actual]}"
           end
         end
       end

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

@@ -10,7 +10,7 @@ module Jade
 
           def message
             "The #{@branch} branch of this if statement is expected to return" +
-              " #{@expected} but got #{@actual}"
+              " #{naming[@expected]} but got #{naming[@actual]}"
           end
         end
       end

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

@@ -9,7 +9,7 @@ module Jade
 
           def message
             "If branches must return the same type. The then branch produces " +
-              "#{@expected} but the else branch produces #{@actual}"
+              "#{naming[@expected]} but the else branch produces #{naming[@actual]}"
           end
         end
       end

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

@@ -8,7 +8,7 @@ module Jade
           end
 
           def message
-            "If condition expects #{@expected} but found #{@actual}"
+            "If condition expects #{naming[@expected]} but found #{naming[@actual]}"
           end
         end
       end

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

@@ -11,7 +11,7 @@ module Jade
 
           def message
             "Implementation of #{@interface}.#{@fn_name}: " \
-              "expected #{@expected} but the provided function has type #{@actual}"
+              "expected #{naming[@expected]} but the provided function has type #{naming[@actual]}"
           end
         end
       end

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

@@ -10,7 +10,7 @@ module Jade
 
           def message
             "The #{ordinal(@actual_index)} item does not match the previous items in the list, " +
-              "expected #{@expected} but found #{@actual}"
+              "expected #{naming[@expected]} but found #{naming[@actual]}"
           end
         end
       end