jade-lang 0.2.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 15e51e91117f799dec4acda81faa5fd62f8f75190570cebc69d69e0c588481cb
-  data.tar.gz: 1bd08d32f23d5b0e3f184f04d72aa1b44fd391bea3536ff2630ea93b1480f179
+  metadata.gz: bb2b101369a0d671ca8f2aa020e7113a49f22e700491e5d14f7e574f62ee17ec
+  data.tar.gz: 7e017dbe893887f9e7ac3dfcb5c434474085771f5062ee509cf8e9ee9682ddd6
 SHA512:
-  metadata.gz: fcb1ae0703cdcd8c29c618b7aaf36d90c1f5b7eb4b95a1ee5f6dd6e4fd81d172977b3786442c1f1635e0ade323ff94a82fd95ee331a23f53459581966d08a346
-  data.tar.gz: 4208a71d7852def7334d49142dc7aea3b4f6344941a9e66cbc9d544b8f877d84680c7206518d61aaeb35d6ecd8eec9261f7a1adf5d64fe6346020e775fadaaae
+  metadata.gz: 45578bee3ec52655fbba6a0cd7a053a6ad65c9981760edd86e2966fd671958a63fc08fb0120b58fda73298c584773a8e6a4c92eb71b2c11d79228bb88a905e16
+  data.tar.gz: 698a60f7e747a8042e32f5da24b8c6c322d25a470e3a65f0ed6dfeb61a89c67cc6394ab993115c8c42e9305e75db9b5445f7b5a42a74974832a2c5cd268fe209

data/CHANGELOG.md

@@ -6,6 +6,79 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.3.1]
+
+### Fixed
+
+- A module whose dependency failed to compile is no longer type checked. It
+  reached for bindings the broken module never produced and raised through the
+  compiler, naming the importer rather than the module at fault, and the
+  original error was never reported. Dependents now say which dependency
+  failed, and modules broken independently of each other are all still
+  reported.
+- The load-path line at the top of every compiled entry module appends the
+  application's `lib` instead of prepending it. At position 0 it shadowed, for
+  the whole process, any gem sharing a name with a directory under `lib` —
+  `sidekiq/`, `sentry/`, `warden/`. The line exists so `uses App::Thing` can
+  resolve `lib/app/thing.rb`; it never needed to outrank gems.
+
+## [0.3.0]
+
+### Changed
+
+- `jade fmt` keeps blank lines between leading comment blocks. A section
+  banner separated from the declaration below it stays separated, where it
+  used to be pulled into that declaration's doc comment. **Formatted output
+  differs from 0.2.0**, so a format check in CI reports diffs on the first
+  run after upgrading.
+- `jade q` requires a `jade.json` and reports what to write when there isn't
+  one. It previously assumed the source root was the working directory, which
+  could not work for a project whose imports come from extension gems — it
+  failed later, inside the loader, instead.
+- `Compiler::Config#source_root=` takes one root and refuses a list of more
+  than one. A list was accepted before but only its first entry was ever
+  read.
+
+### Added
+
+- `jade.json` manifest, read by `Jade::Project`, giving tools that run
+  outside the application — the CLI, an editor's language server, a codegen
+  task — the source roots and extension gems that previously existed only as
+  Ruby run at boot. `Compiler::Config` seeds from it, and a `Jade.setup`
+  block still wins.
+- `Encodable` and `Decodable` derive for unions whose variants take no
+  arguments, using the variant name in snake_case as the wire form. A union
+  mixing nullary and argument-carrying variants does not derive: adding an
+  argument to one variant would otherwise change the encoding of all of them.
+- `SqlMapper` derives for unions whose variants each carry exactly one value,
+  naming the column after the variant. Inert unless jade-sql is loaded.
+- Placeholders in keyed calls: `Point(x: _, y: n)` partially applies the way
+  `Point(_, n)` already did. Blanks bind in the order the fields are written.
+- `Source` records the root it was loaded from, so an application module and
+  one shipped by an extension gem can be told apart without a name list.
+- `UsageAnalysis::Reference` records the declaration each reference was made
+  from, including references with no source range and those inside an
+  `implements` block.
+
+### Fixed
+
+- An interface method can be referenced as a value where the expected type
+  determines the instance. `Decode.field("k", Decode.decoder)` type-checked
+  and then failed in codegen, because the method's constraint named a
+  variable that appeared in nothing and so could never be bound.
+- A constraint that resolves to a concrete type is discharged rather than
+  dropped when a binding is generalized. An interface method referenced
+  outside an argument position previously compiled to a bare name and failed
+  at runtime.
+- Deriving reports which type it could not derive instead of raising through
+  the compiler. A struct with one un-derivable field took the whole run down
+  with a Ruby backtrace, which `tolerant: true` did not contain.
+- `jade fmt` no longer drops comments. A comment above the first declaration
+  in a module attached to a node nothing renders, so a module's first
+  declaration could never carry a doc comment.
+- A type sharing its name with its module no longer generates code that
+  resolves the wrong constant.
+
 ## [0.2.0]
 
 ### Added
