jade-lang 0.9.0 → 0.10.0

data/lib/jade/module_loader.rb

@@ -6,6 +6,7 @@ require 'jade/ast'
 require 'jade/registry'
 require 'jade/frontend'
 require 'jade/codegen'
+require 'jade/module_loader/build'
 require 'jade/module_loader/cache'
 require 'jade/module_loader/dependency_resolver'
 require 'jade/module_loader/dependency_graph'

data/lib/jade/parsing/combinators.rb

@@ -166,6 +166,26 @@ module Jade
         end
       end
 
+      # A word that only reads as a keyword in one position, so it stays
+      # usable as an ordinary name everywhere else.
+      def contextual(word)
+        (@contextuals ||= {})[word] ||= P.new do |state|
+          type(:identifier).call(state).and_then do |(token, next_state)|
+            next Ok[[token, next_state]] if token.value == word
+
+            Err[[
+              Parsing::UnexpectedTokenError.new(
+                entry:    state.entry,
+                span:     token.range,
+                actual:   token,
+                expected: word,
+              ),
+              state,
+            ]]
+          end
+        end
+      end
+
       def lazy(&block)
         P.new do |input|
           block.call.call(input)
@@ -216,6 +236,13 @@ module Jade
           with(diagnostics: diagnostics.add(diagnostic))
         end
 
+        # Is the token here on the same line as the one before it?
+        def continues_line?
+          return true if eof? || position.zero?
+
+          same_line?(tokens[position - 1].range.begin, current.range.begin)
+        end
+
         def skip_until(sync_types)
           (position...tokens.length)
             .find { sync_types.include?(tokens[it].type) }
@@ -228,6 +255,12 @@ module Jade
           @fn = block
         end
 
+        def stalled?(error, state)
+          return state.eof? if error.span.nil?
+
+          error.span.begin == state.current&.range&.begin
+        end
+
         def call(tokens)
           @fn.call(tokens)
         end
@@ -282,8 +315,51 @@ module Jade
           map_error(&:commit)
         end
 
-        def context(name)
-          map_error { |err| err.with_context(name) }
+        # A stalled alternation reports whichever branch it tried last, so
+        # say what the position wanted instead. One that got somewhere is
+        # already reporting the useful error.
+        def expecting(what)
+          P.new do |state|
+            call(state).map_error do |(err, err_state)|
+              [!err.committed? && stalled?(err, state) ? err.copy(expected: what) : err, err_state]
+            end
+          end
+        end
+
+        # A `(` opening a new line starts a statement, it does not continue
+        # the expression above it: `(x, y) = p` is a binding, not a call on
+        # whatever the line before ended with.
+        def on_same_line
+          P.new do |state|
+            next Err[[
+              Parsing::UnexpectedTokenError.new(
+                entry: state.entry,
+                span: state.current.range,
+                actual: state.current,
+                expected: 'the same line',
+              ),
+              state,
+            ]] unless state.continues_line?
+
+            call(state)
+          end
+        end
+
+        def parsing(name)
+          map_error { |err| err.copy(context: [name, *err.context]) }
+        end
+
+        # Opens an empty body's span out to the construct it belongs to.
+        # The innermost one gets there first; past that the span is wider
+        # than the marker `body` left, so an enclosing construct skips it.
+        def spanning_empty_body
+          P.new do |state|
+            call(state).map_error do |(err, err_state)|
+              next [err, err_state] unless err.is_a?(MissingBodyError) && err.span.size == 1
+
+              [err.copy(span: state.current.range.begin...err.actual.range.end), err_state]
+            end
+          end
         end
       end
     end

data/lib/jade/parsing/error.rb

@@ -21,14 +21,15 @@ module Jade
         self
       end
 
-      def with_context(name)
+      def copy(**changes)
         self.class.new(
-          entry:     @entry,
-          span:      @span,
-          actual:    @actual,
-          expected:  @expected,
+          entry: @entry,
+          span: @span,
+          actual: @actual,
+          expected: @expected,
           committed: @committed,
-          context:   [name, *@context],
+          context: @context,
+          **changes,
         )
       end
 
@@ -152,6 +153,42 @@ module Jade
       end
     end
 
