jade-lang 0.1.0

data/lib/jade/decode.rb

@@ -0,0 +1,320 @@
+require 'json'
+
+module Jade
+  module Decode
+    MissingField = Data.define(:_1)
+    WrongType    = Data.define(:_1, :_2)
+    AtField      = Data.define(:_1, :_2)
+    AtIndex      = Data.define(:_1, :_2)
+    Multiple     = Data.define(:_1)
+    Custom       = Data.define(:_1)
+
+    Decoder = Data.define(:desc)
+
+    module Desc
+      Str      = Data.define()
+      Int      = Data.define()
+      Flt      = Data.define()
+      Bool     = Data.define()
+      Pass     = Data.define()
+      Nullable = Data.define(:inner)
+      Field    = Data.define(:key, :inner)
+      OptField = Data.define(:key, :inner)
+      Optional = Data.define(:key, :inner, :default)
+      Idx      = Data.define(:index, :inner)
+      Lst      = Data.define(:inner)
+      Dct      = Data.define(:k_inner, :v_inner)
+      Map      = Data.define(:fn, :d)
+      Succeed  = Data.define(:value)
+      AndMap   = Data.define(:wrapped, :value_d)
+      Sequence = Data.define(:decoders)
+      OneOf    = Data.define(:decoders)
+      AndThen  = Data.define(:fn, :d)
+      Fail     = Data.define(:msg)
+      Variant  = Data.define(:cases)
+    end
+
+    module Runner
+      extend self
+
+      def from_json(decoder, json_string)
+        begin
+          parsed = JSON.parse(json_string)
+        rescue JSON::ParserError => e
+          return err(Jade::Decode::WrongType["valid JSON", e.message])
+        end
+        run(decoder, parsed)
+      end
+
+      def run(decoder, value)
+        interp(decoder.desc, value)
+      end
+
+      private
+
+      def interp(desc, value)
+        case desc
+        in Desc::Str[]
+          value.is_a?(::String) ? ok(value.dup) : type_err("String", value)
+
+        in Desc::Int[]
+          value.is_a?(::Integer) && !value.is_a?(::Float) ? ok(value) : type_err("Int", value)
+
+        in Desc::Flt[]
+          value.is_a?(::Numeric) ? ok(value.to_f) : type_err("Float", value)
+
+        in Desc::Bool[]
+          value == true || value == false ? ok(value) : type_err("Bool", value)
+
+        in Desc::Pass[]
+          ok(value)
+
+        in Desc::Nullable[inner]
+          if value.nil?
+            ok(nothing)
+          else
+            case interp(inner, value)
+            in Jade::Result::Ok[v] then ok(just(v))
+            in Jade::Result::Err => e then e
+            end
+          end
+
+        in Desc::Field[key, inner]
+          h = coerce_hash(value)
+          return type_err("Object", value) unless h
+
+          sym = key.to_sym
+          if h.key?(sym)
+            wrap_at_field(key, interp(inner, h[sym]))
+          elsif h.key?(key)
+            wrap_at_field(key, interp(inner, h[key]))
+          else
+            err(Jade::Decode::MissingField[key.to_s])
+          end
+
+        in Desc::OptField[key, inner]
+          h = coerce_hash(value)
+          return type_err("Object", value) unless h
+
+          sym = key.to_sym
+          if h.key?(sym)
+            wrap_opt_at_field(key, interp(inner, h[sym]))
+          elsif h.key?(key)
+            wrap_opt_at_field(key, interp(inner, h[key]))
+          else
+            ok(nothing)
+          end
+
+        in Desc::Optional[key, inner, default]
+          h = coerce_hash(value)
+          return type_err("Object", value) unless h
+
+          sym = key.to_sym
+          raw = h.fetch(sym) { h.fetch(key) { :__absent__ } }
+
+          if raw == :__absent__ || raw.nil?
+            ok(default)
+          else
+            case interp(inner, raw)
+            in Jade::Result::Ok => r  then r
+            in Jade::Result::Err[e]   then err(Jade::Decode::AtField[key.to_s, e])
+            end
+          end
+
+        in Desc::Idx[index, inner]
+          arr = coerce_array(value)
+          return type_err("Array", value) unless arr
+          return err(Jade::Decode::MissingField["[#{index}]"]) if index >= arr.length
+
+          case interp(inner, arr[index])
+          in Jade::Result::Ok => r  then r
+          in Jade::Result::Err[e]   then err(Jade::Decode::AtIndex[index, e])
+          end
+
+        in Desc::Lst[inner]
+          arr = coerce_array(value)
+          return type_err("Array", value) unless arr
+
+          values = []
+          errors = []
+          arr.each_with_index do |v, i|
+            case interp(inner, v)
+            in Jade::Result::Ok[decoded] then values << decoded
+            in Jade::Result::Err[e]      then errors << Jade::Decode::AtIndex[i, e]
+            end
+          end
+          errors.empty? ? ok(values) : err(wrap_errors(errors))
+
+        in Desc::Dct[k_inner, v_inner]
+          interp_dict(k_inner, v_inner, value)
+
+        in Desc::Map[fn, d]
+          case interp(d, value)
+          in Jade::Result::Ok[v] then ok(fn.call(v))
+          in Jade::Result::Err => e then e
+          end
+
+        in Desc::Succeed[v]
+          ok(v)
+
+        in Desc::AndMap[wrapped, value_d]
+          combine([interp(wrapped, value), interp(value_d, value)]) { |fn_and_a|
+            fn, a = fn_and_a
+            fn.call(a)
+          }
+
+        in Desc::Sequence[ds]
+          combine(ds.map { interp(it, value) }) { it }
+
+        in Desc::OneOf[ds]
+          errors = []
+          ds.each do |d|
+            case interp(d, value)
+            in Jade::Result::Ok => r  then return r
+            in Jade::Result::Err[e]   then errors << e
+            end
+          end
+          err(wrap_errors(errors))
+
+        in Desc::AndThen[fn, d]
+          case interp(d, value)
+          in Jade::Result::Ok[v]    then interp(fn.call(v).desc, value)
+          in Jade::Result::Err => e then e
+          end
+
+        in Desc::Fail[msg]
+          err(Jade::Decode::Custom[msg])
+
+        in Desc::Variant[cases]
+          interp_variant(cases, value)
+        end
+      end
+
+      def interp_variant(cases, value)
+        return type_err('Array', value) unless value.is_a?(::Array)
+        return err(Custom["empty variant array"]) if value.empty?
+
+        tag = value.first
+        return type_err('String tag at index 0', tag) unless tag.is_a?(::String)
+
+        inner = cases[tag]
+        return err(Custom["unknown variant: #{tag.inspect}"]) unless inner
+
+        interp(inner, value)
+      end
+
+      def ok(v)  = Jade::Result::Ok[v]
+      def err(e) = Jade::Result::Err[e]
+      def nothing = Jade::Maybe::Nothing[]
+      def just(v) = Jade::Maybe::Just[v]
+
+      def type_err(expected, got)
+        err(Jade::Decode::WrongType[expected, ruby_type_name(got)])
+      end
+
+      def wrap_at_field(key, result)
+        case result
+        in Jade::Result::Ok => r  then r
+        in Jade::Result::Err[e]   then err(Jade::Decode::AtField[key.to_s, e])
+        end
+      end
+
+      def wrap_opt_at_field(key, result)
+        case result
+        in Jade::Result::Ok[v]  then ok(just(v))
+        in Jade::Result::Err[e] then err(Jade::Decode::AtField[key.to_s, e])
+        end
+      end
+
+      def combine(results, &block)
+        values = []
+        errors = []
+        results.each do |r|
+          case r
+          in Jade::Result::Ok[v]  then values << v
+          in Jade::Result::Err[e] then errors << e
+          end
+        end
+        errors.empty? ? ok(block.call(values)) : err(wrap_errors(errors))
+      end
+
+      def wrap_errors(errors)
+        errors.length == 1 ? errors.first : Jade::Decode::Multiple[errors]
+      end
+
+      # Two accepted wire shapes for Dict: a Hash (the natural Ruby form
+      # and what String-keyed JSON parses to) and an Array of [k, v] pairs
+      # (the form Encode.dict emits — survives non-String keys).
+      def interp_dict(k_inner, v_inner, value)
+        if (h = coerce_hash(value))
+          h.each_pair.map { |k, v| [[k, v], k.to_s] }
+            .then { decode_dict_entries(k_inner, v_inner, it, :at_field) }
+        elsif (arr = coerce_array(value))
+          arr.each_with_index.map { |pair, i| [pair, i] }
+            .then { decode_dict_entries(k_inner, v_inner, it, :at_index) }
+        else
+          type_err("Object or Array", value)
+        end
+      end
+
+      def decode_dict_entries(k_inner, v_inner, entries, position)
+        h = {}
+        errors = []
+        entries.each do |pair, pos|
+          case pair
+          in [k_raw, v_raw]
+            k_res = interp(k_inner, k_raw)
+            v_res = interp(v_inner, v_raw)
+            if k_res.is_a?(Jade::Result::Ok) && v_res.is_a?(Jade::Result::Ok)
+              h[k_res._1] = v_res._1
+            else
+              [k_res, v_res].each do |r|
+                errors << wrap_pos(position, pos, r._1) if r.is_a?(Jade::Result::Err)
+              end
+            end
+          else
+            errors << wrap_pos(position, pos, Jade::Decode::WrongType["Array[2]", ruby_type_name(pair)])
+          end
+        end
+        errors.empty? ? ok(Jade::Dict::Dict[h]) : err(wrap_errors(errors))
+      end
+
+      def wrap_pos(position, pos, inner)
+        position == :at_index \
+          ? Jade::Decode::AtIndex[pos, inner]
+          : Jade::Decode::AtField[pos, inner]
+      end
+
+      def coerce_hash(value)
+        case value
+        when ::Hash then value
+        when ::Data then value.to_h
+        else nil
+        end
+      end
+
+      def coerce_array(value)
+        value.is_a?(::Array) ? value : nil
+      end
+
+      def ruby_type_name(v)
+        Jade::Decode.type_name(v)
+      end
+    end
+
+    # Public so specialized boundary decoders can emit error values matching
+    # the interpreter's `WrongType` format without going through `Runner`.
+    def self.type_name(v)
+      case v
+      when ::String              then "String"
+      when ::Integer             then "Int"
+      when ::Float               then "Float"
+      when TrueClass, FalseClass then "Bool"
+      when ::NilClass            then "null"
+      when ::Array               then "Array"
+      when ::Hash                then "Object"
+      else                            v.class.name
+      end
+    end
+  end
+end

