jade-lang 0.9.0 → 0.10.1

data/lib/jade/frontend/type_checking/inference/division.rb

@@ -0,0 +1,50 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Inference
+        # `/` asks for a `NonZero`, which nothing but `non_zero` can build.
+        # A literal is the exception: the compiler can see whether it is
+        # zero, so `cents / 100` needs no ceremony and `n / 0` is caught
+        # where it is written.
+        module Division
+          extend self
+
+          OPERATOR = '(/)'.freeze
+
+          # Lifted even when the literal is zero: the divide-by-zero error is
+          # the one worth reading, and a type mismatch under it is noise.
+          def lift(node, acc)
+            return acc unless divisor(node)
+
+            acc.with(types: [*acc.types[0..-2], non_zero(acc.types.last)])
+          end
+
+          def by_zero(node, entry_name)
+            return [] unless divisor(node)&.zero?
+
+            [Error::DivisionByZero.new(entry_name, node.args.last.range)]
+          end
+
+          private
+
+          def divisor(node)
+            return nil unless node.args.size == 2 && operator?(node.callee)
+
+            case node.args.last
+            in AST::Literal(value: ::Integer | ::Float => value) then value
+            else nil
+            end
+          end
+
+          def operator?(callee)
+            callee in AST::VariableReference(name: OPERATOR)
+          end
+
+          def non_zero(type)
+            Type.constructor('Basics.NonZero').apply([type])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/type_checking/inference/function_call.rb

@@ -28,10 +28,12 @@ module Jade
                 .then { |(new_state, result)| [new_state, acc.add(result)] }
               end
 
+            args_state = args_state.add_errors(Division.by_zero(node, args_state.env.entry_name))
+
             after_callee_state, result_type = unify_callee(
               args_state,
               callee_result,
-              args_acc,
+              Division.lift(node, args_acc),
               node,
               state,
             )
@@ -170,9 +172,32 @@ module Jade
                 expected: e.expected,
                 actual: e.actual,
                 infix: node.infix,
+                lifted_placeholder: lifted_placeholder?(node),
+                callee_name: source_name(node.callee),
+                arg_names: node.args.map { source_name(it) },
               )
             end
           end
+
+          # Desugaring lifted the `_` into a lambda parameter, so a hole
+          # reads as an argument referring to one by the time we get here.
+          def lifted_placeholder?(node)
+            node.args.any? { it in AST::VariableReference(name: /\A__p\d+__\z/) }
+          end
+
+          # What the author called this, where they called it something.
+          def source_name(node)
+            case node
+            in AST::ConstructorReference | AST::VariableReference
+              node.name
+
+            in AST::QualifiedAccess(path:)
+              path.join('.')
+
+            else
+              nil
+            end
+          end
         end
       end
     end

data/lib/jade/frontend/type_checking/inference/lambda.rb

@@ -56,7 +56,7 @@ module Jade
                 else
                   concrete_t = body_state.env.substitution.apply(t)
                   PatternAnalysis::Exhaustiveness
-                    .assert([p], p.range, acc.env, registry, concrete_t)
+                    .assert([p], p.range, acc.env, concrete_t)
                     .then { acc.add_errors(it) }
                 end
               end

data/lib/jade/frontend/type_checking/inference/pattern.rb

@@ -11,6 +11,32 @@ module Jade
               .then { |s, r| [s.with(env: s.env.pin_type(pattern.id, r.type)), r] }
           end
 
+          def range_type_error(state, pattern)
+            ->(error) do
+              Error::RangePatternType.new(
+                state.env.entry_name, pattern.range,
+                expected: error.expected, actual: error.actual,
+              )
+            end
+          end
+
+          def empty_range(pattern, state, result)
+            pattern => AST::Pattern::Range(from:, to:)
+
+            return [] unless state.env.substitution.apply(result.type) in Type::Application(
+              constructor: Type::Constructor(name: 'Basics.Int'),
+            )
+
+            return [] unless from && to && from.value > to.value
+
+            [Error::EmptyRangePattern.new(
+              state.env.entry_name,
+              pattern.range,
+              from: from.value,
+              to: to.value,
+            )]
+          end
+
           def infer_(pattern, registry, state, expected)
             case pattern
             in AST::Pattern::Record(fields:, symbol:)
@@ -34,6 +60,15 @@ module Jade
                     .unify_result(it, expected.type, &type_error(state, pattern))
                 end
 