@@ -42,7 +115,9 @@ Initial release.
 - `jade` CLI dispatcher: `fmt`, `lsp`, `q`.
 - Language server and headless query interface for editor/agent tooling.
 
-[Unreleased]: https://github.com/agustinrhcp/jade/compare/v0.2.0...HEAD
+[Unreleased]: https://github.com/agustinrhcp/jade/compare/v0.3.1...HEAD
+[0.3.1]: https://github.com/agustinrhcp/jade/compare/v0.3.0...v0.3.1
+[0.3.0]: https://github.com/agustinrhcp/jade/compare/v0.2.0...v0.3.0
 [0.2.0]: https://github.com/agustinrhcp/jade/compare/v0.1.1...v0.2.0
 [0.1.1]: https://github.com/agustinrhcp/jade/compare/v0.1.0...v0.1.1
 [0.1.0]: https://github.com/agustinrhcp/jade/releases/tag/v0.1.0

data/lib/jade/ast/node.rb

@@ -16,6 +16,22 @@ module Jade
         @@_next_id += 1
       end
 
+      # The comment block touching this node. A blank line above it means
+      # a section banner, which documents the region and not this node.
+      def doc(source)
+        leading_comment_groups(source)
+          .last
+          &.then { follows_directly?(it.last, self, source) ? it : nil }
+          &.then { it.map(&:value).join("\n") }
+      end
+
+      # Split wherever a blank line separates one block from the next.
+      def leading_comment_groups(source)
+        leading_comments
+          .slice_when { |a, b| !follows_directly?(a, b, source) }
+          .to_a
+      end
+
       # Deepest descendant whose range covers `offset`, or self if no child
       # matches. Returns nil if this node's range is missing or doesn't
       # cover the offset.
@@ -39,6 +55,20 @@ module Jade
           .first
           .then { [self] + (it || []) }
       end
+
+      private
+
+      def follows_directly?(first, second, source)
+        line_of(second.range.begin, source) -
+          line_of(first.range.end - 1, source) == 1
+      end
+
+      def line_of(pos, source)
+        source
+          .line_starts
+          .bsearch_index { it > pos }
+          .then { it ? it - 1 : source.line_starts.length - 1 }
+      end
     end
   end
 end

data/lib/jade/cli/q.rb

@@ -88,18 +88,22 @@ module Jade
       class Context
         attr_reader :file, :source_root, :registry, :entry
 
+        # jade.json is what says where sources live and which extension gems
+        # ship the modules they import. Without it `Sql.Uuid` resolves
+        # against cwd and the load dies.
         def initialize(file)
-          @file = file
-          @source_root = Dir.pwd
+          project = Jade::Project.find!
+          @file = project.source_relative(file)
+          @source_root = project.source_root
           @registry = Jade::ModuleLoader.load(
-            @source_root, file,
-            cache_dir: File.join(@source_root, '.jade/cache'),
+            @source_root, @file,
+            cache_dir: project.cache_path,
             tolerant: true,
           )
           @entry = @registry
             .modules
             .each_value
