jade-lang 0.9.0 → 0.10.1

data/lib/jade/codegen/function_call.rb

@@ -16,6 +16,9 @@ module Jade
         Inline.try_for(callee, args, dictionaries, registry)
           .then { return it if it }
 
+        constrained_constant(callee, dictionaries, registry)
+          .then { return it if it }
+
         return constructor_call(callee, args, registry) if constructor_callee?(callee, registry)
 
         [generate_many(args, registry), generate_dict_args(callee, dictionaries, registry)]
@@ -24,6 +27,18 @@ module Jade
           .then { "#{generate_callee(callee, args, registry, dictionaries)}#{invocation_op(callee, registry)}(#{it})" }
       end
 
+      # A constrained constant — `Decode.decoder` — has no parameters, so its
+      # dictionary slot holds the value itself rather than something to call.
+      # generate_callee already produced that value; invoking it would be
+      # calling a Decoder.
+      def constrained_constant(callee, dictionaries, registry)
+        symbol = resolve_callee_symbol(callee, registry)
+        return nil unless symbol.is_a?(Symbol::StdlibFunction)
+        return nil unless symbol.params.empty? && symbol.constraints.any?
+
+        generate_callee(callee, [], registry, dictionaries)
+      end
+
       def constructor_call(callee, args, registry)
         resolve_callee_symbol(callee, registry)
           .then { "::#{to_qualified(it.qualified_name)}" }
@@ -102,10 +117,25 @@ module Jade
           Codegen.dict_env[[interface, id]]
 
         in Symbol::Implementation
-          Pretty.hash(generate_impl_dispatch(entry, registry))
+          hoisted(Pretty.hash(generate_impl_dispatch(entry, registry)))
         end
       end
 
+      # A dictionary built only from concrete implementations is the same
+      # object on every call, so it is worth building once. One that names
+      # a dict parameter is not: that slot is the caller's, and differs per
+      # call. Outside a module there is nowhere to put a constant, so the
+      # literal stands.
+      #
+      # Keyed by source, which dedupes the same dictionary across every
+      # call site in the module.
+      def hoisted(source)
+        table = Codegen.dict_consts or return source
+        return source if Codegen.dict_env.values.any? { source.include?(it) }
+
+        table[source] ||= "DICT_#{table.size}"
+      end
+
       # Polymorphic fn referenced as a value (not called). Wraps the fn with
       # its dispatched dictionaries so the result is a monomorphic callable
       # matching the type at the use site. Returns nil when the symbol
@@ -127,13 +157,13 @@ module Jade
             .each_with_index
             .filter_map { |c, i| dispatch_value(dictionaries[i], registry) if c.type.is_a?(Type::Var) }
             .then { (param_names + it).join(', ') }
-            .then { "#{to_qualified(fn.module_name)}::Internal.#{fn_target_name(fn, registry)}(#{it})" }
+            .then { "#{internal(fn.module_name)}.#{fn_target_name(fn, registry)}(#{it})" }
             .then { Pretty.lambda(param_names.join(', '), it) }
 
         in Symbol::InterfaceFunction => fn
-          dispatch_value(dictionaries.first, registry)
-            &.then { "#{it}[#{fn.name.inspect}]" } ||
+          dispatch_lookup(dictionaries.first, fn.name, registry) {
             fail("no dict in scope to reference interface method `#{fn.qualified_name}` as a value")
+          }
 
         else
           nil
@@ -199,7 +229,7 @@ module Jade
           generate_node(callee, registry)
 
         in Symbol::Function => fn_sym
-          to_qualified(fn_sym.module_name) + "::Internal." + fn_target_name(fn_sym, registry)
+          internal(fn_sym.module_name) + "." + fn_target_name(fn_sym, registry)
 
         in Symbol::StdlibImplementation => symbol
           dictionaries
@@ -323,10 +353,10 @@ module Jade
         # 0-arg fn: Ruby auto-invokes on bare reference. Result is the
         # dispatch-slot value (decoder, encoder template, ...) ready to use.
         in Symbol::Function => fn if fn.constant?
-          "#{to_qualified(fn.module_name)}::Internal.#{fn.name}"
+          "#{internal(fn.module_name)}.#{fn.name}"
 
         in Symbol::Function => fn
-          "#{to_qualified(fn.module_name)}::Internal.method(:#{fn.name})"
+          "#{internal(fn.module_name)}.method(:#{fn.name})"
         end
       end
 
@@ -334,6 +364,7 @@ module Jade
         dep_dispatches
           .map { it.is_a?(String) ? it : Pretty.hash(it) }
           .then { Pretty.array(it) }
+          .then { hoisted(it) }
       end
 
       # Stdlib intrinsics implementation language.

data/lib/jade/codegen/function_declaration.rb

@@ -20,12 +20,12 @@ module Jade
         end
 
         args, return_type = Type.signature(fn_type)
-        param_names       = params.map(&:name)
+        param_names       = params.map { Names.local(it.name) }
 
         if task_return?(return_type)
-          task_wrapper_pair(name, args, param_names, return_type, registry)
+          task_wrapper_pair(name, args, param_names, return_type, registry, symbol)
         else
