jade-lang 0.4.0 → 0.6.0

data/lib/jade/api.rb

@@ -0,0 +1,244 @@
+require 'jade'
+require 'jade/module_loader'
+require 'jade/signature'
+
+module Jade
+  # The public surface of everything a module can call, read from the registry
+  # rather than the source. Stdlib modules are written both as Jade heredocs
+  # and as a Ruby DSL, and an extension gem's modules aren't in the tree at
+  # all, so no grep of the source finds them.
+  Api = Data.define(:registry, :source_root, :skipped) do
+    def self.load(project = Project.find)
+      project ? of_project(project) : stdlib
+    end
+
+    def self.stdlib
+      new(registry: stdlib_registry, source_root: nil, skipped: [])
+    end
+
+    def self.stdlib_registry
+      @stdlib_registry ||= Stdlib.load(Registry.new)
+    end
+
+    def self.of_project(project)
+      sources(project)
+        .reduce([stdlib_registry, []]) { |acc, source| absorb(acc, project, source) }
+        .then do |(registry, skipped)|
+          new(registry:, source_root: project.source_root, skipped:)
+        end
+    end
+
+    # A module that won't compile is named rather than dropped: an absent
+    # module reads as "that function doesn't exist".
+    def self.absorb((registry, skipped), project, (root, uri))
+      case load_module(project, root, uri)
+      in nil then [registry, skipped + [uri]]
+      in loaded then [merge(registry, loaded), skipped]
+      end
+    end
+
+    def self.load_module(project, root, uri)
+      ModuleLoader.load(root, uri, cache_dir: project.cache_path, tolerant: true)
+    rescue CompilationError
+      nil
+    end
+
+    def self.merge(into, from)
+      into.with(
+        modules: into.modules.merge(from.modules),
+        implementations: into.implementations.merge(from.implementations),
+      )
+    end
+
+    def self.sources(project)
+      [project.source_root, *Jade.extensions]
+        .uniq
+        .flat_map { |root| jade_files(root).map { [root, it] } }
+    end
+
+    def self.jade_files(root)
+      Dir
+        .glob(File.join(root, '**', '*.jd'))
+        .map { Pathname.new(it).relative_path_from(root).to_s }
+        .sort
+    end
+
+    private_class_method :of_project, :absorb, :load_module, :merge, :sources, :jade_files
+
+    ORIGIN_ORDER = { 'project' => 0, 'extension' => 1, 'stdlib' => 2 }.freeze
+
+    KIND_ORDER = {
+      'type' => 0,
+      'struct' => 0,
+      'interface' => 1,
+      'constructor' => 2,
+      'function' => 3,
+    }.freeze
+
+    def modules
+      registry
+        .modules
+        .map { |name, entry| { name:, origin: origin(entry) } }
+        .sort_by { [ORIGIN_ORDER.fetch(it[:origin]), it[:name]] }
+    end
+
+    def describe(module_name)
+      registry
+        .modules[module_name]
+        &.then do
+          {
+            module: module_name,
+            origin: origin(it),
+            symbols: entries_for(module_name, it),
+          }
+        end
+    end
+
+    def lookup(qualified_name)
+      *module_parts, name = qualified_name.split('.')
+      module_parts
+        .join('.')
+        .then { describe(it) }
+        &.fetch(:symbols)
+        &.find { it[:name] == name }
+    end
+
+    def search(term)
+      registry
+        .modules
+        .flat_map { |name, entry| entries_for(name, entry) }
+        .select { it[:qualified_name].downcase.include?(term.downcase) }
+    end
+
+    private
+
+    # `Source#root` is nil for the stdlib, which never comes off disk.
+    def origin(entry)
+      case entry.source&.root
+      in nil then 'stdlib'
+      in ^(source_root) then 'project'
+      else 'extension'
+      end
+    end
+
+    def entries_for(module_name, entry)
+      entry
+        .exposes
+        .uniq { [it.class, it.name] }
+        .filter_map { symbol_for(entry, it) }
+        .map { entry_for(module_name, it) }
+        .reject { Stdlib.private_constructor?(it[:qualified_name]) }
+        .sort_by { [KIND_ORDER.fetch(it[:kind], 9), it[:name]] }
+    end
+
+    def symbol_for(entry, ref)
+      ref.is_a?(Symbol::TypeRef) ?
+        entry.defined_types[ref.name] :
+        entry.defined_values[ref.name]
+    end
+
+    def entry_for(module_name, symbol)
+      "#{module_name}.#{symbol.name}".then do |qualified_name|
+        {
+          name: symbol.name,
+          qualified_name:,
+          kind: kind_of(symbol),
+          signature: render(symbol, qualified_name),
+          **extras(symbol),
+        }
+      end
+    end
+
+    def kind_of(symbol)
+      case symbol
+      in Symbol::Union then 'type'
+      in Symbol::Struct then 'struct'
+      in Symbol::Interface then 'interface'
+      in Symbol::Constructor | Symbol::Variant then 'constructor'
+      else 'function'
+      end
+    end
+
+    def render(symbol, qualified_name)
+      case symbol
+      in Symbol::Union
+        "type #{symbol.name}#{type_params(symbol.type_params)}"
+
+      in Symbol::Struct
+        "struct #{symbol.name}#{type_params(symbol.type_params)}#{fields(symbol)}"
+
+      in Symbol::Interface
+        "interface #{symbol.name}(#{symbol.type_param.name})"
+
+      else
+        declared(symbol)
+          .then { |(type, cs)| Signature.render(qualified_name, nullary(type), cs) }
+      end
+    end
+
+    # The declared annotation, never the module env's scheme: the env collapses
+    # distinct type variables on stdlib functions backing an interface, so
+    # `Result.map` reads there as `(a) -> a` — unable to change the element
+    # type, which it can.
+    def declared(symbol)
+      Type.from_symbol(symbol, registry, Frontend::TypeChecking::VarGen.new)
+    end
+
+    # `Dict.empty()` is a compile error — it's a value, not a nullary call.
+    def nullary(type)
+      case type
+      in Type::Function(args: [], return_type:) then return_type
+      else type
+      end
+    end
+
+    def fields(symbol)
+      return '' unless symbol.record_type
+
+      declared(symbol.record_type)
+        .then { |(type, _)| " = #{type}" }
+    end
+
+    def type_params(params)
+      return '' if params.nil? || params.empty?
+
+      params
+        .map { it.respond_to?(:name) ? it.name : it.to_s }
+        .join(', ')
+        .then { "(#{it})" }
+    end
+
+    def extras(symbol)
+      case symbol
+      in Symbol::Union
+        { implements: implements(symbol), variants: symbol.constructor_refs.map(&:name) }
+
+      in Symbol::Struct
+        { implements: implements(symbol) }
+
+      in Symbol::Interface
+        { implemented_by: implemented_by(symbol) }
+
+      else
+        {}
+      end
+    end
+
+    def implements(type_symbol)
+      instances { it[1] == type_symbol.qualified_name }.map { it[0] }
+    end
+
+    def implemented_by(interface_symbol)
+      instances { it[0] == interface_symbol.qualified_name }.map { it[1] }
+    end
+
+    def instances(&)
+      registry
+        .implementations
+        .keys
+        .select(&)
+        .uniq
+        .sort
+    end
+  end
+end

