jade-lang 0.8.0 → 0.10.0

data/lib/jade/codegen/implementation.rb

@@ -83,7 +83,7 @@ module Jade
           impl_sym
             .functions[fn_name]
             .then { it.is_a?(Symbol::ValueRef) ? it : nil }
-            &.then { "::#{to_qualified(it.module_name)}::Internal.#{it.name}" }
+            &.then { "#{internal(it.module_name)}.#{it.name}" }
             &.then { Pretty.block("def #{ruby_method}(other)", "#{it}(self, other)") }
         end
       end
@@ -143,7 +143,7 @@ module Jade
         fn_map = symbol.functions.filter_map { |fn_name, ref|
           next unless ref.is_a?(Symbol::ValueRef)
 
-          [fn_name, "->(*args) { ::#{to_qualified(ref.module_name)}::Internal.#{ref.name}(*args) }"]
+          [fn_name, "->(*args) { #{internal(ref.module_name)}.#{ref.name}(*args) }"]
         }.to_h
 
         return "" if fn_map.empty?

data/lib/jade/codegen/inline.rb

@@ -80,7 +80,7 @@ module Jade
 
       def lambda_param_name(pattern)
         case pattern
-        in AST::Pattern::Binding(name:) then name
+        in AST::Pattern::Binding(name:) then Names.local(name)
         in AST::Pattern::Wildcard then '_'
         end
       end

data/lib/jade/codegen/inlines.rb

@@ -5,7 +5,9 @@ module Jade
 
       # Ruby's native ordering on these types matches LT/EQ/GT semantics, so
       # the derived comparison ops can collapse to plain operators.
