jade-lang 0.1.0

data/lib/jade/frontend/semantic_analysis/error/unused_interface_type_param.rb

@@ -0,0 +1,24 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module Error
+        class UnusedInterfaceTypeParam < Jade::Error
+          def initialize(entry, span, interface:, type_param:)
+            super(entry:, span:)
+            @interface  = interface
+            @type_param = type_param
+          end
+
+          def message
+            "Interface `#{@interface}` declares type parameter `#{@type_param}` " \
+              "but no function uses it: there is nothing to dispatch on"
+          end
+
+          def label
+            "unused type parameter `#{@type_param}`"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/semantic_analysis/error/value_not_exposed.rb

@@ -0,0 +1,23 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module Error
+        class ValueNotExposed < Jade::Error
+          def initialize(entry, span, name:, module_name:)
+            @name = name
+            @module_name = module_name
+            super(entry:, span:)
+          end
+
+          def message
+            "#{@module_name} does not a expose `#{@name}`"
+          end
+
+          def label
+            "not exposed by #{@module_name}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/semantic_analysis/error/variable_not_found.rb

@@ -0,0 +1,25 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module Error
+        class VariableNotFound < Jade::Error
+          attr_reader :causes
+
+          def initialize(entry, span, name:, causes: [])
+            @name = name
+            @causes = causes
+            super(entry:, span:)
+          end
+
+          def message
+            "I cannot find a `#{@name}` variable"
+          end
+
+          def label
+            "not found"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+require 'jade/error'
+
+require 'jade/frontend/semantic_analysis/error/circular_extends'
+require 'jade/frontend/semantic_analysis/error/constant_not_callable'
+require 'jade/frontend/semantic_analysis/error/constructor_not_found'
+require 'jade/frontend/semantic_analysis/error/constructor_pattern_arity_mismatch'
+require 'jade/frontend/semantic_analysis/error/duplicate_field'
+require 'jade/frontend/semantic_analysis/error/duplicate_function_declaration'
+require 'jade/frontend/semantic_analysis/error/duplicate_record_field'
+require 'jade/frontend/semantic_analysis/error/invalid_list_rest_pattern'
+require 'jade/frontend/semantic_analysis/error/kwargs_on_non_constructor'
+require 'jade/frontend/semantic_analysis/error/missing_exposing_clause'
+require 'jade/frontend/semantic_analysis/error/missing_extends_implementation'
+require 'jade/frontend/semantic_analysis/error/missing_field'
+require 'jade/frontend/semantic_analysis/error/missing_implementation_function'
+require 'jade/frontend/semantic_analysis/error/module_not_found'
+require 'jade/frontend/semantic_analysis/error/nested_task_port'
+require 'jade/frontend/semantic_analysis/error/non_task_port'
+require 'jade/frontend/semantic_analysis/error/orphan_implementation'
+require 'jade/frontend/semantic_analysis/error/predicate_must_return_bool'
+require 'jade/frontend/semantic_analysis/error/predicate_name_not_allowed'
+require 'jade/frontend/semantic_analysis/error/shadowing_error'
+require 'jade/frontend/semantic_analysis/error/type_args_mismatch'
+require 'jade/frontend/semantic_analysis/error/type_param_required'
+require 'jade/frontend/semantic_analysis/error/unbound_type_variable'
+require 'jade/frontend/semantic_analysis/error/undefined_variable'
+require 'jade/frontend/semantic_analysis/error/unknown_field'
+require 'jade/frontend/semantic_analysis/error/unknown_implementation_function'
+require 'jade/frontend/semantic_analysis/error/unused_interface_type_param'
+require 'jade/frontend/semantic_analysis/error/value_not_exposed'
+require 'jade/frontend/semantic_analysis/error/variable_not_found'
+
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module Error
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module FunctionCall
+        extend self
+        extend Helper
+
+        def analyze(node, registry, scope, entry)
+          node => AST::FunctionCall(callee:, args:)
+
+          callee_r = analyze_node(callee, registry, scope, entry)
+          args_r = analyze_in_parallel(args, registry, scope, entry)
+
+          Result
+            .combine(node, scope:, callee: callee_r, args: args_r)
+            .add_errors(
+              calling_a_constant?(callee_r.node, args_r.node, registry) ?
+                [constant_not_callable(callee_r.node, entry)] :
+                [],
+            )
+        end
+
+        private
+
+        def calling_a_constant?(callee, args, registry)
+          return false unless args.empty?
+
+          case callee_symbol(callee, registry)
+          in Symbol::Function | Symbol::StdlibFunction => fn then fn.constant?
+          in Symbol::Constructor(args: []) then true
+          else false
+          end
+        end
+
+        def callee_symbol(callee, registry)
+          case callee.symbol
+          in Symbol::ValueRef => ref then registry.lookup(ref)
+          in symbol then symbol
+          end
+        end
+
+        def constant_not_callable(callee, entry)
+          Error::ConstantNotCallable.new(
+            entry.name,
+            callee.range,
+            name: callee_display_name(callee),
+          )
+        end
+
+        def callee_display_name(callee)
+          case callee
+          in AST::VariableReference(name:) then name
+          in AST::ConstructorReference(name:) then name
+          in AST::QualifiedAccess(target:, name:) then "#{target.name}.#{name.name}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module FunctionDeclaration
+        extend self
+        extend Helper
+
+        def analyze(node, registry, scope, entry)
+          node => AST::FunctionDeclaration(name:, body:, params:, return_type:)
+
+          symbol_ref = entry.lookup_value(name).to_ref
+
+          params_r = params.reduce(Result[nil, [], scope]) do |acc, param|
+            bind(acc.scope, Symbol.var(param.name, param.range), entry)
+              .add_errors(acc.errors)
+          end
+
+          Result
+            .combine(node, scope:,
+              body: analyze_node(body, registry, params_r.scope, entry),
+            )
+            .map_node { it.with(symbol: symbol_ref) }
+            .add_errors(params_r.errors)
+            .add_errors(validate_type_symbol(symbol_ref, registry, entry))
+            .add_errors(validate_predicate_return(name, return_type, symbol_ref, registry, entry))
+            .add_errors(params.flat_map { validate_no_predicate_param(it, entry) })
+        end
+
+        # `?` suffix is reserved for function declaration names. Forbid
+        # it on parameters so `def f(empty?: Bool) -> Bool` doesn't bind
+        # `empty?` as a value.
+        def validate_no_predicate_param(param, entry)
+          return [] unless param.name.end_with?('?')
+
+          [Error::PredicateNameNotAllowed.new(entry.name, param.range, name: param.name)]
+        end
+
+        # `?`-suffixed function names must declare a `Bool` return type.
+        # Catches `def empty? -> Int` at semantic analysis.
+        def validate_predicate_return(name, return_type_ast, symbol, registry, entry)
+          return [] unless name.end_with?('?')
+
+          case registry.lookup(symbol).return_type
+          in Symbol::TypeRef['Basics', 'Bool'] |
+             Symbol::TypeApplication(constructor: Symbol::TypeRef['Basics', 'Bool'], args: [])
+            []
+          else
+            [Error::PredicateMustReturnBool.new(
+              entry.name,
+              return_type_ast.range,
+              fn_name: name,
+            )]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module Grouping
+        extend self
+        extend Helper
+
+        def analyze(node, registry, scope, entry)
+          node => AST::Grouping(expression:)
+
+          analyze_node(expression, registry, scope, entry)
+            .map_node { node.with(expression: it) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,152 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module Helper
+        def analyze_node(node, registry, scope, entry)
+          SemanticAnalysis.send(:analyze_node, node, registry, scope, entry)
+        end
+
+        def bind(scope, symbol, entry)
+          name = symbol.name
+          if scope.lookup(name)
+            Error::ShadowingError
+              .new(entry.name, symbol.decl_span, name:)
+              .then { Result[nil, [it], scope] }
+
+          else
+            Result[nil, [], scope.bind(name, symbol)]
+          end
+        end
+
+        def lookup(scope, name, entry, span)
+          if (decl = scope.lookup(name))
+            Result[decl, [], scope]
+
+          else
+            Error::UndefinedVariable
+              .new(entry.name, span, var_ref: name)
+              .then { Result[nil, [it], scope] }
+          end
+        end
+
+        # Threaded: child N analyzed with the scope produced by child N-1;
+        # the returned scope is the last child's. Use when later siblings
+        # depend on bindings introduced by earlier ones — body statements,
+        # lambda/function params, sequential pattern bindings.
+        def analyze_in_sequence(nodes, registry, scope, entry)
+          nodes.reduce(Result[[], [], scope]) do |acc, node|
+            r = analyze_node(node, registry, acc.scope, entry)
+            Result[acc.node + [r.node], acc.errors + r.errors, r.scope]
+          end
+        end
+
+        # Independent: every child analyzed with the input scope; the
+        # returned scope is the input scope (no bindings leak). Use when
+        # children don't see each other — record fields, list items,
+        # function-call args, if/case branches.
+        def analyze_in_parallel(nodes, registry, scope, entry)
+          results = nodes.map { analyze_node(it, registry, scope, entry) }
+          Result[results.map(&:node), results.flat_map(&:errors), scope]
+        end
+
+        def analyze_duplicate_fields(fields, entry)
+          fields
+            .group_by(&:key)
+            .select { |_, v| v.size > 1 }
+            .map do |k, v|
+              first, *rest = v
+              Error::DuplicateRecordField
+                .new(entry.name, first.range, field_name: k, duplicate_spans: rest.map(&:range))
+            end
+        end
+
+        def collect_vars(symbol, registry)
+          case symbol
+          in Symbol::TypeRef | Symbol::ValueRef
+            registry
+              .lookup(symbol)
+              .then { collect_vars(it, registry) }
+
+          in Symbol::Constructor(args:)
+            args
+              .flat_map { collect_vars(it, registry) }
+
+          in Symbol::Variable
+            [symbol]
+
+          in Symbol::TypeApplication | Symbol::PartialApplication
+            symbol
+              .args
+              .flat_map { collect_vars(it, registry) }
+
+          in Symbol::FunctionType | Symbol::InterfaceFunction
+            symbol
+              .params
+              .flat_map { collect_vars(it, registry) } +
+                collect_vars(symbol.return_type, registry)
+
+          in Symbol::RecordType(row_var:)
+            row_var.nil? ? [] : [row_var]
+          end
+        end
+
+        def validate_type_symbol(symbol, registry, entry)
+          case symbol
+          in Symbol::Union(variants:, type_params:)
+            variants.flat_map { validate_type_symbol(it, registry, entry) } +
+              type_params.flat_map { validate_type_symbol(it, registry, entry) }
+
+          in Symbol::Constructor(args:)
+            args.flat_map { validate_type_symbol(it, registry, entry) }
+
+          in Symbol::TypeRef
+            registry.lookup(symbol)
+              .then { validate_type_symbol(it, registry, entry) }
+
+          in Symbol::ValueRef
+            registry.lookup(symbol)
+              .then { validate_type_symbol(it, registry, entry) }
+
+          in Symbol::Variable
+            []
+
+          in Symbol::PartialApplication(constructor:, args:)
+            args.flat_map { validate_type_symbol(it, registry, entry) }
+
+          in Symbol::TypeApplication(constructor:, args:)
+            constructor_symbol = registry.lookup(constructor)
+
+            if constructor_symbol.type_params.size != args.size
+              [Error::TypeArgsMismatch.new(
+                  entry.name,
+                  symbol.span,
+                  type_name: constructor.name,
+                  expected: constructor_symbol.type_params.size,
+                  actual: args.size
+              )]
+            else
+              []
+            end + args.flat_map { validate_type_symbol(it, registry, entry) }
+
+          in Symbol::FunctionType | Symbol::InterfaceFunction | Symbol::InteropFunction
+            validate_type_symbol(symbol.return_type, registry, entry) +
+              symbol.params.flat_map { validate_type_symbol(it, registry, entry) }
+
+          in Symbol::Function(params:, return_type:)
+            validate_type_symbol(return_type, registry, entry) +
+              params.values.flat_map { validate_type_symbol(it, registry, entry) }
+
+          in Symbol::RecordType(fields:)
+            fields.reduce([]) do |acc, (k, v)|
+              acc + validate_type_symbol(v, registry, entry)
+            end
+
+          in Symbol::Struct(type_params:, record_type:)
+            validate_type_symbol(record_type, registry, entry) +
+              type_params.flat_map { validate_type_symbol(it, registry, entry) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module IfThenElse
+        extend self
+        extend Helper
+
+        def analyze(node, registry, scope, entry)
+          node => AST::IfThenElse(condition:, if_branch:, else_branch:)
+
+          Result.combine(node, scope:,
+            condition: analyze_node(condition, registry, scope, entry),
+            if_branch: analyze_node(if_branch, registry, scope, entry),
+            else_branch: analyze_node(else_branch, registry, scope, entry),
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,143 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module Implementation
+        extend self
+        extend Helper
+
+        def analyze(node, registry, scope, entry)
+          node => AST::Implementation(interface:, applied_type:, extends:, functions:)
+
+          interface_ref = entry.lookup_type(interface).to_ref
+          type_sym = lookup_applied_type(applied_type, entry)
+          type_ref = type_sym.to_ref
+
+          impl_symbol = entry.implementations[[
+            interface_ref.qualified_name,
+            type_ref.qualified_name,
+          ]]
+
+          functions_r = analyze_in_parallel(functions, registry, scope, entry)
+
+          make_error = ->(klass, **kw) { klass.new(entry.name, node.range, **kw) }
+          type_is_local = entry.defined_types.key?(local_type_name(applied_type))
+
+          unless entry.defined_types.key?(interface) || type_is_local
+            return make_error
+              .(
+                Error::OrphanImplementation,
+                interface: entry.lookup_type(interface).qname,
+                type:      type_sym.qname,
+              )
+              .then { Result[node, [it], scope] }
+          end
+
+          iface_sym = registry.lookup(interface_ref)
+
+          extends_errors = extends
+            .flat_map do |iface_name|
+              ext_sym = entry.lookup_type(iface_name)
+              next [] if entry.implementations.key?([ext_sym.qname, type_sym.qname])
+
+              [make_error.(
+                Error::MissingExtendsImplementation,
+                interface:   ext_sym.qname,
+                type:        type_sym.qname,
+                required_by: iface_sym.qname,
+              )]
+            end
+
+          cycle_errors =
+            if extends_errors.empty? && cycle_in_extends?(iface_sym.qname, type_sym.qname, entry)
+              [make_error.(Error::CircularExtends, interface: iface_sym.qname, type: type_sym.qname)]
+            else
+              []
+            end
+
+          type_param_errors =
+            case [parameterized_interface?(iface_sym), type_sym]
+            in [true, { type_params: [] }]
+              [make_error.(Error::TypeParamRequired, interface: iface_sym.qname, type: type_sym.qname)]
+            else
+              []
+            end
+
+          Result
+            .combine(node, scope:, functions: functions_r)
+            .map_node { it.with(symbol: impl_symbol) }
+            .add_errors(
+              fn_name_errors(functions, iface_sym, &make_error) +
+                extends_errors + cycle_errors + type_param_errors,
+            )
+        end
+
+        private
+
+        def lookup_applied_type(applied_type, entry)
+          case applied_type.constructor
+          in AST::TypeName(type:)
+            entry.lookup_type(type)
+          in AST::QualifiedTypeName(path:)
+            *module_parts, type_name = path
+            entry.lookup_qualified_type(module_parts.join('.'), type_name)
+          end
+        end
+
+        def local_type_name(applied_type)
+          case applied_type.constructor
+          in AST::TypeName(type:) then type
+          in AST::QualifiedTypeName then nil
+          end
+        end
+
+        def parameterized_interface?(iface_sym)
+          iface_sym.functions.any? { contains_partial_application?(it) }
+        end
+
+        def contains_partial_application?(sym)
+          case sym
+          in Symbol::PartialApplication
+            true
+          in { params:, return_type: }
+            params.any? { contains_partial_application?(it) } || contains_partial_application?(return_type)
+          else
+            false
+          end
+        end
+
+        def fn_name_errors(functions, iface_sym, &make_error)
+          impl_names  = functions.map(&:name).to_set
+          iface_names = iface_sym.functions.map(&:name).to_set
+          unknown     = impl_names.difference(iface_names)
+
+          if unknown.any?
+            unknown.map { make_error.(Error::UnknownImplementationFunction, interface: iface_sym.qname, fn_name: it) }
+          else
+            iface_names
+              .difference(impl_names)
+              .map { make_error.(Error::MissingImplementationFunction, interface: iface_sym.qname, fn_name: it) }
+          end
+        end
+
+        def cycle_in_extends?(interface_qname, type_qname, entry, visited: ::Set.new)
+          key = [interface_qname, type_qname]
+          return true if visited.include?(key)
+
+          impl = entry.implementations[key]
+          return false unless impl&.extends&.any?
+
+          impl
+            .extends
+            .any? do
+              cycle_in_extends?(
+                it.qualified_name,
+                type_qname,
+                entry,
+                visited: visited | [key],
+              )
+            end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module ImplementationFunction
+        extend self
+        extend Helper
+
+        def analyze(node, registry, scope, entry)
+          node => AST::ImplementationFunction(fn:)
+
+          Result.combine(node, scope:, fn: analyze_node(fn, registry, scope, entry))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module ImportDeclaration
+        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/interface_declaration.rb

@@ -0,0 +1,45 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module InterfaceDeclaration
+        extend self
+        extend Helper
+
+        def analyze(node, registry, scope, entry)
+          node => AST::InterfaceDeclaration(name:)
+
+          symbol_ref = entry.lookup_type(name).to_ref
+          interface = registry.lookup(symbol_ref)
+
+          Result
+            .init(node.with(symbol: symbol_ref), scope)
+            .add_errors(
+              interface.functions.flat_map { validate_type_symbol(it, registry, entry) } +
+                validate_type_param_used(interface, registry, entry),
+            )
+        end
+
+        private
+
+        def validate_type_param_used(interface, registry, entry)
+          used_names = interface
+            .functions
+            .flat_map { collect_vars(it, registry) }
+            .map(&:name)
+            .to_set
+
+          return [] if used_names.include?(interface.type_param.name)
+
+          [
+            Error::UnusedInterfaceTypeParam.new(
+              entry.name,
+              interface.decl_span,
+              interface: interface.name,
+              type_param: interface.type_param.name,
+            )
+          ]
+        end
+      end
+    end
+  end
+end