jade-lang 0.1.0

data/lib/jade/module_loader/normalize.rb

@@ -0,0 +1,34 @@
+require 'set'
+
+module Jade
+  module ModuleLoader
+    # Strips source positions from a nested Data tree so equivalent shapes
+    # produce equal byte sequences. Used to compute interface digests that
+    # survive whitespace and unrelated edits.
+    module Normalize
+      extend self
+
+      POSITION_FIELDS = %i[decl_span span range origin].freeze
+
+      def apply(value)
+        case value
+        when Data  then normalize_data(value)
+        when Hash  then value.transform_values { apply(it) }
+        when Array then value.map { apply(it) }
+        when Set   then value.map { apply(it) }.to_set
+        else value
+        end
+      end
+
+      private
+
+      def normalize_data(value)
+        value
+          .class
+          .members
+          .to_h { |m| [m, POSITION_FIELDS.include?(m) ? nil : apply(value.public_send(m))] }
+          .then { value.class.new(**it) }
+      end
+    end
+  end
+end

data/lib/jade/module_loader/topological_sort.rb

@@ -0,0 +1,41 @@
+module Jade
+  module ModuleLoader
+    module TopologicalSort
+      extend self
+
+      def sort(graph)
+        graph
+          .nodes
+          .keys
+          .reduce([[], [], []]) { |state, node| visit(graph, state, node) }
+          .first
+      end
+
+      private
+
+      def visit(graph, state, node)
+        visited, visiting, stack = state
+
+        return state if visited.include?(node)
+        raise CycleDependencyError.new(stack + [node]) if visiting.include?(node)
+
+        new_visited, new_visiting, new_stack = graph
+          .nodes[node]
+          .reduce([visited, visiting + [node], stack + [node]]) do |new_state, neighbor|
+            visit(graph, new_state, neighbor)
+          end
+
+        [new_visited + [node], new_visiting - [node], new_stack[0...-1]]
+      end
+    end
+
+    class CycleDependencyError < StandardError
+      attr_reader :cycle_path
+
+      def initialize(cycle_path)
+        @cycle_path = cycle_path
+        super("Cycle detected in module dependencies: #{cycle_path.join(' -> ')}")
+      end
+    end
+  end
+end

data/lib/jade/module_loader.rb

@@ -0,0 +1,127 @@
+require 'fileutils'
+
+require 'jade/parsing'
+require 'jade/lexer'
+require 'jade/ast'
+require 'jade/registry'
+require 'jade/frontend'
+require 'jade/codegen'
+require 'jade/module_loader/cache'
+require 'jade/module_loader/dependency_resolver'
+require 'jade/module_loader/dependency_graph'
+require 'jade/module_loader/normalize'
+require 'jade/module_loader/topological_sort'
+require 'jade/diagnostics'
+
+require 'jade/stdlib'
+
+module Jade
+  module ModuleLoader
+    extend self
+
+    def load(source_root, path, cache_dir: nil, tolerant: false, overlays: {})
+      Source.load(source_root, path, overlays:)
+        .then { load_(it, new_registry(source_root, overlays:), entry: true) }
+        .then { Stdlib.apply(it) }
+        .then { compile(it, cache_dir:, tolerant:) }
+    end
+
+    def load_import(module_name, registry)
+      return registry if registry.get(module_name)&.ast
+
+      Source
+        .load_from_module_name(registry.source_root, module_name, overlays: registry.overlays)
+        .then { load_(it, registry) }
+    end
+
+    def emit(registry, path: '.jade/build')
+      registry
+        .modules
+        .each_value
+        .reject { Stdlib.is_intrinsic?(it) }
+        .each { write_entry(it, path) }
+
+      registry
+    end
+
+    private
+
+    def compile(registry, cache_dir: nil, tolerant: false)
+      registry
+        .modules_in_topo_order
+        .reject { Stdlib.is_stdlib?(it) }
+        .reduce([registry, {}]) do |(acc, digests), entry|
+          compiled, digest = compile_with_cache(entry, acc, digests, cache_dir, tolerant)
+
+          [acc.update_module(compiled), digests.merge(entry.name => digest)]
+        end
+        .first
+    end
+
+    def compile_with_cache(entry, registry, digests, cache_dir, tolerant)
+      return [compile_one(entry, registry, tolerant:), nil] unless cache_dir
+
+      key = direct_deps(entry.name, registry)
+        .filter_map { |dep| digests[dep]&.then { [dep, it] } }
+        .then { Cache.compute_key(entry, it) }
+
+      Cache.read(cache_dir, entry.name, key) ||
+        compile_and_write(entry, registry, cache_dir, key, tolerant)
+    end
+
+    def compile_and_write(entry, registry, cache_dir, key, tolerant)
+      compile_one(entry, registry, tolerant:)
+        .then { [it, it.interface_digest] }
+        .tap { |(compiled, digest)| Cache.write(cache_dir, entry.name, compiled, key, digest) }
+    end
+
+    def write_entry(entry, path)
+      full = File.join(path, entry.path)
+      FileUtils.mkdir_p(File.dirname(full))
+      File.write(full, entry.generated)
+    end
+
+    def compile_one(entry, registry, tolerant: false)
+      Frontend
+        .run_entry(entry, registry)
+        .map { Codegen.generate_entry(it, registry.update_module(it)) }
+        .on_err do |(latest, errors)|
+          diagnostics = errors.reduce(Diagnostics::List.empty) { |list, err| list.add(err.to_diagnostic(registry)) }
+
+          tolerant ? Ok[latest.with(diagnostics:)] : raise(CompilationError.new(diagnostics))
+        end => Ok(compiled)
+
+      compiled
+    end
+
+    def direct_deps(module_name, registry)
+      registry.dependency_graph.nodes[module_name] || []
+    end
+
+    def load_(source, registry, entry: false)
+      Lexer.tokenize(source)
+        .then { Parsing.parse(it, source:) }
+        .on_err do |err|
+          Diagnostics::List
+            .empty
+            .add(err.to_diagnostic(source: source))
+            .then { raise CompilationError.new(it) }
+        end => Ok([raw_ast, comments])
+
+      Frontend::CommentAttacher
+        .attach(raw_ast, comments, source)
+        .then { Registry.entry(source.to_module_name).with(ast: it, source:, entry:) }
+        .then { registry.add_module(it) }
+    end
+
+    # Stdlib content is identical across calls; loading it dominates
+    # short LSP recompiles (~15ms on a tiny user file). Cache the
+    # post-Stdlib.load Registry once per process and stamp the per-call
+    # source_root + overlays on a copy. Invalidated only on restart —
+    # acceptable since compiler code changes need a restart anyway.
+    def new_registry(source_root, overlays: {})
+      @stdlib_base ||= Stdlib.load(Registry.new)
+      @stdlib_base.with(source_root:, overlays:)
+    end
+  end
+end

