rubocop-boochtek 0.2.0 → 0.2.1

data/lib/stone/ast/record_definition.rb

@@ -0,0 +1,180 @@
+require "stone/ast/expression"
+require "stone/error/type_error"
+require "stone/rtti"
+
+
+module Stone
+  class AST
+    # TODO: Records should be first-class Type objects, not AST nodes.
+    # When the type system is refactored:
+    # - Record types should be instances of a RecordType class
+    # - Record types should be global constants with properties
+    # - Record types should have vtables for polymorphic operations
+    # - Record instantiation should work like any other function call
+    class RecordDefinition < Stone::AST::Expression
+
+      attr_reader :fields
+      attr_accessor :assigned_name
+
+      # fields is an array of { name: "field_name", type: "TypeName" } hashes
+      def initialize(fields)
+        @name = :record_definition
+        @fields = fields
+        @assigned_name = nil
+      end
+
+      def to_llir(_builder, mod, scope = Stone::Scope.top_level)
+        # Validate all field types resolve in current scope
+        validate_field_types(scope, mod)
+        # Generate the type constant for this record
+        generate_type_constant(mod, scope) if @assigned_name
+        # Generate and return a constructor function that creates instances of this record
+        generate_constructor_function(mod, scope)
+      end
+
+      private def generate_type_constant(mod, scope)
+        struct_type = llvm_type(mod, scope)
+        size_bytes = calculate_struct_size(struct_type)
+        Stone::RTTI.generate_record_type_constant(mod, @assigned_name, size_bytes, @fields)
+      end
+
+      private def calculate_struct_size(struct_type)
+        # Calculate size based on field types (simplified - assumes packed alignment)
+        total = 0
+        struct_type.element_types.each do |elem_type|
+          total += element_type_size(elem_type)
+        end
+        total
+      end
+
+      private def element_type_size(llvm_type)
+        case llvm_type.kind
+        when :integer then (llvm_type.width + 7) / 8  # Round up to bytes
+        when :pointer then 8  # 64-bit pointers
+        when :struct then llvm_type.element_types.sum { |t| element_type_size(t) }
+        else 8  # Default to 8 bytes
+        end
+      end
+
+      private def validate_field_types(scope, mod)
+        @fields.each { |field| validate_field_type(field, scope, mod) }
+      end
+
+      private def validate_field_type(field, scope, mod)
+        return if Stone::AST::FieldHelpers.union_annotation?(field[:type])
+
+        type_name = Stone::AST::FieldHelpers.field_type_name(field)
+        return if known_type?(type_name, scope, mod)
+
+        fail Stone::TypeError, "Unknown type: #{type_name}"
+      end
+
+      private def known_type?(type_name, scope, mod)
+        type_name == @assigned_name || mod&.record_type?(type_name) || scope.lookup_type(type_name)
+      end
+
+      def field_names
+        @fields.map { |f| f[:name] }
+      end
+
+      def field_types
+        @fields.map { |f| Stone::AST::FieldHelpers.field_type_name(f) }
+      end
+
+      def field_type_annotation(field_name)
+        field = @fields.find { |f| f[:name] == field_name }
+        field&.dig(:type)
+      end
+
+      def field_index(field_name)
+        field_names.index(field_name)
+      end
+
+      def llvm_type(mod = nil, scope = Stone::Scope.top_level)
+        # Convert field types to LLVM types
+        llvm_field_types = @fields.map { |field| llvm_type_for_field(field, mod, scope) }
+        LLVM::Type.struct(llvm_field_types, false)
+      end
+
+      def to_s
+        field_strs = @fields.map { |f| "#{f[:name]} :: #{f[:type_name]}" }
+        "Record(#{field_strs.join(', ')})"
+      end
+
+      def type(_context = nil)
+        return nil unless @assigned_name
+
+        record_type = Stone::Type::Registry.lookup(@assigned_name)
+        return nil unless record_type
+
+        param_types = @fields.map { |f| resolve_field_stone_type(f) }
+        return nil if param_types.any?(&:nil?)
+
+        Stone::Type.function(param_types:, return_type: record_type)
+      end
+
+      private def resolve_field_stone_type(field)
+        Stone::AST::FieldHelpers.resolve_field_type(field)
+      end
+
+      # Returns the LLVM type for a field. Handles union types, primitives, and record types.
+      private def llvm_type_for_field(field, mod, scope)
+        return llvm_type_for_union(field[:type]) if Stone::AST::FieldHelpers.union_annotation?(field[:type])
+
+        type_name = Stone::AST::FieldHelpers.field_type_name(field)
+        resolve_simple_llvm_type(type_name, mod, scope)
+      end
+
+      private def resolve_simple_llvm_type(type_name, mod, scope)
+        return LLVM::Type.ptr if record_reference?(type_name, mod)
+        return Stone::Type::Registry.lookup(type_name).llvm_type if primitive_type?(type_name)
+        return LLVM::Type.ptr if scope.lookup_type(type_name)
+
+        fail Stone::TypeError, "Unknown type: #{type_name}"
+      end
+
+      private def record_reference?(type_name, mod)
+        type_name == @assigned_name || mod&.record_type?(type_name)
+      end
+
+      private def primitive_type?(type_name)
+        Stone::Type::Registry.lookup(type_name)
+      end
+
+      private def llvm_type_for_union(annotation)
+        stone_type = annotation.to_type(Stone::Type::Registry)
+        stone_type.llvm_type
+      end
+
+      private def generate_constructor_function(mod, scope)
+        func_name = "__record_constructor_#{object_id}__"
+        func_type = constructor_function_type(mod, scope)
+
+        mod.functions.add(func_name, func_type).tap do |func|
+          build_constructor_body(func, mod, scope)
+        end
+      end
+
+      private def constructor_function_type(mod, scope)
+        # Constructor function signature: (field_types...) -> struct_type
+        field_llvm_types = @fields.map { |field| llvm_type_for_field(field, mod, scope) }
+        LLVM::Type.function(field_llvm_types, llvm_type(mod, scope))
+      end
+
+      private def build_constructor_body(func, mod, scope)
+        func.basic_blocks.append("entry").build do |builder|
+          # Start with null/undef struct value
+          struct_value = llvm_type(mod, scope).null
+
+          # Insert each field value from function parameters
+          @fields.each_with_index do |_field, index|
+            struct_value = builder.insert_value(struct_value, func.params[index], index)
+          end
+
+          builder.ret(struct_value)
+        end
+      end
+
+    end
+  end
+end

