jade-lang 0.9.0 → 0.10.0

data/lib/jade/ast.rb

@@ -32,6 +32,7 @@ module Jade
     define(:TypeParam, :name)
     define(:ImportDeclaration, :module_name, :as, :exposing)
     define(:StructDeclaration, :name, :type_params, :record_type)
+    define(:TypeAliasDeclaration, :name, :type_params, :body_type)
 
     define(:ExposeAll)
     define(:ExposeNone)
@@ -84,6 +85,7 @@ module Jade
 
       define(:Wildcard)
       define(:Literal, :literal)
+      define(:Range, :from, :to)
       define(:Binding, :name)
       define(:Constructor, :constructor, :patterns)
       define(:Record, :fields)
@@ -364,11 +366,17 @@ module Jade
           module_parts.map(&:value).join('.'),
           exposing,
           body,
-          module_parts.first.range.begin...(body.expressions.last.range.end),
+          module_parts.first.range.begin...module_end(module_parts, body),
         ]
       end
     end
 
+    # Tolerant mode drops a declaration it cannot parse, so a module whose
+    # only declaration is half-written has an empty body.
+    def module_end(module_parts, body)
+      body.expressions.last&.range&.end || module_parts.last.range.end
+    end
+
     def if_then_else
       ->((if_token, condition, if_branch, else_branch, end_token)) do
         IfThenElse[
@@ -442,6 +450,22 @@ module Jade
       end
     end
 
+    def range_pattern
+      ->((from, dotdot, to)) do
+        Pattern::Range[
+          from,
+          to,
+          from.range.begin...(to&.range&.end || dotdot.range.end),
+        ]
+      end
+    end
+
+    def unbounded_below_pattern
+      ->((dotdot, to)) do
+        Pattern::Range[nil, to, dotdot.range.begin...to.range.end]
+      end
+    end
+
     def binding_pattern
       ->(identifier) do
         Pattern::Binding[identifier.value, identifier.range]
@@ -676,6 +700,18 @@ module Jade
       end
     end
 
+    def type_alias_declaration
+      ->((type_token, name, type_params_list, body_type)) do
+        TypeAliasDeclaration.new(
+          name: name.value,
+          type_params: type_params_list.items,
+          body_type:,
+          trailing_comma: type_params_list.trailing_comma,
+          range: type_token.range.begin...body_type.range.end,
+        )
+      end
+    end
+
     def implementation
       ->((implements_token, interface, applied_type, extends, functions, end_token)) do
         Implementation[

data/lib/jade/cli/eject.rb

@@ -0,0 +1,132 @@
+require 'fileutils'
+require 'rbconfig'
+
+require 'jade'
+require 'jade/module_loader'
+
+module Jade
+  module CLI
+    # Writes the project as Ruby that runs without the gem: the compiled
+    # modules, the runtime they call, and requires that point at each other
+    # rather than at a load path.
+    module Eject
+      module_function
+
+      DEFAULT_OUT = 'ejected'.freeze
+
+      def run(argv)
+        usage if argv.any? { it == '-h' || it == '--help' }
+
+        Project
+          .find!
+          .then { [it, out_dir(argv, it)] }
+          .then { |project, out| eject(project, out) }
+      end
+
+      def eject(project, out)
+        FileUtils.rm_rf(out)
+
+        compile_all(project, out)
+        vendor_runtime(out)
+        rewrite_requires(out)
+
+        report(out)
+      end
+
+      # Every module, not only the ones something imports: an ejected tree
+      # that drops a file is not the project.
+      def compile_all(project, out)
+        sources(project).each do |entry|
+          ModuleLoader
+            .load(project.source_root, entry, cache_dir: project.cache_path)
+            .then { ModuleLoader.emit(it, path: out) }
+        end
+      end
+
+      def sources(project)
+        Dir
+          .glob(File.join(project.source_root, '**', '*.jd'))
+          .map { Pathname.new(it).relative_path_from(Pathname.new(project.source_root)).to_s }
+          .sort
+      end
+
+      # Whatever a booted runtime loads is what the ejected code needs, so
+      # ask one rather than keeping a list here.
+      def vendor_runtime(out)
+        runtime_files.each do |file|
+          File.join(out, file)
+            .tap { FileUtils.mkdir_p(File.dirname(it)) }
+            .then { FileUtils.cp(File.join(gem_lib, file), it) }
+        end
+      end
+
+      def runtime_files
+        [RbConfig.ruby, '-I', gem_lib, '-e', BOOT]
+          .then { IO.popen(it, err: [:child, :out], &:read) }
+          .lines(chomp: true)
+          .select { it.start_with?("#{gem_lib}/") }
+          .map { it.delete_prefix("#{gem_lib}/") }
+      end
+
+      BOOT = "require 'jade/runtime'; Jade::Runtime.boot!; puts $LOADED_FEATURES".freeze
+
+      def gem_lib
+        File.expand_path('../../..', __dir__).then { File.join(it, 'lib') }
+      end
+
+      # `require 'jade/x'` finds the gem; the point is not to have one.
+      def rewrite_requires(out)
+        Dir
+          .glob(File.join(out, '**', '*.rb'))
+          .each { rewrite(it, out) }
+      end
+
+      def rewrite(path, out)
+        File
+          .read(path)
+          .gsub(/^\$LOAD_PATH\.push\(File\.expand_path\("lib"\)\)\.uniq!\n/, '')
+          .gsub(/require ['"](jade\/[a-z_\/]+)['"]/) { "require_relative '#{up_to(path, out)}#{$1}'" }
+          .then { File.write(path, it) }
+      end
+
+      def up_to(path, out)
+        Pathname
+          .new(out)
+          .expand_path
+          .relative_path_from(Pathname.new(File.dirname(File.expand_path(path))))
+          .then { it.to_s == '.' ? '' : "#{it}/" }
+      end
+
+      def report(out)
+        puts <<~TXT
+          Ejected to #{out}/ (#{Dir.glob(File.join(out, '**', '*.rb')).size} files).
+
+          Nothing under #{out}/ requires the jade gem. To leave:
+
+            1. point your app at #{out}/ instead of the build directory
+            2. run your suite
+            3. drop jade-lang from your Gemfile and delete the .jd sources
+        TXT
+      end
+
+      def out_dir(argv, project)
+        argv
+          .each_cons(2)
+          .find { |flag, _| flag == '--out' }
+          &.last
+          .then { File.expand_path(it || DEFAULT_OUT, project.root) }
+      end
+
+      def usage
+        warn <<~USAGE
+          Usage: jade eject [--out DIR]
+
+          Compiles the project and writes it, plus the runtime it calls, as
+          Ruby that does not require the jade gem. Writes to ./ejected by
+          default. The directory is replaced if it exists.
+        USAGE
+        exit 1
+      end
+    end
+  end
+end

data/lib/jade/cli.rb

@@ -4,6 +4,7 @@ module Jade
   module CLI
     SUBCOMMANDS = {
       'check' => 'Check',
+      'eject' => 'Eject',
       'fmt' => 'Fmt',
       'lsp' => 'Lsp',
       'q' => 'Q',
@@ -37,6 +38,7 @@ module Jade
         Usage: jade COMMAND [ARGS]
 
           check  Type-check the project (or the given files).
+          eject  Write the project as Ruby that runs without the gem.
           fmt    Format .jd source (stdin or file).
           lsp    Run the language server (stdio JSON-RPC).
           q      Headless query interface (hover/symbols/defn/refs/api).

data/lib/jade/codegen/boundary/specialized/list.rb

@@ -11,11 +11,11 @@ module Jade
         module List
           extend self
 
-          def decode(type, input, registry)
+          def decode(type, input, registry, where = nil)
             inner = inner_of(type) or return nil
 
-            scalar_optimized(inner, input) ||
-              generic_decode(type, inner, input, registry)
+            scalar_optimized(inner, input, where) ||
+              generic_decode(type, inner, input, registry, where)
           end
 
           def encode(type, value_expr, registry)
@@ -51,17 +51,21 @@ module Jade
 
           # `List(scalar)` fast path: validate elements with a single
           # C-loop `all?` check, no per-element decoder call.
-          def scalar_optimized(inner, input)
+          def scalar_optimized(inner, input, where)
             qname = Scalar.qname_for(inner) or return nil
             klass = Scalar::LIST_ELEM_CLASS[qname]
             label = "List(#{Scalar::LABEL[qname]})".inspect
-            "Jade::Interop::Boundary.list_of(#{klass}, #{label}, #{input})"
+            "Jade::Interop::Boundary.list_of(#{klass}, #{label}, #{input}#{Specialized.where_arg(where)})"
           end
 
-          def generic_decode(type, inner, input, registry)
+          # The index comes from `elements`, so the element decoder itself
+          # carries no path of its own.
+          def generic_decode(type, inner, input, registry, where)
             elem = Specialized.decode_expr(inner, '_1', registry) or return nil
             label = "List(#{Specialized.type_label(inner)})".inspect
-            "Jade::Interop::Boundary.array(#{label}, #{input}).map { #{elem} }"
+            at = Specialized.where_arg(where)
+            array = "Jade::Interop::Boundary.array(#{label}, #{input}#{at})"
+            "Jade::Interop::Boundary.elements(#{array}#{at}) { #{elem} }"
           end
         end
       end

data/lib/jade/codegen/boundary/specialized/maybe.rb

@@ -9,9 +9,9 @@ module Jade
         module Maybe
           extend self
 
-          def decode(type, input, registry)
+          def decode(type, input, registry, where = nil)
             inner = inner_of(type) or return nil
-            elem = Specialized.decode_expr(inner, 'it', registry) or return nil
+            elem = Specialized.decode_expr(inner, 'it', registry, where) or return nil
 
             "#{input}.then { it.nil? ? Jade::Maybe::Nothing[] : Jade::Maybe::Just[#{elem}] }"
           end

data/lib/jade/codegen/boundary/specialized/record.rb

@@ -16,9 +16,13 @@ module Jade
           extend self
           extend Helpers
 
-          def decode(type, input, registry)
+          # The helper is shared across call sites, so its fields can only
+          # know where they sit inside the struct: the segment that leads
+          # to the struct itself goes on at the call site.
+          def decode(type, input, registry, where = nil)
             struct = struct_for(type, registry) or return nil
-            "#{decode_helper_name(struct)}(#{input})"
+            call = "#{decode_helper_name(struct)}(#{input})"
+            where ? "Jade::Interop::Boundary.at(#{where.inspect}) { #{call} }" : call
           end
 
           def encode(type, value_expr, registry)
@@ -132,7 +136,7 @@ module Jade
             struct.record_type.fields
               .map { |k, t| field_decode(k, t, registry) }
               .then { Pretty.call(ctor, it, open: '[', close: ']') }
-              .then { Pretty.block("#{hash_call}.then do |h|", it) }
+              .then { Pretty.block("#{hash_call}.then do |h|", it, blaming_the_key(struct)) }
               .then { Pretty.block("def self.#{decode_helper_name(struct)}(value)", it) }
           end
 
@@ -144,7 +148,7 @@ module Jade
           end
 
           def field_decode(key, type, registry)
-            Specialized.decode_expr(type, "h[#{key.to_s.inspect}]", registry) ||
+            Specialized.decode_expr(type, "h[#{key.to_s.inspect}]", registry, ".#{key}") ||
               fail("non-specializable field type for #{key}: #{type}")
           end
 
@@ -156,6 +160,17 @@ module Jade
             end
           end
 
+          # A field the hash never had reads as nil to its decoder, which
+          # blames the type. The key it sat under is right here, and so is
+          # the hash that was supposed to hold it.
+          def blaming_the_key(struct)
+            [
+              'rescue Jade::Interop::DecodeError => e',
+              "  raise Jade::Interop::Boundary.blame(e, h, #{struct.name.inspect})",
+              'end',
+            ].join("\n")
+          end
+
           def snake(name)
             name
               .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')

data/lib/jade/codegen/boundary/specialized/scalar.rb

@@ -31,10 +31,10 @@ module Jade
             'String.String' => '::String',
           }.freeze
 
-          def decode(type, input)
+          def decode(type, input, where = nil)
             qname = qname_for(type) or return nil
             label = LABEL[qname].inspect
-            "Jade::Interop::Boundary.#{HELPER[qname]}(#{label}, #{input})"
+            "Jade::Interop::Boundary.#{HELPER[qname]}(#{label}, #{input}#{Specialized.where_arg(where)})"
           end
 
           # Scalar encoders are identity (Ruby int IS the JSON int, etc.),

data/lib/jade/codegen/boundary/specialized.rb

@@ -21,11 +21,13 @@ module Jade
 
         # Ruby expression that validates `input` and yields the decoded
         # value, or `nil` if `type` isn't specializable.
-        def decode_expr(type, input, registry)
-          Scalar.decode(type, input) ||
-            List.decode(type, input, registry) ||
-            Maybe.decode(type, input, registry) ||
-            Record.decode(type, input, registry)
+        # `where` is the path segment this value sits at, `".cents"`,
+        # baked into the emitted call so a failure can name it.
+        def decode_expr(type, input, registry, where = nil)
+          Scalar.decode(type, input, where) ||
+            List.decode(type, input, registry, where) ||
+            Maybe.decode(type, input, registry, where) ||
+            Record.decode(type, input, registry, where)
         end
 
         # How to encode `value_expr` to the wire form:
@@ -66,6 +68,12 @@ module Jade
           Record.emit_helpers(structs, registry)
         end
 
+        # Trailing argument for the runtime helpers, which all take the
+        # path segment last and default it to nil.
+        def where_arg(where)
+          where ? ", #{where.inspect}" : ''
+        end
+
         # --- type-shape helpers shared across shape modules ---
 
         # Both `Type::Application` (from inferred boundary types) and

data/lib/jade/codegen/boundary.rb

@@ -18,6 +18,9 @@ module Jade
         in Type::Application(constructor: Type::Constructor(name:), args:)
           decode_app(name, args, registry)
 
+        in Type::AnonymousRecord
+          derived_for(DECODABLE, type, registry)&.dig('decoder')
+
         else
           nil
         end
@@ -28,6 +31,9 @@ module Jade
         in Type::Application(constructor: Type::Constructor(name:), args:)
           encode_app(name, args, registry)
 
+        in Type::AnonymousRecord
+          derived_for(ENCODABLE, type, registry)&.dig('encoder')
+
         else
           nil
         end
@@ -153,7 +159,11 @@ module Jade
       end
 
       def derived_dispatch(interface_qname, type_qname, args, registry)
-        type       = Type.constructor(type_qname).apply(args)
+        type = Type.constructor(type_qname).apply(args)
+        derived_for(interface_qname, type, registry)
+      end
+
+      def derived_for(interface_qname, type, registry)
         constraint = Type.constraint(interface_qname, type, nil)
 
         case Frontend::TypeChecking::Constraints.resolve(constraint, registry, nil)
@@ -175,7 +185,7 @@ module Jade
 
         case fn_sym
         in Symbol::Function
-          "#{to_qualified(fn_sym.module_name)}::Internal.method(:#{fn_sym.name})"
+          "#{internal(fn_sym.module_name)}.method(:#{fn_sym.name})"
 
         in Symbol::StdlibFunction(codegen:) if codegen.is_a?(String)
           codegen

data/lib/jade/codegen/context.rb

@@ -22,6 +22,23 @@ module Jade
         @dict_env = prev
       end
 
+      # Dictionary source => constant name, filled while a module emits.
+      # A dictionary built entirely from concrete implementations depends
+      # on nothing at the call site, so it is built once at load instead
+      # of on every call. Nil outside a module: bare expressions have no
+      # constants to reference.
+      def dict_consts
+        @dict_consts
+      end
+
+      def with_dict_consts(table)
+        prev = @dict_consts
+        @dict_consts = table
+        yield
+      ensure
+        @dict_consts = prev
+      end
+
       # When set, references with this name emit as `self` (and field accesses
       # on them as bare method calls). Used to rewrite operator-impl lambda
       # bodies — `(a, b) -> { a.amount == b.amount }` becomes

data/lib/jade/codegen/error.rb

@@ -4,5 +4,6 @@ module Jade
     # this is a bug in jade, not in the source. RuntimeError so the CLI
     # reports it as a message rather than a backtrace.
     MissingDictionary = Class.new(RuntimeError)
+    UnrepresentableType = Class.new(RuntimeError)
   end
 end

data/lib/jade/codegen/function_call.rb

@@ -102,10 +102,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 +142,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 +214,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 +338,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 +349,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