-      RUBY_NATIVE_COMPARES = %w[Basics.int_compare Basics.float_compare String.str_compare].to_set.freeze
+      RUBY_NATIVE_COMPARES = %w[
+        Basics.int_compare Basics.float_compare String.str_compare Char.char_compare
+      ].to_set.freeze
       RUBY_NATIVE_EQS = %w[Basics.int_eq Basics.float_eq Basics.bool_eq String.str_eq].to_set.freeze
 
       DERIVED_COMPARISONS = {
@@ -32,6 +34,7 @@ module Jade
         'Basics.int_mul'    => ->(a, b) { "(#{a} * #{b})" },
         'Basics.int_div'    => ->(a, b) { "(#{a} / #{b})" },
         'Basics.mod'        => ->(a, b) { "(#{a} % #{b})" },
+        'Number.unwrap'      => ->(n)    { n },
         'Basics.float_add'  => ->(a, b) { "(#{a} + #{b})" },
         'Basics.float_sub'  => ->(a, b) { "(#{a} - #{b})" },
         'Basics.float_mul'  => ->(a, b) { "(#{a} * #{b})" },
@@ -113,6 +116,7 @@ module Jade
         'Char.upper?'       => ->(c)           { "#{c}.match?(/[A-Z]/)" },
         'Char.lower?'       => ->(c)           { "#{c}.match?(/[a-z]/)" },
         'Char.char_eq'      => ->(a, b)        { "(#{a} == #{b})" },
+        'Char.char_compare' => ->(a, b)        { "#{a}.compare(#{b})" },
 
         'Tuple.pair'        => ->(a, b)        { "Jade::Tuple::Tuple2[#{a}, #{b}]" },
         'Tuple.first'       => ->(t)           { "#{t}._1" },
@@ -173,6 +177,7 @@ module Jade
 
       # Bodies that don't fit a single Ruby expression.
       NO_INLINE = %w[
+        Number.checked
         List.sort_with
         List.sort_by_with
         List.filter_map

data/lib/jade/codegen/names.rb

@@ -0,0 +1,31 @@
+module Jade
+  module Codegen
+    # Ruby rejects its keywords as local variables and parameters, but accepts
+    # them as method names and Data members — so only bindings are rewritten
+    # here, and nothing a Ruby caller sees changes.
+    module Names
+      extend self
+
+      RESERVED = ::Set[
+        'BEGIN', 'END', '__ENCODING__', '__FILE__', '__LINE__',
+        'alias', 'and', 'begin', 'break', 'case', 'class', 'def',
+        'defined?', 'do', 'else', 'elsif', 'end', 'ensure', 'false',
+        'for', 'if', 'in', 'module', 'next', 'nil', 'not', 'or', 'redo',
+        'rescue', 'retry', 'return', 'self', 'super', 'then', 'true',
+        'undef', 'unless', 'until', 'when', 'while', 'yield',
+      ].freeze
+
+      # Injective: a name that is a reserved word under trailing underscores
+      # gains one more, so `begin` and `begin_` stay distinct.
+      def local(name)
+        reserved_stem?(name) ? "#{name}_" : name
+      end
+
+      private
+
+      def reserved_stem?(name)
+        RESERVED.include?(name.sub(/_+\z/, ''))
+      end
+    end
+  end
+end

data/lib/jade/codegen/pattern/constructor.rb

@@ -8,7 +8,7 @@ module Jade
         def generate(node, registry)
           node => AST::Pattern::Constructor(symbol:, patterns:)
           constructor = registry.lookup(symbol)
-          qualified = to_qualified(constructor.qualified_name)
+          qualified = rooted(constructor.qualified_name)
 
           if keyed_variant?(constructor)
             generate_keyed(qualified, patterns.first, registry)
@@ -39,7 +39,7 @@ module Jade
         def generate_keyed(qualified, pattern, registry)
           case pattern
           in AST::Pattern::Binding(name:)
-            "#{qualified} => #{name}"
+            "#{qualified} => #{Names.local(name)}"
 
           in AST::Pattern::Wildcard
             qualified

data/lib/jade/codegen/transforms/fold_shape.rb

@@ -69,7 +69,7 @@ module Jade
             .then { generate_node(it, registry) }
 
           "#{list_arg}.reverse.reduce(#{base_code}) " \
-            "{ |#{ACC_NAME}, #{head_name}| #{combine_code} }"
+            "{ |#{ACC_NAME}, #{Names.local(head_name)}| #{combine_code} }"
         end
 
         private

data/lib/jade/codegen.rb

@@ -3,6 +3,7 @@ require 'jade/codegen/context'
 require 'jade/codegen/helpers'
 require 'jade/codegen/pretty'
 require 'jade/codegen/method_names'
+require 'jade/codegen/names'
 require 'jade/codegen/inlines'
 require 'jade/codegen/inline'
 require 'jade/codegen/boundary'
@@ -83,10 +84,13 @@ module Jade
     def generate(node, registry, depth: 0)
       case node
       in AST::Module(name:, body:)
+        reopened = reopened_type(name, registry)
+
         preamble = [
           "require 'jade/runtime'",
           *Stdlib.requires(name),
           *namespace_setup_lines(name),
+          *reopening_require(reopened, name),
         ].reject(&:empty?).join(Pretty.newline)
 
         shape_consts = collect_record_shapes(body)
@@ -100,11 +104,15 @@ module Jade
         boundary_helpers = Boundary::Specialized.collect_helpers(body, registry)
           .then { Boundary::Specialized.emit_helpers(it, registry) }
 
+        dict_consts = {}
+
         outer, inner, wrappers =
-          with_boundary_cache(boundary_cache) do
-            with_dispatched_methods(collect_dispatched_methods(body, registry)) do
-              with_hoisted_records do
-                partition_module_body(body.expressions, registry, name.count('.'))
+          with_dict_consts(dict_consts) do
+            with_boundary_cache(boundary_cache) do
+              with_dispatched_methods(collect_dispatched_methods(body, registry)) do
+                with_hoisted_records do
+                  partition_module_body(body.expressions, registry, name.count('.'))
+                end
               end
             end
           end
@@ -114,17 +122,18 @@ module Jade
           .then { Pretty.block("module Internal", it) }
 
         [
-          "extend self",
+          (reopened ? "" : "extend self"),
           *shape_consts,
           *outer,
           inner_module,
+          *referenced_dicts(dict_consts, [*outer, *inner, *wrappers]),
           *boundary_consts,
           *boundary_helpers,
           *wrappers,
         ]
           .reject(&:empty?)
           .join(Pretty.newline(2))
-          .then { Pretty.block("module #{to_qualified(name)}", it) }
+          .then { Pretty.block("#{reopened ? 'class' : 'module'} #{to_qualified(name)}", it) }
           .then { [preamble, it].reject(&:empty?).join(Pretty.newline(2)) }
 
       in AST::ImportDeclaration(module_name:)
@@ -138,7 +147,11 @@ module Jade
         end
 
       in AST::InteropImportDeclaration(module: mod)
-        Pretty.block("begin", "require '#{mod.name.gsub('::', '/').downcase}'\nrescue LoadError")
+        Pretty.block(
+          "begin",
+          "require '#{mod.name.gsub('::', '/').downcase}'",
+          "rescue LoadError\nend",
+        )
 
       in AST::Implementation
         Implementation.generate(node, registry)
@@ -166,17 +179,17 @@ module Jade
             codegen
 
           in Symbol::Function => fn
-            "#{to_qualified(fn.module_name)}::Internal.method(:#{fn.name})"
+            "#{internal(fn.module_name)}.method(:#{fn.name})"
 
           else
-            name
+            Names.local(name)
           end
         end
 
       in AST::Assign(pattern:, expression:)
         case pattern
         in AST::Pattern::Binding(name:)
-          "#{name} = #{generate(expression, registry)}"
+          "#{Names.local(name)} = #{generate(expression, registry)}"
         in AST::Pattern::Wildcard
           generate(expression, registry)
         else
@@ -193,7 +206,7 @@ module Jade
         FunctionDeclaration.generate(node, registry)
 
       in AST::FunctionDeclarationParam(name:)
-        name
+        Names.local(name)
 
       in AST::FunctionCall
         FunctionCall.generate(node, registry)
@@ -209,6 +222,9 @@ module Jade
       in AST::StructDeclaration(name:, record_type:, symbol:)
         data_define_with_methods(name, record_type.fields.keys, "::#{to_qualified(symbol.qualified_name)}")
 
+      in AST::TypeAliasDeclaration
+        ""
+
       in AST::InterfaceDeclaration
         ""
 
@@ -221,7 +237,7 @@ module Jade
             codegen
 
           in Symbol::Function => fn
-            "#{to_qualified(fn.module_name)}::Internal.method(:#{fn.name})"
+            "#{internal(fn.module_name)}.method(:#{fn.name})"
 
           in Symbol::Constructor => sym
             ConstructorReference.from_symbol(sym)
@@ -254,11 +270,14 @@ module Jade
       in AST::Pattern::Literal(literal:)
         generate(literal, registry)
 
+      in AST::Pattern::Range(from:, to:)
+        "#{from&.value}..#{to&.value}"
+
       in AST::Pattern::Wildcard
         "_"
 
       in AST::Pattern::Binding(name:)
-        name
+        Names.local(name)
 
       in AST::Pattern::Record(fields:)
         generate_many(fields, registry)
@@ -270,7 +289,7 @@ module Jade
       in AST::Pattern::List(patterns:, rest:)
         rest_part =
           case rest
-          in AST::Pattern::Binding(name:) then ["*#{name}"]
+          in AST::Pattern::Binding(name:) then ["*#{Names.local(name)}"]
           in AST::Pattern::Wildcard then ["*"]
           in nil then []
           end
@@ -325,7 +344,7 @@ module Jade
 
     def param_name(pattern, index = 0)
       case pattern
-      in AST::Pattern::Binding(name:) then name
+      in AST::Pattern::Binding(name:) then Names.local(name)
       in AST::Pattern::Wildcard then '_'
       else
          param_synthetic_name(index)
@@ -340,6 +359,48 @@ module Jade
       "#{'../' * current_depth}#{import_path}"
     end
 
+    # Emission generates some expressions only to discard them (a decoder
+    # weighed against its specialized form, say), and a discarded one can
+    # still have claimed a constant. Keep the ones that survived, and the
+    # ones those refer to.
+    def referenced_dicts(table, body)
+      reachable_dicts(table, body.join(Pretty.newline))
+        .map { |source, const| "#{const} = #{source}.freeze" }
+    end
+
+    # A kept dictionary can name another one, so widen the search text
+    # with what was kept until nothing new turns up.
+    def reachable_dicts(table, code, kept = {})
+      table
+        .select { |_, const| code.match?(/\b#{const}\b/) }
+        .then do |found|
+          next found if found.size == kept.size
+
+          reachable_dicts(table, [code, *found.keys].join(Pretty.newline), found)
+        end
+    end
+
+    # A module whose name is already a type in its parent shares one Ruby
+    # constant with it, so it reopens that class rather than defining a
+    # module beside it and clobbering whichever loads second.
+    def reopened_type(name, registry)
+      *parent, last = name.split('.')
+      return nil if parent.empty?
+
+      registry
+        .get(parent.join('.'))
+        &.then { it.defined_types.key?(last) ? it : nil }
+    end
+
+    # Before the class body, not inside it: an import writes its require
+    # within the body, by which point `class` has already made a plain
+    # class for the constant and the type will clobber it on load.
+    def reopening_require(entry, name)
+      return [] if entry.nil? || Stdlib.is_stdlib?(entry)
+
+      ["require_relative '#{relative_require(entry.path, name.count('.'))}'"]
+    end
+
     def namespace_setup_lines(name)
       parts = name.split('.')
       (0...parts.length - 1)

data/lib/jade/compiler.rb

@@ -7,6 +7,7 @@ module Jade
     end
 
     def require(path)
+      ModuleLoader::Build.discard_foreign(build_root)
       target = File.expand_path("#{build_root}/#{path}.rb", config.project_root)
 
       if needs_rebuild?(target)
@@ -14,6 +15,7 @@ module Jade
           .load(config.source_root, path + '.jd', cache_dir: cache_root)
           .tap { render_diagnostics(it) }
           .then { ModuleLoader.emit(it, path: build_root) }
+          .then { ModuleLoader::Build.stamp(build_root) }
       end
 
       Kernel.require(File.realpath(target))

data/lib/jade/entry.rb

@@ -89,7 +89,7 @@ module Jade
 
     def define(symbol)
       case symbol
-      in Symbol::Union | Symbol::Struct | Symbol::Interface
+      in Symbol::Union | Symbol::Struct | Symbol::Alias | Symbol::Interface
         add_defined_type(symbol)
 
       in Symbol::Implementation

data/lib/jade/error.rb

@@ -21,6 +21,10 @@ module Jade
       []
     end
 
+    def secondary
+      []
+    end
+
     def queried_name
       nil
     end
@@ -39,6 +43,7 @@ module Jade
       Jade::Diagnostics::Diagnostic.error(
         message,
         primary: Jade::Diagnostics::Label[source, span, label],
+        secondary: secondary.map { |sp, text| Jade::Diagnostics::Label[source, sp, text] },
         annotations: notes + did_you_mean_notes,
       )
     end

data/lib/jade/extensions.rb

@@ -0,0 +1,70 @@
+module Jade
+  # Where an extension gem hooks into compilation. Only gems named in ALLOWED
+  # may register, so jade knows who extends it and nothing about what they do.
+  module Extensions
+    extend self
+
+    ALLOWED = %w[jade-sql].freeze
+    PHASES = %i[call].freeze
+
+    class NotAllowed < StandardError
+      def initialize(gem_name)
+        super(
+          "#{gem_name} may not extend the compiler; " \
+            "allowed: #{ALLOWED.join(', ')}"
+        )
+      end
+    end
+
+    class UnknownPhase < StandardError
+      def initialize(phase)
+        super("no such check phase #{phase.inspect}; known: #{PHASES.join(', ')}")
+      end
+    end
+
+    def register_deriver(gem_name, deriver)
+      allow!(gem_name)
+      @derivers = derivers | [deriver]
+    end
+
+    # A `:call` check answers `watches -> [qualified name]` and
+    # `check(context) -> [error]`. Watching by name keeps every other call in
+    # the program off the check's path entirely.
+    def register_check(gem_name, phase, check)
+      allow!(gem_name)
+      fail UnknownPhase.new(phase) unless PHASES.include?(phase)
+
+      @call_checks = check
+        .watches
+        .reduce(call_checks) { |acc, name| acc.merge(name => acc.fetch(name, []) | [check]) }
+    end
+
+    def derivers = @derivers ||= []
+
+    def call_checks = @call_checks ||= {}
+
+    # The node travels with the types because a literal's value — a SQL string,
+    # a constant predicate — is not in them.
+    CallContext = Data.define(:name, :arg_types, :node, :registry, :entry_name, :span)
+
+    def check_call(name, arg_types, node, registry, entry_name, span)
+      call_checks[name].then do |watching|
+        next [] if watching.nil?
+
+        CallContext[name, arg_types, node, registry, entry_name, span]
+          .then { |ctx| watching.flat_map { it.check(ctx) } }
+      end
+    end
+
+    def reset!
+      @derivers = []
+      @call_checks = {}
+    end
+
+    private
+
+    def allow!(gem_name)
+      fail NotAllowed.new(gem_name) unless ALLOWED.include?(gem_name)
+    end
+  end
+end

data/lib/jade/formatter/calls.rb

@@ -12,7 +12,10 @@ module Jade
 
         callee_str = format_node(callee, source:)
         args_strs  = args.map { format_node(it, source:) }
-        Calls.render(callee_str, args_strs, trailing_comma, indent)
+
+        Calls::Call[callee_str, args_strs, indent].then do |call|
+          Calls.render(call, trailing_comma, opened_last: Calls.render_open(args.last, source))
+        end
       end
     end
 
@@ -25,7 +28,10 @@ module Jade
 
         callee_str = format_node(callee, source:)
         field_strs = fields.map { "#{it.key}: #{format_node(it.value, source:)}" }
-        Calls.render(callee_str, field_strs, trailing_comma, indent)
+
+        Calls::Call[callee_str, field_strs, indent].then do |call|
+          Calls.render(call, trailing_comma, opened_last: Calls.render_open_field(fields.last, source))
+        end
       end
     end
 
@@ -33,19 +39,70 @@ module Jade
       extend self
       extend Helper
 
-      def render(callee_str, item_strs, trailing_comma, indent)
-        inline = "#{callee_str}(#{item_strs.join(', ')})"
+      # A trailing block-shaped argument reads as the call's body, the way a
+      # Ruby block does. Only these three grow a body worth hugging.
+      HUGGABLE = [AST::Lambda, AST::List, AST::RecordLiteral].freeze
+
+      # A rendered call, before the decision of how to lay it out: the callee,
+      # its already-formatted arguments, and the column they sit at.
+      Call = Data.define(:callee, :items, :indent)
+
+      def huggable?(node)
+        HUGGABLE.any? { node.is_a?(it) }
+      end
+
+      def render_open(node, source)
+        return nil unless huggable?(node)
+
+        dispatch_for(node).format(node, indent: 0, source:, open: true)
+      end
 
-        if trailing_comma || too_long?(inline, indent)
-          inner = item_strs
-            .map { "#{it.then(&and_indent(indent + 1))}," }
-            .join("\n")
+      def render_open_field(field, source)
+        render_open(field&.value, source)&.then { "#{field.key}: #{it}" }
+      end
 
-          "#{callee_str.then(&and_indent(indent))}(\n#{inner}\n#{INDENT * indent})"
-        else
-          inline.then(&and_indent(indent))
+      def render(call, trailing_comma, opened_last: nil)
+        case [trailing_comma, inline(call), opened_last]
+        in [false, String => fits, _] then fits
+        in [false, nil, String => last] then hug_last(call, last) || explode(call)
+        else explode(call)
         end
       end
+
+      private
+
+      def inline(call)
+        "#{call.callee}(#{call.items.join(', ')})"
+          .then { too_long?(it, call.indent) ? nil : it.then(&and_indent(call.indent)) }
+      end
+
+      # An earlier multi-line argument would leave the head straddling lines.
+      def hug_last(call, last)
+        case [call.items[..-2], last.split("\n")]
+        in [[*head], [_]] then nil
+        in [[*head], _] if head.any? { it.include?("\n") } then nil
+        in [[*head], [opener, *rest]]
+          "#{call.callee}(#{(head + [opener]).join(', ')}"
+            .then { too_long?(it, call.indent) ? nil : hug_lines(it, rest, call.indent) }
+        end
+      end
+
+      def hug_lines(opening, rest, indent)
+        [opening, *rest[..-2], "#{rest.last})"]
+          .join("\n")
+          .then(&and_indent(indent))
+      end
+
+      def explode(call)
+        call.items
+          .map { "#{it.then(&and_indent(call.indent + 1))}," }
+          .join("\n")
+          .then { "#{indent_callee(call)}(\n#{it}\n#{INDENT * call.indent})" }
+      end
+
+      def indent_callee(call)
+        call.callee.then(&and_indent(call.indent))
+      end
     end
   end
 end

data/lib/jade/formatter/collections.rb

@@ -22,12 +22,12 @@ module Jade
       extend self
       extend Helper
 
-      def format(node, indent:, source:)
+      def format(node, indent:, source:, open: false)
         node => AST::List(items:, trailing_comma:)
 
         format_delimited(
           items.map { format_node(it, source:) },
-          '[', ']', trailing_comma, indent,
+          '[', ']', trailing_comma || open, indent,
         )
       end
     end
@@ -36,13 +36,13 @@ module Jade
       extend self
       extend Helper
 
-      def format(node, indent:, source:)
+      def format(node, indent:, source:, open: false)
         node => AST::RecordLiteral(fields:, trailing_comma:)
 
         field_strs = fields.map { "#{it.key}: #{format_node(it.value, source:)}" }
         inline     = "{ #{field_strs.join(', ')} }"
 
-        if trailing_comma || too_long?(inline, indent)
+        if trailing_comma || open || too_long?(inline, indent)
           inner = field_strs
             .map { "#{it.then(&and_indent(indent + 1))}," }
             .join("\n")

data/lib/jade/formatter/declarations.rb

@@ -68,24 +68,22 @@ module Jade
           "(#{type_params.map(&:name).join(', ')})"
         header = "struct #{name}#{params_str} ="
 
-        record_type => AST::TypeRecord(fields:, row_var:)
-
-        if fields.size > 1
-          format_multiline(header, fields, row_var, indent)
-        else
-          "#{header} #{format_type(record_type)}".then(&and_indent(indent))
-        end
+        format_record_declaration(header, record_type, indent)
       end
+    end
 
-      def format_multiline(header, fields, row_var, indent)
-        open_brace = row_var ? "{ #{row_var.name} |" : "{"
-        fields_str = fields
-          .map { |k, v| "#{k}: #{format_type(v)}".then(&and_indent(indent + 1)) }
-          .join(",\n")
+    module TypeAliasDeclaration
+      extend self
+      extend Helper
+
+      def format(node, indent:, source:)
+        node => AST::TypeAliasDeclaration(name:, type_params:, body_type:)
+
+        params_str = type_params.empty? ?
+          "" :
+          "(#{type_params.map(&:name).join(', ')})"
 
-        and_indent(indent)
-          .call("#{header} #{open_brace}")
-          .then { "#{it}\n#{fields_str}\n#{INDENT * indent}}" }
+        format_record_declaration("type alias #{name}#{params_str} =", body_type, indent)
       end
     end
 

data/lib/jade/formatter/helper.rb

@@ -30,6 +30,7 @@ module Jade
         in AST::TypeDeclaration              then TypeDeclaration
         in AST::VariantDeclaration           then VariantDeclaration
         in AST::StructDeclaration            then StructDeclaration
+        in AST::TypeAliasDeclaration         then TypeAliasDeclaration
         in AST::ImportDeclaration            then ImportDeclaration
         in AST::InteropImportDeclaration     then InteropImportDeclaration
         in AST::InteropFunction              then InteropFunction
@@ -113,6 +114,25 @@ module Jade
         Pattern.format(node, source:)
       end
 
+      # A record body past one field goes multi-line, so a `type alias` over a
+      # record breaks the same way as the `struct` beside it.
+      def format_record_declaration(header, body, indent)
+        case body
+        in AST::TypeRecord(fields:, row_var:) if fields.size > 1
+          open_brace = row_var ? "{ #{row_var.name} |" : "{"
+          fields_str = fields
+            .map { |k, v| "#{k}: #{format_type(v)}".then(&and_indent(indent + 1)) }
+            .join(",\n")
+
+          and_indent(indent)
+            .call("#{header} #{open_brace}")
+            .then { "#{it}\n#{fields_str}\n#{INDENT * indent}}" }
+
+        else
+          "#{header} #{format_type(body)}".then(&and_indent(indent))
+        end
+      end
+
       def format_type(node)
         Type.format(node)
       end