rubocop-boochtek 0.2.0 → 0.2.1

data/lib/stone/ast/block.rb

@@ -0,0 +1,88 @@
+require "stone/ast"
+require "stone/ast/two_phase_processing"
+require "stone/types"
+
+
+module Stone
+  class AST
+    class Block < Stone::AST::Expression
+      include TwoPhaseProcessing
+
+      attr_reader :statements
+
+      class << self
+        attr_accessor :block_count
+      end
+
+      @block_count = 0
+
+      def initialize(statements)
+        @name = :block
+        @statements = statements
+        @block_id = next_block_id
+      end
+
+      def to_llir(_builder, mod, scope = Stone::Scope.top_level)
+        # Check if function already exists (happens if to_llir called multiple times on same block).
+        mod.functions[function_name] || create_function(mod, function_name, function_type, scope)
+      end
+
+      def to_s
+        "{ #{statements.join("\n")} }"
+      end
+
+      def type(context = nil)
+        last_expression = statements.reverse.find { |stmt| stmt.type(context) }
+        last_expression&.type(context)
+      end
+
+      private def next_block_id
+        self.class.block_count += 1
+        self.class.block_count
+      end
+
+      private def function_type
+        # Blocks take no parameters and return an i64.
+        LLVM::Type.function([], I64)
+      end
+
+      private def function_name
+        "__#{function_prefix}_#{@block_id}__"
+      end
+
+      private def function_prefix
+        "block"
+      end
+
+      private def create_function(mod, function_name, function_type, scope)
+        mod.functions.add(function_name, function_type).tap do |func|
+          build_function_body(func, mod, scope)
+        end
+      end
+
+      private def build_function_body(func, mod, scope)
+        func.basic_blocks.append("entry").build do |block_builder|
+          evaluate_body_and_return(block_builder, mod, scope)
+        end
+      end
+
+      # Evaluate all statements in block and return value of last statement.
+      def evaluate_body_and_return(builder, mod, scope)
+        child_scope = scope.child
+        register_type_declarations(child_scope)
+        last_result = compile_statements(builder, mod, child_scope)
+        builder.ret(last_result)
+      end
+
+      private def compile_statements(builder, mod, scope)
+        results = other_statements.map { |stmt| stmt.to_llir(builder, mod, scope) }
+        results.compact.last || LLVM::Int64.from_i(0)
+      end
+
+      private def all_statements
+        @all_statements ||= Array(statements).compact
+      end
+
+    end
+  end
+end

data/lib/stone/ast/boolean_literal.rb

@@ -0,0 +1,43 @@
+require "stone/ast/expression"
+
+# TODO: Eventually, TRUE and FALSE should be top-level constants defined as
+# __BUILTIN__.Boolean.TRUE and __BUILTIN__.Boolean.FALSE rather than literals.
+
+module Stone
+  class AST
+    class BooleanLiteral < Stone::AST::Expression
+
+      TRUE = 1
+      FALSE = 0
+
+      def self.parse(text, location)
+        new(text)
+      rescue ex
+        raise Stone::Error(ex.message, location) # TODO: Make a more specific error?
+      end
+
+      attr_reader :value
+
+      def initialize(value)
+        @name = :boolean_literal
+        case value
+        when "TRUE"
+          @value = TRUE
+        when "FALSE"
+          @value = FALSE
+        else
+          fail "expected TRUE or FALSE"
+        end
+      end
+
+      def to_llir(_builder, _mod, _scope = Stone::Scope.top_level)
+        @value == TRUE ? LLVM::TRUE : LLVM::FALSE
+      end
+
+      def type(_context = nil)
+        Stone::Type::Bool
+      end
+
+    end
+  end
+end

data/lib/stone/ast/computed_property_definition.rb

@@ -0,0 +1,32 @@
+require "stone/ast"
+
+
+module Stone
+  class AST
+    class ComputedPropertyDefinition < Stone::AST
+
+      attr_reader :type_name, :property_name, :lambda
+
+      def initialize(type_name, property_name, lambda)
+        @name = :computed_property_definition
+        @type_name = type_name
+        @property_name = property_name
+        @lambda = lambda
+      end
+
+      def to_llir(builder, mod, scope = Stone::Scope.top_level)
+        # Generate the lambda function
+        func = @lambda.to_llir(builder, mod, scope)
+
+        # Register as a function alias with the name "Type@property"
+        # This allows lookup via mod.lookup_function("Type@property")
+        function_name = "#{@type_name}@#{@property_name}"
+        mod.register_function_alias(function_name, func)
+
+        # Return nil (computed properties are definitions, not expressions)
+        nil
+      end
+
+    end
+  end
+end

