jade-lang 0.1.0

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

@@ -0,0 +1,69 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module InteropImportDeclaration
+        extend self
+        extend Helper
+
+        def analyze(node, registry, scope, entry)
+          node => AST::InteropImportDeclaration(functions:)
+
+          functions_with_symbols = functions.map do |fn|
+            entry
+              .lookup_value(fn.name)
+              .then { fn.with(symbol: it) }
+          end
+
+          type_errors = functions_with_symbols
+            .flat_map { validate_type_symbol(it.symbol, registry, entry) }
+
+          task_errors = functions_with_symbols
+            .flat_map { |fn| task_shape_errors(fn, entry) }
+
+          Result
+            .init(node.with(functions: functions_with_symbols), scope)
+            .add_errors(type_errors + task_errors)
+        end
+
+        private
+
+        def task_shape_errors(fn, entry)
+          unless task_type?(fn.symbol.return_type)
+            Error::NonTaskPort
+              .new(entry.name, fn.range, fn_name: fn.name)
+              .then { return [it] }
+          end
+
+          fn.symbol.return_type => Symbol::TypeApplication(args: [ok_arm, err_arm])
+
+          [ok_arm, err_arm]
+            .any? { contains_task?(it) }
+            .then { it ? [Error::NestedTaskPort.new(entry.name, fn.range, fn_name: fn.name)] : [] }
+        end
+
+        def task_type?(symbol)
+          case symbol
+          in Symbol::TypeApplication(constructor: Symbol::TypeRef['Task', 'Task'])
+            true
+
+          else
+            false
+          end
+        end
+
+        def contains_task?(symbol)
+          case symbol
+          in Symbol::TypeApplication(constructor: Symbol::TypeRef['Task', 'Task'])
+             true
+
+          in Symbol::TypeApplication(args:)
+            args.any? { contains_task?(it) }
+
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,109 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module KeyedCall
+        module Validation
+          extend self
+
+          def errors(node, fields, parent, constructor, registry, entry)
+            duplicate_field_errors(fields, entry) +
+              kwargs_callee_errors(node, parent, entry) +
+              field_set_errors(node, fields, parent, constructor, registry, entry)
+          end
+
+          def expected_field_keys(parent, constructor, registry)
+            case parent
+            in Symbol::Struct then struct_record_keys(parent, registry)
+            in Symbol::Union  then variant_record_keys(constructor)
+            else []
+            end
+          end
+
+          private
+
+          def duplicate_field_errors(fields, entry)
+            fields
+              .group_by(&:key)
+              .filter_map do |key, group|
+                next if group.size < 2
+
+                Error::DuplicateField.new(
+                  entry.name,
+                  group.last.range,
+                  field: key,
+                )
+              end
+          end
+
+          def kwargs_callee_errors(node, parent, entry)
+            case parent
+            in Symbol::Struct | Symbol::Union
+              []
+            else
+              [Error::KwargsOnNonConstructor.new(entry.name, node.range)]
+            end
+          end
+
+          def field_set_errors(node, fields, parent, constructor, registry, entry)
+            parent in Symbol::Struct | Symbol::Union or return []
+
+            expected = expected_field_keys(parent, constructor, registry)
+            provided = fields.map(&:key)
+            type_name = constructor_type_name(parent, constructor)
+
+            unknown = (provided - expected).map do |key|
+              Error::UnknownField.new(
+                entry.name,
+                fields.find { it.key == key }.range,
+                type_name:,
+                field: key,
+                expected:,
+              )
+            end
+
+            (expected - provided)
+              .then do |missing|
+                if missing.empty?
+                  []
+                else
+                  Error::MissingField
+                    .new(
+                      entry.name,
+                      node.range,
+                      type_name:,
+                      fields: missing,
+                    )
+                    .then { [it] }
+                end
+              end
+              .then { unknown + it }
+          end
+
+          def struct_record_keys(struct_sym, registry)
+            case struct_sym.record_type
+            in Symbol::RecordType(fields:)
+              fields.keys
+
+            in Symbol::TypeRef => ref
+              struct_record_keys(registry.lookup(ref), registry)
+            end
+          end
+
+          def variant_record_keys(constructor)
+            case constructor.args
+            in [Symbol::RecordType(fields:)] then fields.keys
+            else []
+            end
+          end
+
+          def constructor_type_name(parent, constructor)
+            case parent
+            in Symbol::Struct then parent.name
+            in Symbol::Union  then constructor.name
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      # Lowers `Foo(name: x, age: y)` into a positional FunctionCall:
+      #   - struct constructor: FunctionCall(Foo, [x, y]) ordered by struct fields
+      #   - keyed variant:      FunctionCall(V, [{a: x, b: y}]) anon record arg
+      module KeyedCall
+        extend self
+        extend Helper
+
+        def analyze(node, registry, scope, entry)
+          node => AST::KeyedCall(callee:, fields:)
+
+          callee_r = analyze_node(callee, registry, scope, entry)
+          callee_resolved = callee_r.node
+          constructor = constructor_symbol(callee_resolved, registry)
+          parent = constructor && registry.lookup(constructor.parent)
+
+          fields_r = analyze_in_parallel(fields, registry, scope, entry)
+          fields_resolved = fields_r.node
+
+          validation_errors = Validation.errors(
+            node, fields_resolved, parent, constructor, registry, entry,
+          )
+
+          lowered = lower(node, callee_resolved, fields_resolved, parent, constructor, registry)
+
+          Result[
+            lowered,
+            callee_r.errors + fields_r.errors + validation_errors,
+            scope,
+          ]
+        end
+
+        private
+
+        def lower(node, callee, fields, parent, constructor, registry)
+          case parent
+          in Symbol::Struct
+            Validation
+              .expected_field_keys(parent, constructor, registry)
+              .then { positional_struct_call(node, callee, fields, it) }
+
+          in Symbol::Union
+            variant_call(node, callee, fields)
+
+          else
+            node.with(callee:, fields:)
+          end
+        end
+
+        def positional_struct_call(node, callee, fields, struct_keys)
+          fields
+            .to_h { [it.key, it.value] }
+            .then { |fields_by_key| struct_keys.map { fields_by_key[it] }.compact }
+            .then do
+              AST::FunctionCall.new(
+                callee:,
+                args: it,
+                infix: false,
+                dictionaries: [],
+                range: node.range,
+              )
+            end
+        end
+
+        def variant_call(node, callee, fields)
+          AST::FunctionCall.new(
+            callee:,
+            args: [AST::RecordLiteral.new(fields:, range: node.range)],
+            infix: false,
+            dictionaries: [],
+            range: node.range,
+          )
+        end
+
+        def constructor_symbol(callee, registry)
+          callee in AST::ConstructorReference or return nil
+
+          case registry.lookup(callee.symbol)
+          in Symbol::Constructor => constructor then constructor
+          else nil
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module Lambda
+        extend self
+        extend Helper
+
+        def analyze(node, registry, scope, entry)
+          node => AST::Lambda(params:, body:)
+
+          params_r = analyze_in_sequence(params, registry, scope, entry)
+
+          Result
+            .combine(node, scope:,
+              params: params_r,
+              body: analyze_node(body, registry, params_r.scope, entry),
+            )
+            .map_node { it.with(symbol: Symbol::Lambda[params.size]) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module List
+        extend self
+        extend Helper
+
+        def analyze(node, registry, scope, entry)
+          node => AST::List(items:)
+
+          analyze_in_parallel(items, registry, scope, entry)
+            .map_node { node.with(items: it, symbol: Symbol::TypeRef['List', 'List']) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module Literal
+        extend self
+        extend Helper
+
+        def analyze(node, _registry, scope, _entry)
+          node => AST::Literal(value:)
+
+          symbol = case value
+          in Integer then Symbol::TypeRef['Basics', 'Int']
+          in TrueClass | FalseClass then Symbol::TypeRef['Basics', 'Bool']
+          in String then Symbol::TypeRef['String', 'String']
+          in Float then Symbol::TypeRef['Basics', 'Float']
+          end
+
+          Result.init(node.with(symbol:), scope)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      # Lowers a MemberAccess chain into either a QualifiedAccess
+      # (when the prefix resolves to an imported module alias) or a
+      # RecordAccess (when it's field access on a value expression).
+      module MemberAccess
+        extend self
+        extend Helper
+
+        def analyze(node, registry, scope, entry)
+          node => AST::MemberAccess(target:)
+
+          qualified_names = collect_qualified_names(node)
+
+          if qualified_names
+            *path, access = qualified_names
+
+            case resolve_qualified_access(path, node, registry, entry)
+            in Ok(symbol)
+              new_node = AST::QualifiedAccess[*node.deconstruct].with(symbol:)
+              Result[new_node, [], scope]
+
+            in Err(error)
+              Result[node, [error], scope]
+            end
+
+          else
+            target_r = analyze_node(target, registry, scope, entry)
+            new_node = AST::RecordAccess[*node.with(target: target_r.node).deconstruct]
+            Result[new_node, target_r.errors, scope]
+          end
+        end
+
+        private
+
+        def collect_qualified_names(node)
+          case node
+          in AST::ConstructorReference
+            [node.name]
+
+          in AST::MemberAccess
+            names = collect_qualified_names(node.target)
+            names ? names + [node.name.name] : nil
+
+          else
+            nil
+          end
+        end
+
+        def resolve_qualified_access(path, node, registry, entry)
+          node => AST::MemberAccess(name:, target:)
+
+          module_name = path.join('.')
+          import = entry
+            .imports
+            .find { it.alias == module_name }
+
+          if import.nil?
+            Error::ModuleNotFound
+              .new(entry.name, node.target.range, name: import)
+
+          else
+            case registry.get(import.module_name).exposed_value(name.name)
+            in nil
+              Error::ValueNotExposed
+                .new(entry.name, name.range, module_name:, name: name.name)
+
+            in symbol
+              return Ok[symbol]
+            end
+          end
+            .then do
+              Error::VariableNotFound
+                .new(
+                  entry.name,
+                  node.range,
+                  name: [module_name, name.name].join('.'),
+                  causes: [it],
+                )
+            end
+            .then { Err[it] }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module ModuleNode
+        extend self
+        extend Helper
+
+        def analyze(node, registry, scope, entry)
+          node => AST::Module(body:, exposing:)
+
+          exposing_errors = case exposing
+          in AST::ExposeNone
+            [Error::MissingExposingClause.new(entry.name, 0..0)]
+          else
+            []
+          end
+
+          Result
+            .combine(node, scope:,
+              body: analyze_node(body, registry, scope, entry),
+            )
+            .add_errors(exposing_errors)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module PatternBinding
+        extend self
+        extend Helper
+
+        def analyze(node, _registry, scope, entry)
+          node => AST::Pattern::Binding(name:)
+
+          predicate_errors =
+            if name.end_with?('?')
+              [Error::PredicateNameNotAllowed.new(entry.name, node.range, name:)]
+            else
+              []
+            end
+
+          bind_r = bind(scope, Symbol.var(name, node.range), entry)
+
+          Result
+            .init(node, bind_r.scope)
+            .add_errors(bind_r.errors + predicate_errors)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module PatternConstructor
+        extend self
+        extend Helper
+
+        def analyze(node, registry, scope, entry)
+          node => AST::Pattern::Constructor(constructor:, patterns:)
+
+          constructor_r = analyze_node(constructor, registry, scope, entry)
+          symbol_ref = constructor_r.node.symbol&.to_ref
+
+          if symbol_ref.nil?
+            return Result.combine(node, scope:, constructor: constructor_r)
+          end
+
+          arity_errors = arity_mismatch_errors(
+            registry.lookup(symbol_ref), patterns, constructor, node.range, entry,
+          )
+          patterns_r = analyze_in_sequence(patterns, registry, scope, entry)
+
+          Result
+            .combine(node, scope: patterns_r.scope,
+              constructor: constructor_r,
+              patterns: patterns_r,
+            )
+            .map_node { it.with(symbol: symbol_ref) }
+            .add_errors(arity_errors)
+        end
+
+        private
+
+        def arity_mismatch_errors(symbol, patterns, constructor, range, entry)
+          return [] if symbol.args.size == patterns.size
+
+          [Error::ConstructorPatternArityMismatch.new(
+            entry.name, range,
+            constructor:,
+            expected_arity: symbol.args.size,
+            actual_arity: patterns.size,
+          )]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module PatternList
+        extend self
+        extend Helper
+
+        def analyze(node, registry, scope, entry)
+          node => AST::Pattern::List(patterns:, rest:)
+
+          patterns_r = analyze_in_sequence(patterns, registry, scope, entry)
+
+          rest_scope, rest_errors =
+            case rest
+            in AST::Pattern::Binding(name:)
+              bind_r = bind(patterns_r.scope, Symbol.var(name, node.range), entry)
+              [bind_r.scope, bind_r.errors]
+
+            in AST::Pattern::Wildcard | nil
+              [patterns_r.scope, []]
+
+            else
+              [patterns_r.scope, [Error::InvalidListRestPattern.new(entry.name, rest.range)]]
+            end
+
+          Result
+            .combine(node, scope: rest_scope, patterns: patterns_r)
+            .add_errors(rest_errors)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module PatternLiteral
+        extend self
+        extend Helper
+
+        def analyze(node, registry, scope, entry)
+          node => AST::Pattern::Literal(literal:)
+
+          analyze_node(literal, registry, scope, entry)
+            .then { Result.combine(node, scope:, literal: it) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module PatternRecord
+        extend self
+        extend Helper
+
+        def analyze(node, registry, scope, entry)
+          node => AST::Pattern::Record(fields:)
+
+          symbol = Symbol
+            .anonymous_record(fields.map(&:name), Symbol.var('a', nil))
+
+          patterns_r = analyze_in_sequence(fields.map(&:pattern), registry, scope, entry)
+
+          fields
+            .zip(patterns_r.node)
+            .map { |f, p| f.with(pattern: p) }
+            .then { node.with(fields: it, symbol:) }
+            .then { Result[it, patterns_r.errors, patterns_r.scope] }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module PatternWildcard
+        extend self
+        extend Helper
+
+        def analyze(node, _registry, scope, _entry)
+          Result.init(node, scope)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module QualifiedAccess
+        extend self
+        extend Helper
+
+        def analyze(node, _registry, scope, _entry)
+          Result.init(node, scope)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module RecordAccess
+        extend self
+        extend Helper
+
+        def analyze(node, _registry, scope, _entry)
+          Result.init(node, scope)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module RecordField
+        extend self
+        extend Helper
+
+        def analyze(node, registry, scope, entry)
+          node => AST::RecordField(value:)
+
+          analyze_node(value, registry, scope, entry)
+            .then { Result.combine(node, scope:, value: it) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module RecordLiteral
+        extend self
+        extend Helper
+
+        def analyze(node, registry, scope, entry)
+          node => AST::RecordLiteral(fields:)
+
+          Result
+            .combine(node, scope:,
+              fields: analyze_in_parallel(fields, registry, scope, entry),
+            )
+            .map_node { it.with(symbol: Symbol.anonymous_record(fields.map(&:key))) }
+            .add_errors(analyze_duplicate_fields(fields, entry))
+        end
+      end
+    end
+  end
+end