jade-lang 0.1.0

data/lib/jade/frontend/comment_attacher.rb

@@ -0,0 +1,121 @@
+module Jade
+  module Frontend
+    module CommentAttacher
+      extend self
+
+      SKIP_FIELDS = %i[range symbol id leading_comments trailing_comments dangling_comments].freeze
+
+      def attach(ast, comments, source)
+        return ast if comments.empty?
+
+        collect_nodes(ast)
+          .reject { |n| n.range.nil? }
+          .sort_by { |n| n.range.begin }
+          .then { build_map(comments, it, source) }
+          .then { reattach(ast, it) }
+      end
+
+      private
+
+      def collect_nodes(node)
+        node
+          .to_h
+          .reject { |field, _| SKIP_FIELDS.include?(field) }
+          .values
+          .flat_map { walk_collect(it) }
+          .then { [node, *it] }
+      end
+
+      def walk_collect(val)
+        case val
+        in AST::Node then collect_nodes(val)
+        in Array     then val.flat_map { walk_collect(it) }
+        else              []
+        end
+      end
+
+      def build_map(comments, sorted_nodes, source)
+        comments
+          .filter_map { classify(it, sorted_nodes, source) }
+          .group_by(&:node_id)
+          .transform_values { CommentGroup.from_comments(it) }
+      end
+
+      def classify(comment, sorted_nodes, source)
+        comment_line = line_of(comment.range.begin, source)
+        prev_node    = last_node_ending_before(comment.range.begin, sorted_nodes)
+        next_node    = first_node_starting_after(comment.range.end, sorted_nodes)
+
+        if prev_node && line_of(prev_node.range.end - 1, source) == comment_line
+          CommentEntry::Trailing.new(node_id: prev_node.id, comment:)
+
+        elsif next_node
+          CommentEntry::Leading.new(node_id: next_node.id, comment:)
+
+        else
+          enclosing = smallest_enclosing(comment.range.begin, sorted_nodes)
+          CommentEntry::Dangling.new(node_id: enclosing.id, comment:) if enclosing
+        end
+      end
+
+      def line_of(pos, source)
+        idx = source.line_starts.bsearch_index { |ls| ls > pos }
+        idx ? idx - 1 : source.line_starts.length - 1
+      end
+
+      def last_node_ending_before(pos, sorted_nodes)
+        sorted_nodes
+          .select { |n| n.range.end <= pos }
+          .last
+      end
+
+      def first_node_starting_after(pos, sorted_nodes)
+        sorted_nodes.bsearch { |n| n.range.begin >= pos }
+      end
+
+      def smallest_enclosing(pos, sorted_nodes)
+        sorted_nodes
+          .select { |n| n.range.cover?(pos) }
+          .min_by { |n| n.range.size }
+      end
+
+      def reattach(node, map)
+        rebuilt_children = node
+          .to_h
+          .reject { |field, _| SKIP_FIELDS.include?(field) }
+          .transform_values { walk_reattach(it, map) }
+
+        node
+          .with(
+            **rebuilt_children,
+            **((map[node.id]&.to_h || {}).transform_keys { :"#{it}_comments" }),
+          )
+      end
+
+      def walk_reattach(val, map)
+        case val
+        in AST::Node then reattach(val, map)
+        in Array     then val.map { walk_reattach(it, map) }
+        else              val
+        end
+      end
+
+      module CommentEntry
+        Leading  = Data.define(:node_id, :comment)
+        Trailing = Data.define(:node_id, :comment)
+        Dangling = Data.define(:node_id, :comment)
+      end
+
+      CommentGroup = Data.define(:leading, :trailing, :dangling) do
+        def self.from_comments(entries)
+          by_type = entries.group_by(&:class)
+          new(
+            leading:  (by_type[CommentEntry::Leading]  || []).map(&:comment),
+            trailing: (by_type[CommentEntry::Trailing] || []).map(&:comment),
+            dangling: (by_type[CommentEntry::Dangling] || []).map(&:comment),
+          )
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/desugaring/placeholder.rb