-            .find { it.source&.uri == file } || fail("no module at #{file}")
+            .find { it.source&.uri == @file } || fail("no module at #{@file}")
         end
 
         def path_at(line, col)

data/lib/jade/cli.rb

@@ -26,6 +26,9 @@ module Jade
         usage($stderr)
         exit 1
       end
+    rescue Project::NotFound => e
+      warn "jade: #{e.message}"
+      exit 1
     end
 
     def usage(io = $stdout)

data/lib/jade/codegen/emitter.rb

@@ -48,7 +48,7 @@ module Jade
           "Jade::Runtime.intr(#{name.inspect})"
 
         in [:struct_constructor, qualified_name, arity]
-          "Jade::Runtime.curry(#{to_qualified(qualified_name)}.method(:[]), #{arity})"
+          "Jade::Runtime.curry(::#{to_qualified(qualified_name)}.method(:[]), #{arity})"
 
         in [:anon_record_constructor, keys]
           "Jade::Runtime.curry(#{data_define(keys)}.method(:[]), #{keys.size})"
@@ -68,7 +68,7 @@ module Jade
           args
             .map { "#{it}" }
             .join(',')
-            .then { "#{to_qualified(name)}(#{it})" }
+            .then { "::#{to_qualified(name)}(#{it})" }
 
         in [:_]
           '_'

data/lib/jade/codegen/inlines.rb

@@ -192,6 +192,7 @@ module Jade
         Decode.required
         Decode.sequence
         Decode.string
+        Decode.string_enum
         Decode.succeed
         Decode.tuple
         Decode.tuple3

data/lib/jade/codegen.rb

@@ -393,8 +393,12 @@ module Jade
       node.is_a?(AST::ImportDeclaration) || node.is_a?(AST::InteropImportDeclaration)
     end
 
+    # Appended, not prepended: this exists so `uses App::Thing` can find
+    # `lib/app/thing.rb`, and an application's lib directory routinely holds
+    # directories named after the gems it depends on. At position 0 those
+    # shadow the real gems for the whole process.
     def load_path
-      '$LOAD_PATH.unshift(File.expand_path("lib"))'
+      '$LOAD_PATH.push(File.expand_path("lib")).uniq!'
     end
   end
 end

data/lib/jade/compiler.rb

@@ -11,7 +11,7 @@ module Jade
 
       if needs_rebuild?(target)
         ModuleLoader
-          .load(config.source_root.first, path + '.jd', cache_dir: cache_root)
+          .load(config.source_root, path + '.jd', cache_dir: cache_root)
           .tap { render_diagnostics(it) }
           .then { ModuleLoader.emit(it, path: build_root) }
       end
@@ -47,22 +47,31 @@ module Jade
 
       target_mtime = File.mtime(target)
       Dir
-        .glob(File.join(config.source_root.first, '**/*.jd'))
+        .glob(File.join(config.source_root, '**/*.jd'))
         .any? { |src| File.mtime(src) > target_mtime }
     end
 
     class Config
       attr_accessor :project_root, :source_root, :build_dir, :cache_dir
 
-      def initialize
-        @project_root = Dir.pwd
-        @source_root = []
-        @build_dir   = ".jade/build"
-        @cache_dir   = ".jade/cache"
+      # Seeded from jade.json when there is one, so `Jade.setup` needs only
+      # what the manifest doesn't say. A setup block still wins — it runs
+      # after this.
+      def initialize(project = Project.find)
+        @project_root = project&.root || Dir.pwd
+        @source_root = project&.source_root
+        @build_dir = project&.build_dir || ".jade/build"
+        @cache_dir = project&.cache_dir || ".jade/cache"
       end
 
+      # One root. A list was accepted but only ever read at `.first`, so
+      # anything past the first was silently dropped — say so instead.
       def source_root=(root)
