jade-lang 0.9.0 → 0.10.0

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

@@ -0,0 +1,72 @@
+module Jade
+  module Frontend
+    module PatternAnalysis
+      # Maranget's other half: can any value reach `row` that the rows above it
+      # did not already take? A branch that is not useful is dead code.
+      module Usefulness
+        extend self
+
+        def useful?(matrix, row, env)
+          return matrix.empty? if matrix.types.empty?
+
+          type = matrix.types.first
+
+          return false if Signature.uninhabited?(type)
+          return expanded(matrix, row, env) if Signature.expandable?(type, env)
+
+          # The row under test cuts the column too, so its own bounds have to
+          # be in the split or it will not line up with the cases.
+          split = Signature.of(type, matrix.heads + [row.first], env)
+
+          case row.first
+          in Wildcard
+            open_column(matrix, row, split, env)
+
+          in Interval
+            split.covering(row.first).any? { narrowed(matrix, row, it, env) }
+
+          in Literal(value:)
+            split
+              .covering(row.first)
+              .then { it.empty? ? [ValueCase[value]] : it }
+              .any? { narrowed(matrix, row, it, env) }
+
+          # Deadness is a proof. A constructor this column's type does not have
+          # yields none, so the branch stands.
+          in Constructor
+            split
+              .covering(row.first)
+              .then { it.empty? || it.any? { narrowed(matrix, row, it, env) } }
+          end
+        end
+
+        private
+
+        # A wildcard reaches whatever the rows above left open. When they name
+        # every case of the type there is no such ground, and the question
+        # moves inside the cases instead.
+        def open_column(matrix, row, split, env)
+          if split.covered_by?(matrix.heads)
+            split.cases.any? { narrowed(matrix, row, it, env) }
+          else
+            useful?(matrix.default, row.drop(1), env)
+          end
+        end
+
+        def narrowed(matrix, row, kase, env)
+          head = row.first
+          args =
+            kase.matches?(head) ? head.args : Array.new(kase.arity) { Wildcard[] }
+
+          useful?(matrix.specialize(kase), args + row.drop(1), env)
+        end
+
+        def expanded(matrix, row, env)
+          fields = Signature.fields(matrix.types.first, env)
+
+          useful?(matrix.expand(env), matrix.expand_row(row, fields), env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+module Jade
+  module Frontend
+    module PatternAnalysis
+      # Maranget's witness generation: the patterns a match would need to add
+      # to become exhaustive. An empty result means it already is.
+      module Witnesses
+        extend self
+
+        def missing(matrix, env)
+          return exhausted_columns(matrix) if matrix.types.empty?
+
+          type = matrix.types.first
+
+          return Matrix.empty if Signature.uninhabited?(type)
+          return Matrix.wildcard(matrix.types) if matrix.empty?
+          return expanded(matrix, env) if Signature.expandable?(type, env)
+
+          heads = matrix.heads
+          split = Signature.of(type, heads, env)
+
+          return unmatched_column(matrix, env) unless split.touched_by?(heads)
+
+          split
+            .cases
+            .reduce(Matrix.empty(matrix.types)) do |acc, kase|
+              witnesses(matrix, kase, env, heads.any? { kase.matches?(it) })
+                .then { acc.concat(it) }
+            end
+        end
+
+        private
+
+        def expanded(matrix, env)
+          missing(matrix.expand(env), env)
+        end
+
+        def exhausted_columns(matrix)
+          matrix.empty? ? Matrix[[[]], []] : Matrix.empty
+        end
+
+        # Nothing in this column narrows anything — a type with no cases to
+        # enumerate, or one every row left open. Whatever is missing lives in
+        # the columns after it.
+        def unmatched_column(matrix, env)
+          missing(matrix.default, env)
+            .map { [Wildcard[]] + it }
+            .with(types: matrix.types)
+        end
+
+        # A case the first column matches is explored by specializing on it.
+        # One it never matches can only be missing as a whole, so its witnesses
+        # come from the rows that would have covered it — the ones headed by a
+        # wildcard. Recursing there instead of into the case is what keeps a
+        # recursive type from expanding forever.
+        def witnesses(matrix, kase, env, matched)
+          return Matrix.empty if kase.arg_types.any? { Signature.uninhabited?(it) }
+
+          found =
+            if matched
+              missing(matrix.specialize(kase), env)
+                .map { [kase.witness(it.take(kase.arity))] + it.drop(kase.arity) }
+
+            else
+              missing(matrix.default, env)
+                .map { [kase.witness(Array.new(kase.arity) { Wildcard[] })] + it }
+            end
+
+          found.with(types: matrix.types)
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/pattern_analysis.rb

@@ -1,40 +1,7 @@
+require 'jade/frontend/pattern_analysis/pattern'
+require 'jade/frontend/pattern_analysis/signature'
 require 'jade/frontend/pattern_analysis/matrix'
+require 'jade/frontend/pattern_analysis/witnesses'
+require 'jade/frontend/pattern_analysis/usefulness'
 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
+require 'jade/frontend/pattern_analysis/redundancy'

data/lib/jade/frontend/semantic_analysis/error/implementation_on_alias.rb

@@ -0,0 +1,24 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module Error
+        class ImplementationOnAlias < Jade::Error
+          def initialize(entry, span, interface:, alias_name:)
+            super(entry:, span:)
+            @interface = interface
+            @alias_name = alias_name
+          end
+
+          def message
+            "Cannot implement `#{@interface}` for type alias `#{@alias_name}`; " \
+              "an alias is its body, so use a `struct` or a single-variant `type`"
+          end
+
+          def label
+            "no impls on type aliases"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/semantic_analysis/error/no_base_case.rb

@@ -0,0 +1,45 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module Error
+        class NoBaseCase < Jade::Error
+          HELP = {
+            'struct' => 'wrap the field in something that has an empty case: ' \
+                        '`Maybe(%<name>s)` can be `Nothing`, `List(%<name>s)` can be empty',
+            'type' => 'add a variant that does not mention `%<name>s`, ' \
+                      'the way `Nothing` does for `Maybe`',
+          }.freeze
+
+          def initialize(entry, span, name:, kind:)
+            @name = name
+            @kind = kind
+            super(entry:, span:)
+          end
+
+          def message
+            "`#{@name}` can never be built: every `#{@name}` needs a `#{@name}` " \
+              'inside it first'
+          end
+
+          def label
+            'nothing here stops the recursion'
+          end
+
+          def notes
+            [
+              Jade::Diagnostics::Annotation[
+                :note,
+                "a type may refer to itself; `#{@name}` just has no case that " \
+                  "stops, so there is no smallest `#{@name}` to start from",
+              ],
+              Jade::Diagnostics::Annotation[
+                :help,
+                format(HELP.fetch(@kind), name: @name),
+              ],
+            ]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/semantic_analysis/error/placeholder_not_allowed.rb

@@ -2,18 +2,30 @@ module Jade
   module Frontend
     module SemanticAnalysis
       module Error
+        # `Rect(w: _, h: 2)` where `Rect` is `Rect(Int, Int)`: positional, so
+        # `w:` names nothing. A variant carrying a record takes the hole.
         class PlaceholderNotAllowed < Jade::Error
-          def initialize(entry, span, field:)
+          def initialize(entry, span, field:, name:)
             @field = field
+            @name = name
             super(entry:, span:)
           end
 
           def message
-            "`#{@field}: _` is only allowed when constructing a struct"
+            "`#{@name}` is a union variant; its arguments are positional " \
+              "and have no names, so `#{@field}:` has nothing to refer to"
           end
 
           def label
-            "not allowed here"
+            'not allowed here'
+          end
+
+          def notes
+            [Jade::Diagnostics::Annotation[
+              :help,
+              "write `#{@name}(_, x)` positionally, or pipe into the " \
+                "first argument with `|> #{@name}(x)`",
+            ]]
           end
         end
       end

data/lib/jade/frontend/semantic_analysis/error/recursive_type_alias.rb

@@ -0,0 +1,24 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module Error
+        class RecursiveTypeAlias < Jade::Error
+          def initialize(entry, span, name:, cycle:)
+            super(entry:, span:)
+            @name = name
+            @cycle = cycle
+          end
+
+          def message
+            "Type alias `#{@name}` is recursive (cycle: #{@cycle.join(' -> ')}); " \
+              "an alias must be finite, so use a `type` for a recursive shape"
+          end
+
+          def label
+            "recursive type alias"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,5 +1,6 @@
 require 'jade/error'
 
+require 'jade/frontend/semantic_analysis/error/no_base_case'
 require 'jade/frontend/semantic_analysis/error/circular_extends'
 require 'jade/frontend/semantic_analysis/error/constant_not_callable'
 require 'jade/frontend/semantic_analysis/error/constructor_not_found'
@@ -9,6 +10,7 @@ require 'jade/frontend/semantic_analysis/error/placeholder_not_allowed'
 require 'jade/frontend/semantic_analysis/error/duplicate_function_declaration'
 require 'jade/frontend/semantic_analysis/error/duplicate_implementation'
 require 'jade/frontend/semantic_analysis/error/duplicate_record_field'
+require 'jade/frontend/semantic_analysis/error/implementation_on_alias'
 require 'jade/frontend/semantic_analysis/error/invalid_list_rest_pattern'
 require 'jade/frontend/semantic_analysis/error/kwargs_on_non_constructor'
 require 'jade/frontend/semantic_analysis/error/missing_exposing_clause'
@@ -21,6 +23,7 @@ require 'jade/frontend/semantic_analysis/error/non_task_port'
 require 'jade/frontend/semantic_analysis/error/orphan_implementation'
 require 'jade/frontend/semantic_analysis/error/predicate_must_return_bool'
 require 'jade/frontend/semantic_analysis/error/predicate_name_not_allowed'
+require 'jade/frontend/semantic_analysis/error/recursive_type_alias'
 require 'jade/frontend/semantic_analysis/error/shadowing_error'
 require 'jade/frontend/semantic_analysis/error/type_args_mismatch'
 require 'jade/frontend/semantic_analysis/error/type_param_required'

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

@@ -49,6 +49,14 @@ 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:)
@@ -97,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:)
@@ -154,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

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