@@ -0,0 +1,39 @@
+require 'jade/codegen/helpers'
+
+module Jade
+  module Frontend
+    module Desugaring
+      module Placeholder
+        extend self
+        extend Codegen::Helpers
+
+        def lift(call)
+          return call unless call.args.any?(AST::Placeholder)
+
+          filled_args, names = call
+            .args
+            .reduce([[], []]) do |(args, names), arg|
+              case arg
+              in AST::Placeholder
+                param_synthetic_name(names.size)
+                  .then { [args + [AST::VariableReference[it, nil]], names + [it]] }
+
+              else
+                [args + [arg], names]
+              end
+          end
+
+          names
+            .reverse
+            .reduce(call.with(args: filled_args)) do |body, name|
+              AST::Lambda[
+                [AST::Pattern::Binding[name, nil]],
+                AST::Body[[body], nil],
+                call.range,
+              ]
+            end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/desugaring/resolved.rb

@@ -0,0 +1,63 @@
+module Jade
+  module Frontend
+    module Desugaring
+      extend self
+
+      # Runs after SemanticAnalysis (which resolves names and attaches
+      # symbols). Add new post-resolution rewrites as `in` branches
+      # below; `map_children` handles transparent recursion.
+      def desugar_resolved_entry(entry, registry)
+        desugar_resolved(entry.ast, registry)
+          .then { entry.with(ast: it) }
+      end
+
+      def desugar_resolved(node, registry)
+        case node
+        in AST::VariableReference | AST::QualifiedAccess
+          zero_arg_fn?(node.symbol, registry) ? wrap_call(node) : node
+
+        else
+          map_children(node) { desugar_resolved(it, registry) }
+        end
+      end
+
+      private
+
+      def map_children(node)
+        node
+          .to_h
+          .transform_values { walk_field(it) { yield(it) } }
+          .then { node.class.new(**it) }
+      end
+
+      # AST node fields are either an AST::Node, an array of AST::Nodes,
+      # or non-AST metadata (range, symbol, id, comments, bools). The
+      # block walks the first two; metadata passes through untouched.
+      def walk_field(value, &block)
+        case value
+        in AST::Node then block.call(value)
+        in [AST::Node, *] then value.map(&block)
+        else value
+        end
+      end
+
+      def wrap_call(ref)
+        AST::FunctionCall.new(
+          callee: ref,
+          args: [],
+          infix: false,
+          dictionaries: [],
+          range: ref.range,
+        )
+      end
+
+      def zero_arg_fn?(symbol, registry)
+        resolved = symbol.is_a?(Symbol::ValueRef) ? registry.lookup(symbol) : symbol
+        case resolved
+        in Symbol::Function | Symbol::StdlibFunction => fn then fn.constant?
+        else false
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/desugaring.rb