data/lib/stone/ast/constant_definition.rb

@@ -0,0 +1,124 @@
+require "stone/ast/expression"
+
+
+module Stone
+  class AST
+    class ConstantDefinition < Stone::AST::Expression
+
+      attr_reader :identifier, :value_expression
+
+      def initialize(identifier, value_expression)
+        @identifier = identifier
+        @value_expression = value_expression
+        @name = :constant_definition
+      end
+
+      def to_llir(builder, mod, scope = Stone::Scope.top_level)
+        return register_record_type(mod, builder, scope) if value_expression.is_a?(Stone::AST::RecordDefinition)
+
+        llvm_value = value_expression.to_llir(builder, mod, scope)
+
+        return handle_record_definition(mod, llvm_value) if value_expression.is_a?(Stone::AST::RecordDefinition)
+        return register_function_alias(mod, llvm_value, scope) if llvm_value.is_a?(LLVM::Function)
+
+        handle_value_expression(mod, scope)
+        create_global(mod, builder, llvm_value, scope)
+      end
+
+      def type(_context = nil)
+        # ConstantDefinition doesn't have a value itself, it defines a binding
+        # Return nil to indicate this isn't an expression
+        nil
+      end
+
+      private def create_global(mod, builder, llvm_value, scope)
+        global = mod.globals.add(llvm_value.type, identifier)
+        global.linkage = :internal
+
+        if literal_constant?
+          initialize_as_constant(global, llvm_value)
+        else
+          initialize_at_runtime(global, builder, llvm_value)
+        end
+
+        # Register in scope for lexical lookup
+        scope.define(identifier, value: llvm_value)
+
+        nil
+      end
+
+      private def handle_record_definition(mod, llvm_value)
+        mod.register_record_type(identifier, value_expression)
+        mod.register_function_alias(identifier, llvm_value)
+        nil
+      end
+
+      # Register type information for expressions whose types cannot be inferred from LLVM types.
+      # - Strings: LLVM value is ptr-as-i64, need explicit String type tracking
+      # - Records: User-defined types, need explicit type name tracking
+      # - Integers/Booleans: Types inferred from LLVM types (i64, i1), no special handling needed
+      private def handle_value_expression(mod, scope)
+        if value_expression.is_a?(Stone::AST::StringLiteral)
+          mod.register_string_constant(identifier, value_expression)
+          scope.declare_type(identifier, type: Stone::Type::String)
+        end
+        register_record_instance(mod, scope)
+      end
+
+      # Register a record type definition and generate its type constant
+      private def register_record_type(mod, builder = nil, scope = Stone::Scope.top_level)
+        mod.register_record_type(identifier, value_expression)
+        # Generate constructor function and type constant
+        value_expression.to_llir(builder, mod, scope) if builder
+        nil
+      end
+
+      # Register a function (lambda) as an alias so it can be called by the constant name
+      private def register_function_alias(mod, function, scope)
+        mod.register_function_alias(identifier, function)
+        scope.define(identifier, value: function)
+        nil
+      end
+
+      # Use true LLVM constants, when we can
+      private def initialize_as_constant(global, llvm_value)
+        global.global_constant = true
+        global.initializer = llvm_value
+      end
+
+      # Runtime initialization for non-constant expressions
+      private def initialize_at_runtime(global, builder, llvm_value)
+        global.global_constant = false # Allow runtime update
+        global.initializer = llvm_value.type.null
+        builder.store(llvm_value, global)
+      end
+
+      private def literal_constant?
+        value_expression.is_a?(Stone::AST::IntegerLiteral) ||
+          value_expression.is_a?(Stone::AST::BooleanLiteral) ||
+          value_expression.is_a?(Stone::AST::StringLiteral)
+      end
+
+      private def register_record_instance(mod, scope)
+        type_name = record_type_name(mod)
+        return unless type_name
+
+        mod.register_record_instance(identifier, type_name)
+        record_type = Stone::TypeRegistry.instance.lookup(type_name)
+        scope.declare_type(identifier, type: record_type) if record_type
+      end
+
+      private def record_type_name(mod)
+        return value_expression.record_type_name if value_expression.is_a?(Stone::AST::RecordInstantiation)
+        return value_expression.function_name if record_constructor_call?(mod)
+
+        nil
+      end
+
+      private def record_constructor_call?(mod)
+        value_expression.is_a?(Stone::AST::FunctionCall) && mod.record_type?(value_expression.function_name)
+      end
+
+    end
+  end
+end