+    # `in 0..limit`. Rejecting it is right — coverage is decided before
+    # `limit` exists — but the reader needs to be told that, not sent to
+    # look at their `then`.
+    class NonLiteralRangeBoundError < Error
+      def message
+        "#{context_prefix}A range pattern's bounds have to be literals, and " \
+          "#{@actual.value.inspect} is a value. Which integers a branch " \
+          "covers is settled when the code is compiled, so a bound the " \
+          "compiler cannot see cannot be checked."
+      end
+
+      def label
+        'range bound is not a literal'
+      end
+
+      def notes
+        [
+          Jade::Diagnostics::Annotation[
+            :help,
+            'match `_` and compare in the body, or use `if` — either way the ' \
+              'branch is no longer something exhaustiveness can account for',
+          ],
+        ]
+      end
+    end
+
+    class MissingBodyError < UnexpectedTokenError
+      def hint
+        '(a body has to produce a value)'
+      end
+
+      def label
+        'missing body'
+      end
+    end
+
     class InvalidOperatorError < Error
       HINTS = {
         '/=' => 'Use `!=` for inequality.',

data/lib/jade/parsing/type.rb

@@ -5,7 +5,9 @@ module Jade
     module Type
       extend Combinators::Dsl
 
-      parser(:type_expression) { type_function | type_atom | type_record }
+      parser(:type_expression) {
+        (type_function | type_atom | type_record).expecting('a type')
+      }
 
       parser(:type_atom) {
         type_application | type_var | type_tuple | grouped(lazy { type_function })
@@ -65,8 +67,8 @@ module Jade
         no_args = [Combinators::CommaList.empty, nil]
 
         (
-          (type_name >> optional(type_application_args, default: no_args)) |
-          (type_var  >> type_application_args)
+          (type_name >> optional(type_application_args.on_same_line, default: no_args)) |
+          (type_var  >> type_application_args.on_same_line)
         ).map(&AST.type_application)
       }
 

data/lib/jade/parsing.rb

@@ -92,7 +92,7 @@ module Jade
     parser(:program) { module_ | program_body }
 
     parser(:program_body) {
-      (declaration | statement).then { |item|
+      (declaration | statement).expecting('a declaration or an expression').then { |item|
         P.new do |state|
           (
             state.tolerant ?
@@ -105,11 +105,11 @@ module Jade
       }
     }
 
-    parser(:statement) { bind | assign | expression }
+    parser(:statement) { (bind | assign | expression).expecting('an expression') }
 
     parser(:declaration) {
-      function_declaration | type_declaration | import_declaration | interop_import_declaration |
-        struct_declaration | implementation | interface_declaration
+      function_declaration | type_alias_declaration | type_declaration | import_declaration |
+        interop_import_declaration | struct_declaration | implementation | interface_declaration
     }
 
     parser(:expression) {
@@ -129,15 +129,15 @@ module Jade
           type(:colon).skip >>
           lazy { expression }
         ).commit
-        .context("ternary")
+        .parsing("ternary")
     }
 
     parser(:tuple) {
       (
         type(:lparen) >>
-          lazy { expression } >>
+          function_call_arg >>
           type(:comma).skip >>
-          comma_sequence(lazy { expression }) >>
+          comma_sequence(function_call_arg) >>
           type(:rparen)
       ).map(&AST.tuple)
     }
@@ -182,7 +182,8 @@ module Jade
             type(:end)
           ).commit
       ).map(&AST.if_then_else)
-       .context("if/then/else")
+       .parsing("if/then/else")
+       .spanning_empty_body
     }
 
     parser(:case_of) {
@@ -195,7 +196,8 @@ module Jade
             type(:end)
           ).commit
       ).map(&AST.case_of)
-       .context("case")
+       .parsing("case")
+       .spanning_empty_body
     }
 
     # `then` is optional before a branch body. The formatter emits it for
@@ -233,6 +235,21 @@ module Jade
       state.current&.type == :then ? body.call(state.advance) : body.call(state)
     end
 
+    def empty_body?(state)
+      state.position.positive? &&
+        !state.eof? &&
+        BODY_TERMINATORS.include?(state.current.type)
+    end
+
+    # Widened to the whole construct by `spanning_empty_body`.
+    def empty_body_start(state)
+      state
+        .tokens[state.position - 1]
+        .range
+        .end
+        .then { it...(it + 1) }
+    end
+
     def checked_branch_body(in_tok)
       P.new do |state|
         next body.call(state.advance) if state.current&.type == :then