@@ -0,0 +1,217 @@
+require 'jade/frontend/desugaring/placeholder'
+
+module Jade
+  module Frontend
+    module Desugaring
+      extend self
+
+      def desugar_entry(entry)
+        desugar(entry.ast)
+          .then { entry.with(ast: it) }
+      end
+
+      def desugar(node)
+        case node
+        in AST::Module(body:)
+          node.with(body: desugar(body))
+
+        in AST::Body(expressions:)
+          node.with(expressions: desugar_expressions(expressions))
+
+        in AST::InfixApplication(left:, right:, operator:)
+          case operator
+          in AST::InfixOperator(value: '|>')
+            case right
+            in AST::FunctionCall(args:)
+              right
+                .with(args: [left] + args)
+                .then { desugar(it) }
+
+            else
+              AST::FunctionCall.new(
+                callee: right,
+                args: [left],
+                infix: operator,
+                range: node.range,
+              )
+
+            end
+              .then { desugar(it) }
+
+          else
+            AST::FunctionCall.new(
+              callee: AST::VariableReference["(#{operator.value})", operator.range],
+              args: [desugar(left), desugar(right)],
+              infix: operator,
+              range: node.range,
+            )
+          end
+
+        in AST::FunctionCall(callee:, args:)
+          node
+            .with(callee: desugar(callee))
+            .with(args: args.map { desugar(it) })
+            .then { Placeholder.lift(it) }
+
+        in AST::KeyedCall(callee:, fields:)
+          node
+            .with(callee: desugar(callee))
+            .with(fields: fields.map { desugar(it) })
+
+        in AST::FunctionDeclaration(body:)
+          node
+            .with(body: desugar(body))
+
+        in AST::MemberAccess(target:)
+          node
+            .with(target: desugar(target))
+
+        in AST::CaseOf(expression:, branches:)
+          node
+            .with(expression: desugar(expression))
+            .with(branches: branches.map { desugar(it) })
+
+        in AST::CaseOfBranch(pattern:, body:)
+          node
+            .with(pattern: desugar(pattern))
+            .with(body: desugar(body))
+
+        in AST::IfThenElse(condition:, if_branch:, else_branch:)
+          node
+            .with(condition: desugar(condition))
+            .with(if_branch: desugar(if_branch))
+            .with(else_branch: desugar(else_branch))
+
+        in AST::Assign(pattern:, expression:)
+          node.with(pattern: desugar(pattern), expression: desugar(expression))
+
+        in AST::Grouping(expression:)
+          node.with(expression: desugar(expression))
+
+        in AST::Lambda(params:, body:)
+          node
+            .with(params: params.map { desugar(it) })
+            .with(body: desugar(body))
+
+        in AST::List(items:)
+          node
+            .with(items: items.map { desugar(it) })
+
+        in AST::RecordLiteral(fields:)
+          fields.map { desugar(it) }.then { node.with(fields: it) }
+
+        in AST::RecordUpdate(fields:)
+          fields.map { desugar(it) }.then { node.with(fields: it) }
+
+        in AST::RecordField(value:)
+          desugar(value).then { node.with(value: it) }
+
+        in AST::RecordAccessSugar(field_key:, range:)
+          AST::VariableReference['x', nil]
+            .then { AST::MemberAccess[it, AST::VariableReference[field_key, nil], range] }
+            .then { AST::Body[[it], nil] }
+            .then { AST::Lambda[[AST::Pattern::Binding['x', nil]], it, range] }
+
+        in AST::RecordUpdateSugar(field_key:, range:)
+          value_reference = AST::VariableReference['value', nil]
+
+          AST::VariableReference['x', nil]
+            .then { AST::RecordUpdate[it, [AST::RecordField[field_key, value_reference, nil]], range] }
+            .then { AST::Body[[it], nil] }
+            .then do |body|
+              AST::Lambda[
+                [
+                  AST::Pattern::Binding['x', nil],
+                  AST::Pattern::Binding[value_reference.name, nil],
+                ],
+                body,
+                range,
+              ]
+            end
+
+        in AST::Tuple(items:)
+          AST::FunctionCall.new(
+            callee: AST::ConstructorReference["Tuple.Tuple#{items.size}", node.range],
+            args: items.map { desugar(it) },
+            infix: false,
+            range: node.range,
+          )
+
+        in AST::Pattern::Tuple(patterns:)
+          AST::ConstructorReference[
+            "Tuple.Tuple#{patterns.size}",
+            node.range,
+          ]
+            .then do
+              AST::Pattern::Constructor.new(
+                constructor: it,
+                patterns: patterns.map { desugar(it) },
+                range: node.range,
+              )
+            end
+
+        in AST::Pattern::Constructor(patterns:)
+          node.with(patterns: patterns.map { desugar(it) })
+
+        in AST::Pattern::Record(fields:)
+          fields
+            .map { it.with(pattern: desugar(it.pattern)) }
+            .then { node.with(fields: it) }
+
+        in AST::Pattern::List(patterns:, rest:)
+          node
+            .with(patterns: patterns.map { desugar(it) })
+            .with(rest: rest && desugar(rest))
+
+        in AST::Implementation(functions:)
+          functions
+            .map { desugar(it) }
+            .then { node.with(functions: it) }
+
+        in AST::ImplementationFunction(fn:)
+          node.with(fn: desugar(fn))
+
+        in AST::Literal | AST::CharLiteral | AST::VariableReference | AST::ConstructorReference |
+          AST::TypeDeclaration | AST::ImportDeclaration |
+          AST::Pattern::Literal | AST::Pattern::Binding | AST::Pattern::Wildcard |
+          AST::Pattern::Record | AST::InteropImportDeclaration | AST::StructDeclaration |
+          AST::QualifiedAccess | AST::Placeholder | AST::InterfaceDeclaration
+
+          node
+        end
+      end
+
+      private
+
+      def desugar_expressions(expressions)
+        case expressions
+        in [AST::Bind(pattern:, expression: expr, range: bind_range), *rest]
+          AST::Lambda[
+            [pattern],
+            AST::Body[rest, nil],
+            nil,
+          ]
+            .then { [expr, it] }
+            .map { desugar(it) }
+            .then do
+              AST::FunctionCall.new(
+                callee:       AST::VariableReference['and_then', nil],
+                args:         it,
+                infix:        false,
+                dictionaries: [],
+                range:        bind_range,
+              )
+            end
+            .then { [it] }
+
+        in [expr, *rest]
+          [desugar(expr)] + desugar_expressions(rest)
+
+        in []
+          []
+        end
+      end
+
+    end
+  end
+end