-        @source_root = Array(root)
+        Array(root).then do
+          fail ArgumentError, "source_root takes one root, got #{it.size}" if it.size > 1
+
+          @source_root = it.first
+        end
       end
     end
   end

data/lib/jade/formatter/helper.rb

@@ -13,7 +13,7 @@ module Jade
     #     walks delegated to their own modules.
     module Helper
       def format_node(node, indent: 0, source: nil)
-        leading  = format_leading_comments(node, indent)
+        leading  = format_leading_comments(node, indent, source)
         trailing = format_trailing_comment(node)
 
         dispatch_for(node)
@@ -75,15 +75,21 @@ module Jade
         (INDENT * indent).length + line.length > LINE_LIMIT
       end
 
-      def format_leading_comments(node, indent)
+      # The blank line between blocks is load-bearing: collapsing it turns
+      # a section banner into the next declaration's doc comment.
+      def format_leading_comments(node, indent, source = nil)
         return "" if node.leading_comments.empty?
 
-        node.leading_comments
-          .map { |tok| tok.value.then(&and_indent(indent)) }
-          .join("\n")
+        leading_comment_blocks(node, source)
+          .map { |block| block.map { it.value.then(&and_indent(indent)) }.join("\n") }
+          .join("\n\n")
           .then { it + "\n" }
       end
 
+      def leading_comment_blocks(node, source)
+        source ? node.leading_comment_groups(source) : [node.leading_comments]
+      end
+
       def format_trailing_comment(node)
         return "" if node.trailing_comments.empty?
 

data/lib/jade/frontend/comment_attacher.rb

@@ -10,7 +10,9 @@ module Jade
 
         collect_nodes(ast)
           .reject { |n| n.range.nil? }
-          .sort_by { |n| n.range.begin }
+          # Outermost first, so `x = f(y)` anchors on the Assign rather
+          # than the pattern nested inside it.
+          .sort_by { |n| [n.range.begin, -n.range.size] }
           .then { build_map(comments, it, source) }
           .then { reattach(ast, it) }
       end
@@ -70,7 +72,16 @@ module Jade
       end
 
       def first_node_starting_after(pos, sorted_nodes)
-        sorted_nodes.bsearch { |n| n.range.begin >= pos }
+        sorted_nodes
+          .bsearch_index { |n| n.range.begin >= pos }
+          &.then { |from| (from...sorted_nodes.size).find { renders_own_comments?(sorted_nodes[it]) } }
+          &.then { sorted_nodes[it] }
+      end
+
+      # ModuleNode walks `body.expressions` directly, so a Body's own
+      # leading comments reach no formatter and would be lost.
+      def renders_own_comments?(node)
+        !node.is_a?(AST::Body)
       end
 
       def smallest_enclosing(pos, sorted_nodes)

data/lib/jade/frontend/semantic_analysis/error/placeholder_not_allowed.rb

@@ -0,0 +1,22 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module Error
+        class PlaceholderNotAllowed < Jade::Error
+          def initialize(entry, span, field:)
+            @field = field
+            super(entry:, span:)
+          end
+
+          def message
+            "`#{@field}: _` is only allowed when constructing a struct"
+          end
+
+          def label
+            "not allowed here"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/semantic_analysis/error.rb

@@ -5,6 +5,7 @@ require 'jade/frontend/semantic_analysis/error/constant_not_callable'
 require 'jade/frontend/semantic_analysis/error/constructor_not_found'
 require 'jade/frontend/semantic_analysis/error/constructor_pattern_arity_mismatch'
 require 'jade/frontend/semantic_analysis/error/duplicate_field'
+require 'jade/frontend/semantic_analysis/error/placeholder_not_allowed'
 require 'jade/frontend/semantic_analysis/error/duplicate_function_declaration'
 require 'jade/frontend/semantic_analysis/error/duplicate_record_field'
 require 'jade/frontend/semantic_analysis/error/invalid_list_rest_pattern'

data/lib/jade/frontend/semantic_analysis/keyed_call.rb