data/lib/jade/cli/check.rb

@@ -0,0 +1,97 @@
+require 'jade'
+require 'jade/module_loader'
+require 'jade/diagnostics/renderer'
+
+module Jade
+  module CLI
+    # Type-checks without generating anything.
+    module Check
+      module_function
+
+      def run(argv)
+        usage if argv.any? { it == '-h' || it == '--help' }
+
+        Project
+          .find!
+          .then { report(diagnose(it, argv), it) }
+      end
+
+      def diagnose(project, files)
+        entries(project, files)
+          .flat_map { compile(project, it) }
+          .uniq { |d| [d.primary&.source&.uri, d.message, d.primary&.span] }
+      end
+
+      def entries(project, files)
+        return sources(project) if files.empty?
+
+        files.map { project.source_relative(it) }
+      end
+
+      def sources(project)
+        Dir
+          .glob(File.join(project.source_root, '**', '*.jd'))
+          .map { Pathname.new(it).relative_path_from(project.source_root).to_s }
+          .sort
+      end
+
+      # Tolerant, so a module yields every diagnostic rather than the first.
+      def compile(project, entry)
+        ModuleLoader
+          .load(project.source_root, entry, cache_dir: project.cache_path, tolerant: true)
+          .then { collect(it) }
+      rescue CompilationError => e
+        e.diagnostics.items
+      end
+
+      def collect(registry)
+        registry
+          .modules
+          .each_value
+          .reject { Stdlib.is_stdlib?(it) }
+          .reject { it.source.nil? }
+          .flat_map { it.diagnostics.items }
+      end
+
+      def report(items, project)
+        return if items.empty?
+
+        Diagnostics::Renderer
+          .new(colors: $stdout.tty?)
+          .render_all(Diagnostics::List.new(items:))
+          .then { warn(it) }
+
+        warn(summary(items, project))
+        exit 1 if items.any?(&:error?)
+      end
+
+      def summary(items, project)
+        items
+          .partition(&:error?)
+          .then { |(errors, rest)| [count(errors, 'error'), count(rest, 'warning')] }
+          .compact
+          .join(', ')
+          .then { "\n#{it} in #{project.source_roots.first}" }
+      end
+
+      def count(items, noun)
+        return nil if items.empty?
+
+        "#{items.size} #{noun}#{'s' unless items.size == 1}"
+      end
+
+      def usage
+        warn <<~USAGE
+          Usage: jade check [FILE...]
+
+          Type-checks FILEs and everything they import, writing diagnostics
+          to stderr. Checks every .jd file under the source root when given
+          no arguments. Exits 1 if there were errors, 0 otherwise.
+
+          FILE is relative to the project root or the source root.
+        USAGE
+        exit 1
+      end
+    end
+  end
+end

