jade-lang 0.8.0 → 0.10.0

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
 
 

data/lib/jade/stdlib/decimal.rb

@@ -36,6 +36,7 @@ module Jade
           import Maybe
           import Decode exposing (Decodable, Decoder)
           import Encode exposing (Encodable)
+          import Number exposing (non_zero)
 
 
           # An exact base-10 decimal: value = coefficient * 10 ^ exponent.
@@ -81,24 +82,45 @@ module Jade
 
 
           # Integer division, rounding ties half away from zero (Java HALF_UP /
-          # Ruby BigDecimal default: 2.5 -> 3, -2.5 -> -3). A zero `den` raises
-          # through Int `/`.
+          # Ruby BigDecimal default: 2.5 -> 3, -2.5 -> -3).
           def round_div(num: Int, den: Int) -> Int
             negative = not ((num < 0) == (den < 0))
-            n = abs(num)
-            d = abs(den)
-            q = n / d
+            magnitude = round_div_abs(abs(num), abs(den))
+
+            negative ? 0 - magnitude : magnitude
+          end
+
+
+          # Every caller divides by a scale or by a checked divisor, so the
+          # Nothing arm is unreachable rather than a rounding decision.
+          def round_div_abs(n: Int, d: Int) -> Int
+            case non_zero(d)
+            in Just(nz) then rounded_quotient(n, nz, d)
+            in Nothing then 0
+            end
+          end
+
+
+          def rounded_quotient(n: Int, nz: NonZero(Int), d: Int) -> Int
+            q = n / nz
             r = n - q * d
-            rounded = (2 * r) >= d ? q + 1 : q
 
-            negative ? 0 - rounded : rounded
+            (2 * r) >= d ? q + 1 : q
           end
 
 
           def trunc_div(num: Int, den: Int) -> Int
-            q = abs(num) / abs(den)
+            magnitude = trunc_div_abs(abs(num), abs(den))
+
+            num < 0 ? 0 - magnitude : magnitude
+          end
 
-            num < 0 ? 0 - q : q
+
+          def trunc_div_abs(n: Int, d: Int) -> Int
+            case non_zero(d)
+            in Just(nz) then n / nz
+            in Nothing then 0
+            end
           end
 
 
@@ -132,9 +154,9 @@ module Jade
 
           # a / b rounded half-up to `scale` decimal places, like Java's
           # BigDecimal.divide(divisor, scale, HALF_UP). Division by zero raises.
-          def div(a: Decimal, b: Decimal, scale: Int) -> Decimal
+          def div(a: Decimal, b: NonZero(Decimal), scale: Int) -> Decimal
             Decimal(ma, ea) = a
-            Decimal(mb, eb) = b
+            Decimal(mb, eb) = Number.unwrap(b)
             k = (ea - eb) + scale
             num = k >= 0 ? ma * pow10(k) : ma
             den = k >= 0 ? mb : mb * pow10(0 - k)
@@ -145,16 +167,22 @@ module Jade
 
           # The Numeric `/`: like Ruby's BigDecimal `/`, it can't be exact for a
           # repeating quotient (1/3), so it rounds half-up to a generous scale.
-          def divide(a: Decimal, b: Decimal) -> Decimal
+          def divide(a: Decimal, b: NonZero(Decimal)) -> Decimal
             div(a, b, 32)
           end
 
 
+          def from_int(n: Int) -> Decimal
+            Decimal(n, 0)
+          end
+
+
           implements Numeric(Decimal) with
             (+): add,
             (-): sub,
             (*): mul,
-            (/): divide
+            (/): divide,
+            from_int: from_int
           end
 
 
@@ -181,7 +209,16 @@ module Jade
 
             e >= 0
               ? Basics.to_float(m * pow10(e))
-              : Basics.to_float(m) / Basics.to_float(pow10(0 - e))
+              : scaled_down(Basics.to_float(m), Basics.to_float(pow10(0 - e)))
+          end
+
+
+          # `pow10` is never zero, so the Nothing arm cannot be reached.
+          def scaled_down(m: Float, scale: Float) -> Float
+            case non_zero(scale)
+            in Just(nz) then m / nz
+            in Nothing then m
+            end
           end