data/lib/jade/parsing/combinators.rb

@@ -0,0 +1,291 @@
+require 'jade/diagnostics'
+
+module Jade
+  module Parsing
+    module Combinators
+      module Dsl
+        def parser(name, private: false, &block)
+          builder = :"_build_#{name}"
+          define_method(builder, &block)
+          send(:private, builder)
+          module_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+            def #{name}
+              @#{name} ||= #{builder}
+            end
+          RUBY
+          send(:private, name) if private
+        end
+      end
+      extend Dsl
+
+      def grouped(parser)
+        type(:lparen).skip >> parser >> type(:rparen).skip
+      end
+
+      def at_least_one(parser, separated_by: none.skip)
+        tail = separated_by >> sequence(parser, separated_by:)
+        parser >> optional(tail, default: [])
+      end
+
+      # Consume `parser` if it matches; if not, drop the slot from the
+      # surrounding `>>` tuple (no value, no failure).
+      def maybe(parser)
+        (parser | none).skip
+      end
+
+      # Consume `parser` if it matches; otherwise inject `default` as the
+      # value. Keeps tuple arity stable in `>>` chains.
+      def optional(parser, default: nil)
+        parser | none.map { default }
+      end
+
+      def sequence(parser, separated_by: none.skip)
+        (parser.map { [it] } >> many(separated_by >> parser))
+          .map { it.flatten(1) }
+      end
+
+      CommaList = Data.define(:items, :trailing_comma) do
+        def self.empty
+          new(items: [], trailing_comma: false)
+        end
+      end
+
+      def comma_sequence(parser)
+        inner = sequence(parser, separated_by: type(:comma).skip)
+        P.new do |state|
+          inner.call(state).and_then do |(items, state1)|
+            trailing, state2 =
+              if !state1.eof? && state1.current.type == :comma
+                [true, state1.advance]
+              else
+                [false, state1]
+              end
+
+            Ok[[CommaList.new(items:, trailing_comma: trailing), state2]]
+          end
+        end
+      end
+
+      parser(:empty_comma_list) { none.map { CommaList.empty } }
+
+      parser(:none) { P.new { |state| Ok[[nil, state]] } }
+
+
+      # Tolerant counterpart of `sequence`. Strict mode (the default) behaves
+      # identically; tolerant mode records a diagnostic and resumes at the
+      # next sync token instead of failing.
+      def recovering_sequence(parser, sync_types:)
+        P.new { recovering_step(parser, sync_types, it, []) }
+      end
+
+      def recovering_step(parser, sync_types, state, results)
+        return Ok[[results, state]] if state.eof?
+
+        case parser.call(state)
+        in Ok([value, next_state])
+          recovering_step(parser, sync_types, next_state, [*results, value])
+
+        in Err([err, err_state]) unless state.tolerant
+          err.committed? ? Err[[err, err_state]] : Ok[[results, state]]
+
+        in Err([err, err_state])
+          # Always advance at least one token so termination is guaranteed
+          # even when sync_types isn't ahead.
+          moved_past = err.committed? && err_state.position > state.position
+          recovered = (moved_past ? err_state : state.advance)
+            .skip_until(sync_types)
+            .add_diagnostic(err.to_diagnostic)
+
+          recovering_step(parser, sync_types, recovered, results)
+        end
+      end
+
+      def skip(parser)
+        parser.map { |_| :skip }
+      end
+
+      def many(parser)
+        P.new do |state|
+          oks = []
+          current = state
+          committed_err = nil
+
+          loop do
+            break if current.eof?
+
+            case parser.call(current)
+            in Ok([value, next_state])
+              oks << value
+              current = next_state
+            in Err([err, err_state])
+              committed_err = Err[[err, err_state]] if err.committed?
+              break
+            end
+          end
+
+          committed_err || Ok[[oks, current]]
+        end
+      end
+
+      def type(type)
+        (@types ||= {})[type] ||= P.new do |state|
+          if state.eof?
+            Err[[
+              Parsing::EOFError.new(
+                entry:    state.entry,
+                span:     nil,
+                expected: type,
+              ),
+              state,
+            ]]
+
+          elsif state.current.type == :invalid_op
+            Err[[
+              Parsing::InvalidOperatorError.new(
+                entry:    state.entry,
+                span:     state.current.range,
+                actual:   state.current,
+              ),
+              state,
+            ]]
+
+          elsif state.current.type == type
+            Ok[([state.current, state.advance])]
+
+          else
+            Err[[
+              Parsing::UnexpectedTokenError.new(
+                entry:    state.entry,
+                span:     state.current.range,
+                actual:   state.current,
+                expected: type,
+              ),
+              state,
+            ]]
+          end
+        end
+      end
+
+      def lazy(&block)
+        P.new do |input|
+          block.call.call(input)
+        end
+      end
+
+      State = Data.define(
+        :tokens, :position, :entry, :context_stack, :tolerant, :diagnostics,
+        :source,
+      ) do
+        def initialize(
+          tokens:,
+          entry:,
+          position: 0,
+          context_stack: [],
+          tolerant: false,
+          diagnostics: Diagnostics::List.empty,
+          source: nil
+        )
+          super
+        end
+
+        def current
+          tokens[position]
+        end
+
+        def advance(n = 1)
+          with(position: position + n)
+        end
+
+        def eof?
+          position >= tokens.length
+        end
+
+        # Two positions on the same source line. Uses the source's
+        # `line_starts` index; returns true when source is unavailable so
+        # callers degrade to "accept whatever parses" rather than spurious
+        # errors.
+        def same_line?(pos_a, pos_b)
+          return true unless source
+
+          starts = source.line_starts
+          starts.bsearch_index { |ls| ls > pos_a } ==
+            starts.bsearch_index { |ls| ls > pos_b }
+        end
+
+        def add_diagnostic(diagnostic)
+          with(diagnostics: diagnostics.add(diagnostic))
+        end
+
+        def skip_until(sync_types)
+          (position...tokens.length)
+            .find { sync_types.include?(tokens[it].type) }
+            .then { with(position: it || tokens.length) }
+        end
+      end
+
+      class P
+        def initialize(&block)
+          @fn = block
+        end
+
+        def call(tokens)
+          @fn.call(tokens)
+        end
+
+        def map(&block)
+          P.new do |state|
+            call(state)
+              .map { |(value, ok_state)| [block.call(value), ok_state] }
+          end
+        end
+
+        def map_error(&block)
+          P
+            .new do |state|
+              call(state)
+                .map_error { |(err, err_state)| [block.call(err), err_state] }
+            end
+        end
+
+        def |(other)
+          P.new do |state|
+            call(state)
+              .on_err do |(error, state2)|
+                if error.committed?
+                  Err[[error, state2]]
+                else
+                  other.call(state)
+                end
+              end
+          end
+        end
+
+        def >>(other)
+          P.new do |state|
+            call(state).and_then do |(value1, state1)|
+              other.call(state1)
+                .map do |(value2, state2)|
+                  [[value1, value2].reject { it == :skip }.flatten(1), state2]
+                end
+                .map_error do |(err, err_state)|
+                  [err, state]
+                end
+            end
+          end
+        end
+
+        def skip
+          self.map { |_| :skip }
+        end
+
+        def commit
+          map_error(&:commit)
+        end
+
+        def context(name)
+          map_error { |err| err.with_context(name) }
+        end
+      end
+    end
+  end
+end