@@ -256,10 +273,72 @@ module Jade
     end
 
     parser(:pattern) {
-      wildcard_pattern | list_pattern | literal_pattern | binding_pattern |
-        constructor_pattern | tuple_pattern | record_pattern
+      wildcard_pattern | list_pattern | range_pattern | literal_pattern |
+        binding_pattern | constructor_pattern | tuple_pattern | record_pattern
+    }
+
+    # Tried ahead of `literal_pattern`, which would otherwise take the lower
+    # bound and leave the `..` stranded.
+    parser(:range_pattern) {
+      ((range_bound >> type(:dotdot) >> upper_bound).map(&AST.range_pattern)) |
+        ((type(:dotdot) >> range_bound).map(&AST.unbounded_below_pattern)) |
+        non_literal_lower_bound
     }
 
+    parser(:non_literal_lower_bound, private: true) {
+      P.new do |state|
+        bound = state.current
+
+        next not_a_range(state) unless bound&.type == :identifier
+        next not_a_range(state) unless state.advance.current&.type == :dotdot
+
+        Err[[non_literal_bound(state, bound), state]]
+      end
+    }
+
+    parser(:range_bound, private: true) {
+      negative_literal | int | float | char | string
+    }
+
+    # A branch whose body is on the next line has no `then` to stop at, so an
+    # open range would otherwise take the first line of the body as its upper
+    # bound.
+    parser(:upper_bound, private: true) {
+      P.new do |state|
+        next Ok[[nil, state]] if state.eof?
+        next Ok[[nil, state]] unless state.same_line?(
+          state.tokens[state.position - 1].range.begin,
+          state.current.range.begin,
+        )
+
+        bound = state.current
+        next Err[[non_literal_bound(state, bound), state]] if bound.type == :identifier
+
+        optional(range_bound).call(state)
+      end
+    }
+
+    def not_a_range(state)
+      UnexpectedTokenError
+        .new(
+          entry: state.entry,
+          span: state.current&.range || (0...0),
+          actual: state.current,
+          expected: :int,
+        )
+        .then { Err[[it, state]] }
+    end
+
+    def non_literal_bound(state, token)
+      NonLiteralRangeBoundError.new(
+        entry: state.entry,
+        span: token.range,
+        actual: token,
+        expected: :int,
+        committed: true,
+      )
+    end
+
     parser(:tuple_pattern) {
       (
         type(:lparen) >>
@@ -308,13 +387,31 @@ module Jade
       ).map(&AST.record_field_pattern)
     }
 
-    parser(:body) { sequence(lazy { statement }).map(&AST.body) }
+    # One of these with nothing before it is an empty body.
+    BODY_TERMINATORS = %i[end else rbrace in].freeze
+
+    parser(:body) {
+      P.new do |state|
+        next sequence(lazy { statement }).map(&AST.body).call(state) unless empty_body?(state)
+
+        Err[[
+          MissingBodyError.new(
+            entry: state.entry,
+            span: empty_body_start(state),
+            actual: state.current,
+            expected: 'an expression',
+            committed: true,
+          ),
+          state,
+        ]]
+      end
+    }
 
     parser(:operator) {
       type(:plus) | type(:minus) | type(:star) | type(:slash) |
         type(:pipe_forward) | type(:pipe_backward) | type(:eq) | type(:not_eq) |
         type(:lt) | type(:gt) | type(:lte) | type(:gte) | type(:andand) | type(:oror) |
-        type(:plusplus)
+        type(:plusplus) | type(:dotdot)
     }
 
     parser(:primary) {
@@ -342,7 +439,7 @@ module Jade
         record_literal | record_update_sugar | record_access_sugar | record_update
     }
 
-    parser(:postfix) { function_call | member_access }
+    parser(:postfix) { function_call.on_same_line | member_access }
 
     parser(:module_name) {
       sequence(constant, separated_by: type(:dot).skip).map { [it] }
@@ -394,14 +491,16 @@ module Jade
             optional(exposing, default: [[]])
           ).commit
       ).map(&AST.import_declaration)
-       .context("import declaration")
+       .parsing("import declaration")
     }
 
     parser(:exposing) {
       (type(:exposing).skip >>
-          type(:lparen).skip >>
-          (expose_list | expose_all) >>
-          type(:rparen).skip
+          (
+            type(:lparen).skip >>
+            (expose_list | expose_all).expecting('a name to expose, or `..`') >>
+            type(:rparen).skip
+          ).commit
       ) | expose_none
     }
 
@@ -437,11 +536,12 @@ module Jade
             ) >>
             type(:arrow).skip >>
             type_expression >>
