jade-lang 0.1.0

data/lib/jade/calendar/runtime.rb

@@ -0,0 +1,15 @@
+require 'jade/port'
+
+module Jade
+  module Calendar
+    module Runtime
+      extend Jade::Port
+
+      task :today_raw do |t|
+        ::Time.now
+          .then { { year: it.year, month: it.month, day: it.day } }
+          .then { t.ok(it) }
+      end
+    end
+  end
+end

data/lib/jade/cli/fmt.rb

@@ -0,0 +1,96 @@
+require 'jade/source'
+require 'jade/lexer'
+require 'jade/ast'
+require 'jade/parsing'
+require 'jade/formatter'
+require 'jade/frontend/comment_attacher'
+
+module Jade
+  module CLI
+    module Fmt
+      module_function
+
+      def run(argv)
+        mode = :stdout
+        file = nil
+
+        argv.each do |arg|
+          case arg
+          when '-i', '--in-place' then mode = :in_place
+          when '-c', '--check'    then mode = :check
+          when '-h', '--help'     then usage
+          when /\A-/
+            warn "unknown option: #{arg}"
+            usage
+          else
+            usage if file
+            file = arg
+          end
+        end
+
+        format(file, mode)
+      end
+
+      def format(file, mode)
+        source_text = read_source(file)
+        source = Source.new(uri: file || 'stdin', text: source_text)
+
+        case Parsing.parse(Lexer.tokenize(source), source:)
+        in Ok([ast, comments])
+          emit(Formatter.format(ast, comments:, source:) + "\n",
+               source_text, file, mode)
+
+        in Err(error)
+          warn "Parse error: #{error.message}"
+          exit 2
+        end
+      end
+
+      def read_source(file)
+        case
+        when file then File.read(file)
+        when !$stdin.tty? then $stdin.read
+        else usage
+        end
+      end
+
+      def emit(formatted, source_text, file, mode)
+        case mode
+        when :in_place
+          usage unless file
+          write_in_place(formatted, source_text, file)
+
+        when :check
+          exit 0 if formatted == source_text
+          warn "#{file || 'stdin'}: not formatted"
+          exit 1
+
+        when :stdout
+          print formatted
+        end
+      end
+
+      def write_in_place(formatted, source_text, file)
+        return if formatted == source_text
+
+        File.write(file, formatted)
+        warn "Formatted #{file}"
+      end
+
+      def usage
+        warn <<~USAGE
+          Usage: jade fmt [options] [file]
+
+          Options:
+            -i, --in-place   Rewrite the file in place.
+            -c, --check      Exit 0 if formatted, 1 if drift, 2 on parse error.
+                             Does not write.
+            -h, --help       Show this message.
+
+          Reads from stdin when no file is given.
+        USAGE
+        exit 1
+      end
+    end
+  end
+end

data/lib/jade/cli/lsp.rb

@@ -0,0 +1,13 @@
+require 'jade/lsp'
+
+module Jade
+  module CLI
+    module Lsp
+      module_function
+
+      def run(_argv)
+        Jade::LSP::Server.new.run
+      end
+    end
+  end
+end

data/lib/jade/cli/q.rb