data/lib/jade/cli/q.rb

@@ -1,4 +1,5 @@
 require 'jade'
+require 'jade/api'
 require 'jade/lsp'
 require 'json'
 
@@ -15,11 +16,20 @@ module Jade
           symbols FILE             Document symbols (outline) for FILE.
           defn    FILE:LINE:COL    Goto-definition location.
           refs    FILE:LINE:COL    Find all references (incl. declaration).
+          api     [MODULE|NAME]    Stdlib signatures. No argument lists the
+                                   modules; `Maybe` describes one; `List.map`
+                                   picks a single symbol.
+          find    TERM             Symbols whose name matches TERM.
+          syntax  [FORM]           How a form is written (`lambda`, `case`,
+                                   `interface`, …). No argument lists them all.
 
         FILE is relative to the project root (cwd).
         LINE and COL are 0-indexed (LSP convention).
 
-        Compile cache lives at .jade/cache, so repeat queries are fast.
+        `api` and `find` cover the stdlib plus, inside a project, its own and
+        its extensions' modules. `syntax` needs nothing at all. Everything
+        else compiles the project, caching at .jade/cache so repeat queries
+        are fast.
       TXT
 
       module_function
@@ -30,12 +40,48 @@ module Jade
         when 'symbols' then dump(symbols(argv[1]))
         when 'defn'    then dump(defn(argv[1]))
         when 'refs'    then dump(refs(argv[1]))
+        when 'api'     then dump(api(argv[1]))
+        when 'find'    then dump(find(argv[1]))
+        when 'syntax'  then dump(syntax(argv[1]))
         else
           warn USAGE
           exit 1
         end
       end
 
+      def api(name)
+        Api.load.then do |api|
+          next listing(api) unless name
+
+          (api.describe(name) || api.lookup(name))
+            .then { it || fail("no module or symbol named #{name}") }
+        end
+      end
+
+      def find(term)
+        fail 'TERM required' unless term
+
+        Api
+          .load
+          .then { { matches: it.search(term), **skipped(it) } }
+      end
+
+      def syntax(form)
+        return { forms: LSP::Snippets.catalog } unless form
+
+        LSP::Snippets
+          .find(form)
+          .then { it || fail("no syntax form named #{form}") }
+      end
+
+      def listing(api)
+        { modules: api.modules, **skipped(api) }
+      end
+
+      def skipped(api)
+        api.skipped.empty? ? {} : { skipped: api.skipped }
+      end
+
       def hover(arg)
         file, line, col = parse_position(arg)
         Context.new(file).then do |ctx|