data/lib/jade/parsing/error.rb

@@ -0,0 +1,154 @@
+require 'jade/error'
+require 'jade/lexer'
+
+module Jade
+  module Parsing
+    class Error < Jade::Error
+      def initialize(entry:, span:, actual:, expected:, committed: false, context: [])
+        super(entry:, span:)
+        @actual    = actual
+        @expected  = expected
+        @committed = committed
+        @context   = context
+      end
+
+      def committed?
+        @committed
+      end
+
+      def commit
+        @committed = true
+        self
+      end
+
+      def with_context(name)
+        self.class.new(
+          entry:     @entry,
+          span:      @span,
+          actual:    @actual,
+          expected:  @expected,
+          committed: @committed,
+          context:   [name, *@context],
+        )
+      end
+
+      attr_reader :actual, :expected, :context
+
+      protected
+
+      def context_prefix
+        return "" if @context.empty?
+
+        "While parsing #{@context.join(' > ')}: "
+      end
+    end
+
+    class EOFError < Error
+      def initialize(entry:, span:, expected:, actual: nil, committed: false, context: [])
+        super
+      end
+
+      def message
+        "#{context_prefix}Unexpected end of input, expected #{expected}"
+      end
+    end
+
+    class UnexpectedTokenError < Error
+      def initialize(entry:, span:, actual:, expected:, committed: false, context: [])
+        super
+      end
+
+      def hint
+        return leading_pipe_hint if leading_pipe_in_type_decl?
+        return reserved_keyword_hint if reserved_keyword_as_name?
+        return colon_not_eq_hint if eq_where_colon_expected?
+        return record_eq_hint if eq_where_record_pipe_expected?
+        nil
+      end
+
+      def message
+        "#{context_prefix}Unexpected token #{actual.value.inspect}, expected #{expected}#{" #{hint}" if hint}"
+      end
+
+      def label
+        "unexpected #{@actual.value.inspect}"
+      end
+
+      private
+
+      def leading_pipe_in_type_decl?
+        actual.type == :pipe &&
+          expected == :constant &&
+          @context.include?('type declaration')
+      end
+
+      def leading_pipe_hint
+        "(leading `|` isn't supported — write `type Foo = A | B` with no `|` before the first variant)"
+      end
+
+      def reserved_keyword_as_name?
+        expected == :identifier && Jade::Lexer::KEYWORDS.include?(actual.value)
+      end
+
+      def reserved_keyword_hint
+        "(`#{actual.value}` is a reserved keyword — choose a different name)"
+      end
+
+      # `=` where `:` is expected: record field, param, or annotation —
+      # all written `name: value`. e.g. `{ d | f = x }` chokes on the colon.
+      def eq_where_colon_expected?
+        actual.type == :assign && expected == :colon
+      end
+
+      def colon_not_eq_hint
+        "(use `:`, not `=`)"
+      end
+
+      # A bare `{ f = x }` literal backtracks into the record-update parser
+      # and chokes on the missing `|`. The real mistake is `=` for `:`.
+      def eq_where_record_pipe_expected?
+        actual.type == :assign &&
+          expected == :pipe &&
+          !@context.include?('type declaration')
+      end
+
+      def record_eq_hint
+        "(record fields use `:`, not `=` — write `{ name: value }`)"
+      end
+    end
+
+    # Specific case-branch shape: `in <pat> <body>` on the same source
+    # line, no `then` between them. Almost always the user meant
+    # `in <pat> then <body>` for an inline branch.
+    class MissingThenError < Error
+      def message
+        "#{context_prefix}Case branch needs `then` before an inline body " \
+          "(got #{@actual.value.inspect} on the same line as `in`). " \
+          "Write `in <pat> then <expr>`, or put the body on the next " \
+          "line for the multi-statement form."
+      end
+
+      def label
+        "missing `then`"
+      end
+    end
+
+    class InvalidOperatorError < Error
+      HINTS = {
+        '/=' => 'Use `!=` for inequality.',
+      }.freeze
+
+      def initialize(entry:, span:, actual:, expected: nil, committed: true, context: [])
+        super
+      end
+
+      def hint
+        HINTS[actual.value]
+      end
+
+      def message
+        "#{context_prefix}Invalid operator #{actual.value.inspect}.#{" #{hint}" if hint}"
+      end
+    end
+  end
+end

data/lib/jade/parsing/token.rb

@@ -0,0 +1,12 @@
+require 'jade/parsing/combinators'
+
+module Jade
+  module Parsing
+    module Token
+      extend Combinators::Dsl
+
+      parser(:identifier) { type(:identifier) }
+      parser(:constant)   { type(:constant) }
+    end
+  end
+end