jade-lang 0.9.0 → 0.10.1

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

@@ -10,6 +10,64 @@ module Jade
           ForwardDeclaration.deep_declare_node(ast, entry, registry)
         end
 
+        # Only the shallow pass still has the declaration being replaced;
+        # by the deep pass the entry holds the winner alone. The deep pass
+        # keeps its kind check to bail out, not to report.
+        def duplicate_type_error(entry, name, span, declaring:)
+          entry.defined_types[name].then do |existing|
+            next nil if existing.nil? || existing.decl_span == span
+
+            Error::DuplicateTypeName.new(
+              entry.name,
+              span,
+              name,
+              declaring:,
+              existing: Error::DuplicateTypeName.kind_of(existing),
+              first_span: existing.decl_span,
+            )
+          end
+        end
+
+        # A constructor is named without its type, so one module cannot hold
+        # two of a name — a union's variant and a struct both define one, and
+        # the second shadows the first. `introduced` is what this declaration
+        # is about to define, each with the span to point at.
+        def duplicate_constructor_errors(entry, name, introduced, declaring:)
+          declared_constructors(entry).then do |seen|
+            introduced.filter_map { duplicate_constructor_error(entry, name, it, seen, declaring) }
+          end
+        end
+
+        def declared_constructors(entry)
+          entry
+            .defined_types
+            .values
+            .flat_map do |symbol|
+              case symbol
+              in Symbol::Union then symbol.variants.map { [it.name, symbol] }
+              in Symbol::Struct then [[symbol.name, symbol]]
+              else []
+              end
+            end
+            .to_h
+        end
+
+        def duplicate_constructor_error(entry, name, (constructor, span), seen, declaring)
+          seen[constructor].then do |owner|
+            next nil if owner.nil? || owner.name == name
+
+            Error::DuplicateConstructorName.new(
+              entry.name,
+              span,
+              constructor,
+              declaring:,
+              type: name,
+              owner:,
+              first_span: owner.decl_span,
+            )
+          end
+        end
+
         def figure_out_type(entry, node)
           case node
           in AST::TypeVar(type:)

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

@@ -83,6 +83,10 @@ module Jade
         end
 
         def handling_exposing_type_expansion(type, name, span, current_entry, importing_module)
+          if importing_module.types[name].is_a?(Symbol::Alias)
+            return Err[Error::AliasExpansion.new(current_entry.name, span, name:)]
+          end
+
           importing_module
             .exposed_type_variants(name)
             .then  do |variants|

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

@@ -8,6 +8,9 @@ module Jade
         def shallow(node, _registry, entry)
           node => AST::InterfaceDeclaration(name:, type_param:, functions:)
 
+          duplicate_type_error(entry, name, node.range, declaring: 'an interface')
+            .then { return Result[entry, [it]] if it }
+
           interface_ref = Symbol.type_ref(entry.name, name)
           type_var = Symbol.var(type_param.name, type_param.range)
 
@@ -28,6 +31,9 @@ module Jade
           node => AST::InterfaceDeclaration(name:, functions:)
 
           symbol = entry.lookup_type(name)
+
+          return Result[entry, []] unless symbol.is_a?(Symbol::Interface)
+
           interface_ref = symbol.to_ref
 
           functions

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

@@ -71,6 +71,10 @@ module Jade
             ]
           end
 
+          if symbol.is_a?(Symbol::Alias)
+            return Result[entry, [Error::AliasExpansion.new(entry.name, span, name:)]]
+          end
+
           symbol
             .constructor_refs
             .reduce(entry) { |acc, ctor| acc.expose(ctor.to_ref) }

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

@@ -8,11 +8,18 @@ module Jade
         def shallow(node, registry, entry)
           node => AST::StructDeclaration(name:, type_params:)
 
+          duplicate_type_error(entry, name, node.range, declaring: 'a struct')
+            .then { return Result[entry, [it]] if it }
+
+          # The struct is still declared, so a signature naming it does not
+          # report a second, misleading error.
+          errors = duplicate_constructor_errors(entry, name, [[name, node.range]], declaring: :struct)
+
           type_params
             .map { Symbol.var(it.name, it.range) }
             .then { Symbol.predeclared_struct(name, it, node.range) }
             .then { entry.define(it) }
-            .then { Result[it, []] }
+            .then { Result[it, errors] }
         end
 
         def deep(node, entry, _)
@@ -20,6 +27,8 @@ module Jade
 
           symbol = entry.lookup_type(name)
 
