jade-lang 0.3.1 → 0.5.0

data/lib/jade/frontend/fixity_fixer.rb

@@ -146,7 +146,8 @@ module Jade
 
         in AST::VariableReference | AST::ConstructorReference | AST::TypeDeclaration |
           AST::ImportDeclaration | AST::Literal | AST::CharLiteral | AST::RecordAccessSugar | AST::InteropImportDeclaration |
-          AST::StructDeclaration | AST::QualifiedAccess | AST::Placeholder | AST::InterfaceDeclaration
+          AST::StructDeclaration | AST::QualifiedAccess | AST::Placeholder | AST::InterfaceDeclaration |
+          AST::RecordUpdateSugar
 
           node
 
@@ -164,7 +165,7 @@ module Jade
           flatten(left) + [operator] + flatten(right)
 
         else
-          [ast]
+          [fix(ast)]
         end
       end
 

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

@@ -47,8 +47,8 @@ module Jade
         end
 
         def fn_type_to_interop(interop_mod_name, function_node, symbol, entry, registry)
-          lifted_errors = Interop::Lowering
-            .validate(symbol.return_type, registry, entry)
+          lifted_errors = [symbol.return_type, *symbol.params]
+            .flat_map { Interop::Lowering.validate(it, registry, entry) }
             .map { Error::TypeNotLowerable.new(entry, function_node.range, message: it.message) }
 
           Symbol
@@ -57,7 +57,8 @@ module Jade
               symbol.params,
               symbol.return_type,
               interop_mod_name.name,
-              constraints: implicit_decodable_constraints(symbol.return_type),
+              constraints: implicit_decodable_constraints(symbol.return_type) +
+                implicit_encodable_constraints(symbol.params),
             )
             .then { [it, lifted_errors] }
         end
@@ -78,6 +79,15 @@ module Jade
           end
         end
 
+        # Arguments travel the other way, so a free variable in a parameter
+        # needs the caller's Encodable instance rather than its Decodable one.
+        def implicit_encodable_constraints(params)
+          params
+            .flat_map { collect_var_names(it) }
+            .uniq
+            .map { ['Encode.Encodable', it] }
+        end
+
         def collect_var_names(type_sym)
           case type_sym
           in Symbol::Variable(name:)

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

@@ -39,7 +39,7 @@ module Jade
           with(rows: rows + other.rows)
         end
 
-        def missing_patterns(env, seen_recursive_types = ::Set.new)
+        def missing_patterns(env)
           if types.empty?
             return rows.empty? ? Matrix[[[]], types] : Matrix.empty
           end
@@ -49,37 +49,72 @@ module Jade
           return Matrix.empty if never?(type)
           return Matrix.wildcard(types) if rows.empty?
 
-          if infinite?(type) || type_var?(type) || seen_recursive_types.include?(type)
-            matrix = default
-              .missing_patterns(env, seen_recursive_types)
+          heads = head_constructors
 
-            matrix
-              .map { [Wildcard[]] + it }
+          if infinite?(type) || type_var?(type)
+            unmatched_column(env)
 
           elsif expandable?(type, env)
-            expand(env).missing_patterns(env, seen_recursive_types)
+            expand(env).missing_patterns(env)
+
+          elsif heads.empty?
+            unmatched_column(env)
 
           else
-            new_seen = seen_recursive_types | ::Set[type]
             constructors_of(type, env)
               .reduce(Matrix.empty.with(types:)) do |acc, constructor|
-                missing = specialize(constructor)
-                  .missing_patterns(env, new_seen)
-
-                missing
-                  .map do |row|
-                    new_args = row.take(constructor.args.size)
-                    tail = row.drop(constructor.args.size)
-
-                  [Constructor[constructor.name, new_args]] + tail
-                end
-                .then { acc.concat(it) }
+                witnesses(constructor, env, heads.include?(constructor.name))
+                  .then { acc.concat(it) }
               end
           end
         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
@@ -125,9 +160,8 @@ module Jade
               TypeChecking::ConstructorDef['Basics.True', 'Basics.Bool', []],
               TypeChecking::ConstructorDef['Basics.False', 'Basics.Bool', []],
             ]
-          in Type::Application(constructor: Type::Constructor(name: /^Tuple\.Tuple([2-4])$/ => name))
-            n = name[-1].to_i
-            [TypeChecking::Definition.constructor(name, name, Array.new(n) { env.fresh })]
+          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])
             [
@@ -181,7 +215,7 @@ module Jade
               end
             end
             .then { with(rows: it) }
-            .then { it.with(types: constructor.args) }
+            .then { it.with(types: constructor.args + types.drop(1)) }
         end
 
         def default

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

@@ -17,7 +17,7 @@ module Jade
                 entry.name,
                 node.range,
                 name:,
-                exposed_type_module: exposed_type_origin(name, entry, registry),
+                hint: constructor_hint(name, entry, registry),
                 candidates: scope.bindings.keys.select { it.match?(/\A[A-Z]/) },
               ))
               .then do