data/lib/stone/ast/record_instantiation.rb

@@ -0,0 +1,141 @@
+require "stone/ast/expression"
+require "stone/error/arity_error"
+require "stone/rtti"
+
+
+module Stone
+  class AST
+    class RecordInstantiation < Stone::AST::Expression
+
+      attr_reader :record_type_name, :field_values, :record_definition
+
+      def initialize(record_type_name, field_values)
+        @name = :record_instantiation
+        @record_type_name = record_type_name
+        @field_values = field_values
+        @record_definition = nil
+      end
+
+      def to_llir(builder, mod, scope = Stone::Scope.top_level)
+        record_def = mod.record_types[@record_type_name]
+        fail "Unknown record type: #{@record_type_name}" unless record_def
+
+        # Store record definition for later access
+        @record_definition = record_def
+
+        # Verify field count matches
+        if @field_values.size != record_def.fields.size
+          fail Stone::ArityError, "wrong number of arguments for #{@record_type_name} (given #{@field_values.size}, expected #{record_def.fields.size})"
+        end
+
+        # Evaluate each field value
+        llvm_values = @field_values.map { |field_ast| field_ast.to_llir(builder, mod, scope) }
+
+        # Convert struct values to pointers for record-typed fields
+        llvm_values = convert_structs_to_pointers(builder, mod, record_def, llvm_values)
+
+        # Create struct value
+        create_struct(record_def.llvm_type(mod), llvm_values, builder)
+      end
+
+      def to_s
+        "#{@record_type_name}(#{@field_values.map(&:to_s).join(', ')})"
+      end
+
+      def type(_context = nil)
+        Stone::Type::Registry.lookup(@record_type_name)
+      end
+
+      private def verify_field_type(field_name, expected_type, llvm_value)
+        expected_llvm_type = llvm_type_for(expected_type)
+        actual_llvm_type = llvm_value.type
+
+        # Compare LLVM types
+        return if types_match?(expected_llvm_type, actual_llvm_type)
+
+        fail "Type mismatch for field '#{field_name}': expected #{expected_type}, got #{actual_llvm_type}"
+      end
+
+      private def types_match?(expected, actual)
+        expected.to_s == actual.to_s
+      end
+
+      private def llvm_type_for(type_name)
+        case type_name
+        when "Int" then LLVM::Int64
+        when "Bool" then LLVM::Int1
+        when "String" then Stone::Type::String.llvm_type
+        else
+          fail "Unknown type: #{type_name}"
+        end
+      end
+
+      private def convert_structs_to_pointers(builder, mod, record_def, llvm_values)
+        llvm_values.each_with_index.map do |value, index|
+          convert_field_value(builder, mod, record_def.fields[index], value, index)
+        end
+      end
+
+      private def convert_field_value(builder, mod, field, value, index)
+        if Stone::AST::FieldHelpers.union_annotation?(field[:type])
+          union_type = Stone::AST::FieldHelpers.resolve_field_type(field)
+          return wrap_in_tagged_union(builder, mod, value, @field_values[index], union_type)
+        end
+        return allocate_and_store(builder, value) if needs_pointer_conversion?(field, mod, value)
+
+        value
+      end
+
+      private def needs_pointer_conversion?(field, mod, value)
+        field_expects_pointer?(field[:type_name], mod) && value.type.kind == :struct
+      end
+
+      private def wrap_in_tagged_union(builder, mod, llvm_value, ast_value, union_type)
+        value_type = ast_value.type(Stone::TypeContext.new(mod))
+        type_constant = Stone::RTTI.type_constant_for(mod, value_type)
+
+        # Allocate union on stack
+        union_ptr = builder.alloca(union_type.llvm_type, "union_alloca")
+
+        # Store type tag (field 0)
+        tag_ptr = builder.struct_gep2(union_type.llvm_type, union_ptr, 0, "tag_ptr")
+        builder.store(type_constant, tag_ptr)
+
+        # Store payload (field 1) - no ptr2int needed
+        payload_ptr = builder.struct_gep2(union_type.llvm_type, union_ptr, 1, "payload_ptr")
+        store_payload(builder, payload_ptr, llvm_value, value_type)
+
+        # Load and return the union value
+        builder.load2(union_type.llvm_type, union_ptr, "union_value")
+      end
+
+      private def store_payload(builder, payload_ptr, llvm_value, _value_type)
+        value_to_store = llvm_value.type.kind == :struct ? allocate_and_store(builder, llvm_value) : llvm_value
+        builder.store(value_to_store, payload_ptr)
+      end
+
+      private def field_expects_pointer?(field_type_name, mod)
+        field_type_name == @record_type_name || mod.record_type?(field_type_name)
+      end
+
+      private def allocate_and_store(builder, struct_value)
+        ptr = builder.alloca(struct_value.type, "nested_record")
+        builder.store(struct_value, ptr)
+        ptr
+      end
+
+      private def create_struct(struct_type, values, builder)
+        # Start with a null/undef struct value
+        struct_value = struct_type.null
+
+        # Insert each field value
+        values.each_with_index do |value, index|
+          struct_value = builder.insert_value(struct_value, value, index)
+        end
+
+        struct_value
+      end
+
+    end
+  end
+end