-          eligible_wrapper(name, args, param_names, return_type, registry)
+          eligible_wrapper(name, args, param_names, return_type, registry, symbol)
         end
       end
 
@@ -58,8 +58,8 @@ module Jade
         end
       end
 
-      def eligible_wrapper(name, args, param_names, return_type, registry)
-        decoded_args(args, param_names, registry)
+      def eligible_wrapper(name, args, param_names, return_type, registry, symbol)
+        decoded_args(args, param_names, registry, name, symbol)
           .then { Pretty.call("Internal.#{name}", it) }
           .then { encode_return(return_type, it, registry) }
           .then { Pretty.block(boundary_def_header(name, param_names), it) }
@@ -69,14 +69,26 @@ module Jade
         "def self.#{name}(#{param_names.join(', ')})"
       end
 
-      def decoded_args(args, param_names, registry)
-        args.zip(param_names).map { |t, pname| decode_call(t, pname, registry) }
+      def decoded_args(args, param_names, registry, name, symbol)
+        args
+          .zip(param_names)
+          .map do |t, pname|
+            decode_call(t, pname, registry, "#{to_qualified(symbol.module_name)}.#{name}(#{pname})")
+          end
+      end
+
+      def named(expr, where)
+        "Jade::Interop::Boundary.arg(#{where.inspect}) { #{expr} }"
       end
 
-      def decode_call(arg_type, pname, registry)
-        Codegen::Boundary::Specialized.decode_expr(arg_type, pname, registry) ||
+      # A specialized decoder carries the argument name itself, in a
+      # constant it was going to pass anyway. Only the generic path needs a
+      # frame around it to say where the value came from.
+      def decode_call(arg_type, pname, registry, where)
+        Codegen::Boundary::Specialized.decode_expr(arg_type, pname, registry, where) ||
           Codegen::Boundary::Cache.decoder_for(arg_type, registry)
             .then { "Jade::Interop::Boundary.decode_or_raise(#{it}, #{pname})" }
+            .then { named(it, where) }
       end
 
       def encode_return(return_type, call_expr, registry)
@@ -92,17 +104,17 @@ module Jade
         end
       end
 
-      def task_wrapper_pair(name, args, param_names, task_return, registry)
+      def task_wrapper_pair(name, args, param_names, task_return, registry, symbol)
         ok_enc, err_enc = Codegen::Boundary::Cache.task_arms(task_return, registry)
 
         [
-          task_run_def(name, args, param_names, ok_enc, err_enc, registry),
+          task_run_def(name, args, param_names, ok_enc, err_enc, registry, symbol),
           task_bang_def(name, param_names),
         ].join(Pretty.newline(2))
       end
 
-      def task_run_def(name, args, param_names, ok_enc, err_enc, registry)
-        decoded_args(args, param_names, registry)
+      def task_run_def(name, args, param_names, ok_enc, err_enc, registry, symbol)
+        decoded_args(args, param_names, registry, name, symbol)
           .then { Pretty.call("Internal.#{name}", it) }
           .then { task_run_body(it, ok_enc, err_enc) }
           .then { Pretty.block(boundary_def_header(name, param_names), it) }

data/lib/jade/codegen/helpers.rb

@@ -16,8 +16,19 @@ module Jade
         Stdlib.stdlib_name?(module_name) ? "Jade::#{base}" : base
       end
 
+      # Inside `module Plan`, a bare `Plan::` resolves to whatever `Plan`
+      # names there, which may be a type. `module X` is the only name that
+      # cannot be rooted.
+      def rooted(module_name)
+        "::#{to_qualified(module_name)}"
+      end
+
+      def internal(module_name)
+        "#{rooted(module_name)}::Internal"
+      end
+
       def data_define(fields)
-        return "Data.define" if fields.empty?
+        return "Jade.nullary" if fields.empty?
 
         "Data.define(#{fields.map { ":#{it}" }.join(', ')})"
       end
@@ -44,8 +55,14 @@ module Jade
       end
 
       def impl_synthetic_name(interface, type_name, fn_name)
-        sanitized = fn_name.gsub(/[^a-zA-Z0-9_]/) { |c| "x#{c.ord.to_s(16)}" }
-        "__impl_#{interface}_#{type_name}_#{sanitized}__"
+        sanitized_name(fn_name)
+          .then { "__impl_#{interface}_#{type_name}_#{it}__" }
+      end
+
+      # `contains?` is a fine Jade name and not a fine Ruby one anywhere but
+      # the end of a method name, which is not where these put it.
+      def sanitized_name(name)
+        name.gsub(/[^a-zA-Z0-9_]/) { |c| "x#{c.ord.to_s(16)}" }
       end
 
       def dict_synthetic_name(index)
@@ -53,7 +70,8 @@ module Jade
       end
 
       def fn_impl_synthetic_name(name)
-        "__#{name}__impl__"
+        sanitized_name(name)
+          .then { "__#{it}__impl__" }
       end
 
       def fn_constraints(fn_symbol, registry)
@@ -101,6 +119,11 @@ module Jade
 
         in Symbol::Interface
           []
+
+        in other
+          raise(UnrepresentableType, "`#{qname}` has no runtime form " \
+                                     "(#{other.class}); this is a jade bug, " \
+                                     'please report it')
         end
       end
 

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