data/lib/jade/diagnostics/renderer.rb

@@ -0,0 +1,121 @@
+require 'jade/diagnostics'
+
+module Jade::Diagnostics
+  class Renderer
+    SEVERITY_COLOR = {
+      error: "\e[31m",
+      warning: "\e[33m",
+      note: "\e[36m",
+      help: "\e[32m",
+    }.freeze
+
+    BLUE = "\e[34m".freeze
+    BOLD = "\e[1m".freeze
+    RESET = "\e[0m".freeze
+
+    def initialize(colors: $stdout.tty?)
+      @colors = colors
+    end
+
+    def render(diagnostic)
+      [
+        header(diagnostic),
+        diagnostic.primary&.then { span_block(it, severity: diagnostic.severity) if it.source },
+        *diagnostic
+          .secondary
+          .map { span_block(_1, severity: :secondary) },
+        *diagnostic
+          .annotations
+          .map { annotation(_1) },
+      ]
+        .compact
+        .join("\n")
+    end
+
+    def render_all(diagnostics)
+      diagnostics
+        .items
+        .map { render(_1) }
+        .join("\n\n")
+    end
+
+    private
+
+    def header(diagnostic)
+      "#{bold}#{color(diagnostic.severity)}#{diagnostic.severity}:#{reset} " \
+        "#{bold}#{diagnostic.message}#{reset}"
+    end
+
+    def span_block(label, severity:)
+      loc = location_of(label.source, label.span.begin)
+      end_offset = [label.span.end - 1, 0].max
+      end_loc = location_of(label.source, [end_offset, label.source.text.length - 1].min)
+      multiline = end_loc.line > loc.line
+      gutter_w = (multiline ? end_loc.line : loc.line).to_s.length
+      blank = " " * gutter_w
+      col_offset = loc.col - 1
+      first_line = extract_line(label.source, loc.line).chomp
+      span_len = [multiline ? first_line.length - col_offset : label.span.size, 1].max
+      caret = severity == :secondary ? "-" : "^"
+      underline = " " * col_offset + caret * span_len
+      ann_text = label.message ? " #{label.message}" : ""
+      uc = severity == :secondary ? blue : color(severity)
+
+      lines = [
+        "#{blank}#{blue} --> #{reset}#{label.source.uri}:#{loc.line}:#{loc.col}",
+        "#{blank}#{blue} |#{reset}",
+        "#{blue}#{loc.line.to_s.rjust(gutter_w)} | #{reset}#{first_line}",
+        "#{blank}#{blue} | #{reset}#{bold}#{uc}#{underline}#{reset}",
+      ]
+
+      if multiline
+        (loc.line + 1..end_loc.line).each do |n|
+          source_line = extract_line(label.source, n).chomp
+          lines << "#{blue}#{n.to_s.rjust(gutter_w)} | #{reset}#{source_line}"
+          next unless n == end_loc.line
+
+          last_underline = caret * [[end_loc.col, 1].max, source_line.length].min
+          lines << "#{blank}#{blue} | #{reset}#{bold}#{uc}#{last_underline}#{ann_text}#{reset}"
+        end
+      else
+        lines[-1] = "#{blank}#{blue} | #{reset}#{bold}#{uc}#{underline}#{ann_text}#{reset}"
+      end
+
+      lines << "#{blank}#{blue} |#{reset}"
+      lines.join("\n")
+    end
+
+    def annotation(ann)
+      "  #{bold}#{color(ann.kind)}= #{ann.kind}:#{reset} #{ann.message}"
+    end
+
+    Location = Data.define(:line, :col)
+
+    def location_of(source, offset)
+      (source.line_starts.rindex { _1 <= offset } || 0)
+        .then { Location[it + 1, offset - source.line_starts[it] + 1] }
+    end
+
+    def extract_line(source, line_number)
+      s = source.line_starts[line_number - 1]
+      e = source.line_starts[line_number] || source.text.length
+      source.text[s...e]
+    end
+
+    def color(severity)
+      @colors ? SEVERITY_COLOR.fetch(severity, "") : ""
+    end
+
+    def blue
+      @colors ? BLUE : ""
+    end
+
+    def bold
+      @colors ? BOLD : ""
+    end
+
+    def reset
+      @colors ? RESET : ""
+    end
+  end
+end