data/lib/jade/cli.rb

@@ -3,6 +3,7 @@ require 'jade'
 module Jade
   module CLI
     SUBCOMMANDS = {
+      'check' => 'Check',
       'fmt' => 'Fmt',
       'lsp' => 'Lsp',
       'q' => 'Q',
@@ -26,7 +27,7 @@ module Jade
         usage($stderr)
         exit 1
       end
-    rescue Project::NotFound => e
+    rescue Project::NotFound, RuntimeError => e
       warn "jade: #{e.message}"
       exit 1
     end
@@ -35,9 +36,10 @@ module Jade
       io.puts <<~TXT
         Usage: jade COMMAND [ARGS]
 
+          check  Type-check the project (or the given files).
           fmt    Format .jd source (stdin or file).
           lsp    Run the language server (stdio JSON-RPC).
-          q      Headless query interface (hover/symbols/defn/refs).
+          q      Headless query interface (hover/symbols/defn/refs/api).
 
         Run `jade COMMAND --help` for command-specific options.
       TXT

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

@@ -36,8 +36,7 @@ module Jade
               Boundary::Specialized.decode_expr(t, '_', registry)
             },
             encoders: cache_map(per_fn.flat_map { it[:encoders] }, 'ENC') { |t|
-              Boundary::Specialized.identity_encoder?(t) ||
-                Boundary::Specialized.encode_expr(t, '_', registry)
+              Boundary::Specialized.encode_expr(t, '_', registry)
             },
           }
         end

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

@@ -19,11 +19,16 @@ module Jade
           end
 
           def encode(type, value_expr, registry)
-            inner = inner_of(type) or return nil
-            return nil if Specialized.identity_encoder?(inner)
+            inner_of(type)
+              &.then { Specialized.encode_expr(it, '_1', registry) }
+              &.then { map_expr(it, value_expr) }
+          end
 
-            elem = Specialized.encode_expr(inner, '_1', registry) or return nil
-            "#{value_expr}.map { #{elem} }"
+          def map_expr(elem, value_expr)
+            case elem
+            in ::String then "#{value_expr}.map { #{elem} }"
+            in :identity then nil
+            end
           end
 
           def identity_encoder?(type)

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

@@ -17,10 +17,22 @@ module Jade
           end
 
           def encode(type, value_expr, registry)
-            inner = inner_of(type) or return nil
-            inner_enc = Specialized.encode_expr(inner, 'it._1', registry) || 'it._1'
+            inner_of(type)
+              &.then { element_encoder(it, registry) }
+              &.then { unwrap_expr(it, value_expr) }
+          end
+
+          def unwrap_expr(elem, value_expr)
+            "#{value_expr}.then { it.is_a?(::Jade::Maybe::Just) ? #{elem} : nil }"
+          end
 
-            "#{value_expr}.then { it.is_a?(::Jade::Maybe::Just) ? #{inner_enc} : nil }"
+          # Never identity even when the element is: the Just still unwraps.
+          def element_encoder(inner, registry)
+            case Specialized.encode_expr(inner, 'it._1', registry)
+            in :identity then 'it._1'
+            in ::String => expr then expr
+            in nil then nil
+            end
           end
 
           def specializable?(type, registry, seen)

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

@@ -138,7 +138,7 @@ module Jade
 
           def encode_helper(struct, registry)
             struct.record_type.fields
