jade-lang 0.3.1 → 0.5.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/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_call.rb

@@ -180,7 +180,7 @@ module Jade
         in Symbol::InteropFunction
           registry
             .lookup(callee.symbol.to_ref)
-            .then { PortDecoder.task_call(it, registry, dictionaries) }
+            .then { PortCodec.task_call(it, registry, dictionaries) }
 
         in Symbol::StdlibFunction => symbol if symbol.constraints.any?
           dictionaries

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

@@ -16,6 +16,15 @@ module Jade
       }.freeze
 
       INLINES = {
+        'Debug.log'         => ->(l, v) { "Jade::Debug.log(#{l}, #{v})" },
+        'Show.int_show'   => ->(n)    { "#{n}.to_s" },
+        'Show.float_show' => ->(f)    { "#{f}.to_s" },
+        'Show.bool_show'  => ->(b)    { "#{b}.to_s" },
+        'Show.str_show'   => ->(s)    { "#{s}.inspect" },
+        'Show.char_show'  => ->(c)    { "#{c}.inspect" },
+        # Never is uninhabited, so reaching this is a compiler bug, not a
+        # rendering problem — say so rather than print a plausible string.
+        'Show.never_show' => ->(_)    { 'fail("Show.never_show: Never has no values")' },
         'Basics.identity'   => ->(a)    { a },
         'Basics.always'     => ->(x)    { "->(_) { #{x} }" },
         'Basics.int_add'    => ->(a, b) { "(#{a} + #{b})" },
@@ -174,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
@@ -189,8 +201,10 @@ module Jade
         Decode.one_of
         Decode.optional
         Decode.optional_field
+        Decode.record
         Decode.required
         Decode.sequence
+        Decode.set
         Decode.string
         Decode.string_enum
         Decode.succeed
@@ -198,9 +212,11 @@ module Jade
         Decode.tuple3
         Decode.tuple4
         Decode.type_
+        Decode.value
         Decode.variant
         Encode.bool
         Encode.dict
+        Encode.instant
         Encode.encode_to_string
         Encode.field
         Encode.float
@@ -209,10 +225,12 @@ module Jade
         Encode.null
         Encode.nullable
         Encode.object
+        Encode.set
         Encode.string
         Encode.tuple
         Encode.tuple3
         Encode.tuple4
+        Encode.value
         Encode.variant
         Task.and_then
         Task.fail

data/lib/jade/codegen/{port_decoder.rb → port_codec.rb}

@@ -1,18 +1,20 @@
 module Jade
   module Codegen
-    module PortDecoder
+    module PortCodec
       extend self
 
-      PASS = "Jade::Decode::Decoder[Jade::Decode::Desc::Pass[]]"
+      PASS_DECODER = "Jade::Decode::Decoder[Jade::Decode::Desc::Pass[]]"
+      PASS_ENCODER = "->(v) { v }"
 
       # `dictionaries` is the call site's constraint-attachment list; only
-      # used when an arm is a Dict marker.
+      # used when an arm or a parameter is a Dict marker.
       def task_call(interop_fn, registry, dictionaries = [])
         [
           interop_fn.interop_module_name,
           ":#{interop_fn.name}",
-          decoder(interop_fn, :ok, registry, dictionaries),
-          decoder(interop_fn, :err, registry, dictionaries),
+          codec(interop_fn.decoders.fetch(:ok), 'decoder', interop_fn, registry, dictionaries),
+          codec(interop_fn.decoders.fetch(:err), 'decoder', interop_fn, registry, dictionaries),
+          encoders(interop_fn, registry, dictionaries),
         ]
           .join(', ')
           .then { "Jade::Runtime.task_call(#{it})" }
@@ -20,32 +22,42 @@ module Jade
 
       private
 
-      # Per-arm decoder. PortResolution stamps one of:
-      # - :pass — Decode.Value or Never arm, no decoder needed
+      def encoders(interop_fn, registry, dictionaries)
+        interop_fn
+          .encoders
+          .map { codec(it, 'encoder', interop_fn, registry, dictionaries) }
+          .join(', ')
+          .then { "[#{it}]" }
+      end
+
+      # Per-arm, per-argument codec. PortResolution stamps one of:
+      # - :pass — Decode.Value or Never, nothing to convert
       # - Symbol::Implementation — concrete OR partial impl (with marker
       #   deps for free vars). We push a synthetic dict_env mapping the
       #   port's vars to the call-site dictionaries so generate_impl_dispatch
       #   can resolve markers uniformly.
-      # - Symbol::InteropFunction::Dict — bare-var arm, decoder comes
+      # - Symbol::InteropFunction::Dict — bare-var position; the codec comes
       #   from the caller's threaded dictionary at the given constraint index
-      def decoder(interop_fn, arm, registry, dictionaries)
-        case interop_fn.decoders.fetch(arm)
+      def codec(resolution, kind, interop_fn, registry, dictionaries)
+        case resolution
         in Symbol::InteropFunction::PASS
-          PASS
+          kind == 'decoder' ? PASS_DECODER : PASS_ENCODER
 
         in Symbol::Implementation => impl
-          emit_impl_decoder(impl, interop_fn, dictionaries, registry)
+          emit_impl_codec(impl, kind, interop_fn, dictionaries, registry)
 
         in Symbol::InteropFunction::Dict(constraint_index:)
-          "#{FunctionCall.dispatch_value(dictionaries.fetch(constraint_index), registry)}[\"decoder\"]"
+          FunctionCall
+            .dispatch_value(dictionaries.fetch(constraint_index), registry)
+            .then { "#{it}[#{kind.inspect}]" }
         end
       end
 
-      def emit_impl_decoder(impl, interop_fn, dictionaries, registry)
+      def emit_impl_codec(impl, kind, interop_fn, dictionaries, registry)
         synthetic_env = build_synthetic_dict_env(impl, interop_fn, dictionaries, registry)
 
         Codegen.with_dict_env(synthetic_env) {
-          FunctionCall.generate_impl_dispatch(impl, registry).fetch('decoder')
+          FunctionCall.generate_impl_dispatch(impl, registry).fetch(kind)
         }
       end
 

data/lib/jade/codegen.rb

@@ -19,7 +19,7 @@ require 'jade/codegen/transforms/fold_shape'
 require 'jade/codegen/function_declaration'
 require 'jade/codegen/function_call'
 require 'jade/codegen/implementation'
-require 'jade/codegen/port_decoder'
+require 'jade/codegen/port_codec'
 
 module Jade
   module Codegen
@@ -159,7 +159,7 @@ module Jade
           in Symbol::InteropFunction => sym
             registry
               .lookup(sym.to_ref)
-              .then { PortDecoder.task_call(it, registry) }
+              .then { PortCodec.task_call(it, registry) }
 
           in Symbol::StdlibFunction(codegen:)
             codegen