data/lib/stone/ast/reference.rb

@@ -0,0 +1,145 @@
+require "stone/ast/expression"
+require "stone/error/type_error"
+
+
+module Stone
+  class AST
+    class Reference < Stone::AST::Expression
+
+      attr_reader :identifier
+
+      def initialize(identifier, type: nil)
+        @identifier = identifier
+        @type = type
+        @name = :reference
+      end
+
+      def type(context = nil)
+        return @type if @type
+        return nil unless context
+
+        type_from_context(context) || type_from_module(context)
+      end
+
+      private def type_from_context(context)
+        return nil unless context.is_a?(Stone::TypeContext)
+
+        context.lookup(@identifier)
+      end
+
+      private def type_from_module(context)
+        # Fallback to old module-based lookup for backwards compatibility during migration
+        mod = context.is_a?(Stone::TypeContext) ? context.llvm_module : context
+        return nil unless mod
+
+        type_from_record_instance(mod) || type_from_parameter(mod) || type_from_string_constant(mod) || type_from_global(mod)
+      end
+
+      def record_instance?(mod)
+        mod.record_instance?(identifier)
+      end
+
+      def to_llir(builder, mod, scope = Stone::Scope.top_level)
+        # Check lambda parameters first - they should shadow outer scope definitions
+        lookup_parameter(builder, mod) ||
+          lookup_in_scope(scope) ||
+          lookup_global(builder, mod) ||
+          lookup_function(mod) ||
+          lookup_record_type(mod) ||
+          fail_with_reference_error
+      end
+
+      def to_s
+        identifier
+      end
+
+      private def type_from_parameter(mod)
+        return unless mod.lambda_param_storage&.key?(identifier)
+
+        llvm_type_to_stone_type(mod.lambda_param_storage[identifier].allocated_type)
+      end
+
+      private def type_from_string_constant(mod)
+        Stone::Type::String if mod.string_constant?(identifier)
+      end
+
+      private def type_from_record_instance(mod)
+        return unless mod.record_instance?(identifier)
+
+        type_name = mod.record_instance_type(identifier)
+        Stone::Type::Registry.lookup(type_name)
+      end
+
+      private def type_from_global(mod)
+        global = mod.globals[identifier]
+        return unless global
+
+        # Check if the initializer is a null pointer (NULL constant)
+        initializer = global.initializer
+        return Stone::Type::Null if null_pointer?(initializer)
+
+        # In LLVM 21+, globals use opaque pointers, so check the initializer's type
+        llvm_type = initializer&.type
+        llvm_type_to_stone_type(llvm_type) if llvm_type
+      end
+
+      private def null_pointer?(value)
+        return false unless value
+
+        value.type.kind == :pointer && value.null?
+      end
+
+      private def llvm_type_to_stone_type(llvm_type)
+        return nil unless llvm_type
+
+        llvm_kind_to_stone_type(llvm_type)
+      end
+
+      # Maps LLVM type kinds to Stone types.
+      # Note: Record instances are handled by type_from_record_instance BEFORE this is called,
+      # so :struct here represents Stone strings (which use struct {i64 len, i8* data}).
+      private def llvm_kind_to_stone_type(llvm_type)
+        case llvm_type.kind
+        when :integer then llvm_type.width == 1 ? Stone::Type::Bool : Stone::Type::Int
+        when :pointer, :struct then Stone::Type::String
+        end
+      end
+
+      private def lookup_parameter(builder, mod)
+        param_storage = mod.lambda_param_storage
+        return nil unless param_storage && param_storage[identifier]
+
+        builder.load(param_storage[identifier], identifier)
+      end
+
+      private def lookup_global(builder, mod)
+        global = mod.globals[identifier]
+        return nil unless global
+
+        builder.load(global, identifier)
+      end
+
+      private def lookup_function(mod)
+        mod.lookup_function(identifier)
+      end
+
+      private def lookup_record_type(mod)
+        # Record types aren't really values, but if referenced, return a dummy value
+        # This allows code like "Person := Record(...)\nPerson" to not fail
+        return LLVM::Int64.from_i(0) if mod.record_type?(identifier)
+
+        nil
+      end
+
+      private def lookup_in_scope(scope)
+        definition = scope&.lookup(identifier)
+        definition&.dig(:value)
+      end
+
+      private def fail_with_reference_error
+        fail Stone::ReferenceError, "undefined constant, variable, or function: #{identifier}"
+      end
+
+    end
+  end
+end