+            in AST::Pattern::Range
+              state
+                .unify_result(
+                  Result.init(Type.int),
+                  expected.type,
+                  &range_type_error(state, pattern)
+                )
+                .then { |(st, r)| [st.add_errors(empty_range(pattern, st, r)), r] }
+
             in AST::Pattern::Literal(literal:)
               new_state, literal_result = check(literal, registry, state, expected)
               new_state.unify_result(literal_result, expected.type, &type_error(state, pattern))

data/lib/jade/frontend/type_checking/inference/record_update.rb

@@ -28,7 +28,14 @@ module Jade
               )
             end
 
-            after_state.unify_result(result, expected.type)
+            after_state.unify_result(result, expected.type) do
+              Error::RecordUpdateTypeMismatch.new(
+                state.env.entry_name,
+                node.range,
+                expected: it.expected,
+                actual: it.actual,
+              )
+            end
           end
         end
       end

data/lib/jade/frontend/type_checking/inference/type_alias_declaration.rb

@@ -0,0 +1,18 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Inference
+        module TypeAliasDeclaration
+          extend Helpers
+          extend self
+
+          def infer(node, _, state, _)
+            node => AST::TypeAliasDeclaration
+
+            [state, Result.init(Type.unit)]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,6 +3,7 @@ require 'jade/frontend/type_checking/inference/helpers'
 require 'jade/frontend/type_checking/inference/body'
 require 'jade/frontend/type_checking/inference/case_of'
 require 'jade/frontend/type_checking/inference/constructor_reference'
+require 'jade/frontend/type_checking/inference/division'
 require 'jade/frontend/type_checking/inference/function_call'
 require 'jade/frontend/type_checking/inference/function_declaration'
 require 'jade/frontend/type_checking/inference/implementation'
@@ -21,6 +22,7 @@ require 'jade/frontend/type_checking/inference/record_field'
 require 'jade/frontend/type_checking/inference/record_literal'
 require 'jade/frontend/type_checking/inference/record_update'
 require 'jade/frontend/type_checking/inference/struct_declaration'
+require 'jade/frontend/type_checking/inference/type_alias_declaration'
 require 'jade/frontend/type_checking/inference/interface_declaration'
 require 'jade/frontend/type_checking/inference/type_declaration'
 require 'jade/frontend/type_checking/inference/assign'

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

@@ -35,12 +35,22 @@ module Jade
           entry
             .types
             .reduce(env) do |e, (_, sym)|
+              # Aliases are transparent — they get expanded into their
+              # body whenever a TypeRef resolves to one. They never need
+              # to be looked up as definitions during unification.
+              next e if alias_symbol?(sym, registry)
+
               Definition
                 .from_symbol(sym, registry)
                 .then { e.define(sym.qualified_name, it) }
             end
         end
 
+        def alias_symbol?(sym, registry)
+          sym.is_a?(Symbol::Alias) ||
+            (sym.is_a?(Symbol::TypeRef) && registry.lookup(sym).is_a?(Symbol::Alias))
+        end
+
         def load_imports(env, entry, registry)
           entry
             .imports
@@ -65,6 +75,7 @@ module Jade
 
           in Symbol::TypeRef
             return env if env.lookup_def(sym.qualified_name)
+            return env if registry.lookup(sym).is_a?(Symbol::Alias)
 
             Definition
               .from_symbol(sym, registry)

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

@@ -36,9 +36,12 @@ module Jade
 
         private
 
+        # Every port reaching here returns a Task: `NonTaskPort` runs in
+        # semantic analysis and stops compilation before this, which is what
+        # lets `resolve_port` destructure the return type without checking.
         def resolve_value(sym, entry, registry)
           case sym
-          in Symbol::InteropFunction(return_type: Symbol::TypeApplication)
+          in Symbol::InteropFunction
             resolve_port(sym, entry, registry)
 
           else
@@ -47,7 +50,7 @@ module Jade
         end
 
         def resolve_port(interop_fn, entry, registry)
-          interop_fn.return_type => Symbol::TypeApplication(args: [ok_sym, err_sym])
+          ok_sym, err_sym = arm_symbols(interop_fn.return_type)
 
           # Single Type.from_symbol over the whole port so a var appearing in
           # more than one position gets the same Type::Var id. PortCodec relies
@@ -66,6 +69,19 @@ module Jade
           ]
         end
 