data/lib/stone/ast/expression.rb

@@ -0,0 +1,12 @@
+require "stone/ast"
+
+
+module Stone
+  class AST
+    class Expression < Stone::AST
+
+      def type(_context = nil) = fail NotImplementedError, "#{self.class} must implement #type"
+
+    end
+  end
+end

data/lib/stone/ast/function_call.rb

@@ -0,0 +1,291 @@
+require "stone/ast/expression"
+require "stone/libc"
+require "stone/error/argument_error"
+
+
+module Stone
+  class AST
+    class FunctionCall < Stone::AST::Expression
+
+      attr_reader :function_name, :arguments
+
+      def initialize(function_name, arguments)
+        @function_name = function_name
+        @arguments = arguments
+        @name = :function_call
+      end
+
+      def to_llir(builder, mod, scope = Stone::Scope.top_level)
+        # NULL comparisons with non-NULL values are always unequal (different types)
+        return null_comparison_result if mixed_null_comparison?
+
+        # TODO: Record equality should be delegated to the type system.
+        # When the type system is refactored, equality should be polymorphic:
+        # - Global `==` checks that both args are the same type
+        # - If same type, delegate to type-specific comparison
+        # - This special case should be removed
+        return generate_record_equality(builder, mod, scope) if record_equality_comparison?(mod)
+        # TODO: Record instantiation should not be special-cased here.
+        # When the type system is refactored, record constructors should be
+        # regular functions, and this check should be removed.
+        return instantiate_record(builder, mod, scope) if mod.record_type?(function_name)
+
+        # For chained comparisons, generate inline comparison logic
+        return generate_chained_comparison(builder, mod, scope) if chained_comparison?
+
+        # For chained boolean operations, generate inline logic
+        return generate_chained_boolean(builder, mod, scope) if chained_boolean?
+
+        # Regular function call
+        generate_function_call(builder, mod, scope)
+      end
+
+      def to_s
+        "#{function_name}(#{arguments.join(', ')})"
+      end
+
+      def type(context = nil)
+        return Stone::Type::Bool if comparison_operator? || boolean_operator?
+        return record_constructor_type if context&.record_type?(function_name)
+
+        function_return_type
+      end
+
+      private def record_constructor_type
+        Stone::Type::Registry.lookup(function_name)
+      end
+
+      private def function_return_type
+        Stone::Type::Registry.lookup(function_name)&.return_type
+      end
+
+      private def generate_function_call(builder, mod, scope)
+        func = mod.lookup_function(function_name)
+        fail Stone::ReferenceError, "undefined function: #{function_name}" unless func
+
+        validate_argument_count(func.function_type.argument_types.size)
+        args = evaluate_arguments(builder, mod, scope)
+        builder.call(func, *args, "#{function_name}_result")
+      end
+
+      private def chained_comparison?
+        comparison_operator? && arguments.length > 2
+      end
+
+      private def comparison_operator?
+        %w[== != ≠ < <= ≤ > >= ≥].include?(function_name)
+      end
+
+      private def boolean_operator?
+        %w[∧ ∨ ⊻ ¬].include?(function_name)
+      end
+
+      private def chained_boolean?
+        boolean_operator? && arguments.length > 2
+      end
+
+      private def generate_chained_boolean(builder, mod, scope)
+        # Generate inline code for chained boolean operations
+        # ∧(a, b, c) generates: (a && b) && c
+        func = lookup_and_validate_function(mod)
+        args = evaluate_arguments(builder, mod, scope)
+        build_chained_boolean_op(builder, func, args)
+      end
+
+      private def lookup_and_validate_function(mod)
+        func = mod.lookup_function(function_name)
+        fail Stone::ReferenceError, "undefined function: #{function_name}" unless func
+
+        func
+      end
+
+      private def build_chained_boolean_op(builder, func, args)
+        # Compute first pair using the function
+        result = builder.call(func, args[0], args[1], "bool_0")
+
+        # Chain remaining operands left-to-right: (a ⊻ b) ⊻ c
+        # This produces: ((a op b) op c) op d ...
+        # NOT overlapping pairs like: (a op b) and (b op c)
+        remaining_args = args[2..]
+        remaining_args.each_with_index do |arg, i|
+          result = chain_with_next_operand(builder, result, arg, i + 1)
+        end
+
+        result
+      end
+
+      private def chain_with_next_operand(builder, current_result, next_arg, index)
+        # NOTE: NOT (¬) is unary and never reaches this code path
+        # because chained_boolean? requires arguments.length > 2
+        case function_name
+        when "∧"
+          builder.and(current_result, next_arg, "and_#{index}")
+        when "∨"
+          builder.or(current_result, next_arg, "or_#{index}")
+        when "⊻"
+          builder.xor(current_result, next_arg, "xor_#{index}")
+        else
+          fail "Unsupported boolean operator for chaining: #{function_name}"
+        end
+      end
+
+      private def generate_chained_comparison(builder, mod, scope)
+        # Generate inline code for chained comparisons
+        # <(a, b, c) generates: (a < b) && (b < c)
+        func = lookup_and_validate_function(mod)
+        args = evaluate_arguments(builder, mod, scope)
+        build_comparison_conjunction(builder, func, args)
+      end
+
+
+      private def build_comparison_conjunction(builder, func, args)
+        result = builder.call(func, args[0], args[1], "cmp_0")
+
+        (1...args.length - 1).each do |i|
+          pair_result = builder.call(func, args[i], args[i + 1], "cmp_#{i}")
+          result = builder.and(result, pair_result, "and_#{i}")
+        end
+
+        result
+      end
+
+      private def validate_argument_count(expected)
+        return if arguments.length == expected
+
+        fail Stone::ArgumentError, "wrong number of arguments for #{function_name} (given #{arguments.length}, expected #{expected})"
+      end
+
+      private def evaluate_arguments(builder, mod, scope)
+        arguments.map { |arg| arg.to_llir(builder, mod, scope) }
+      end
+
+      private def record_equality_comparison?(mod)
+        return false unless equality_operator?
+        return false unless arguments.size == 2
+
+        both_arguments_are_records?(mod)
+      end
+
+      private def both_arguments_are_records?(mod)
+        Stone::AST::RecordHelpers.record_instance?(arguments[0], mod) &&
+          Stone::AST::RecordHelpers.record_instance?(arguments[1], mod)
+      end
+
+      private def instantiate_record(builder, mod, scope)
+        record_instantiation = Stone::AST::RecordInstantiation.new(function_name, arguments)
+        record_instantiation.to_llir(builder, mod, scope)
+      end
+
+      private def equality_operator?
+        %w[== != ≠].include?(function_name)
+      end
+
+      private def mixed_null_comparison?
+        return false unless equality_operator?
+        return false unless arguments.size == 2
+
+        null_args = arguments.count { |arg| arg.is_a?(Stone::AST::NullLiteral) }
+        return false unless null_args == 1 # Exactly one NULL
+
+        # If the non-NULL operand returns a pointer, it's a valid pointer comparison
+        non_null_arg = arguments.find { |arg| !arg.is_a?(Stone::AST::NullLiteral) }
+        !returns_pointer?(non_null_arg)
+      end
+
+      private def returns_pointer?(node)
+        # PropertyAccess to a recursive field returns a pointer
+        return true if node.is_a?(Stone::AST::PropertyAccess)
+
+        false
+      end
+
+      private def null_comparison_result
+        # For ==: different types are not equal, return false
+        # For != or ≠: different types are not equal, return true
+        function_name == "==" ? LLVM::FALSE : LLVM::TRUE
+      end
+
+      private def generate_record_equality(builder, mod, scope)
+        records = evaluate_record_arguments(builder, mod, scope)
+        type1, type2 = get_record_types(mod)
+
+        return different_types_result if type1 != type2
+
+        result = compare_all_fields(builder, records, mod.record_types[type1], mod)
+        apply_not_operator(builder, result)
+      end
+
+      private def evaluate_record_arguments(builder, mod, scope)
+        [arguments[0].to_llir(builder, mod, scope), arguments[1].to_llir(builder, mod, scope)]
+      end
+
+      private def get_record_types(mod)
+        [mod.record_instance_type(arguments[0].identifier), mod.record_instance_type(arguments[1].identifier)]
+      end
+
+      private def different_types_result
+        function_name == "==" ? LLVM::Int1.from_i(0) : LLVM::Int1.from_i(1)
+      end
+
+      private def apply_not_operator(builder, result)
+        function_name == "==" ? result : builder.not(result, "not_equal")
+      end
+
+      private def compare_all_fields(builder, records, record_def, mod)
+        fields = record_def.fields
+        result = compare_fields_at_index(builder, records, fields, mod, 0)
+
+        (1...fields.size).each do |i|
+          field_equal = compare_fields_at_index(builder, records, fields, mod, i)
+          result = builder.and(result, field_equal, "and_#{i}")
+        end
+
+        result
+      end
+
+      private def compare_fields_at_index(builder, records, fields, mod, index)
+        field = fields[index]
+        val1 = builder.extract_value(records[0], index, "field1_#{field[:name]}")
+        val2 = builder.extract_value(records[1], index, "field2_#{field[:name]}")
+
+        compare_field_values(builder, val1, val2, field[:type_name], mod)
+      end
+
+      private def compare_field_values(builder, val1, val2, type_name, mod)
+        case type_name
+        when "Int", "Bool"
+          builder.icmp(:eq, val1, val2, "field_eq")
+        when "String"
+          # Stone represents strings as i64 pointers to null-terminated C strings
+          # We need to compare the string contents, not just the pointers
+          compare_strings(builder, val1, val2, mod)
+        else
+          fail "Unknown type for comparison: #{type_name}"
+        end
+      end
+
+      private def compare_strings(builder, str_ptr1, str_ptr2, mod)
+        # Optimization: check if pointers are equal first
+        # If pointers differ, we still need strcmp for content comparison
+        ptrs_equal = builder.icmp(:eq, str_ptr1, str_ptr2, "ptrs_eq")
+
+        # Convert i64 pointers back to i8* for strcmp
+        ptr1 = builder.int2ptr(str_ptr1, LLVM::Type.pointer(LLVM::Int8), "ptr1")
+        ptr2 = builder.int2ptr(str_ptr2, LLVM::Type.pointer(LLVM::Int8), "ptr2")
+
+        # Declare or get strcmp function
+        strcmp_func = Stone::LibC.get_or_declare_strcmp(mod)
+        strcmp_result = builder.call(strcmp_func, ptr1, ptr2, "strcmp_result")
+
+        # strcmp returns 0 if strings are equal
+        strings_equal = builder.icmp(:eq, strcmp_result, LLVM::Int32.from_i(0), "strings_eq")
+
+        # Return true if pointers are equal OR string contents are equal
+        # Note: This always calls strcmp, but LLVM's optimizer will likely eliminate
+        # the strcmp call when ptrs_equal is true at compile time
+        builder.or(ptrs_equal, strings_equal, "str_cmp_result")
+      end
+
+    end
+  end
+end