+          return Result[entry, []] unless symbol.is_a?(Symbol::Struct)
+
           figure_out_type(entry, record_type)
             .map do |record_type_symbol|
               constructor_fn_symbol = Symbol.constructor(

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

@@ -0,0 +1,37 @@
+module Jade
+  module Frontend
+    module ForwardDeclaration
+      module TypeAliasDeclaration
+        extend self
+        extend Helper
+
+        def shallow(node, registry, entry)
+          node => AST::TypeAliasDeclaration(name:, type_params:)
+
+          duplicate_type_error(entry, name, node.range, declaring: 'a type alias')
+            .then { return Result[entry, [it]] if it }
+
+          type_params
+            .map { Symbol.var(it.name, it.range) }
+            .then { Symbol.predeclared_alias(name, it, node.range) }
+            .then { entry.define(it) }
+            .then { Result[it, []] }
+        end
+
+        def deep(node, entry, _)
+          node => AST::TypeAliasDeclaration(name:, body_type:)
+
+          symbol = entry.lookup_type(name)
+
+          return Result[entry, []] unless symbol.is_a?(Symbol::Alias)
+
+          figure_out_type(entry, body_type)
+            .map do |body_symbol|
+              entry.define(symbol.with(body: body_symbol))
+            end
+            .then { to_declaration_result(entry, it) }
+        end
+      end
+    end
+  end
+end

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

@@ -8,13 +8,20 @@ module Jade
         def shallow(node, registry, entry)
           node => AST::TypeDeclaration(name:, type_params:, variants:)
 
+          duplicate_type_error(entry, name, node.range, declaring: 'a type')
+            .then { return Result[entry, [it]] if it }
+
+          # The type is still declared, so a signature naming it does not
+          # report a second, misleading error.
+          errors = duplicate_constructor_errors(entry, name, variants.map { [it.name, it.range] }, declaring: :variant)
+
           predeclared_variants = variants
             .map { |var| Symbol.predeclared_constructor(var.name, var.range) }
 
           type_params.map { Symbol.var(it.name, it.range) }
             .then { Symbol.union(name, it, predeclared_variants, node.range) }
             .then { entry.define(it) }
-            .then { Result[it, []] }
+            .then { Result[it, errors] }
         end
 
         def deep(node, entry, _)
@@ -22,6 +29,8 @@ module Jade
 
           symbol = entry.lookup_type(name)
 
+          return Result[entry, []] unless symbol.is_a?(Symbol::Union)
+
           variants
             .map do |var|
               var.args.map { figure_out_type(entry, it) }

data/lib/jade/frontend/forward_declaration.rb

@@ -11,6 +11,7 @@ require 'jade/frontend/forward_declaration/import_declaration'
 require 'jade/frontend/forward_declaration/interop_import_declaration'
 require 'jade/frontend/forward_declaration/module'
 require 'jade/frontend/forward_declaration/struct_declaration'
+require 'jade/frontend/forward_declaration/type_alias_declaration'
 require 'jade/frontend/forward_declaration/type_declaration'
 require 'jade/frontend/forward_declaration/interface_declaration'
 
@@ -60,6 +61,7 @@ module Jade
         in AST::InteropImportDeclaration then InteropImportDeclaration
         in AST::Module then Module
         in AST::StructDeclaration then StructDeclaration
+        in AST::TypeAliasDeclaration then TypeAliasDeclaration
         in AST::TypeDeclaration then TypeDeclaration
         in AST::InterfaceDeclaration then InterfaceDeclaration
         else

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

@@ -4,17 +4,58 @@ module Jade
       module Exhaustiveness
         extend self
 
-        def assert(patterns, range, env, registry, expected)
-          Matrix[
-            patterns.map { [node_to_matrix_pattern(it)] },
-            [expected],
-          ]
-            .missing_patterns(env)
+        def assert(patterns, range, env, expected)
+          Matrix[patterns.map { [Pattern.from_node(it)] }, [expected]]
+            .then { Witnesses.missing(it, env) }
+            .then { it.with(rows: coalesced(it.rows)) }
             .then { to_errors(it, range, env) }
         end
 
         private
 
+        # Splitting a column cuts it at every bound any pattern mentions, so
+        # one hole can come back as several touching pieces. Report the hole.
+        def coalesced(rows)
+          joined = rows
+            .combination(2)
+            .lazy
+            .filter_map { |(left, right)| join(left, right)&.then { [left, right, it] } }
+            .first
+
+          return rows if joined.nil?
+
+          joined => [left, right, combined]
+
+          coalesced(rows - [left, right] + [combined])
+        end
+
+        def join(left, right)
+          return if left.size != right.size
+
+          differing = left.each_index.reject { left[it] == right[it] }
+
+          return if differing.size != 1
+
+          index = differing.first
+
+          span(left[index], right[index])
+            &.then { |joined| left.take(index) + [joined] + left.drop(index + 1) }
+        end
+
+        def span(left, right)
+          case [left, right]
+          in [Interval(from:, to: Integer => last), Interval(from: ^(last + 1), to:)]
+            Interval[from, to]
+
+          in [Constructor(constructor: name, args: left_args),
+              Constructor(constructor: ^name, args: right_args)]
+            join(left_args, right_args)&.then { Constructor[name, it] }
+
+          else
+            nil
+          end
+        end
+
         def to_errors(matrix, range, env)
           return [] if matrix.empty?
 
@@ -22,43 +63,6 @@ module Jade
             .new(env.entry_name, range, missing_patterns: matrix.rows)
             .then { [it] }
         end
-
-        def node_to_matrix_pattern(pattern_node)
-          case pattern_node
-          in AST::Pattern::Record(fields:)
-            Record[
-              fields
-                .map(&:name)
-                .zip(fields.map(&:pattern))
-                .to_h
-                .transform_values { node_to_matrix_pattern(it) },
-            ]
-
-          in AST::Pattern::Constructor(constructor:, patterns:)
-            Constructor[
-              constructor.symbol.qualified_name,
-              patterns.map { node_to_matrix_pattern(it) },
-            ]
-
-          in AST::Pattern::List(patterns:, rest:)
-            # Rewrite [x, y | xs] / [x, y] into nested Cons/Nil constructors
-            tail = rest ? Wildcard[] : Constructor['List.Nil', []]
-            patterns
-              .map { node_to_matrix_pattern(it) }
-              .reverse
-              .reduce(tail) { |acc, head| Constructor['List.Cons', [head, acc]] }
-
-          in AST::Pattern::Binding | AST::Pattern::Wildcard
-            Wildcard[]
-
-          in AST::Pattern::Literal(literal: { value:, symbol: })
-            Literal[
-              value,
-              symbol.qualified_name,
-            ]
-
-          end
-        end
       end
     end
   end

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

@@ -5,12 +5,11 @@ module Jade
         def self.wildcard(types)
           types
             .map { Wildcard[] }
-            .then { [it] }
-            .then { Matrix[it, types] }
+            .then { Matrix[[it], types] }
         end
 
         def self.empty(types = [])
-          self.new([], types)
+          Matrix[[], types]
         end
 
         def map
@@ -19,248 +18,58 @@ module Jade
             .then { with(rows: it) }
         end
 
-        def include?(row)
-          rows.include?(row)
-        end
-
-        def size
-          rows.size
-        end
-
         def empty?
           rows.empty?
         end
 
-        def any?
-          rows.any?
-        end
-
         def concat(other)
           with(rows: rows + other.rows)
         end
 
-        def missing_patterns(env)
-          if types.empty?
-            return rows.empty? ? Matrix[[[]], types] : Matrix.empty
-          end
-
-          type = types.first
-
-          return Matrix.empty if never?(type)
-          return Matrix.wildcard(types) if rows.empty?
-
-          heads = head_constructors
-
-          if infinite?(type) || type_var?(type)
-            unmatched_column(env)
-
-          elsif expandable?(type, env)
-            expand(env).missing_patterns(env)
-
-          elsif heads.empty?
-            unmatched_column(env)
-
-          else
-            constructors_of(type, env)
-              .reduce(Matrix.empty.with(types:)) do |acc, constructor|
-                witnesses(constructor, env, heads.include?(constructor.name))
-                  .then { acc.concat(it) }
-              end
-          end
+        def heads
+          rows.map(&:first)
         end
 
-        protected
-
-        # Nothing in this column narrows anything — a type with no constructors
-        # to enumerate, or one every row left open. Whatever is missing lives in
-        # the columns after it.
-        def unmatched_column(env)
-          default
-            .missing_patterns(env)
-            .map { [Wildcard[]] + it }
-        end
-
-        # A constructor 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 constructor
-        # is what keeps a recursive type from expanding forever.
-        def witnesses(constructor, env, matched)
-          return Matrix.empty if constructor.args.any? { never?(it) }
-
-          arity = constructor.args.size
-
-          if matched
-            specialize(constructor)
-              .missing_patterns(env)
-              .map { [Constructor[constructor.name, it.take(arity)]] + it.drop(arity) }
-
-          else
-            default
-              .missing_patterns(env)
-              .map { [Constructor[constructor.name, Array.new(arity) { Wildcard[] }]] + it }
-          end
-        end
-
-        def head_constructors
-          rows.filter_map { head_constructor(it.first) }
-        end
-
-        def head_constructor(pattern)
-          case pattern
-          in Constructor(constructor: name) then name
-          in Literal(value: true) then 'Basics.True'
-          in Literal(value: false) then 'Basics.False'
-          in Literal | Record | Wildcard then nil
-          end
-        end
-
-        def expandable?(type, env)
-          case type
-          in Type::AnonymousRecord
-            true
-
-          in Type::Application(constructor:)
-            env.lookup_def(constructor.name).is_a?(TypeChecking::StructDef)
-
-          else
-            false
-          end
-        end
-
-        def expand(env)
-          type_fields = 
-            case types.first
-            in Type::AnonymousRecord(fields:)
-              fields
-
-            in Type::Application(constructor:)
-              env.lookup_def(constructor.name).body.fields
-            end
-
-          map do |row|
-            case row.first
-            in Record(fields:)
-              type_fields
-                .map do |(k, v)|
-                  fields[k] || Wildcard[]
-                end + row.drop(1)
-
-            in Wildcard
-              type_fields.map { Wildcard[] } + row.drop(1)
-            end
-          end
-            .with(types: type_fields.values + types.drop(1))
-        end
-
-        def constructors_of(type, env)
-          case type
-          in Type::Application(constructor: Type::Constructor(name: 'Basics.Bool'))
-            [
-              TypeChecking::ConstructorDef['Basics.True', 'Basics.Bool', []],
-              TypeChecking::ConstructorDef['Basics.False', 'Basics.Bool', []],
-            ]
-          in Type::Application(constructor: Type::Constructor(name: /^Tuple\.Tuple[2-4]$/ => name), args:)
-            [TypeChecking::Definition.constructor(name, name, args)]
-
-          in Type::Application(constructor: Type::Constructor(name: 'List.List'), args: [elem_type])
-            [
-              TypeChecking::ConstructorDef['List.Nil',  'List.List', []],
-              TypeChecking::ConstructorDef['List.Cons', 'List.List', [elem_type, type]],
-            ]
-
-          else
-            type_def = env.lookup_def(type.constructor.name)
-
-            # Type the user can't destructure from here (transitively reached
-            # through an imported struct field, or opaque intrinsic) —
-            # any pattern they can write is trivially exhaustive.
-            return [] if type_def.nil? || type_def.opaque?
-
-            type_def
-              .constructors
-              .map do |con|
-                con
-                  .args
-                  .map do |arg|
-                    if type_var?(arg)
-                      type_def
-                        .type_params
-                        .find_index { arg.name == it.name }
-                        .then { type.args.at(it) }
-
-                    else
-                      arg
-                    end
-                  end
-                .then { con.with(args: it) }
-              end
-          end
-        end
-
-        def specialize(constructor)
+        # Rows the case can match, each opened up into the columns the case
+        # carries. A row headed by a wildcard matches every case, and says
+        # nothing about the columns it opens.
+        def specialize(kase)
           rows
-            .filter_map do |cols|
-              case cols.first
-              in Literal(value:)
-                next [] + cols.drop(1) if value == false && "Basics.False" == constructor.name
-                next [] + cols.drop(1) if value == true && "Basics.True" == constructor.name
-
-              in Constructor(constructor: cons_name, args:)
-                args + cols.drop(1) if cons_name == constructor.name
-
-              in Wildcard
-                constructor.args.map { Wildcard[] } + cols.drop(1)
+            .filter_map do |row|
+              head = row.first
 
+              if kase.matches?(head)
+                head.args + row.drop(1)
+              elsif head.wildcard?
+                Array.new(kase.arity) { Wildcard[] } + row.drop(1)
               end
             end
-            .then { with(rows: it) }
-            .then { it.with(types: constructor.args + types.drop(1)) }
+            .then { Matrix[it, kase.arg_types + types.drop(1)] }
         end
 
+        # The rows that survive when the first column is decided by no case at
+        # all — only the ones that were not asking about it.
         def default
           rows
             .select { it.first.wildcard? }
             .map { it.drop(1) }
-            .then { with(rows: it) }
-            .with(types: types.drop(1))
+            .then { Matrix[it, types.drop(1)] }
         end
 
-        def add(columns)
-          with(rows: rows.concat(columns))
-        end
-
-        private
-
-        def never?(type)
-          case type
-          in Type::Application(constructor: Type::Constructor(name: 'Basics.Never'))
-            true
-          else
-            false
-          end
-        end
+        def expand(env)
+          fields = Signature.fields(types.first, env)
 
-        def type_var?(type)
-          type.is_a?(Type::Var)
+          map { |row| expand_row(row, fields) }
+            .with(types: fields.values + types.drop(1))
         end
 
-        def infinite?(type)
-          case type
-          in Type::Function
-            true
-
-          in Type::Application(constructor:)
-            case constructor
-            in Type::Constructor(name: 'Basics.Int') then true
-            in Type::Constructor(name: 'Basics.Float') then true
-            in Type::Constructor(name: 'String.String') then true
-            else
-              false
-            end
+        def expand_row(row, fields)
+          case row.first
+          in Record(fields: matched)
+            fields.keys.map { matched[it] || Wildcard[] } + row.drop(1)
 
-          else
-            false
+          in Wildcard
+            fields.keys.map { Wildcard[] } + row.drop(1)
           end
         end
       end