rubocop-boochtek 0.2.0 → 0.2.1

data/lib/stone/ast/type_reference.rb

@@ -0,0 +1,28 @@
+require "stone/ast/expression"
+require "stone/rtti"
+
+
+module Stone
+  class AST
+    class TypeReference < Stone::AST::Expression
+
+      def initialize
+        @name = :type_reference
+      end
+
+      def type(_context = nil)
+        Stone::Type::Type
+      end
+
+      def to_llir(_builder, mod, _scope = Stone::Scope.top_level)
+        # Return pointer to the Type type constant
+        Stone::RTTI.type_constant_for(mod, Stone::Type::Type)
+      end
+
+      def to_s
+        "Type"
+      end
+
+    end
+  end
+end

data/lib/stone/ast/union_type_annotation.rb

@@ -0,0 +1,26 @@
+require "stone/ast"
+
+
+module Stone
+  class AST
+    class UnionTypeAnnotation < Stone::AST
+
+      attr_reader :alternatives
+
+      def initialize(alternatives)
+        @alternatives = alternatives
+        @name = :union_type_annotation
+      end
+
+      def to_s
+        @alternatives.map(&:to_s).join(" | ")
+      end
+
+      def to_type(registry)
+        alternative_types = @alternatives.map { |t| t.to_type(registry) }.compact
+        Stone::Type.union(alternatives: alternative_types)
+      end
+
+    end
+  end
+end

data/lib/stone/ast.rb

@@ -0,0 +1,64 @@
+module Stone
+  class AST
+
+    attr_reader :name, :children
+
+    def initialize(name, children = nil)
+      @name = name
+      @children = children
+    end
+
+    # Helper module for checking if a node represents a record instance
+    module RecordHelpers
+      # Check if a node is a Reference to a record instance
+      module_function def record_instance?(node, mod)
+        node.is_a?(Stone::AST::Reference) && mod.record_instance?(node.identifier)
+      end
+
+    end
+
+    # Shared type resolution logic for AST nodes
+    module TypeResolver
+      module_function def resolve_node_type(node, mod)
+        case node
+        when Stone::AST::Reference then node.type(mod)
+        when Stone::AST::FunctionCall then node.type(mod)
+        when Stone::AST::PropertyAccess then resolve_property_type(node, mod)
+        else node.type
+        end
+      end
+
+      module_function def resolve_property_type(node, mod)
+        receiver_type = resolve_node_type(node.receiver, mod)
+        return nil unless receiver_type
+
+        receiver_type.property_return_type(node.property)
+      end
+    end
+
+    # Shared utilities for working with field annotations
+    module FieldHelpers
+      # Check if an annotation represents a union type
+      module_function def union_annotation?(annotation)
+        annotation.is_a?(Stone::AST::UnionTypeAnnotation)
+      end
+
+      # Resolve a field's annotation to a Stone::Type
+      # Returns nil if the type cannot be resolved
+      module_function def resolve_field_type(field, registry = Stone::Type::Registry)
+        annotation = field[:type]
+        if annotation.respond_to?(:to_type)
+          annotation.to_type(registry)
+        else
+          registry.lookup(field[:type_name] || field[:type])
+        end
+      end
+
+      # Get the string representation of a field's type
+      module_function def field_type_name(field)
+        field[:type_name] || field[:type].to_s
+      end
+    end
+
+  end
+end

data/lib/stone/built_ins.rb