@@ -49,14 +49,40 @@ module Jade
             &.then { klass.new(entry.name, span, arity: it) }
         end
 
-        def exposed_type_origin(name, entry, registry)
-          type_ref = entry.imported_types[name]
-          return nil unless type_ref
+        # An imported module owning a constructor by this name is the whole
+        # story: either it keeps its constructors private, or it exposes them
+        # and the import here asked for the type alone.
+        def constructor_hint(name, entry, registry)
+          entry
+            .imports
+            .filter_map { hint_for(it.module_name, name, registry) }
+            .first
+        end
+
+        def hint_for(module_name, name, registry)
+          target = registry.get(module_name)
+          return nil if target.nil? || Stdlib.is_stdlib?(target)
+
+          type_name = owning_type(target, name)
+          return nil unless type_name && target.exposed_type(type_name)
 
-          target_entry = registry.get(type_ref.module_name)
-          return nil if target_entry.nil? || Stdlib.is_stdlib?(target_entry)
+          exposes_constructor?(target, type_name, name)
+            .then { it ? :import : :expose }
+            .then { Error::ConstructorNotFound::Hint[module_name, type_name, it] }
+        end
+
+        def owning_type(target, name)
+          target
+            .defined_types
+            .find { |_, sym| sym.constructor_refs.any? { it.name == name } }
+            &.first
+        end
 
-          type_ref.module_name
+        def exposes_constructor?(target, type_name, name)
+          target
+            .exposed_type_variants(type_name)
+            .to_a
+            .any? { it.name == name }
         end
       end
     end

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

@@ -3,21 +3,36 @@ module Jade
     module SemanticAnalysis
       module Error
         class ConstructorNotFound < Jade::Error
+          # `fix` is where the `(..)` is missing: `:expose` when the module
+          # that owns the type keeps its constructors to itself, `:import`
+          # when it exposes them and this module's import didn't ask for them.
+          Hint = Data.define(:module_name, :type_name, :fix)
+
           attr_reader :candidates
 
-          def initialize(entry, span, name:, exposed_type_module: nil, candidates: [])
+          def initialize(entry, span, name:, hint: nil, candidates: [])
             @name = name
-            @exposed_type_module = exposed_type_module
+            @hint = hint
             @candidates = candidates
             super(entry:, span:)
           end
 
           def message
             base = "I cannot find a `#{@name}` constructor"
-            return base unless @exposed_type_module
 
-            "#{base}. The type `#{@name}` is exposed by `#{@exposed_type_module}` but its " \
-              "constructor is private — add `#{@name}(..)` to that module's `exposing` list."
+            case @hint
+            in nil
+              base
+
+            in Hint(module_name:, type_name:, fix: :expose)
+              "#{base}. The type `#{type_name}` is exposed by `#{module_name}` but its " \
+                "constructor is private — add `#{type_name}(..)` to that module's " \
+                "`exposing` list."
+
+            in Hint(module_name:, type_name:, fix: :import)
+              "#{base}. `#{module_name}` exposes it — add `#{type_name}(..)` to this " \
+                "module's `import #{module_name} exposing (...)`."
+            end
           end
 
           def label

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

@@ -3,11 +3,12 @@ module Jade
     module SemanticAnalysis
       module Error
         class VariableNotFound < Jade::Error
-          attr_reader :causes
+          attr_reader :causes, :candidates
 
-          def initialize(entry, span, name:, causes: [])
+          def initialize(entry, span, name:, causes: [], candidates: [])
             @name = name
             @causes = causes
+            @candidates = candidates
             super(entry:, span:)
           end
 
@@ -18,6 +19,12 @@ module Jade
           def label
             "not found"
           end
+
+          # Qualified, like `candidates`: bare `fold_left` against `fold` is
+          # too short to clear the spell checker's threshold.
+          def queried_name
+            @name
+          end
         end
       end
     end

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

@@ -55,13 +55,14 @@ module Jade
           import = entry
             .imports
             .find { it.alias == module_name }
+          imported = import&.then { registry.get(it.module_name) }
 
           if import.nil?
             Error::ModuleNotFound
               .new(entry.name, node.target.range, name: import)
 
           else