-            sequence(statement).map(&AST.body) >>
+            body >>
             type(:end)
           ).commit
       ).map(&AST.function_declaration)
-       .context("function declaration")
+       .parsing("function declaration")
+       .spanning_empty_body
     }
 
     parser(:type_declaration) {
@@ -454,7 +554,21 @@ module Jade
             sequence(variant_declaration, separated_by: type(:pipe).skip).map { [it] }
           ).commit
       ).map(&AST.type_declaration)
-       .context("type declaration")
+       .parsing("type declaration")
+    }
+
+    parser(:type_alias_declaration) {
+      (
+        type(:type) >>
+          contextual('alias').skip >>
+          (
+            constant >>
+            (type_params | empty_comma_list) >>
+            type(:assign).skip >>
+            type_expression
+          ).commit
+      ).map(&AST.type_alias_declaration)
+       .parsing("type alias declaration")
     }
 
     parser(:record_declaration) {
@@ -549,7 +663,7 @@ module Jade
     parser(:record_fields) { comma_sequence(record_field) }
 
     parser(:record_field) {
-      (identifier >> type(:colon).skip >> lazy { expression }).map(&AST.record_field)
+      (identifier >> type(:colon).skip >> function_call_arg).map(&AST.record_field)
     }
 
     parser(:record_access_sugar) {
@@ -571,7 +685,7 @@ module Jade
           (interop_module_name >> type(:with) >> interop_functions >> type(:end))
             .commit
       ).map(&AST.interop_import_declaration)
-       .context("interop import declaration")
+       .parsing("interop import declaration")
     }
 
     parser(:interop_namespace_sep) { type(:coloncolon) }
@@ -615,7 +729,7 @@ module Jade
             type(:end)
           ).commit
       ).map(&AST.implementation)
-       .context("implementation")
+       .parsing("implementation")
     }
 
     parser(:interface_declaration) {
@@ -635,7 +749,7 @@ module Jade
             type(:end)
           ).commit
       ).map(&AST.interface_declaration)
-       .context("interface declaration")
+       .parsing("interface declaration")
     }
 
     parser(:interface_function_decl) {
@@ -665,7 +779,7 @@ module Jade
             type_record
           ).commit
       ).map(&AST.struct_declaration)
-       .context("struct declaration")
+       .parsing("struct declaration")
     }
 
     parser(:int)   { type(:int).map(&AST.literal) }

data/lib/jade/runtime.rb

@@ -8,6 +8,25 @@ require 'jade/interop/boundary'
 module Jade
   module Records; end
 
+  # A variant with no fields carries no state, so every construction can
+  # hand back the same object. Prepended to the class's singleton so
+  # `super` still reaches the real constructor the first time.
+  module Nullary
+    def new
+      @instance ||= super
+    end
+
+    def []
+      @instance ||= super
+    end
+  end
+
+  def self.nullary(&block)
+    Data.define
+      .tap { it.class_eval(&block) if block }
+      .tap { it.singleton_class.prepend(Nullary) }
+  end
+
   module Tuple
     Tuple2 = Data.define(:_1, :_2) do
       def to_s = "(#{[_1, _2].map(&:to_s).join(', ')})"
@@ -23,9 +42,9 @@ module Jade
   end
 
   module Basics
-    GT = Data.define()
-    EQ = Data.define()
-    LT = Data.define()
+    GT = Jade.nullary
+    EQ = Jade.nullary
+    LT = Jade.nullary
   end
 
   # Compiled code calls `a.compare(b)`; natives ship `<=>` not `compare`.
@@ -77,20 +96,20 @@ module Jade
     RECORD_CLASSES = {}
     @booted = false
 
+    # In dependency order: a module's `import` names the constant of another.
+    STDLIB = %w[
+      basics maybe number tuple list char string result task dict set
+      decode decode/params encode bytes show debug
+    ].freeze
+
     def boot!
       return if @booted
       @booted = true
 
-      require "jade/stdlib/basics"
-      require "jade/stdlib/string"
-      require "jade/stdlib/list"
-      require "jade/stdlib/tuple"
-      require "jade/stdlib/task"
-      require "jade/stdlib/decode"
-      require "jade/stdlib/encode"
-      require "jade/stdlib/bytes"
-      require "jade/stdlib/dict"
-      require "jade/stdlib/set"
+      require 'jade/stdlib/intrinsics'
+      Stdlib::Intrinsics.runtime_only! unless defined?(Jade::Frontend)
+
+      STDLIB.each { require_relative "stdlib/#{it}" }
     end
 
     def intr(name)