data/lib/jade/diagnostics.rb

@@ -0,0 +1,77 @@
+require 'jade/result'
+
+module Jade
+  module Diagnostics
+    Label = Data.define(:source, :span, :message)
+    Annotation = Data.define(:kind, :message)
+
+    Diagnostic = Data.define(:severity, :message, :primary, :secondary, :annotations) do
+      def self.error(message, primary:, secondary: [], annotations: [])
+        new(severity: :error, message:, primary:, secondary:, annotations:)
+      end
+
+      def self.warning(message, primary:, secondary: [], annotations: [])
+        new(severity: :warning, message:, primary:, secondary:, annotations:)
+      end
+
+      def error?
+        severity == :error
+      end
+
+      def annotate(kind, text)
+        with(annotations: annotations + [Annotation[kind, text]])
+      end
+    end
+
+    List = Data.define(:items) do
+      def self.empty
+        new(items: [])
+      end
+
+      def add(diagnostic)
+        with(items: items + [diagnostic])
+      end
+
+      def error(message, source:, span:, label: nil, secondary: [], annotations: [])
+        add(Diagnostic.error(
+          message,
+          primary: Label[source, span, label],
+          secondary:,
+          annotations:,
+        ))
+      end
+
+      def note(text)
+        update_last { _1.annotate(:note, text) }
+      end
+
+      def help(text)
+        update_last { _1.annotate(:help, text) }
+      end
+
+      def merge(other)
+        with(items: items + other.items)
+      end
+
+      def any_errors?
+        items.any?(&:error?)
+      end
+
+      def empty?
+        items.empty?
+      end
+
+      def to_result(value)
+        any_errors? ? Err.new(self) : Ok.new(value)
+      end
+
+      private
+
+      def update_last(&block)
+        return self if items.empty?
+
+        with(items: items[0...-1] + [block.call(items.last)])
+      end
+    end
+  end
+end