-            case registry.get(import.module_name).exposed_value(name.name)
+            case imported.exposed_value(name.name)
             in nil
               Error::ValueNotExposed
                 .new(entry.name, name.range, module_name:, name: name.name)
@@ -77,10 +78,19 @@ module Jade
                   node.range,
                   name: [module_name, name.name].join('.'),
                   causes: [it],
+                  candidates: exposed_value_names(imported, module_name),
                 )
             end
             .then { Err[it] }
         end
+
+        def exposed_value_names(imported, module_name)
+          return [] unless imported
+
+          imported
+            .exposes
+            .filter_map { "#{module_name}.#{it.name}" if it.is_a?(Symbol::ValueRef) }
+        end
       end
     end
   end

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

@@ -11,13 +11,23 @@ module Jade
 
             def supports?(interface) = interface == INTERFACE
 
+            # One decoder combinator per structural type, taking a decoder per
+            # element. `Tuple2(a, b)` is `Decode.tuple(dec_a, dec_b)` the same
+            # way `List(a)` is `Decode.list(dec_a)`.
+            STRUCTURAL = {
+              'List.List' => 'Decode.list',
+              'Maybe.Maybe' => 'Decode.nullable',
+              'Set.Set' => 'Decode.set',
+              'Dict.Dict' => 'Decode.dict',
+              'Tuple.Tuple2' => 'Decode.tuple',
+              'Tuple.Tuple3' => 'Decode.tuple3',
+              'Tuple.Tuple4' => 'Decode.tuple4',
+            }.freeze
+
             def derive(constraint, registry, entry_name, &lookup)
               case constraint.type
-              in Type::Application(constructor: Type::Constructor(name: 'List.List'), args: [inner])
-                derive_unary(constraint, inner, 'Decode.list', lookup, entry_name)
-
-              in Type::Application(constructor: Type::Constructor(name: 'Maybe.Maybe'), args: [inner])
-                derive_unary(constraint, inner, 'Decode.nullable', lookup, entry_name)
+              in Type::Application(constructor: Type::Constructor(name:), args:) if STRUCTURAL.key?(name)
+                derive_structural(constraint, args, STRUCTURAL.fetch(name), lookup, entry_name)
 
               in Type::Application(constructor: Type::Constructor(name:), args:)
                 resolved_sym = Symbol
@@ -56,32 +66,30 @@ module Jade
               ]
             end
 
-            def derive_unary(constraint, inner_type, stdlib_fn, lookup, entry_name)
-              dep = Type.constraint(INTERFACE, inner_type, nil)
-
-              resolve_dep(dep, lookup, entry_name).and_then do |dep_impl|
-                body = [:call,
-                  [:stdlib_fn, stdlib_fn],
-                  [
-                    [:impl_arg, 0, 'decoder'],
-                  ],
-                ]
+            def derive_structural(constraint, inner_types, stdlib_fn, lookup, entry_name)
+              body = [:call,
+                [:stdlib_fn, stdlib_fn],
+                inner_types.each_index.map { [:impl_arg, it, 'decoder'] },
+              ]
 
-                Ok[implementation(constraint, body, [dep_impl])]
-              end
+              inner_types
+                .map { Type.constraint(INTERFACE, it, nil) }
+                .map { resolve_dep(it, lookup, entry_name) }
+                .then { Results.sequence(it) }
+                .map { implementation(constraint, body, it) }
             end
 
             def derive_struct(constraint, struct_sym, type_args, registry, lookup, entry_name)
               fields = struct_fields(struct_sym, type_args, registry)
 
-              [:struct_constructor, struct_sym.qualified_name, fields.size]
+              [:struct_class, struct_sym.qualified_name]
                 .then { derive_record(constraint, fields, it, lookup, entry_name) }
             end
 
             def derive_anonymous_record(constraint, fields, lookup, entry_name)
               keys = fields.keys.map(&:to_s)
 
-              [:anon_record_constructor, keys]
+              [:anon_record_class, keys]
                 .then { derive_record(constraint, fields.to_a, it, lookup, entry_name) }
             end
 
@@ -113,19 +121,14 @@ module Jade
             end
 
             def record_body(fields, constructor_ref)
-              seed = [:call, [:stdlib_fn, 'Decode.succeed'], [constructor_ref]]
-
-              fields.each_with_index.reduce(seed) do |acc, ((field_name, _), idx)|
-                field_decoder = [:call,
-                  [:stdlib_fn, 'Decode.field'],
-                  [
-                    field_name.to_s,
-                    [:impl_arg, idx, 'decoder'],
-                  ],
-                ]
-
-                [:call, [:stdlib_fn, 'Decode.and_map'], [acc, field_decoder]]
-              end
+              [:call,
+                [:stdlib_fn, 'Decode.record'],
+                [
+                  [:list, fields.map { |name, _| name.to_s }],
+                  [:list, fields.each_index.map { [:impl_arg, it, 'decoder'] }],
+                  constructor_ref,
+                ],
+              ]
             end
 
             # Free-var inner constraints fall back to the constraint marker

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