@@ -0,0 +1,245 @@
+require "llvm/core"
+require "stone/types"
+require "stone/rtti"
+
+
+module Stone
+  # Handles registration of built-in constants (including functions and operators).
+  class BuiltIns
+
+    def initialize(mod)
+      @mod = mod
+    end
+
+    def setup
+      setup_rtti
+      define_predefined_constants
+      define_builtin_functions
+      register_builtin_function_types
+    end
+
+    private def setup_rtti
+      Stone::RTTI.new(@mod).setup
+    end
+
+    private def define_predefined_constants
+      define_constant("ZERO", 0)
+      define_constant("ONE", 1)
+    end
+
+    private def define_builtin_functions
+      define_if_function
+      define_sum_function
+      define_comparison_operators
+      define_boolean_operators
+    end
+
+    private def define_constant(name, value)
+      @mod.globals.add(LLVM::Int64, name).tap do |global|
+        global.initializer = LLVM::Int64.from_i(value)
+        global.linkage = :internal
+        global.global_constant = true
+      end
+    end
+
+    private def define_comparison_operators
+      define_comparison("==", :eq)
+      define_comparison("!=", :ne)
+      define_comparison("≠", :ne)
+      define_comparison("<", :slt)
+      define_comparison("<=", :sle)
+      define_comparison("≤", :sle)
+      define_comparison(">", :sgt)
+      define_comparison(">=", :sge)
+      define_comparison("≥", :sge)
+    end
+
+    private def define_comparison(name, predicate)
+      # Define binary comparison function
+      # <(a, b) checks a < b
+      # Chained comparisons like <(a, b, c) are handled inline in FunctionCall#to_llir
+      @mod.functions.add(name, comparison_function_type).tap { |func| build_icmp_body(func, predicate) }
+    end
+
+    private def comparison_function_type
+      @comparison_function_type ||= LLVM::Type.function([LLVM::Int64.type, LLVM::Int64.type], LLVM::Int1.type)
+    end
+
+    private def build_icmp_body(func, predicate)
+      func.basic_blocks.append("entry").build do |builder|
+        result = builder.icmp(predicate, func.params[0], func.params[1], "cmp_result")
+        builder.ret(result)
+      end
+    end
+
+    private def define_boolean_operators
+      define_boolean_binary("and", :and)
+      define_boolean_binary("or", :or)
+      define_boolean_binary("xor", :xor)
+      define_boolean_unary("not", :xor)
+
+      define_boolean_binary("∧", :and)
+      define_boolean_binary("∨", :or)
+      define_boolean_binary("⊻", :xor)
+      define_boolean_unary("¬", :xor)
+
+      # TODO: Overload `==` and `!=` for Bool type once we support function overloading.
+      # Currently these operators only work for Int. For Booleans, use `xor` for XOR/inequality,
+      # or the integer comparison operators will work since TRUE=1 and FALSE=0.
+    end
+
+    private def define_boolean_binary(name, instruction)
+      @mod.functions.add(name, boolean_binary_function_type).tap do |func|
+        build_boolean_binary_body(func, instruction)
+      end
+    end
+
+    private def define_boolean_unary(name, instruction)
+      @mod.functions.add(name, boolean_unary_function_type).tap do |func|
+        build_boolean_unary_body(func, instruction)
+      end
+    end
+
+    private def boolean_binary_function_type
+      @boolean_binary_function_type ||= LLVM::Type.function([LLVM::Int1.type, LLVM::Int1.type], LLVM::Int1.type)
+    end
+
+    private def boolean_unary_function_type
+      @boolean_unary_function_type ||= LLVM::Type.function([LLVM::Int1.type], LLVM::Int1.type)
+    end
+
+    private def build_boolean_binary_body(func, instruction)
+      func.basic_blocks.append("entry").build do |builder|
+        result = builder.send(instruction, func.params[0], func.params[1], "bool_result") # rubocop:disable Style/Send
+        builder.ret(result)
+      end
+    end
+
+    private def build_boolean_unary_body(func, instruction)
+      func.basic_blocks.append("entry").build do |builder|
+        # NOT is implemented as XOR with TRUE (i.e., not(a) = a xor TRUE)
+        # The instruction parameter should always be :xor for unary boolean operations
+        result = builder.send(instruction, func.params[0], LLVM::TRUE, "not_result") # rubocop:disable Style/Send
+        builder.ret(result)
+      end
+    end
+
+    # Define the sum function: sum(i64, i64) -> i64.
+    # Uses LLVM's sadd.with.overflow intrinsic for overflow detection.
+    private def define_sum_function
+      i64 = LLVM::Int64.type
+      function_type = LLVM::Type.function([i64, i64], i64)
+      @mod.functions.add("sum", function_type).tap { |func| build_sum_body(func) }
+    end
+
+    private def build_sum_body(func)
+      func.basic_blocks.append("entry").build do |builder|
+        intrinsic = sadd_with_overflow_intrinsic
+        result = builder.call(intrinsic, func.params[0], func.params[1], "sadd_result")
+        # TODO: Check for overflow (something like `builder.extract_value(result, 0) == 1`) and branch to return a Stone::Type::Error if true.
+        # overflowed = builder.extract_value(result, 1)
+        sum_value = builder.extract_value(result, 0, "sum")
+        builder.ret(sum_value)
+      end
+    end
+
+    private def sadd_with_overflow_intrinsic
+      intrinsic_name = "llvm.sadd.with.overflow.i64"
+      return @mod.functions[intrinsic_name] if @mod.functions[intrinsic_name]
+
+      i64 = LLVM::Int64.type
+      i1 = LLVM::Int1.type
+      result_type = LLVM::Type.struct([i64, i1], false)
+      function_type = LLVM::Type.function([i64, i64], result_type)
+      @mod.functions.add(intrinsic_name, function_type)
+    end
+
+    # Define the if function: if(i1 condition, block* then_block, block* else_block) -> i64.
+    # Takes a boolean condition and two block pointers, executes the appropriate block.
+    private def define_if_function
+      i1 = LLVM::Int1.type
+      i64 = LLVM::Int64.type
+      # Block type: () -> i64
+      block_type = LLVM::Type.function([], i64)
+      block_ptr = LLVM::Type.pointer(block_type)
+      # if takes: (i1 condition, block* then_block, block* else_block) -> i64
+      function_type = LLVM::Type.function([i1, block_ptr, block_ptr], i64)
+      @mod.functions.add("if", function_type).tap { |func| build_if_body(func) }
+    end
+
+    private def build_if_body(func)
+      blocks = create_if_basic_blocks(func)
+      build_if_entry(blocks, func.params[0])
+      then_result = build_if_branch(blocks[:then_bb], blocks[:merge_bb], func.params[1], "then_result")
+      else_result = build_if_branch(blocks[:else_bb], blocks[:merge_bb], func.params[2], "else_result")
+      build_if_merge(blocks, then_result, else_result)
+    end
+
+    private def create_if_basic_blocks(func)
+      {
+        entry_bb: func.basic_blocks.append("entry"),
+        then_bb: func.basic_blocks.append("then"),
+        else_bb: func.basic_blocks.append("else"),
+        merge_bb: func.basic_blocks.append("merge")
+      }
+    end
+
+    private def build_if_entry(blocks, condition)
+      blocks[:entry_bb].build { |builder| builder.cond(condition, blocks[:then_bb], blocks[:else_bb]) }
+    end
+
+    private def build_if_branch(branch_bb, merge_bb, block_ptr, result_name)
+      result = nil
+      branch_bb.build do |builder|
+        result = builder.call2(block_func_type, block_ptr, result_name)
+        builder.br(merge_bb)
+      end
+      result
+    end
+
+    private def build_if_merge(blocks, then_result, else_result)
+      blocks[:merge_bb].build do |builder|
+        phi = builder.phi(LLVM::Int64.type, {blocks[:then_bb] => then_result, blocks[:else_bb] => else_result}, "if_result")
+        builder.ret(phi)
+      end
+    end
+
+    private def block_func_type
+      @block_func_type ||= LLVM::Type.function([], LLVM::Int64.type)
+    end
+
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    private def register_builtin_function_types
+      int = Stone::Type::Int
+      bool = Stone::Type::Bool
+
+      # sum(Int, Int) -> Int
+      Stone::Type::Registry.register_as("sum", Stone::Type.function(param_types: [int, int], return_type: int))
+
+      # if(Bool, Block, Block) -> Int
+      # Note: Block type not yet in type system, so we just record param count conceptually
+      Stone::Type::Registry.register_as("if", Stone::Type.function(param_types: [bool], return_type: int))
+
+      # Boolean operators
+      # and(Bool, Bool) -> Bool
+      Stone::Type::Registry.register_as("and", Stone::Type.function(param_types: [bool, bool], return_type: bool))
+
+      # or(Bool, Bool) -> Bool
+      Stone::Type::Registry.register_as("or", Stone::Type.function(param_types: [bool, bool], return_type: bool))
+
+      # xor(Bool, Bool) -> Bool
+      Stone::Type::Registry.register_as("xor", Stone::Type.function(param_types: [bool, bool], return_type: bool))
+
+      # not(Bool) -> Bool
+      Stone::Type::Registry.register_as("not", Stone::Type.function(param_types: [bool], return_type: bool))
+
+      # Unicode operator aliases
+      Stone::Type::Registry.register_as("∧", Stone::Type.function(param_types: [bool, bool], return_type: bool))
+      Stone::Type::Registry.register_as("∨", Stone::Type.function(param_types: [bool, bool], return_type: bool))
+      Stone::Type::Registry.register_as("⊻", Stone::Type.function(param_types: [bool, bool], return_type: bool))
+      Stone::Type::Registry.register_as("¬", Stone::Type.function(param_types: [bool], return_type: bool))
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+  end
+end