data/lib/jade/did_you_mean.rb

@@ -0,0 +1,16 @@
+require 'did_you_mean'
+
+module Jade
+  module DidYouMean
+    extend self
+
+    def suggest(name, candidates, max: 3)
+      return [] if name.nil? || candidates.empty?
+
+      ::DidYouMean::SpellChecker
+        .new(dictionary: candidates.uniq)
+        .correct(name)
+        .first(max)
+    end
+  end
+end

data/lib/jade/entry.rb

@@ -0,0 +1,177 @@
+module Jade
+  Entry = Data.define(
+    :name,
+    :defined_values,
+    :defined_types,
+    :imports,
+    :exposes,
+    :ast,
+    :source,
+    :env,
+    :generated,
+    :implementations,
+    :entry,
+    :diagnostics,
+    :usage_index,
+  ) do
+
+    def self.empty(name)
+      new(
+        name:,
+        defined_values: {},
+        defined_types: {},
+        imports: ::Set[],
+        exposes: ::Set[],
+        ast: nil,
+        source: nil,
+        generated: nil,
+        env: nil,
+        implementations: {},
+        entry: false,
+        diagnostics: Diagnostics::List.empty,
+        usage_index: nil,
+      )
+    end
+
+    def expose(symbol)
+      with(exposes: exposes + ::Set[symbol])
+    end
+
+    def import(import_entry)
+      with(imports: imports + ::Set[import_entry])
+    end
+
+    def exposed_value(unqualified_name)
+      exposes
+        .find { it.is_a?(Symbol::ValueRef) && it.name == unqualified_name }
+    end
+
+    def exposed_type(unqualified_name)
+      exposes
+        .find { it.is_a?(Symbol::TypeRef) && it.name == unqualified_name }
+    end
+
+    def exposed_type_variants(unqualified_name)
+      type_ref = exposes
+        .find { it.is_a?(Symbol::TypeRef) && it.name == unqualified_name }
+
+      return nil unless type_ref
+
+      types[unqualified_name]
+        .constructor_refs
+        .then { it & exposes.to_a }
+        .then { it.empty? ? nil : it }
+    end
+
+    def imported_values
+      imports
+        .flat_map(&:unqualified_symbols)
+        .select { it.is_a?(Symbol::ValueRef) }
+        .map { [it.name, it] }
+        .to_h
+    end
+
+    def imported_types
+      imports
+        .flat_map(&:unqualified_symbols)
+        .select { it.is_a?(Symbol::TypeRef) }
+        .map { [it.name, it] }
+        .to_h
+    end
+
+    def values
+      imported_values.merge(defined_values)
+    end
+
+    def types
+      imported_types.merge(defined_types)
+    end
+
+    def define(symbol)
+      case symbol
+      in Symbol::Union | Symbol::Struct | Symbol::Interface
+        add_defined_type(symbol)
+
+      in Symbol::Implementation
+        add_implementation(symbol)
+
+      in Symbol::Function | Symbol::StdlibFunction |
+        Symbol::Constructor | Symbol::Variant |
+        Symbol::InteropFunction | Symbol::InterfaceFunction
+        add_defined_value(symbol)
+      end
+    end
+
+    def lookup_value(name)
+      values[name]
+    end
+
+    def lookup_type(name)
+      types[name]
+    end
+
+    def lookup_qualified_type(as, type_name)
+      imports
+        .find { it.alias == as }
+        &.qualified_symbols&.find { it.is_a?(Symbol::TypeRef) && it.name == type_name }
+    end
+
+    def path
+      source.uri.gsub('.jd', '.rb')
+    end
+
+    # Source spans are stripped so unrelated edits (e.g. whitespace) shifting
+    # one definition's span don't bust caches for consumers of others.
+    def interface_digest
+      Digest::SHA256.hexdigest(Marshal.dump(interface_snapshot))
+    end
+
+    private
+
+    def interface_snapshot
+      value_names = exposes.filter_map { it.is_a?(Symbol::ValueRef) ? it.name : nil }.sort
+      type_names  = exposes.filter_map { it.is_a?(Symbol::TypeRef)  ? it.name : nil }.sort
+
+      [
+        value_names,
+        type_names,
+        value_names.map { ModuleLoader::Normalize.apply(defined_values[it]) },
+        type_names .map { ModuleLoader::Normalize.apply(defined_types[it])  },
+        implementations.keys.sort.map { [it, ModuleLoader::Normalize.apply(implementations[it])] },
+      ]
+    end
+
+    def add_implementation(symbol)
+      symbol
+        .with(module_name: name)
+        .then { implementations.merge([it.interface.qualified_name, it.type.qualified_name] => it) }
+        .then { with(implementations: it) }
+    end
+
+    def add_defined_value(symbol)
+      symbol
+        .with(module_name: name)
+        .then { with(defined_values: defined_values.merge(it.name => it)) }
+    end
+
+    def add_defined_type(symbol)
+      case symbol
+      in Symbol::Union
+        symbol
+          .with(
+            module_name: name,
+            variants: symbol.variants.map { it.with(module_name: name) },
+          )
+
+      in Symbol::Interface(functions:)
+        symbol
+          .with(module_name: name)
+          .with(functions: functions.map { it.with(module_name: name) })
+
+      else
+        symbol.with(module_name: name)
+      end
+        .then { with(defined_types: defined_types.merge(it.name => it)) }
+    end
+  end
+end