data/lib/stone/ast/string_literal.rb

@@ -0,0 +1,79 @@
+require "stone/ast/expression"
+
+
+module Stone
+  class AST
+    class StringLiteral < Stone::AST::Expression
+
+      def self.parse(text, location)
+        # Remove surrounding quotes, but do NOT process escape sequences.
+        value = text[1..-2]
+        new(value)
+      rescue ex
+        raise Stone::Error.new(ex.message, location)
+      end
+
+      attr_reader :value
+
+      def initialize(value)
+        @name = :string_literal
+        @value = value
+      end
+
+      # Byte count (for system/memory operations)
+      def bytesize
+        @value.bytesize
+      end
+
+      # Character count (for user-facing string length)
+      def length
+        @value.length
+      end
+
+      def to_llir(builder, mod, _scope = Stone::Scope.top_level)
+        string_global = create_global_string(mod)
+
+        # Get pointer to the string data (GEP to first element)
+        # Array size is bytesize + 1 for null terminator
+        builder.gep2(
+          LLVM::Type.array(LLVM::Int8, @value.bytesize + 1),
+          string_global,
+          [LLVM::Int64.from_i(0), LLVM::Int64.from_i(0)],
+          "string_ptr"
+        )
+        # Return pointer directly - no ptr2int (CHERI-safe)
+      end
+
+      private def create_global_string(mod)
+        global_name = ".str.#{mod.globals.count}"
+        string_constant = create_string_constant
+        add_global_constant(mod, global_name, string_constant)
+      end
+
+      # Create string constant from bytes manually to work around ruby-llvm bugs:
+      # 1. ConstantArray.string truncates Unicode strings
+      # 2. ConstantArray.const with unsigned bytes > 127 produces poison values
+      # Solution: convert bytes > 127 to signed i8 equivalent
+      # Include null terminator for C string compatibility
+      private def create_string_constant
+        bytes_with_null = @value.bytes + [0]
+        i8_constants = bytes_with_null.map { |byte| LLVM::Int8.from_i(byte > 127 ? byte - 256 : byte) }
+        LLVM::ConstantArray.const(LLVM::Int8, i8_constants)
+      end
+
+      private def add_global_constant(mod, name, constant)
+        mod.globals.add(constant.type, name).tap do |global|
+          global.initializer = constant
+          global.linkage = :private
+          global.global_constant = true
+          global.unnamed_addr = true
+        end
+      end
+
+      def type(_context = nil)
+        Stone::Type::String
+      end
+
+    end
+  end
+end