@@ -16,6 +16,12 @@ module Jade
           constructor = constructor_symbol(callee_resolved, registry)
           parent = constructor && registry.lookup(constructor.parent)
 
+          if fields.any? { it.value.is_a?(AST::Placeholder) }
+            return partially_applied(
+              node, callee, fields, parent, constructor, registry, scope, entry, callee_r
+            )
+          end
+
           fields_r = analyze_in_parallel(fields, registry, scope, entry)
           fields_resolved = fields_r.node
 
@@ -34,6 +40,55 @@ module Jade
 
         private
 
+        # Lowered before the fields are analyzed, so the placeholders are
+        # still bare AST and `Placeholder.lift` can turn the call into a
+        # lambda — the same route a positional partial application takes.
+        def partially_applied(node, callee, fields, parent, constructor, registry, scope, entry, callee_r)
+          errors = Validation.errors(node, fields, parent, constructor, registry, entry) +
+            placeholder_errors(fields, parent, entry)
+
+          return Result[node, callee_r.errors + errors, scope] if errors.any?
+
+          named, params = name_placeholders(fields)
+
+          lower(node, callee, named, parent, constructor, registry)
+            .then { wrap_in_lambdas(it, params, node.range) }
+            .then { analyze_node(it, registry, scope, entry) }
+            .then { Result[it.node, callee_r.errors + it.errors, scope] }
+        end
+
+        # Named in the order the fields were written, not the order the
+        # struct declares them, so `Point(y: _, x: _)` takes y first.
+        def name_placeholders(fields)
+          fields.reduce([[], []]) do |(named, params), field|
+            case field.value
+            in AST::Placeholder
+              Codegen::Helpers.param_synthetic_name(params.size).then do |name|
+                [named + [field.with(value: AST::VariableReference[name, nil])], params + [name]]
+              end
+
+            else
+              [named + [field], params]
+            end
+          end
+        end
+
+        def wrap_in_lambdas(call, params, range)
+          params
+            .reverse
+            .reduce(call) do |body, name|
+              AST::Lambda[[AST::Pattern::Binding[name, nil]], AST::Body[[body], nil], range]
+            end
+        end
+
+        def placeholder_errors(fields, parent, entry)
+          return [] if parent.is_a?(Symbol::Struct)
+
+          fields
+            .select { it.value.is_a?(AST::Placeholder) }
+            .map { Error::PlaceholderNotAllowed.new(entry.name, it.range, field: it.key) }
+        end
+
         def lower(node, callee, fields, parent, constructor, registry)
           case parent
           in Symbol::Struct

data/lib/jade/frontend/type_checking/constraints/deriving/decodable.rb

@@ -28,6 +28,9 @@ module Jade
                 in Symbol::Struct
                   derive_struct(constraint, resolved_sym, args, registry, lookup, entry_name)
 
+                in Symbol::Union if nullary?(resolved_sym, registry)
+                  derive_nullary_union(constraint, resolved_sym, registry)
+
                 else
                   failed(constraint, entry_name)
                 end
@@ -87,14 +90,32 @@ module Jade
                 Type.constraint(INTERFACE, field_type, nil)
               end
 
-              resolved_deps = field_deps.map do |dep|
-                resolve_dep(dep, lookup, entry_name) => Ok[impl]
-                impl
-              end
+              field_deps
+                .map { resolve_dep(it, lookup, entry_name) }
+                .then { Results.sequence(it) }
+                .map { implementation(constraint, record_body(fields, constructor_ref), it) }
+            end
+
+            def derive_nullary_union(constraint, union_sym, registry)
+              variants(union_sym, registry)
+                .then { nullary_union_body(it) }
+                .then { Ok[implementation(constraint, it, [])] }
+            end
 
+            def nullary_union_body(variants)
+              [:call,
+                [:stdlib_fn, 'Decode.string_enum'],
+                [
+                  [:list, variants.map { wire_name(it) }],
+                  [:list, variants.map { [:call, [:struct_constructor, it.qualified_name, 0], []] }],
+                ],
+              ]
+            end
+
+            def record_body(fields, constructor_ref)
               seed = [:call, [:stdlib_fn, 'Decode.succeed'], [constructor_ref]]
 