data/lib/jade/frontend/fixity_fixer.rb

@@ -0,0 +1,209 @@
+module Jade
+  module Frontend
+    module FixityFixer
+      extend self
+
+      module SplitWhen
+        refine Enumerable do
+          def split_when
+            i = self.index { |x| !yield(x) } || self.length
+            [self.take(i), self.drop(i)]
+          end
+        end
+      end
+
+      using SplitWhen
+
+      Fixity = Data.define(:precedence, :assoc) do
+        # Compare the rank of two operators for shunting-yard purposes
+        # Returns:
+        #   - negative if self has lower rank
+        #   - zero if self and other are equal rank
+        #   - positive if self has higher rank
+        def <=>(other)
+          # rank by precedence first
+          prec_cmp = precedence <=> other.precedence
+          return prec_cmp unless prec_cmp.zero?
+
+          # same precedence → rank by associativity
+          case assoc
+          when :left
+            0   # equal rank: left-assoc
+          when :right
+            1   # higher rank: right-assoc
+          when :none
+            raise "Non-associative operator cannot be chained"
+          end
+        end
+      end
+
+      FIXITY = {
+        '+' => Fixity[6, :left],
+        '-' => Fixity[6, :left],
+        '*' => Fixity[7, :left],
+        '/' => Fixity[7, :left],
+        '++' => Fixity[5, :right],
+        '|>' => Fixity[1, :left],
+        '<|' => Fixity[1, :right],
+        '==' => Fixity[4, :none],
+        '!=' => Fixity[4, :none],
+        '<=' => Fixity[4, :none],
+        '>=' => Fixity[4, :none],
+        '>' => Fixity[4, :none],
+        '<' => Fixity[4, :none],
+        '&&' => Fixity[3, :right],
+        '||' => Fixity[2, :right],
+      }.freeze
+
+      def fix_entry(entry)
+        fix(entry.ast)
+          .then { entry.with(ast: it) }
+      end
+
+      def fix(node)
+        case node
+        in AST::Module(body:)
+          fix(body)
+            .then { node.with(body: it) }
+
+        in AST::InfixApplication
+          flatten(node)
+            .then { shunting_yard(it) }
+            .then { unflatten(it) }
+
+        in AST::Assign(expression:)
+          node.with(expression: fix(expression))
+
+        in AST::FunctionDeclaration(body:)
+          node.with(body: fix(body))
+
+        in AST::Body(expressions:)
+          expressions
+            .map { fix(it) }
+            .then { node.with(expressions: it) } 
+
+        in AST::FunctionCall(callee:, args:)
+          args
+            .map { fix(it) }
+            .then { node.with(args: it, callee: fix(callee)) }
+
+        in AST::KeyedCall(callee:, fields:)
+          fields
+            .map { fix(it) }
+            .then { node.with(fields: it, callee: fix(callee)) }
+
+        in AST::MemberAccess(target:)
+          fix(target)
+            .then { node.with(target: it) }
+
+        in AST::CaseOf(expression:, branches:)
+          branches.map { fix(it) }
+            .then { node.with(branches:, expression: fix(expression)) }
+
+        in AST::CaseOfBranch(body:)
+          node.with(body: fix(body))
+
+        in AST::IfThenElse(condition:, if_branch:, else_branch:)
+          node.with(
+            condition: fix(condition),
+            if_branch: fix(if_branch),
+            else_branch: fix(else_branch),
+          )
+
+        in AST::Lambda(body:)
+          node.with(body: fix(body))
+
+        in AST::ImplementationFunction(fn:)
+          node.with(fn: fix(fn))
+
+        in AST::Implementation(functions:)
+          functions
+            .map { fix(it) }
+            .then { node.with(functions: it) }
+
+        in AST::Grouping(expression:)
+          node.with(expression: fix(expression))
+
+        in AST::List(items:)
+          items
+            .map { fix(it) }
+            .then { node.with(items: it) }
+
+        in AST::RecordLiteral(fields:)
+          fields.map { fix(it) }.then { node.with(fields: it) }
+
+        in AST::RecordField(value:)
+          fix(value).then { node.with(value: it) }
+
+        in AST::RecordUpdate(fields:)
+          fields.map { fix(it) }.then { node.with(fields: it) }
+
+        in AST::Tuple(items:)
+          items.map { fix(it) }.then { node.with(items: it) }
+
+        in AST::Bind(expression:)
+          node.with(expression: fix(expression))
+
+        in AST::VariableReference | AST::ConstructorReference | AST::TypeDeclaration |
+          AST::ImportDeclaration | AST::Literal | AST::CharLiteral | AST::RecordAccessSugar | AST::InteropImportDeclaration |
+          AST::StructDeclaration | AST::QualifiedAccess | AST::Placeholder | AST::InterfaceDeclaration
+
+          node
+
+        in AST::RecordAccess(target:)
+          fix(target)
+            .then { node.with(target: it) }
+        end
+      end
+
+      private
+
+      def flatten(ast)
+        case ast
+        in AST::InfixApplication(left:, operator:, right:)
+          flatten(left) + [operator] + flatten(right)
+
+        else
+          [ast]
+        end
+      end
+
+      def shunting_yard(flat_infix)
+        flat_infix
+          .reduce([[], []]) do |(output, stack), node|
+            case node
+            in AST::InfixOperator(value:)
+              to_pop, to_keep = stack
+                .reverse
+                .split_when do |op|
+                  (FIXITY[value] <=> FIXITY[op.value]) <= 0
+                end
+
+              [output + to_pop, to_keep.reverse + [node]]
+
+            else
+              [output + [node], stack]
+            end
+          end
+          .then { |(output, stack)| output + stack.reverse }
+      end
+
+      def unflatten(npr)
+        npr
+          .reduce([]) do |stack, node|
+            case node
+            in AST::InfixOperator
+              *rest, left, right = stack
+              AST
+                .infix_application.call(left, node, right)
+                .then { rest + [it] }
+
+            else
+              stack + [node]
+            end
+          end
+          .first
+      end
+    end
+  end
+end

data/lib/jade/frontend/forward_declaration/body.rb

@@ -0,0 +1,30 @@
+module Jade
+  module Frontend
+    module ForwardDeclaration
+      module Body
+        extend self
+        extend Helper
+
+        def shallow(node, registry, entry)
+          walk(node, entry) { |acc, expr| shallow_declare_node(expr, registry, acc) }
+        end
+
+        def deep(node, entry, registry)
+          walk(node, entry) { |acc, expr| deep_declare_node(expr, acc, registry) }
+        end
+
+        private
+
+        def walk(node, entry, &block)
+          node => AST::Body(expressions:)
+
+          expressions
+            .reduce(Result[entry, []]) do |result, expression|
+              yield(result.entry, expression)
+                .add_errors(result.errors)
+            end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/forward_declaration/error/bad_import.rb

@@ -0,0 +1,19 @@
+module Jade
+  module Frontend
+    module ForwardDeclaration
+      module Error
+        class BadImport < Jade::Error
+          def initialize(entry, span, name:, module_name:)
+            @name = name
+            @module_name = module_name
+            super(entry:, span:)
+          end
+
+          def message
+            "The `#{@module_name}` module does not expose `#{@name}`"
+          end
+        end
+      end
+    end
+  end
+end