data/lib/stone/ast/function_type_annotation.rb

@@ -0,0 +1,31 @@
+require "stone/ast"
+
+
+module Stone
+  class AST
+    class FunctionTypeAnnotation < Stone::AST
+
+      attr_reader :param_types, :return_type
+
+      def initialize(param_types, return_type)
+        @param_types = param_types
+        @return_type = return_type
+        @name = :function_type_annotation
+      end
+
+      def to_s
+        params = @param_types.map(&:to_s).join(", ")
+        return_str = @return_type.is_a?(FunctionTypeAnnotation) ? "(#{@return_type})" : @return_type.to_s
+        "(#{params}) -> #{return_str}"
+      end
+
+      # Convert to Stone::Type for type checking
+      def to_type(registry)
+        param_stone_types = @param_types.map { |t| t.to_type(registry) }
+        return_stone_type = @return_type.to_type(registry)
+        Stone::Type.function(param_types: param_stone_types, return_type: return_stone_type)
+      end
+
+    end
+  end
+end

data/lib/stone/ast/integer_literal.rb

@@ -0,0 +1,46 @@
+require "stone/ast/expression"
+
+
+module Stone
+  class AST
+    class IntegerLiteral < Stone::AST::Expression
+
+      BASES = {
+        "0b" => 2,
+        "0o" => 8,
+        "0x" => 16
+      }.freeze
+
+      # TODO: This looks like a good place to set a good example: refactor into a Method Object.
+      def self.parse(text, location)
+        sign = text.start_with?("-") ? -1 : 1
+        unsigned_text = text.sub(/^[+-]/, "")
+        base = BASES.fetch(unsigned_text[0..1], 10)
+        digits = base == 10 ? unsigned_text : unsigned_text[2..]
+        value = sign * Integer(digits, base)
+        fail Stone::Error::Overflow.new(location:, literal: text) unless in_range?(value)
+        new(value)
+      end
+
+      def self.in_range?(value)
+        value >= Stone::Type::Int.min && value <= Stone::Type::Int.max
+      end
+
+      attr_reader :value
+
+      def initialize(value)
+        @value = value
+        @name = :integer_literal
+      end
+
+      def to_llir(_builder, _mod, _scope = Stone::Scope.top_level)
+        LLVM::Int64.from_i(@value)
+      end
+
+      def type(_context = nil)
+        Stone::Type::Int
+      end
+
+    end
+  end
+end