data/lib/jade/source.rb

@@ -35,10 +35,14 @@ module Jade
     end
 
     def to_module_name
-      uri
+      Source.module_name_for(uri)
+    end
+
+    def self.module_name_for(path)
+      path
         .delete_suffix('.jd')
         .split('/')
-        .map { Source.camelize(it) }
+        .map { camelize(it) }
         .join('.')
     end
 

data/lib/jade/stdlib/basics.rb

@@ -14,6 +14,10 @@ module Jade
       native_type :Float, ::Float
       native_type :Bool,  TrueClass, FalseClass
 
+      # No variants, so the only way to hold one is `non_zero`. Erased at
+      # runtime: a NonZero(Int) is the Int.
+      union :NonZero, 'a'
+
       union :Ordering
       variant :GT, of: :Ordering
       variant :EQ, of: :Ordering
@@ -41,11 +45,25 @@ module Jade
       interface(
         'Numeric',
         'a',
-        { '(+)' => 'a, a -> a', '(-)' => 'a, a -> a', '(*)' => 'a, a -> a', '(/)' => 'a, a -> a' }
+        {
+          '(+)' => 'a, a -> a',
+          '(-)' => 'a, a -> a',
+          '(*)' => 'a, a -> a',
+          '(/)' => 'a, NonZero(a) -> a',
+          'from_int' => 'Int -> a',
+        }
       )
 
-      implementation('Numeric', 'Int',   '(+)' => 'int_add', '(-)' => 'int_sub', '(*)' => 'int_mul', '(/)' => 'int_div')
-      implementation('Numeric', 'Float', '(+)' => 'float_add', '(-)' => 'float_sub', '(*)' => 'float_mul', '(/)' => 'float_div')
+      implementation(
+        'Numeric', 'Int',
+        '(+)' => 'int_add', '(-)' => 'int_sub', '(*)' => 'int_mul', '(/)' => 'int_div',
+        'from_int' => 'identity'
+      )
+      implementation(
+        'Numeric', 'Float',
+        '(+)' => 'float_add', '(-)' => 'float_sub', '(*)' => 'float_mul', '(/)' => 'float_div',
+        'from_int' => 'to_float'
+      )
 
       interface(
         'Appendable',
@@ -82,6 +100,7 @@ module Jade
       function('int_div', { a: 'Int', b: 'Int' }, 'Int')
       function('mod', { a: 'Int', b: 'Int' }, 'Int')
 
+
       function('float_add', { a: 'Float', b: 'Float' }, 'Float')
       function('float_sub', { a: 'Float', b: 'Float' }, 'Float')
       function('float_mul', { a: 'Float', b: 'Float' }, 'Float')

data/lib/jade/stdlib/char.rb

@@ -10,6 +10,7 @@ module Jade
       union :Char
 
       implementation('Eq', 'Char', '(==)' => 'char_eq')
+      implementation('Comparable', 'Char', 'compare' => 'char_compare')
 
       function(:to_code, { char: 'Char' }, 'Int')
       function(:from_code, { code: 'Int' }, 'Maybe(Char)')
@@ -22,6 +23,7 @@ module Jade
       default_importing('Char')
 
       function('char_eq', { one: 'Char', other: 'Char' }, 'Bool')
+      function('char_compare', { one: 'Char', other: 'Char' }, 'Ordering')
     end
   end
 end

data/lib/jade/stdlib/clock.rb

@@ -11,7 +11,7 @@ module Jade
       end
 
       def imports
-        [Basics, Maybe, Result, Task, String, Tuple, Decode, Encode, Calendar]
+        [Basics, Maybe, Number, Result, Task, String, Tuple, Decode, Encode, Calendar]
       end
 
       def default_imports
@@ -46,6 +46,7 @@ module Jade
 
           import Decode exposing (Decodable, Decoder, Value)
           import Encode exposing (Encodable)
+          import Number exposing (non_zero)
 
 
           type Instant = Instant(Int)
@@ -259,7 +260,10 @@ module Jade
 
 
           def frac_to_millis(n: Int, digits: Int) -> Int
-            digits == 3 ? n : digits < 3 ? n * pow10(3 - digits) : n / pow10(digits - 3)
+            case non_zero(pow10(digits - 3))
+            in Just(d) then digits == 3 ? n : digits < 3 ? n * pow10(3 - digits) : n / d
+            in Nothing then n
+            end
           end