+        # The arms are only wanted for their spans, and an alias keeps its
+        # arms in another declaration, so there is often none to point at and
+        # the port's own return type is the best there is.
+        def arm_symbols(return_type)
+          case return_type
+          in Symbol::TypeApplication(constructor: Symbol::TypeRef['Task', 'Task'], args: [ok, err])
+            [ok, err]
+
+          else
+            [nil, nil]
+          end
+        end
+
         # Without the constraints the shared VarGen would still hand every
         # position its own var; `from_symbol` only ties them together through
         # the map it threads across params and return.
@@ -83,7 +99,7 @@ module Jade
         end
 
         def resolve_param(type_sym, type, interop_fn, index, entry, registry)
-          return [Symbol::InteropFunction::PASS, []] if pass_through?(type_sym)
+          return [Symbol::InteropFunction::PASS, []] if pass_through?(type)
 
           case type
           in Type::Var(name:)
@@ -99,7 +115,7 @@ module Jade
         end
 
         def resolve_arm(type_sym, type, interop_fn, arm, entry, registry)
-          return [Symbol::InteropFunction::PASS, []] if pass_through?(type_sym)
+          return [Symbol::InteropFunction::PASS, []] if pass_through?(type)
 
           case type
           in Type::Var(name:)
@@ -156,10 +172,12 @@ module Jade
           end
         end
 
-        def pass_through?(type_sym)
-          case type_sym
-          in Symbol::TypeApplication(constructor: Symbol::TypeRef(module_name:, name:))
-            [module_name, name] in ['Basics', 'Never'] | ['Decode', 'Value']
+        # Asked of the expanded type, so an alias over `Never` or
+        # `Decode.Value` passes through the same as the type it names.
+        def pass_through?(type)
+          case type
+          in Type::Application(constructor: Type::Constructor(name: 'Basics.Never' | 'Decode.Value'))
+            true
 
           else
             false

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

@@ -47,7 +47,7 @@ module Jade
           in Type::Application(args:)
             case apply(type.constructor)
             in Type::PartialApplication(constructor:, args: tail_args)
-              Type::Application[constructor, args.map { apply(it) } + tail_args]
+              Type::Application[constructor, args.map { apply(it) } + tail_args, type.display]
 
             in constructor
               type.with(constructor:, args: args.map { apply(it) })
@@ -60,7 +60,7 @@ module Jade
 
             case apply(row_var)
             in Type::AnonymousRecord(fields: extra_fields, row_var: new_row_var)
-              Type.anonymous_record(applied_fields.merge(extra_fields), new_row_var)
+              Type.anonymous_record(applied_fields.merge(extra_fields), new_row_var, type.display)
 
             in Type::Var => applied_row_var
               type.with(fields: applied_fields, row_var: applied_row_var)

data/lib/jade/frontend/type_checking.rb

@@ -1,3 +1,4 @@
+require 'jade/frontend/type_checking/cascade'
 require 'jade/frontend/type_checking/canonicalize'
 require 'jade/frontend/type_checking/constraints'
 require 'jade/frontend/type_checking/definition'
@@ -97,7 +98,7 @@ module Jade
         # with those constraints — rather than being dropped silently.
 
         state
-          .with(errors: state.errors + errors)
+          .with(errors: Cascade.prune(state.errors + errors))
           .to_result
       end
 
@@ -143,6 +144,7 @@ module Jade
         in AST::QualifiedAccess then Inference::QualifiedAccess
         in AST::RecordAccess then Inference::RecordAccess
         in AST::StructDeclaration then Inference::StructDeclaration
+        in AST::TypeAliasDeclaration then Inference::TypeAliasDeclaration
         in AST::InterfaceDeclaration then Inference::InterfaceDeclaration
         in AST::RecordField then Inference::RecordField
         in AST::RecordLiteral then Inference::RecordLiteral

data/lib/jade/frontend/usage_analysis.rb

@@ -97,7 +97,8 @@ module Jade
         in AST::Pattern::Record(fields:)
           fields.flat_map { walk(it.pattern, :as_value, entry, owner) }
 
-        in AST::Pattern::Literal | AST::Pattern::Binding | AST::Pattern::Wildcard
+        in AST::Pattern::Literal | AST::Pattern::Binding | AST::Pattern::Wildcard |
+          AST::Pattern::Range
           []
 
         in AST::Grouping(expression:)
@@ -138,6 +139,9 @@ module Jade
         in AST::StructDeclaration(record_type:, symbol:)
           walk_type(record_type, entry, ReferenceIndex.key_for(symbol))
 