@@ -0,0 +1,113 @@
+require 'jade'
+require 'jade/lsp'
+require 'json'
+
+module Jade
+  module CLI
+    # Headless query interface to the same compiler intelligence the LSP
+    # server uses. Intended for tools and agents that want a quick JSON
+    # answer instead of speaking JSON-RPC.
+    module Q
+      USAGE = <<~TXT.freeze
+        Usage: jade q COMMAND [ARGS]
+
+          hover   FILE:LINE:COL    Type info at the given position.
+          symbols FILE             Document symbols (outline) for FILE.
+          defn    FILE:LINE:COL    Goto-definition location.
+          refs    FILE:LINE:COL    Find all references (incl. declaration).
+
+        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.
+      TXT
+
+      module_function
+
+      def run(argv)
+        case argv[0]
+        when 'hover'   then dump(hover(argv[1]))
+        when 'symbols' then dump(symbols(argv[1]))
+        when 'defn'    then dump(defn(argv[1]))
+        when 'refs'    then dump(refs(argv[1]))
+        else
+          warn USAGE
+          exit 1
+        end
+      end
+
+      def hover(arg)
+        file, line, col = parse_position(arg)
+        Context.new(file).then do |ctx|
+          Jade::LSP::Converters.hover_for_path(
+            ctx.path_at(line, col), ctx.registry, ctx.entry
+          )
+        end
+      end
+
+      def symbols(file)
+        fail 'FILE required' unless file
+
+        Context.new(file).entry.then do |entry|
+          entry.ast.body.expressions.filter_map do |node|
+            Jade::LSP::Converters.to_document_symbol(node, entry.source)
+          end
+        end
+      end
+
+      def defn(arg)
+        file, line, col = parse_position(arg)
+        Context.new(file).then do |ctx|
+          Jade::LSP::Converters.definition_for_path(
+            ctx.path_at(line, col), ctx.registry, ctx.entry, ctx.source_root
+          )
+        end
+      end
+
+      def refs(arg)
+        file, line, col = parse_position(arg)
+        Context.new(file).then do |ctx|
+          Jade::LSP::Converters.references_for_path(
+            ctx.path_at(line, col), ctx.registry, ctx.entry, ctx.source_root,
+            include_declaration: true,
+          )
+        end
+      end
+
+      def parse_position(arg)
+        fail 'FILE:LINE:COL required' unless arg
+        fail "expected FILE:LINE:COL, got #{arg.inspect}" unless arg.count(':') == 2
+
+        arg.split(':').then { |(file, line, col)| [file, line.to_i, col.to_i] }
+      end
+
+      def dump(result)
+        puts JSON.pretty_generate(result)
+      end
+
+      class Context
+        attr_reader :file, :source_root, :registry, :entry
+
+        def initialize(file)
+          @file = file
+          @source_root = Dir.pwd
+          @registry = Jade::ModuleLoader.load(
+            @source_root, file,
+            cache_dir: File.join(@source_root, '.jade/cache'),
+            tolerant: true,
+          )
+          @entry = @registry
+            .modules
+            .each_value
+            .find { it.source&.uri == file } || fail("no module at #{file}")
+        end
+
+        def path_at(line, col)
+          Jade::LSP::Converters
+            .position_to_offset(entry.source, line, col)
+            .then { entry.ast.find_at_path(it) }
+        end
+      end
+    end
+  end
+end

data/lib/jade/cli.rb

@@ -0,0 +1,43 @@
+require 'jade'
+
+module Jade
+  module CLI
+    SUBCOMMANDS = {
+      'fmt' => 'Fmt',
+      'lsp' => 'Lsp',
+      'q' => 'Q',
+    }.freeze
+
+    module_function
+
+    def run(argv)
+      sub, *rest = argv
+
+      case sub
+      when nil, '-h', '--help', 'help'
+        usage
+
+      when *SUBCOMMANDS.keys
+        require "jade/cli/#{sub}"
+        const_get(SUBCOMMANDS.fetch(sub)).run(rest)
+
+      else
+        warn "jade: unknown command #{sub.inspect}\n\n"
+        usage($stderr)
+        exit 1
+      end
+    end
+
+    def usage(io = $stdout)
+      io.puts <<~TXT
+        Usage: jade COMMAND [ARGS]
+
+          fmt    Format .jd source (stdin or file).
+          lsp    Run the language server (stdio JSON-RPC).
+          q      Headless query interface (hover/symbols/defn/refs).
+
+        Run `jade COMMAND --help` for command-specific options.
+      TXT
+    end
+  end
+end

data/lib/jade/clock/runtime.rb