-              .map { |k, t| "#{k.inspect} => #{field_encode_value(t, "p.#{k}", registry)}" }
+              .map { |k, t| "#{k.inspect} => #{field_encode(k, t, "p.#{k}", registry)}" }
               .then { "{ #{it.join(', ')} }" }
               .then { Pretty.block("def self.#{encode_helper_name(struct)}(p)", it) }
           end
@@ -148,8 +148,12 @@ module Jade
               fail("non-specializable field type for #{key}: #{type}")
           end
 
-          def field_encode_value(type, accessor, registry)
-            Specialized.encode_expr(type, accessor, registry) || accessor
+          def field_encode(key, type, accessor, registry)
+            case Specialized.encode_expr(type, accessor, registry)
+            in :identity then accessor
+            in ::String => expr then expr
+            in nil then fail("non-encodable field type for #{key}: #{type}")
+            end
           end
 
           def snake(name)

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

@@ -28,10 +28,14 @@ module Jade
             Record.decode(type, input, registry)
         end
 
-        # Ruby expression that encodes `value_expr` to the wire form, or
-        # `nil` if the encoder is identity (caller skips the wrap) or the
-        # type isn't specializable (caller falls back to the cache).
+        # How to encode `value_expr` to the wire form:
+        #
+        #   String    inline expression
+        #   :identity the value is already wire-shaped; emit it unchanged
+        #   nil       not specializable; fall back to the cached encoder
         def encode_expr(type, value_expr, registry)
+          return :identity if identity_encoder?(type)
+
           Record.encode(type, value_expr, registry) ||
             List.encode(type, value_expr, registry) ||
             Maybe.encode(type, value_expr, registry)

data/lib/jade/codegen/emitter.rb

@@ -50,8 +50,11 @@ module Jade
         in [:struct_constructor, qualified_name, arity]
           "Jade::Runtime.curry(::#{to_qualified(qualified_name)}.method(:[]), #{arity})"
 
-        in [:anon_record_constructor, keys]
-          "Jade::Runtime.curry(#{data_define(keys)}.method(:[]), #{keys.size})"
+        in [:struct_class, qualified_name]
+          "::#{to_qualified(qualified_name)}"
+
+        in [:anon_record_class, keys]
+          record_class(keys)
 
         in [:list, exprs]
           exprs
@@ -59,6 +62,12 @@ module Jade
             .join(', ')
             .then { "[#{it}]" }
 
+        in [:hash, pairs]
+          pairs
+            .map { |key, value| "#{key.inspect} => #{emit(value)}" }
+            .join(', ')
+            .then { it.empty? ? '{}' : "{ #{it} }" }
+
         in [:access, expr, key]
           "#{emit(expr)}.#{key}"
 

data/lib/jade/codegen/function_declaration.rb

@@ -80,14 +80,15 @@ module Jade
       end
 
       def encode_return(return_type, call_expr, registry)
-        if Codegen::Boundary::Specialized.identity_encoder?(return_type)
-          call_expr
-        elsif (expr = Codegen::Boundary::Specialized.encode_expr(return_type, call_expr, registry))
-          expr
-        else
+        case Codegen::Boundary::Specialized.encode_expr(return_type, call_expr, registry)
+        in :identity then call_expr
+
+        in ::String => expr then expr
+
+        in nil
           Codegen::Boundary::Cache
             .encoder_for(return_type, registry)
-            .then { |encoder| "#{encoder}.call(#{call_expr})" }
+            .then { "#{it}.call(#{call_expr})" }
         end
       end
 

data/lib/jade/codegen/helpers.rb

@@ -22,6 +22,12 @@ module Jade
         "Data.define(#{fields.map { ":#{it}" }.join(', ')})"
       end
 
+      # Record literals resolve through the same registry, so two records
+      # with the same keys compare equal however they were built.
+      def record_class(keys)
+        "Jade::Runtime.record(#{keys.map { ":#{it}" }.join(', ')})"
+      end
+
       def generate_node(node, registry)
         Codegen.generate(node, registry)
       end

data/lib/jade/codegen/inlines.rb

@@ -183,6 +183,9 @@ module Jade
         Decode.and_map
         Decode.and_then
         Decode.bool
+        Decode.decimal
+        Decode.instant
+        Decode.iso_date
         Decode.decode
         Decode.decode_string
         Decode.dict
@@ -198,6 +201,7 @@ module Jade
         Decode.one_of
         Decode.optional
         Decode.optional_field
+        Decode.record
         Decode.required
         Decode.sequence
         Decode.set
@@ -212,6 +216,7 @@ module Jade
         Decode.variant
         Encode.bool
         Encode.dict
+        Encode.instant
         Encode.encode_to_string
         Encode.field
         Encode.float