data/lib/stone/ast/two_phase_processing.rb

@@ -0,0 +1,36 @@
+require "stone/ast/type_declaration"
+require "stone/type_registry"
+
+module Stone
+  class AST
+    # Mixin for AST nodes that process statements in two phases:
+    # 1. Register all type declarations in scope
+    # 2. Compile other statements
+    #
+    # This ensures type declarations are available before definitions that reference them.
+    module TwoPhaseProcessing
+
+      private def register_type_declarations(scope)
+        registry = Stone::TypeRegistry.instance
+        type_declarations.each do |td|
+          stone_type = td.type_annotation.to_type(registry)
+          scope.declare_type(td.identifier, type: stone_type, location: td.location)
+        end
+      end
+
+      private def type_declarations
+        all_statements.select { |s| s.is_a?(Stone::AST::TypeDeclaration) }
+      end
+
+      private def other_statements
+        all_statements.reject { |s| s.is_a?(Stone::AST::TypeDeclaration) }
+      end
+
+      # Subclasses must implement this method to return the list of statements to process
+      private def all_statements
+        fail NotImplementedError, "Subclasses must implement #all_statements"
+      end
+
+    end
+  end
+end

data/lib/stone/ast/type_annotation.rb

@@ -0,0 +1,26 @@
+require "stone/ast"
+
+
+module Stone
+  class AST
+    class TypeAnnotation < Stone::AST
+
+      attr_reader :type_name
+
+      def initialize(type_name)
+        @type_name = type_name
+        @name = :type_annotation
+      end
+
+      def to_s
+        type_name
+      end
+
+      # Convert to Stone::Type for type checking
+      def to_type(registry)
+        registry.lookup(type_name)
+      end
+
+    end
+  end
+end

data/lib/stone/ast/type_declaration.rb

@@ -0,0 +1,28 @@
+require "stone/ast"
+
+
+module Stone
+  class AST
+    class TypeDeclaration < Stone::AST
+
+      attr_reader :identifier, :type_annotation, :location
+
+      def initialize(identifier, type_annotation, location: nil)
+        @identifier = identifier
+        @type_annotation = type_annotation
+        @location = location
+        @name = :type_declaration
+      end
+
+      def to_s
+        "#{identifier} :: #{type_annotation}"
+      end
+
+      # Type declarations don't produce a value, so they have no type
+      def type(_context = nil)
+        nil
+      end
+
+    end
+  end
+end

data/lib/stone/ast/type_of_expression.rb

@@ -0,0 +1,41 @@
+require "stone/ast/expression"
+require "stone/type_context"
+require "stone/rtti"
+
+
+module Stone
+  class AST
+    class TypeOfExpression < Stone::AST::Expression
+
+      attr_reader :inner_expression
+
+      def initialize(inner_expression)
+        @inner_expression = inner_expression
+        @name = :type_of_expression
+      end
+
+      def type(_context = nil)
+        Stone::Type::Type
+      end
+
+      def to_llir(builder, mod, scope = Stone::Scope.top_level)
+        # Union field access: extract type tag at runtime
+        return @inner_expression.extract_union_type_tag(builder, mod, scope) if union_field_access?(mod)
+
+        # Default: return compile-time type constant
+        context = Stone::TypeContext.new(mod)
+        result_type = @inner_expression.type(context)
+        Stone::RTTI.type_constant_for(mod, result_type)
+      end
+
+      def to_s
+        "Type.of(#{@inner_expression})"
+      end
+
+      private def union_field_access?(mod)
+        @inner_expression.is_a?(PropertyAccess) && @inner_expression.union_field_access?(mod)
+      end
+
+    end
+  end
+end