jade-lang 0.1.0

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

@@ -0,0 +1,14 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module CharLiteral
+        extend self
+        extend Helper
+
+        def analyze(node, _registry, scope, _entry)
+          Result.init(node.with(symbol: Symbol::TypeRef['Char', 'Char']), scope)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module ConstructorReference
+        extend self
+        extend Helper
+
+        def analyze(node, registry, scope, entry)
+          node => AST::ConstructorReference(name:)
+
+          symbol = scope.lookup(name) || resolve_private_constructor(name, registry)
+
+          case symbol
+          in nil
+            (tuple_arity_overflow(name, entry, node.range) ||
+              Error::ConstructorNotFound.new(
+                entry.name,
+                node.range,
+                name:,
+                exposed_type_module: exposed_type_origin(name, entry, registry),
+                candidates: scope.bindings.keys.select { it.match?(/\A[A-Z]/) },
+              ))
+              .then do
+                Result
+                  .init(node, scope)
+                  .add_errors([it])
+              end
+
+          in symbol
+            Result.init(node.with(symbol: symbol.to_ref), scope)
+          end
+        end
+
+        private
+
+        def resolve_private_constructor(name, registry)
+          if Stdlib.private_constructor?(name)
+            registry.lookup(Symbol::ValueRef.new(*name.split('.')))
+          end
+        end
+
+        def tuple_arity_overflow(name, entry, span)
+          klass = ForwardDeclaration::Error::TupleArityOverflow
+
+          name
+            .match(/^Tuple\.Tuple(?<arity>\d+)$/)
+            &.then { it[:arity].to_i }
+            &.then { it > klass::MAX_ARITY ? it : nil }
+            &.then { klass.new(entry.name, span, arity: it) }
+        end
+
+        def exposed_type_origin(name, entry, registry)
+          type_ref = entry.imported_types[name]
+          return nil unless type_ref
+
+          target_entry = registry.get(type_ref.module_name)
+          return nil if target_entry.nil? || Stdlib.is_stdlib?(target_entry)
+
+          type_ref.module_name
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module Error
+        class CircularExtends < Jade::Error
+          def initialize(entry, span, interface:, type:)
+            super(entry:, span:)
+            @interface = interface
+            @type      = type
+          end
+
+          def message
+            "circular extends detected: #{@interface} for #{@type} is part of a cycle"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module Error
+        class ConstantNotCallable < Jade::Error
+          def initialize(entry, span, name:)
+            @name = name
+            super(entry:, span:)
+          end
+
+          attr_reader :name
+
+          def message
+            "`#{name}` is a value, not a function — write `#{name}`, not `#{name}()`"
+          end
+
+          def label
+            "not callable"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module Error
+        class ConstructorNotFound < Jade::Error
+          attr_reader :candidates
+
+          def initialize(entry, span, name:, exposed_type_module: nil, candidates: [])
+            @name = name
+            @exposed_type_module = exposed_type_module
+            @candidates = candidates
+            super(entry:, span:)
+          end
+
+          def message
+            base = "I cannot find a `#{@name}` constructor"
+            return base unless @exposed_type_module
+
+            "#{base}. The type `#{@name}` is exposed by `#{@exposed_type_module}` but its " \
+              "constructor is private — add `#{@name}(..)` to that module's `exposing` list."
+          end
+
+          def label
+            "not found"
+          end
+
+          def queried_name
+            @name
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module Error
+        class ConstructorPatternArityMismatch < Jade::Error
+          def initialize(entry, span, constructor:, expected_arity:, actual_arity:)
+            super(entry:, span:)
+            @constructor = constructor
+            @expected_arity = expected_arity
+            @actual_arity = actual_arity
+          end
+
+          def message
+            "Arity mismatch, #{@constructor} expects #{@expected_arity} patterns but found #{@actual_arity}"
+          end
+
+          def label
+            "expected #{@expected_arity} pattern#{@expected_arity > 1 ? 's' : ''}, got #{@actual_arity}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module Error
+        class DuplicateField < Jade::Error
+          def initialize(entry, span, field:)
+            @field = field
+            super(entry:, span:)
+          end
+
+          def message
+            "Field `#{@field}:` was given more than once"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module Error
+        class DuplicateFunctionDeclaration < Jade::Error
+          attr_reader :duplicate_spans
+
+          def initialize(entry, span, name, duplicate_spans:)
+            @name = name
+            @duplicate_spans = duplicate_spans
+            super(entry:, span:)
+          end
+
+          def message
+            "Duplicate function definition `#{@name}` (#{duplicate_spans.size + 1} declarations)"
+          end
+
+          def label
+            "already defined"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module Error
+        class DuplicateRecordField < Jade::Error
+          def initialize(entry, span, field_name:, duplicate_spans:)
+            super(entry:, span:)
+            @field_name = field_name
+            @duplicate_spans = duplicate_spans
+          end
+
+          def message
+            "This record has multipe `#{field_name}` fields"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module Error
+        class InvalidListRestPattern < Jade::Error
+          def initialize(entry, span)
+            super(entry:, span:)
+          end
+
+          def message
+            "List rest pattern must be a name (e.g. `xs`) or wildcard (`_`)"
+          end
+
+          def label
+            "invalid rest pattern"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module Error
+        class KwargsOnNonConstructor < Jade::Error
+          def initialize(entry, span)
+            super(entry:, span:)
+          end
+
+          def message
+            "Keyword-argument syntax is only valid for struct or variant constructors"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module Error
+        class MissingExposingClause < Jade::Error
+          def initialize(entry, span)
+            super(entry:, span:)
+          end
+
+          def message
+            "This module is missing an exposing clause"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module Error
+        class MissingExtendsImplementation < Jade::Error
+          def initialize(entry, span, interface:, type:, required_by:)
+            super(entry:, span:)
+            @interface   = interface
+            @type        = type
+            @required_by = required_by
+          end
+
+          def message
+            "implements #{@required_by} extends #{@interface}: " \
+              "#{@interface} is not implemented for #{@type}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module Error
+        class MissingField < Jade::Error
+          def initialize(entry, span, type_name:, fields:)
+            @type_name = type_name
+            @fields = fields
+            super(entry:, span:)
+          end
+
+          def message
+            list = @fields.map { "`#{it}:`" }.join(', ')
+            "`#{@type_name}` is missing #{@fields.size == 1 ? 'field' : 'fields'} #{list}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module Error
+        class MissingImplementationFunction < Jade::Error
+          def initialize(entry, span, interface:, fn_name:)
+            super(entry:, span:)
+            @interface = interface
+            @fn_name   = fn_name
+          end
+
+          def message
+            "Implementation of #{@interface} is missing required function `#{@fn_name}`"
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,19 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module Error
+        class NestedTaskPort < Jade::Error
+          def initialize(entry, span, fn_name:)
+            super(entry:, span:)
+            @fn_name = fn_name
+          end
+
+          def message
+            "Port `#{@fn_name}` declares a Task whose Ok or Err arm is itself a Task; " \
+              "tasks must not return tasks — compose with map/and_then/sequence in Jade instead"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module Error
+        class NonTaskPort < Jade::Error
+          def initialize(entry, span, fn_name:)
+            super(entry:, span:)
+            @fn_name = fn_name
+          end
+
+          def message
+            "Port `#{@fn_name}` must return a Task type, e.g. `#{@fn_name}: Task(Ok, Err)`"
+          end
+
+          def label
+            "must return a Task"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module Error
+        class OrphanImplementation < Jade::Error
+          def initialize(entry, span, interface:, type:)
+            super(entry:, span:)
+            @interface = interface
+            @type      = type
+          end
+
+          def message
+            "Cannot implement #{@interface} for #{@type} here: " \
+              "only the owner of the interface or the type can add implementations"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module Error
+        class PredicateMustReturnBool < Jade::Error
+          def initialize(entry, span, fn_name:)
+            super(entry:, span:)
+            @fn_name = fn_name
+          end
+
+          def message
+            "`#{@fn_name}` ends in `?` so it must return `Bool`."
+          end
+
+          def label
+            "expected `Bool` return"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module Error
+        # Names ending in `?` are reserved for function declarations. Using
+        # the `?` suffix on a variable, parameter, or destructured binding
+        # would let a non-Bool value shadow the predicate convention.
+        class PredicateNameNotAllowed < Jade::Error
+          def initialize(entry, span, name:)
+            super(entry:, span:)
+            @name = name
+          end
+
+          def message
+            "`#{@name}` ends in `?` but only function names may use that suffix."
+          end
+
+          def label
+            "`?` only on function names"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module Error
+        class ShadowingError < Jade::Error
+          def initialize(entry, span, name:)
+            super(entry:, span:)
+            @name = name
+          end
+
+          def message
+            "Variable #{@name} shadows existing variable"
+          end
+
+          def label
+            "shadows existing variable"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module Error
+        class TypeArgsMismatch < Jade::Error
+          def initialize(entry, span, type_name:, expected:, actual:)
+            super(entry:, span:)
+            @type_name = type_name
+            @expected = expected
+            @actual = actual
+          end
+
+          def message
+            "`#{@type_name}` type needs #{@expected}" +
+              " argument#{@expected > 1 ? 's' : ''} but got #{@actual}"
+          end
+
+          def label
+            "expected #{@expected} argument#{@expected > 1 ? 's' : ''}, got #{@actual}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module Error
+        class TypeParamRequired < Jade::Error
+          def initialize(entry, span, interface:, type:)
+            super(entry:, span:)
+            @interface = interface
+            @type      = type
+          end
+
+          def message
+            "#{@type} cannot implement #{@interface}: the type needs at least one type parameter"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module Error
+        class UnboundTypeVariable < Jade::Error
+          def initialize(entry, span, type_name:, variables:)
+            super(entry:, span:)
+            @type_name = type_name
+            @variables = variables
+          end
+
+          def message
+            @variables
+              .map { "`#{it}`" }
+              .join(', ')
+              .then { "Type `#{@type_name}` has unbound variables #{it}" }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module Error
+        class UndefinedVariable < Jade::Error
+          attr_reader :candidates
+
+          def initialize(entry, span, var_ref:, candidates: [])
+            super(entry:, span:)
+            @var_ref = var_ref
+            @candidates = candidates
+          end
+
+          def message
+            "Undefined variable #{@var_ref}"
+          end
+
+          def label
+            "undefined"
+          end
+
+          def queried_name
+            @var_ref
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module Error
+        class UnknownField < Jade::Error
+          def initialize(entry, span, type_name:, field:, expected:)
+            @type_name = type_name
+            @field = field
+            @expected = expected
+            super(entry:, span:)
+          end
+
+          def message
+            "`#{@type_name}` has no field `#{@field}` (has: #{@expected.map { "`#{it}`" }.join(', ')})"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module Error
+        class UnknownImplementationFunction < Jade::Error
+          def initialize(entry, span, interface:, fn_name:)
+            super(entry:, span:)
+            @interface = interface
+            @fn_name   = fn_name
+          end
+
+          def message
+            "`#{@fn_name}` is not a function of interface #{@interface}"
+          end
+        end
+      end
+    end
+  end
+end