+        in AST::TypeAliasDeclaration(body_type:, symbol:)
+          walk_type(body_type, entry, ReferenceIndex.key_for(symbol))
+
         in AST::InterfaceDeclaration(functions:, symbol:)
           ReferenceIndex.key_for(symbol).then do |declared|
             functions.flat_map { walk_type(it.type, entry, declared) }

data/lib/jade/interop/boundary.rb

@@ -11,6 +11,50 @@ module Jade
     # Result wrap/unwrap that user-level Decode.from_value uses is dead
     # weight at the boundary because failure always raises anyway. Skipping
     # it removes one allocation per arg per Ruby→Jade call.
+      # Names the argument a failure came from. Costs nothing until one
+      # does: Ruby only pays for a rescue that fires.
+      def arg(where)
+        yield
+      rescue DecodeError => e
+        raise e.under(where)
+      end
+      alias at arg
+
+      # Finding the element costs a second pass, which only a failure pays
+      # for: the map stays a map.
+      def elements(array, where = nil)
+        array.map { yield(it) }
+      rescue DecodeError => e
+        raise e.under("#{where}[#{failing_index(array) { yield(it) }}]")
+      end
+
+      def failing_index(array)
+        array.each_with_index do |element, index|
+          yield(element)
+        rescue DecodeError
+          return index
+        end
+      end
+
+      # An absent key reads as nil to the field decoder, which then blames
+      # the type it wanted. The path says which key that was, so a struct
+      # can check whether it was ever there.
+      def blame(error, hash, label)
+        key = error.where.to_s[/\A\.([^.\[]+)/, 1]
+        return error if key.nil? || hash.key?(key)
+
+        symbol_keys!(label, hash)
+        error.as(Jade::Decode::MissingField[key])
+      end
+
+      # Mixed keys are a real shape mismatch; the per-field errors say more
+      # than a guess about intent would.
+      def symbol_keys!(label, hash)
+        return if hash.empty? || hash.keys.any?(::String)
+
+        hash.keys.grep(::Symbol).then { raise SymbolKeys.new(label, it) unless it.empty? }
+      end
+
       def decode_or_raise(decoder, value)
         Jade::Decode::Runner.run!(decoder, value) do |error|
           raise Jade::Interop::DecodeError.new(error, value)
@@ -21,54 +65,50 @@ module Jade
       # argument types in place of the generic `decode_or_raise` path —
       # avoids constructing a Decoder descriptor and walking the
       # interpreter for primitives.
-      def integer(label, v)
-        ::Integer === v ? v : type_error!(label, v)
+      def integer(label, v, where = nil)
+        ::Integer === v ? v : type_error!(label, v, where)
       end
 
-      def string(label, v)
-        ::String === v ? v.dup : type_error!(label, v)
+      def string(label, v, where = nil)
+        ::String === v ? v.dup : type_error!(label, v, where)
       end
 
-      def bool(label, v)
-        v == true || v == false ? v : type_error!(label, v)
+      def bool(label, v, where = nil)
+        v == true || v == false ? v : type_error!(label, v, where)
       end
 
-      def float(label, v)
-        ::Numeric === v ? v.to_f : type_error!(label, v)
+      def float(label, v, where = nil)
+        ::Numeric === v ? v.to_f : type_error!(label, v, where)
       end
 
-      def list_of(klass, label, v)
-        v.is_a?(::Array) && v.all? { klass === _1 } ? v : type_error!(label, v)
+      # Copied, because the caller keeps its array and Jade values do not
+      # change. The copy is under 1% of the check that precedes it.
+      def list_of(klass, label, v, where = nil)
+        v.is_a?(::Array) && v.all? { klass === _1 } ? v.dup : type_error!(label, v, where)
       end
 
       # Validates that v is an Array but doesn't check element types — used
       # when the per-element decoder isn't a simple `is_a?` (e.g. nested
       # structs). The caller maps a decoder over the result.
-      def array(label, v)
-        v.is_a?(::Array) ? v : type_error!(label, v)
+      def array(label, v, where = nil)
+        v.is_a?(::Array) ? v : type_error!(label, v, where)
       end
 
+      # Symbol keys are not checked here: every field would then be
+      # missing, and the rescue around the fields catches that for free.
       def hash(label, v)
         case v
-        when ::Hash then string_keyed!(label, v)
+        when ::Hash then v
         when ::Data then v.to_h.transform_keys(&:to_s)
-        else type_error!(label, v)
+        else type_error!(label, v, nil)
         end
       end
 
-      # Mixed keys are a real shape mismatch; the per-field errors say more
-      # than a guess about intent would.
-      def string_keyed!(label, v)
-        return v if v.empty? || v.keys.any?(::String)
-
-        v.keys.grep(::Symbol)
-          .then { it.empty? ? v : raise(Jade::Interop::SymbolKeys.new(label, it)) }
-      end
-
-      def type_error!(label, v)
+      def type_error!(label, v, where)
         raise Jade::Interop::DecodeError.new(
           Jade::Decode::WrongType[label, Jade::Decode.type_name(v)],
           v,
+          where:,
         )
       end
     end

data/lib/jade/interop/error.rb

@@ -54,36 +54,48 @@ module Jade
     end
 
     class DecodeError < Error
-      attr_reader :decode_error, :value, :source
+      attr_reader :decode_error, :value, :source, :where
 
       SUBJECTS = {
         argument: 'Ruby passed a value that failed to decode',
         port_return: 'Port returned a value that failed to decode',
       }.freeze
 
-      def initialize(decode_error, value, source: :argument)
+      # Ruby has no null.
+      TYPE_NAMES = { 'null' => 'nil' }.freeze
+
+      def initialize(decode_error, value, source: :argument, where: nil)
         @decode_error = decode_error
         @value = value
         @source = source
+        @where = where
         super(format(decode_error, value))
       end
 
+      # Frames unwind innermost first, so each one puts itself in front of
+      # the path the frames below it built.
+      def under(segment)
+        self.class.new(decode_error, value, source:, where: "#{segment}#{where}")
+      end
+
+      def as(error)
+        self.class.new(error, value, source:, where:)
+      end
+
       private
 
       def format(error, value)
         path, leaf = unwind(error)
-        location = path.empty? ? "value" : path.join
-        subject = SUBJECTS.fetch(@source)
 
         case leaf
         in Jade::Decode::WrongType[expected, got]
-          "#{subject} at #{location}: expected #{expected}, got #{got} (#{value.inspect})"
+          "#{subject(path)}: expected #{expected}, got #{type_name(got)}#{seen(value)}"
 
         in Jade::Decode::MissingField[key]
-          "#{subject} at #{location}: missing field `#{key}` (#{value.inspect})"
+          "#{subject(path)}: missing field `#{key}`#{seen(value)}"
 
         in Jade::Decode::Custom[msg]
-          "#{subject} at #{location}: #{msg} (#{value.inspect})"
+          "#{subject(path)}: #{msg}#{seen(value)}"
 
         in Jade::Decode::Multiple[errors]
           errors
@@ -92,6 +104,22 @@ module Jade
         end
       end
 
+      # `Shop.price(item).cents` when the caller said where it was, and the
+      # old sentence when it did not.
+      def subject(path)
+        return "#{SUBJECTS.fetch(@source)} at #{path.empty? ? 'value' : path.join}" unless @where
+
+        "#{@where}#{path.join}"
+      end
+
+      def type_name(got)
+        TYPE_NAMES.fetch(got.to_s, got)
+      end
+
+      def seen(value)
+        value.nil? ? '' : " (#{value.inspect})"
+      end
+
       def unwind(error, path = [])
         case error
         in Jade::Decode::AtField[key, inner] then unwind(inner, path + [".#{key}"])

data/lib/jade/interop/lowering.rb

@@ -21,8 +21,9 @@ module Jade
         in Symbol::FunctionType
           [FunctionError.new('inline function type')]
 
-        in Symbol::TypeApplication(args:)
-          args.flat_map { validate(it, registry, entry) }
+        in Symbol::TypeApplication(constructor:, args:)
+          validate(constructor, registry, entry) +
+            args.flat_map { validate(it, registry, entry) }
 
         in Symbol::RecordType(fields:)
           fields.values.flat_map { validate(it, registry, entry) }
@@ -34,6 +35,11 @@ module Jade
           lookup_type(symbol, registry, entry)
             &.then { validate(it, registry, entry) } || []
 
+        # An alias is its body here as everywhere else, so a function type
+        # behind one is still a function type that cannot be lowered.
+        in Symbol::Alias(body:)
+          body ? validate(body, registry, entry) : []
+
         else
           []
         end