rubocop-boochtek 0.2.0 → 0.2.1

data/lib/stone/ast/lambda.rb

@@ -0,0 +1,126 @@
+require "stone/ast/expression"
+require "stone/ast/block"
+require "stone/types"
+
+
+module Stone
+  class AST
+    class Lambda < Stone::AST::Expression
+
+      attr_reader :parameters, :block
+
+      class << self
+        attr_accessor :lambda_count
+      end
+
+      @lambda_count = 0
+
+      def initialize(parameters, statements)
+        @name = :lambda
+        @parameters = parameters
+        @block = Block.new(statements)
+        @lambda_id = next_lambda_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 lambda).
+        mod.functions[function_name] || create_function(mod, function_name, function_type, scope)
+      end
+
+      def to_s
+        "λ(#{parameters.join(', ')}) { #{block.statements.join("\n")} }"
+      end
+
+      def type(context = nil)
+        return_type = @block.type(context) || Stone::Type::Int
+        param_types = parameters.map { Stone::Type::Int }
+        Stone::Type.function(param_types:, return_type:)
+      end
+
+      private def next_lambda_id
+        self.class.lambda_count += 1
+        self.class.lambda_count
+      end
+
+      private def function_type
+        # For now, we assume all functions return an i64.
+        LLVM::Type.function(param_types, I64)
+      end
+
+      private def param_types
+        # For now, we assume all parameters are i64.
+        [I64] * parameters.size
+      end
+
+      private def function_name
+        "__#{function_prefix}_#{@lambda_id}__"
+      end
+
+      private def function_prefix
+        "lambda"
+      end
+
+      private def create_function(mod, function_name, function_type, scope)
+        mod.functions.add(function_name, function_type).tap do |func|
+          name_parameters(func)
+          build_function_body(func, mod, scope)
+        end
+      end
+
+      private def name_parameters(func)
+        func.params.each_with_index do |param, i|
+          param.name = parameters[i]
+        end
+      end
+
+      private def build_function_body(func, mod, scope)
+        func.basic_blocks.append("entry").build do |lambda_builder|
+          args = argument_storage(func, lambda_builder)
+
+          # Create child scope with lambda parameters for type resolution
+          lambda_scope = scope.child
+          bind_parameters_in_scope(lambda_scope)
+
+          with_parameter_context(mod, args) do
+            evaluate_body_and_return(lambda_builder, mod, lambda_scope)
+          end
+        end
+      end
+
+      # Bind lambda parameters in scope so they can be resolved as types in annotations.
+      # The value :type_parameter is a placeholder - only the presence in scope matters
+      # for type resolution. Runtime access uses lambda_param_storage instead.
+      private def bind_parameters_in_scope(scope)
+        @parameters.each do |param|
+          scope.define(param, value: :type_parameter)
+        end
+      end
+
+      # Store arguments on the stack so they are treated the same as local variables.
+      private def argument_storage(func, builder)
+        {}.tap do |storage|
+          parameters.each_with_index do |param_name, i|
+            alloca = builder.alloca(LLVM::Int64.type, param_name)
+            builder.store(func.params[i], alloca)
+            storage[param_name] = alloca
+          end
+        end
+      end
+
+      # Temporarily set module's parameter context so Reference nodes within the block can resolve parameter names.
+      private def with_parameter_context(mod, args)
+        original = mod.lambda_param_storage
+        mod.lambda_param_storage = args
+        yield
+      ensure
+        mod.lambda_param_storage = original
+      end
+
+      # Lambda parameters use lambda_param_storage (not scope) for stack alloca loading.
+      private def evaluate_body_and_return(builder, mod, scope)
+        @block.evaluate_body_and_return(builder, mod, scope)
+      end
+
+    end
+  end
+end

data/lib/stone/ast/null_literal.rb