data/lib/stone/error/argument_error.rb

@@ -0,0 +1,7 @@
+require "stone/error"
+
+
+module Stone
+  class ArgumentError < Stone::Error
+  end
+end

data/lib/stone/error/arity_error.rb

@@ -0,0 +1,7 @@
+require "stone/error/argument_error"
+
+
+module Stone
+  class ArityError < Stone::ArgumentError
+  end
+end

data/lib/stone/error/overflow.rb

@@ -0,0 +1,18 @@
+require "stone/error"
+
+
+module Stone
+  class Error
+    class Overflow < Stone::Error
+
+      attr_reader :literal
+
+      def initialize(message = nil, location:, literal:)
+        @literal = literal
+        message ||= "Overflow Error: #{literal} falls outside 64-bit Int range at line #{location.line}, column #{location.column}"
+        super(message, location: location)
+      end
+
+    end
+  end
+end

data/lib/stone/error/property_error.rb

@@ -0,0 +1,7 @@
+require "stone/error"
+
+
+module Stone
+  class PropertyError < Stone::Error
+  end
+end

data/lib/stone/error/reference_error.rb

@@ -0,0 +1,4 @@
+module Stone
+  class ReferenceError < Stone::Error
+  end
+end

data/lib/stone/error/type_error.rb

@@ -0,0 +1,7 @@
+require "stone/error"
+
+
+module Stone
+  class TypeError < Stone::Error
+  end
+end