-              body = fields.each_with_index.reduce(seed) do |acc, ((field_name, _), idx)|
+              fields.each_with_index.reduce(seed) do |acc, ((field_name, _), idx)|
                 field_decoder = [:call,
                   [:stdlib_fn, 'Decode.field'],
                   [
@@ -105,8 +126,6 @@ module Jade
 
                 [:call, [:stdlib_fn, 'Decode.and_map'], [acc, field_decoder]]
               end
-
-              Ok[implementation(constraint, body, resolved_deps)]
             end
 
             # Free-var inner constraints fall back to the constraint marker

data/lib/jade/frontend/type_checking/constraints/deriving/encodable.rb

@@ -30,6 +30,9 @@ module Jade
                 in Symbol::Struct
                   derive_struct(constraint, resolved_sym, args, registry, lookup, entry_name)
 
+                in Symbol::Union if nullary?(resolved_sym, registry)
+                  derive_nullary_union(constraint, resolved_sym, registry)
+
                 else
                   failed(constraint, entry_name)
                 end
@@ -84,18 +87,25 @@ module Jade
               end
             end
 
+            def derive_nullary_union(constraint, union_sym, registry)
+              body = variants(union_sym, registry)
+                .map { |v|
+                  [
+                    [:constructor, v.qualified_name, []],
+                    [[:call, [:stdlib_fn, 'Encode.string'], [wire_name(v)]]],
+                  ]
+                }
+                .then { [:case, [:var, 'v'], it] }
+
+              Ok[implementation(constraint, params: ['v'], body:, deps: [])]
+            end
+
             def derive_struct(constraint, struct_sym, type_args, registry, lookup, entry_name)
               fields = struct_fields(struct_sym, type_args, registry)
 
               field_deps = fields
                 .map { |_, field_type| Type.constraint(INTERFACE, field_type, nil) }
 
-              resolved_deps = field_deps
-                .map do |dep|
-                  lookup.call(dep) => Ok[impl]
-                  impl
-                end
-
               pair_irs = fields
                 .each_with_index
                 .map do |(field_name, _), idx|
@@ -118,7 +128,10 @@ module Jade
                 ],
               ]
 
-              Ok[implementation(constraint, params: ['rec'], body:, deps: resolved_deps)]
+              field_deps
+                .map { lookup.call(it) }
+                .then { Results.sequence(it) }
+                .map { implementation(constraint, params: ['rec'], body:, deps: it) }
             end
 
             def implementation(constraint, params:, body:, deps:)

data/lib/jade/frontend/type_checking/constraints/deriving/eq.rb

@@ -34,7 +34,8 @@ module Jade
                   deps = dependencies_of(impl, args)
                   resolved_deps = deps.filter_map { |dep|
                     next if dep.type in Type::Var
-                    lookup.call(dep) => Ok[resolved]; resolved
+                    lookup.call(dep).on_err { return Err[it] } => Ok[resolved]
+                    resolved
                   }
 
                   Symbol::Implementation.new(

data/lib/jade/frontend/type_checking/constraints/deriving/helpers.rb

@@ -6,6 +6,23 @@ module Jade
           module Helpers
             extend self
 
+            # `union :Int` and friends are variant-less unions standing in
+            # for native types, so an empty variant list is not an enum.
+            def nullary?(union_sym, registry)
+              variants(union_sym, registry)
+                .then { it.any? && it.all? { it.args.empty? } }
+            end
+
+            def variants(union_sym, registry)
+              union_sym.variants.map { registry.lookup(it) }
+            end
+
+            # The wire name a variant carries when nothing says otherwise.
+            # Matches what hand-written mappings already use.
+            def wire_name(variant)
+              Source.snake_case(variant.name)
+            end
+
             def struct_fields(struct_sym, type_args, registry)
               record = struct_sym.record_type
               type_param_names = struct_sym.type_params.map(&:name)