@@ -0,0 +1,13 @@
+require 'jade/port'
+
+module Jade
+  module Clock
+    module Runtime
+      extend Jade::Port
+
+      task :now_raw do |t|
+        t.ok({ millis: (::Time.now.to_r * 1000).to_i })
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+module Jade
+  module Codegen
+    module Boundary
+      # Per-module cache mapping each type a boundary wrapper needs to
+      # decode/encode to a const name (`BOUNDARY_DEC_0`, etc.) that holds
+      # the value once at module load. `collect` walks the body to build
+      # the map; `decoder_for` / `encoder_for` consult it from wrapper
+      # codegen, falling back to the raw `Boundary` spec when uncached
+      # (e.g. when emission runs outside a Module).
+      module Cache
+        extend self
+        extend Helpers
+
+        def decoder_for(type, registry)
+          Codegen.boundary_cache[:decoders][type] || Boundary.decoder_for(type, registry)
+        end
+
+        def encoder_for(type, registry)
+          Codegen.boundary_cache[:encoders][type] || Boundary.encoder_for(type, registry)
+        end
+
+        def task_arms(task_type, registry)
+          task_type => Type::Application(args: [ok_t, err_t])
+          [encoder_for(ok_t, registry), encoder_for(err_t, registry)]
+        end
+
+        def collect(body, registry)
+          per_fn = body
+            .expressions
+            .filter_map do
+              boundary_types(it, registry) if it.is_a?(AST::FunctionDeclaration)
+            end
+
+          {
+            decoders: cache_map(per_fn.flat_map { it[:decoders] }, 'DEC') { |t|
+              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)
+            },
+          }
+        end
+
+        # Types with a specialized inline emission don't need a cached
+        # constant — the wrapper emits the validation directly.
+        def cache_map(types, tag, &specialized)
+          types
+            .reject(&specialized)
+            .uniq
+            .each_with_index
+            .map { |t, i| [t, "BOUNDARY_#{tag}_#{i}"] }
+            .to_h
+        end
+
+        def constants(cache, registry)
+          cache[:decoders].map { |type, name| "#{name} = #{Boundary.decoder_for(type, registry)}" } +
+            cache[:encoders].map { |type, name| "#{name} = #{Boundary.encoder_for(type, registry)}" }
+        end
+
+        private
+
+        # Returns the {decoders:, encoders:} type lists this fn's wrapper
+        # would touch, or `nil` when the fn produces no wrapper (not
+        # exposed, polymorphic, or ineligible).
+        def boundary_types(fn_node, registry)
+          symbol = fn_node.symbol
+          return nil unless registry.get(symbol.module_name).exposed_value(symbol.name)
+          return nil unless dict_constraints(symbol, registry).empty?
+
+          fn_type = fn_type_for(symbol, registry)
+          return nil unless Boundary.eligible?(fn_type, registry)
+
+          args, return_type = Type.signature(fn_type)
+
+          case return_type
+          in Type::Application(constructor: Type::Constructor(name: 'Task.Task'), args: arms)
+            arms
+          else
+            [return_type]
+          end
+            .then { { decoders: args, encoders: it } }
+        end
+
+        def fn_type_for(symbol, registry)
+          registry
+            .get(symbol.module_name)
+            .env
+            .then { it.substitution.apply(it.bindings[symbol.qualified_name].type) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+module Jade
+  module Codegen
+    module Boundary
+      module Specialized
+        # `List(t)` where `t` is itself specializable. Two shapes:
+        #
+        # - `List(scalar)` — emits a single `Array#all?` C-loop check via
+        #   `Boundary.list_of`, then passes the array through.
+        # - `List(specializable)` — validates Array shape with
+        #   `Boundary.array`, then maps the inner decoder over each element.
+        module List
+          extend self
+
+          def decode(type, input, registry)
+            inner = inner_of(type) or return nil
+
+            scalar_optimized(inner, input) ||
+              generic_decode(type, inner, input, registry)
+          end
+
+          def encode(type, value_expr, registry)
+            inner = inner_of(type) or return nil
+            return nil if Specialized.identity_encoder?(inner)
+
+            elem = Specialized.encode_expr(inner, '_1', registry) or return nil
+            "#{value_expr}.map { #{elem} }"
+          end
+
+          def identity_encoder?(type)
+            inner = inner_of(type) or return false
+            Specialized.identity_encoder?(inner)
+          end
+
+          def specializable?(type, registry, seen)
+            inner = inner_of(type) or return false
+            Specialized.specializable_field?(inner, registry, seen)
+          end
+
+          def inner_of(type)
+            return nil unless Specialized.qname_of(type) == 'List.List'
+            args = Specialized.args_of(type)
+            args&.size == 1 ? args[0] : nil
+          end
+
+          private
+
+          # `List(scalar)` fast path: validate elements with a single
+          # C-loop `all?` check, no per-element decoder call.
+          def scalar_optimized(inner, input)
+            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})"
+          end
+
+          def generic_decode(type, inner, input, registry)
+            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} }"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module Jade
+  module Codegen
+    module Boundary
+      module Specialized
+        # `Maybe(t)` where `t` is itself specializable. Both decode and
+        # encode bind the input via `.then { it ... }` so a complex
+        # `value_expr` (e.g. a full `Internal.X(...)` call) isn't
+        # re-evaluated.
+        module Maybe
+          extend self
+
+          def decode(type, input, registry)
+            inner = inner_of(type) or return nil
+            elem = Specialized.decode_expr(inner, 'it', registry) or return nil
+
+            "#{input}.then { it.nil? ? Jade::Maybe::Nothing[] : Jade::Maybe::Just[#{elem}] }"
+          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'
+
+            "#{value_expr}.then { it.is_a?(::Jade::Maybe::Just) ? #{inner_enc} : nil }"
+          end
+
+          def specializable?(type, registry, seen)
+            inner = inner_of(type) or return false
+            Specialized.specializable_field?(inner, registry, seen)
+          end
+
+          def inner_of(type)
+            return nil unless Specialized.qname_of(type) == 'Maybe.Maybe'
+            args = Specialized.args_of(type)
+            args&.size == 1 ? args[0] : nil
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,165 @@
+module Jade
+  module Codegen
+    module Boundary
+      module Specialized
+        # Structs whose fields are all specializable. Each specializable
+        # struct gets a pair of `def self.decode_<name>` / `encode_<name>`
+        # helper methods emitted at module level; the wrapper body for
+        # `birthday(person: Person) -> Person` becomes
+        # `encode_person(Internal.birthday(decode_person(person)))`.
+        #
+        # Cycle detection: a struct referencing itself (directly or
+        # mutually) falls back to the descriptor cache path. The `seen`
+        # set carries qnames of structs we're currently inside; revisiting
+        # one means we'd loop, so we bail with nil.
+        module Record
+          extend self
+          extend Helpers
+
+          def decode(type, input, registry)
+            struct = struct_for(type, registry) or return nil
+            "#{decode_helper_name(struct)}(#{input})"
+          end
+
+          def encode(type, value_expr, registry)
+            struct = struct_for(type, registry) or return nil
+            "#{encode_helper_name(struct)}(#{value_expr})"
+          end
+
+          def specializable?(type, registry, seen)
+            specializable_struct(type, registry, seen) ? true : false
+          end
+
+          # All specializable structs reachable from any exposed
+          # function's boundary signature, transitively (through nested
+          # struct fields and `List` / `Maybe` wrappers). Each one needs
+          # `decode_<name>` / `encode_<name>` helper methods emitted.
+          def collect_helpers(body, registry)
+            body.expressions
+              .filter { it.is_a?(AST::FunctionDeclaration) }
+              .flat_map { fn_reachable_structs(it, registry) }
+              .uniq
+              .then { transitive_closure(it, registry) }
+          end
+
+          def emit_helpers(structs, registry)
+            structs.flat_map do
+              [decode_helper(it, registry), encode_helper(it, registry)]
+            end
+          end
+
+          def struct_for(type, registry)
+            specializable_struct(type, registry, ::Set.new)
+          end
+
+          # Returns specializable structs reachable from `type` through
+          # any depth of `List` / `Maybe` / nested struct fields. Used by
+          # `collect_helpers` to seed the closure walk.
+          def structs_in(type, registry)
+            if (struct = struct_for(type, registry))
+              [struct]
+            elsif (inner = List.inner_of(type))
+              structs_in(inner, registry)
+            elsif (inner = Maybe.inner_of(type))
+              structs_in(inner, registry)
+            else
+              []
+            end
+          end
+
+          private
+
+          def specializable_struct(type, registry, seen)
+            struct = lookup_struct(type, registry) or return nil
+            return nil if seen.include?(struct.qualified_name)
+
+            struct.record_type.fields.values
+              .all? { Specialized.specializable_field?(it, registry, seen + [struct.qualified_name]) }
+              .then { it ? struct : nil }
+          end
+
+          def lookup_struct(type, registry)
+            return nil unless Specialized.args_of(type) == []
+            qname = Specialized.qname_of(type) or return nil
+
+            parts = qname.split('.')
+            ref   = Symbol.type_ref(parts[0..-2].join('.'), parts[-1])
+            sym   = registry.lookup(ref) or return nil
+            sym.is_a?(Symbol::Struct) ? sym : nil
+          end
+
+          # Reachability walk from `seeds` through nested struct fields.
+          # Pure-functional: each call builds a fresh `collected + frontier`.
+          def transitive_closure(seeds, registry, collected = ::Set.new)
+            frontier = seeds.reject { collected.include?(it) }
+            return collected.to_a if frontier.empty?
+
+            transitive_closure(
+              frontier.flat_map { nested_structs(it, registry) },
+              registry,
+              collected + frontier,
+            )
+          end
+
+          def nested_structs(struct, registry)
+            struct.record_type.fields.values.flat_map { structs_in(it, registry) }
+          end
+
+          def fn_reachable_structs(fn_node, registry)
+            symbol = fn_node.symbol
+            return [] unless registry.get(symbol.module_name).exposed_value(symbol.name)
+
+            fn_type = registry.get(symbol.module_name)
+              .env
+              .then { it.substitution.apply(it.bindings[symbol.qualified_name].type) }
+
+            args, ret = Type.signature(fn_type)
+            (args + [ret]).flat_map { structs_in(it, registry) }
+          end
+
+          def decode_helper_name(struct)
+            "decode_#{snake(struct.name)}"
+          end
+
+          def encode_helper_name(struct)
+            "encode_#{snake(struct.name)}"
+          end
+
+          def decode_helper(struct, registry)
+            ctor      = "::#{to_qualified(struct.module_name)}::#{struct.name}"
+            hash_call = "Jade::Interop::Boundary.hash(#{struct.name.inspect}, value)"
+
+            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("def self.#{decode_helper_name(struct)}(value)", it) }
+          end
+
+          def encode_helper(struct, registry)
+            struct.record_type.fields
+              .map { |k, t| "#{k.inspect} => #{field_encode_value(t, "p.#{k}", registry)}" }
+              .then { "{ #{it.join(', ')} }" }
+              .then { Pretty.block("def self.#{encode_helper_name(struct)}(p)", it) }
+          end
+
+          def field_decode(key, type, registry)
+            Specialized.decode_expr(type, "h[#{key.to_s.inspect}]", registry) ||
+              fail("non-specializable field type for #{key}: #{type}")
+          end
+
+          def field_encode_value(type, accessor, registry)
+            Specialized.encode_expr(type, accessor, registry) || accessor
+          end
+
+          def snake(name)
+            name
+              .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+              .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+              .downcase
+          end
+        end
+      end
+    end
+  end
+end