data/lib/stone/error.rb

@@ -0,0 +1,12 @@
+module Stone
+  class Error < StandardError
+
+    attr_reader :location
+
+    def initialize(message, location: nil)
+      super(message)
+      @location = location
+    end
+
+  end
+end

data/lib/stone/grammar.rb

@@ -0,0 +1,124 @@
+require "grammy/grammar"
+
+
+module Stone
+  class Grammar < Grammy::Grammar
+
+    # Identifier and operator patterns
+    ALPHA_IDENTIFIER = /[a-zA-Z_][a-zA-Z0-9_]*[!?]?/
+    COMPUTED_PROPERTY_ID = /[A-Z][a-zA-Z0-9_]*@[a-zA-Z_][a-zA-Z0-9_]*[!?]?/
+    COMPARISON_OPERATOR = /(==|!=|<=|>=|≠|≤|≥|<|>)/
+    BOOLEAN_OPERATOR = /(∧|∨|⊻|¬)/
+
+    start :program_unit
+
+    # Program structure
+    rule(:program_unit) { statement_list + eof }
+    rule(:statement_list) { list(statement, separated_by: statement_separator, allow_repeated_separator: true) }
+    rule(:statement_separator) { newline | semi }
+    rule(:statement) { (definition | expression | comment) + (ws_no_nl? + comment)[0..1] }
+    rule(:definition) { (computed_property_id | identifier) + ws! + define_op + ws! + expression }
+
+    # Expressions
+    # Expression hierarchy (from lowest to highest precedence):
+    # 1. comparison_operation (lowest - binary/variadic operators)
+    # 2. boolean_operation (binary/variadic boolean operators)
+    # 3. postfix (function_call, property_access)
+    # 4. primary (highest - atoms)
+    #
+    # Comparisons operate on boolean operations, which operate on postfix expressions.
+    # boolean_operation with zero operators is equivalent to postfix_expression.
+    # This allows mixing with parentheses: (5 < 3) ∧ TRUE
+    # Both can chain: 1 < 2 < 3 desugars to <(1, 2, 3)
+    rule(:expression) { type_declaration | comparison_operation | boolean_operation }
+    rule(:type_declaration) { identifier + ws! + str("::") + ws! + type_annotation }
+    rule(:type_annotation) { type_union }
+    rule(:type_union) { type_term + (ws? + str("|") + ws? + type_term)[0..] }
+    rule(:type_term) { type_function | parens(type_annotation) | type_name }
+    rule(:type_function) { type_params + ws? + str("->") + ws? + type_return }
+    rule(:type_params) { parens(comma_separated(type_annotation, allow_trailing: false)) }
+    rule(:type_return) { type_return_union | parens(type_annotation) }
+    rule(:type_return_union) { type_name + (ws? + str("|") + ws? + type_name)[0..] }
+    rule(:type_name) { identifier }
+    rule(:comparison_operation) { boolean_operation + (ws! + comparison_operator + ws! + boolean_operation)[1..] }
+    rule(:boolean_operation) { postfix_expression + (ws! + boolean_operator + ws! + postfix_expression)[0..] }
+    rule(:postfix_expression) { primary + (argument_list | property_accessor)[0..] }
+    rule(:property_accessor) { str(".") + identifier }
+    rule(:primary) { parens(expression) | type_of_expression | record_definition | literal | type_reference | reference | lambda | block }
+    rule(:type_of_expression) { str("Type.of") + parens(expression) }
+    rule(:type_reference) { str("Type") }
+    rule(:argument_list) { parens(comma_separated(argument)) }
+    rule(:argument) { expression }
+    rule(:literal) { literal_null | literal_boolean | literal_string | literal_i64 }
+    rule(:reference) { identifier }
+    rule(:lambda) { lambda_op + parameter_list + ws? + block }
+    rule(:parameter_list) { parens(comma_separated(parameter, allow_trailing: false)) }
+    rule(:parameter) { identifier }
+    rule(:block) { braces(statement_list) }
+    rule(:record_definition) { str("Record") + parens(comma_separated(type_declaration, allow_trailing: false)) }
+
+    # Custom Matchers/Combinators
+    # Match the passed-in matchers/combinators within parentheses, with whitespace allowed.
+    def parens(submatchers)
+      str("(") + ws? + submatchers + ws? + str(")")
+    end
+
+    # Match the passed-in matchers/combinators within curly braces, with whitespace allowed.
+    def braces(submatchers)
+      str("{") + ws? + submatchers + ws? + str("}")
+    end
+
+    # Match a comma-separated list, optionally allowing a trailing comma.
+    def comma_separated(submatchers, allow_trailing: true)
+      list(submatchers, separated_by: str(","), allow_trailing: allow_trailing)
+    end
+
+    # Match a list of matchers/combinators, separated by a specified separator.
+    # - Supports allowing trailing separator (default: true)
+    # - Supports allowing repeated consecutive separators (default: false)
+    # - Supports minimum item count (default: 0)
+    def list(items, separated_by:, allow_trailing: true, allow_repeated_separator: false, min: 0)
+      list_repetition = min.zero? ? [0..] : [min..]
+      items_with_separators = ws? + items + (separated_by + ws? + items)[0..]
+      if allow_trailing
+        trailing_repetition = allow_repeated_separator ? [0..] : [0..1]
+        (items_with_separators + (separated_by + ws?)[*trailing_repetition])[*list_repetition]
+      else
+        items_with_separators[*list_repetition]
+      end
+    end
+
+    # Identifiers
+    terminal(:computed_property_id) { COMPUTED_PROPERTY_ID }
+    terminal(:identifier) { Regexp.union(ALPHA_IDENTIFIER, BOOLEAN_OPERATOR, COMPARISON_OPERATOR) }
+
+    # Operators
+    terminal(:comparison_operator) { COMPARISON_OPERATOR }
+    terminal(:boolean_operator) { BOOLEAN_OPERATOR }
+    terminal(:lambda_op) { "λ" }
+    terminal(:define_op) { ":=" }
+
+    # Literals
+    rule(:literal_null) { str("NULL") }
+    rule(:literal_boolean) { reg(/(TRUE|FALSE)/) }
+    # WARNING: String literal rule must come before comment rule to handle `#` inside strings correctly.
+    rule(:literal_string) { reg(/"(?:[^"\\]|\\.)*"/) }
+    # NOTE: Decimal must be last to avoid consuming `0` from the prefixes.
+    rule(:literal_i64) { literal_i64_binary | literal_i64_octal | literal_i64_hex | literal_i64_decimal }
+    terminal(:literal_i64_decimal) { /[+-]?\d+/ }
+    terminal(:literal_i64_binary) { /[+-]?0b[01]+/ }
+    terminal(:literal_i64_octal) { /[+-]?0o[0-7]+/ }
+    terminal(:literal_i64_hex) { /[+-]?0x[0-9a-fA-F]+/ }
+
+    # Whitespace and separators
+    terminal(:comment) { /#[^\n\r]*/ } # Does **NOT** include trailing EOL.
+    terminal(:newline) { /(\n|\r\n)/ }
+    terminal(:semi) { ";" }
+    terminal(:ws) { /[ \t\n\r]+/ }
+    terminal(:ws_no_nl) { /[ \t]+/ }
+    rule(:ws?) { ws[0..] } # White space is **allowed**.
+    rule(:ws!) { ws[1..] } # White space is **required**.
+    rule(:ws_no_nl?) { ws_no_nl[0..] }
+
+  end
+end

data/lib/stone/libc.rb

@@ -0,0 +1,27 @@
+require "llvm/core"
+
+
+module Stone
+  # Module for declaring C standard library functions in LLVM
+  module LibC
+
+  module_function
+
+    def get_or_declare_strcmp(mod)
+      return mod.functions["strcmp"] if mod.functions["strcmp"]
+
+      # Declare strcmp: i32 strcmp(i8*, i8*)
+      strcmp_type = LLVM::Type.function([LLVM::Type.pointer(LLVM::Int8), LLVM::Type.pointer(LLVM::Int8)], LLVM::Int32)
+      mod.functions.add("strcmp", strcmp_type)
+    end
+
+    def get_or_declare_strlen(mod)
+      return mod.functions["strlen"] if mod.functions["strlen"]
+
+      # Declare strlen: i64 strlen(i8*)
+      strlen_type = LLVM::Type.function([LLVM::Type.pointer(LLVM::Int8)], LLVM::Int64)
+      mod.functions.add("strlen", strlen_type)
+    end
+
+  end
+end

data/lib/stone/prelude.stone

@@ -0,0 +1,11 @@
+# Stone Standard Library Prelude
+# This file is automatically loaded before user code.
+# It defines standard properties for built-in types.
+
+# Boolean properties
+Bool@not := λ(this) { if(this, { FALSE }, { TRUE }) }
+
+# Integer properties
+Int@positive? := λ(this) { this > 0 }
+Int@negative? := λ(this) { this < 0 }
+Int@zero? := λ(this) { this == 0 }