@@ -13,13 +13,23 @@ module Jade
               interface == INTERFACE
             end
 
+            # One encoder combinator per structural type, taking an encoder per
+            # element plus the value itself. The name is what the emitted
+            # encoder binds its argument to.
+            STRUCTURAL = {
+              'List.List' => ['Encode.list', 'items'],
+              'Maybe.Maybe' => ['Encode.nullable', 'maybe'],
+              'Set.Set' => ['Encode.set', 'set'],
+              'Dict.Dict' => ['Encode.dict', 'dict'],
+              'Tuple.Tuple2' => ['Encode.tuple', 'pair'],
+              'Tuple.Tuple3' => ['Encode.tuple3', 'triple'],
+              'Tuple.Tuple4' => ['Encode.tuple4', 'quad'],
+            }.freeze
+
             def derive(constraint, registry, entry_name, &lookup)
               case constraint.type
-              in Type::Application(constructor: Type::Constructor(name: 'List.List'), args: [inner])
-                derive_list(constraint, inner, lookup, entry_name)
-
-              in Type::Application(constructor: Type::Constructor(name: 'Maybe.Maybe'), args: [inner])
-                derive_nullable(constraint, inner, lookup, entry_name)
+              in Type::Application(constructor: Type::Constructor(name:), args:) if STRUCTURAL.key?(name)
+                derive_structural(constraint, args, *STRUCTURAL.fetch(name), lookup, entry_name)
 
               in Type::Application(constructor: Type::Constructor(name:), args:)
                 resolved_sym = Symbol
@@ -55,36 +65,17 @@ module Jade
               ]
             end
 
-            def derive_list(constraint, inner_type, lookup, entry_name)
-              dep = Type.constraint(INTERFACE, inner_type, nil)
-
-              lookup.call(dep).and_then do |dep_impl|
-                body = [:call,
-                  [:stdlib_fn, 'Encode.list'],
-                  [
-                    [:impl_arg, 0, 'encoder'],
-                    [:var, 'items'],
-                  ],
-                ]
-
-                Ok[implementation(constraint, params: ['items'], body:, deps: [dep_impl])]
-              end
-            end
-
-            def derive_nullable(constraint, inner_type, lookup, entry_name)
-              dep = Type.constraint(INTERFACE, inner_type, nil)
-
-              lookup.call(dep).and_then do |dep_impl|
-                body = [:call,
-                  [:stdlib_fn, 'Encode.nullable'],
-                  [
-                    [:impl_arg, 0, 'encoder'],
-                    [:var, 'maybe'],
-                  ],
-                ]
+            def derive_structural(constraint, inner_types, stdlib_fn, param, lookup, entry_name)
+              body = [:call,
+                [:stdlib_fn, stdlib_fn],
+                inner_types.each_index.map { [:impl_arg, it, 'encoder'] } + [[:var, param]],
+              ]
 
-                Ok[implementation(constraint, params: ['maybe'], body:, deps: [dep_impl])]
-              end
+              inner_types
+                .map { Type.constraint(INTERFACE, it, nil) }
+                .map { lookup.call(it) }
+                .then { Results.sequence(it) }
+                .map { implementation(constraint, params: [param], body:, deps: it) }
             end
 
             def derive_nullary_union(constraint, union_sym, registry)
@@ -106,27 +97,18 @@ module Jade
               field_deps = fields
                 .map { |_, field_type| Type.constraint(INTERFACE, field_type, nil) }
 
-              pair_irs = fields
+              body = fields
                 .each_with_index
                 .map do |(field_name, _), idx|
-                  [:call,
-                    [:stdlib_fn, 'Tuple.pair'],
-                    [
-                      field_name.to_s,
-                      [:call,
-                        [:impl_arg, idx, 'encoder'],
-                        [[:access, [:var, 'rec'], field_name.to_s]],
-                      ],
+                  [
+                    field_name.to_s,
+                    [:call,
+                      [:impl_arg, idx, 'encoder'],
+                      [[:access, [:var, 'rec'], field_name.to_s]],
                     ],
                   ]
                 end
-
-              body = [:call,
-                [:stdlib_fn, 'Encode.object'],
-                [
-                  [:list, pair_irs],
-                ],
-              ]
+                .then { [:hash, it] }
 
               field_deps
                 .map { lookup.call(it) }