@@ -0,0 +1,29 @@
+require "stone/ast/expression"
+
+module Stone
+  class AST
+    class NullLiteral < Stone::AST::Expression
+
+      def self.parse(_text, _location)
+        new
+      end
+
+      def initialize
+        @name = :null_literal
+      end
+
+      def to_llir(_builder, _mod, _scope = Stone::Scope.top_level)
+        LLVM::Type.ptr.null
+      end
+
+      def to_s
+        "NULL"
+      end
+
+      def type(_context = nil)
+        Stone::Type::Null
+      end
+
+    end
+  end
+end

data/lib/stone/ast/program_unit/top_function.rb

@@ -0,0 +1,209 @@
+require "llvm/core"
+require "stone/libc"
+require "stone/scope"
+require "stone/ast/two_phase_processing"
+
+
+module Stone
+  class AST
+    class ProgramUnit < Stone::AST
+      class TopFunction
+        include TwoPhaseProcessing
+
+        def initialize(children)
+          @children = children
+          @mod = nil
+        end
+
+        def generate(mod, scope = Stone::Scope.top_level)
+          @mod = mod
+          @scope = scope
+          register_all_types(mod, scope)
+          mod.functions.add("__top__", function_type) { |func| build_function_body(func, mod, scope) }
+        end
+
+        private def register_all_types(mod, scope)
+          register_type_declarations(scope)
+          register_record_types(mod, scope)
+          register_function_types
+        end
+
+        private def build_function_body(func, mod, scope)
+          func.basic_blocks.append("entry").build do |builder|
+            compiled = compile_children(builder, mod, scope)
+            build_return(builder, compiled&.last)
+          end
+        end
+
+        private def function_type
+          # Return type is determined at compile time based on the last expression
+          # - Pointers are returned as-is (CHERI-safe, no ptr2int)
+          # - Integers and bools are returned as i64
+          LLVM::Type.function([], compute_return_type, varargs: false)
+        end
+
+        private def compute_return_type
+          last_child = other_statements.last
+          return LLVM::Int64.type unless last_child
+
+          # Check if the result will be a pointer
+          return LLVM::Type.pointer if returns_pointer?(last_child)
+
+          LLVM::Int64.type
+        end
+
+        private def returns_pointer?(node)
+          tagged_union_field_access?(node) ||
+            node.is_a?(Stone::AST::StringLiteral) ||
+            reference_to_string_constant?(node) ||
+            string_returning_property?(node) ||
+            returns_pointer_by_type?(node)
+        end
+
+        private def returns_pointer_by_type?(node)
+          stone_type = safe_get_type(node)
+          stone_type == Stone::Type::String || stone_type&.record?
+        end
+
+        private def tagged_union_field_access?(node)
+          return false unless node.is_a?(Stone::AST::PropertyAccess)
+          return false unless node.respond_to?(:union_field_access?)
+          return false unless node.union_field_access?(@mod)
+
+          union_type = get_union_type_for(node)
+          union_type&.needs_runtime_type_tag?
+        end
+
+        # PropertyAccess patterns that return string pointers
+        private def string_returning_property?(node)
+          return false unless node.is_a?(Stone::AST::PropertyAccess)
+
+          property = node.property
+          # Type.as_String returns a string pointer
+          return true if property == "as_String"
+          # FieldList.name returns a string pointer
+          return true if property == "name"
+
+          false
+        end
+
+        private def safe_get_type(node)
+          node.type(@mod)
+        rescue Stone::PropertyError, Stone::TypeError
+          # Type couldn't be determined at this stage - default to non-pointer (i64)
+          nil
+        end
+
+        private def reference_to_string_constant?(node)
+          return false unless node.is_a?(Stone::AST::Reference)
+
+          # Look in children for a constant definition with this name that has a string value
+          find_string_constant_value(node.identifier)&.is_a?(Stone::AST::StringLiteral)
+        end
+
+        private def mixed_union_field_access?(node)
+          return false unless node.is_a?(Stone::AST::PropertyAccess)
+          return false unless node.respond_to?(:union_field_access?)
+          return false unless node.union_field_access?(@mod)
+
+          union_type = get_union_type_for(node)
+          union_type && !union_type.homogeneous?
+        end
+
+        private def get_union_type_for(property_access)
+          record_type_name = property_access.get_record_type_name(@mod)
+          return nil unless record_type_name
+
+          record_def = @mod.record_types[record_type_name]
+          return nil unless record_def
+
+          annotation = record_def.field_type_annotation(property_access.property)
+          return nil unless Stone::AST::FieldHelpers.union_annotation?(annotation)
+
+          Stone::AST::FieldHelpers.resolve_field_type({type: annotation})
+        end
+
+        private def build_return(builder, last_value)
+          builder.ret(return_value_for(builder, last_value))
+        end
+
+        # Convert return value based on target return type.
+        # - No ptr2int conversions (CHERI-safe)
+        # - Integers/bools return as i64
+        # - Pointers return as-is
+        private def return_value_for(builder, value)
+          return LLVM::Int64.from_i(0) if value.nil?
+          return builder.zext(value, LLVM::Int64.type, "bool_to_i64") if value.type.to_s == "i1"
+
+          # Pointers stay as pointers - no ptr2int
+          value
+        end
+
+        private def compile_children(builder, mod, scope)
+          # Type declarations already registered in generate()
+          compile_statements(builder, mod, scope)
+        end
+
+        private def compile_statements(builder, mod, scope)
+          other_statements.select { |child| child.respond_to?(:to_llir) }.map { |child| child.to_llir(builder, mod, scope) }
+        end
+
+        private def all_statements
+          @all_statements ||= Array(@children).compact
+        end
+
+        private def find_string_constant_value(name)
+          @children&.find { |c| string_constant_definition?(c) && c.identifier == name }&.value_expression
+        end
+
+        private def string_constant_definition?(node)
+          node.is_a?(Stone::AST::ConstantDefinition) && node.value_expression.is_a?(Stone::AST::StringLiteral)
+        end
+
+        private def register_record_types(mod, scope)
+          @children&.each do |child|
+            next unless child.is_a?(Stone::AST::ConstantDefinition)
+
+            register_record_type_definition(child, mod, scope)
+            register_record_instance_if_needed(child, mod)
+          end
+        end
+
+        private def register_record_type_definition(child, mod, scope)
+          return unless child.value_expression.is_a?(Stone::AST::RecordDefinition)
+
+          record_def = child.value_expression
+          record_def.assigned_name = child.identifier
+          mod.register_record_type(child.identifier, record_def)
+          register_record_type_in_registry(child.identifier, record_def, mod, scope)
+        end
+
+        private def register_record_type_in_registry(name, record_def, mod, scope)
+          fields = record_def.fields.map { |f| {name: f[:name], type: f[:type]} }
+          type = Stone::Type.record(name:, fields:, llvm_type: record_def.llvm_type(mod, scope))
+          Stone::Type::Registry.register(type)
+        end
+
+        private def register_record_instance_if_needed(child, mod)
+          if child.value_expression.is_a?(Stone::AST::RecordInstantiation)
+            record_type_name = child.value_expression.record_type_name
+            mod.register_record_instance(child.identifier, record_type_name)
+          elsif child.value_expression.is_a?(Stone::AST::FunctionCall) && mod.record_type?(child.value_expression.function_name)
+            mod.register_record_instance(child.identifier, child.value_expression.function_name)
+          end
+        end
+
+        private def register_function_types
+          @children&.each do |child|
+            next unless child.is_a?(Stone::AST::ConstantDefinition)
+            next unless child.value_expression.is_a?(Stone::AST::Lambda)
+
+            func_type = child.value_expression.type
+            Stone::Type::Registry.register_as(child.identifier, func_type)
+          end
+        end
+
+      end
+    end
+  end
+end