rubocop-boochtek 0.2.0 → 0.2.1

data/lib/stone/type.rb

@@ -0,0 +1,323 @@
+module Stone
+  # Value object representing a type in the Stone language.
+  # Each type (Int, Bool, String, etc.) is a singleton instance registered in TypeRegistry.
+  # Access via Stone::Type::Int, Stone::Type::Bool, etc.
+  class Type
+
+    # Size in bytes for primitive types, used for union payload sizing
+    PRIMITIVE_SIZES = {
+      "Int" => 8,
+      "Bool" => 1,
+      "String" => 8,  # pointer size
+      "Null" => 0,
+      "Type" => 8,    # pointer size
+      "FieldList" => 8  # pointer size
+    }.freeze
+
+    # Alignment requirements for primitive types
+    PRIMITIVE_ALIGNMENTS = {
+      "Int" => 8,
+      "Bool" => 1,
+      "String" => 8,  # pointer alignment
+      "Null" => 1,
+      "Type" => 8,    # pointer alignment
+      "FieldList" => 8  # pointer alignment
+    }.freeze
+
+    attr_reader :name, :llvm_type, :fields, :min, :max, :param_types, :return_type
+    attr_accessor :property_types
+
+    def initialize(name:, llvm_type:, property_types: {}, fields: nil, **options)
+      @name = name
+      @llvm_type = llvm_type
+      @property_types = property_types
+      @fields = fields
+      @primitive = options[:primitive] || false
+      @min = options[:min]
+      @max = options[:max]
+      @param_types = options[:param_types]
+      @return_type = options[:return_type]
+    end
+
+    def property_return_type(property_name)
+      @property_types[property_name] || field_type(property_name)
+    end
+
+    private def field_type(field_name)
+      return nil unless @fields
+
+      field = @fields.find { |f| f[:name] == field_name }
+      return nil unless field
+
+      Stone::AST::FieldHelpers.resolve_field_type(field)
+    end
+
+    def primitive?
+      @primitive
+    end
+
+    def record?
+      !@primitive && !@fields.nil?
+    end
+
+    def size_bytes
+      return PRIMITIVE_SIZES[@name] if primitive? && PRIMITIVE_SIZES.key?(@name)
+      # Records are stored as pointers in unions (to avoid infinite recursion with recursive types)
+      return 8 if record?  # pointer size
+      return 8 if function?  # function pointer
+
+      8  # default
+    end
+
+    def alignment
+      return PRIMITIVE_ALIGNMENTS[@name] if primitive? && PRIMITIVE_ALIGNMENTS.key?(@name)
+      # Records are stored as pointers in unions
+      return 8 if record?  # pointer alignment
+
+      8  # default pointer alignment
+    end
+
+    def pointer_type?
+      %w[String Null].include?(@name) || record?
+    end
+
+    def payload_llvm_type
+      case @name
+      when "Null" then LLVM::Type.pointer
+      when "Int" then LLVM::Int64.type
+      when "Bool" then LLVM::Int1.type
+      when "String" then LLVM::Type.pointer
+      else LLVM::Type.pointer  # records and other pointer types
+      end
+    end
+
+    def function?
+      @param_types.is_a?(Array)
+    end
+
+    def union?
+      false
+    end
+
+    def nullable?
+      false
+    end
+
+    def non_null_type
+      self
+    end
+
+    def compatible_with?(other)
+      return true if self == other
+      return other.alternatives.any? { |alt| compatible_with?(alt) } if other.union?
+
+      function? && function_compatible_with?(other)
+    end
+
+    private def function_compatible_with?(other)
+      return false unless other.function?
+      return false unless param_types.length == other.param_types.length
+
+      params_compatible?(other) && return_type.compatible_with?(other.return_type)
+    end
+
+    private def params_compatible?(other)
+      param_types.zip(other.param_types).all? { |a, b| a.compatible_with?(b) }
+    end
+
+    def as_String
+      name
+    end
+
+    def ==(other)
+      other.is_a?(self.class) && other.name == name
+    end
+    alias eql? ==
+
+    def hash
+      name.hash
+    end
+
+    def to_s
+      name
+    end
+
+    def inspect
+      "#<Stone::Type:#{name}>"
+    end
+
+    def self.primitive(name:, llvm_type:, property_types: {}, min: nil, max: nil)
+      new(name:, llvm_type:, property_types:, primitive: true, min:, max:)
+    end
+
+    def self.record(name:, fields:, llvm_type:)
+      new(name:, llvm_type:, fields:, primitive: false)
+    end
+
+    def self.function(param_types:, return_type:)
+      param_names = param_types.map(&:name).join(", ")
+      return_name = return_type.function? ? "(#{return_type.name})" : return_type.name
+      name = "(#{param_names}) -> #{return_name}"
+      new(name:, llvm_type: nil, param_types:, return_type:)
+    end
+
+    def self.union(alternatives:)
+      union = Union.new(alternatives:)
+      union.alternatives.length == 1 ? union.alternatives.first : union
+    end
+
+    # Union type - represents a value that can be one of several types
+    class Union < Type
+      attr_reader :alternatives
+
+      def initialize(alternatives:)
+        @alternatives = flatten_and_dedupe(alternatives)
+        fail ::ArgumentError, "Union type requires at least one alternative" if @alternatives.empty?
+
+        super(name: generate_name, llvm_type: create_variable_sized_llvm_type)
+      end
+
+      def size_bytes
+        8 + payload_size  # tag pointer (8 bytes) + payload
+      end
+
+      def alignment
+        # Union alignment is max of pointer alignment and payload alignment
+        [8, payload_alignment].max
+      end
+
+      def payload_size
+        @alternatives.map(&:size_bytes).max || 0
+      end
+
+      def payload_alignment
+        @alternatives.map(&:alignment).max || 1
+      end
+
+      def common_llvm_result_type
+        # Determine best common type for phi merge without int2ptr/ptr2int conversions.
+        # - If ALL non-null alternatives are pointers, use pointer
+        # - If ALL non-null alternatives are integers, use i64
+        # - For MIXED types, return nil (caller should not extract, return union as-is)
+        non_null_alts = @alternatives.reject { |alt| alt.name == "Null" }
+        return LLVM::Int64.type if non_null_alts.empty?
+
+        all_pointers = non_null_alts.all?(&:pointer_type?)
+        all_integers = non_null_alts.all? { |alt| %w[Int Bool].include?(alt.name) }
+
+        return LLVM::Type.pointer if all_pointers
+        return LLVM::Int64.type if all_integers
+
+        nil # Mixed types - don't extract
+      end
+
+      def homogeneous?
+        # Returns true if all non-null alternatives have compatible LLVM types
+        !common_llvm_result_type.nil?
+      end
+
+      # Returns true if the union contains types that cannot be distinguished by value alone.
+      # For example, Bool | Int - both are integers, and Bool(1) looks like Int(1).
+      # Such unions require returning the runtime type tag to Ruby for proper interpretation.
+      def needs_runtime_type_tag?
+        non_null_names = @alternatives.reject { |alt| alt.name == "Null" }.map(&:name)
+        non_null_names.include?("Bool") && non_null_names.include?("Int")
+      end
+
+      private def create_variable_sized_llvm_type
+        payload_array = LLVM::Type.array(LLVM::Int8.type, payload_size)
+        LLVM::Type.struct([LLVM::Type.pointer, payload_array], false)
+      end
+
+      def union?
+        true
+      end
+
+      def primitive?
+        false
+      end
+
+      def record?
+        false
+      end
+
+      def function?
+        false
+      end
+
+      def nullable?
+        @alternatives.any? { |t| null_type?(t) }
+      end
+
+      # Look through non-null alternatives for a property.
+      # Returns the property type if ALL non-null alternatives have it with the same type.
+      # This enables chained access like `o.value.x` where `value` is `Point | Null`.
+      def property_return_type(property_name)
+        non_null_alts = @alternatives.reject { |alt| null_type?(alt) }
+        return nil if non_null_alts.empty?
+
+        # Get property type from each non-null alternative
+        prop_types = non_null_alts.map { |alt| alt.property_return_type(property_name) }
+
+        # All alternatives must have this property
+        return nil if prop_types.any?(&:nil?)
+
+        # For now, require all alternatives to return the same type
+        # (Future: could return a union of the return types)
+        return nil unless prop_types.uniq.length == 1
+
+        prop_types.first
+      end
+
+      def non_null_type
+        remaining = @alternatives.reject { |t| null_type?(t) }
+        return remaining.first if remaining.length == 1
+
+        Stone::Type.union(alternatives: remaining)
+      end
+
+      def compatible_with?(other)
+        other.union? ? covers_all_alternatives?(other) : includes_compatible_type?(other)
+      end
+
+      private def covers_all_alternatives?(union)
+        union.alternatives.all? { |alt| includes_compatible_type?(alt) }
+      end
+
+      private def includes_compatible_type?(type)
+        @alternatives.any? { |t| t.compatible_with?(type) }
+      end
+
+      def ==(other)
+        return false unless other.is_a?(Union)
+
+        Set.new(@alternatives) == Set.new(other.alternatives)
+      end
+      alias eql? ==
+
+      def hash
+        Set.new(@alternatives).hash
+      end
+
+      private def generate_name
+        names = @alternatives.map(&:name)
+        non_null = names.reject { |n| n == "Null" }.sort
+        null = names.select { |n| n == "Null" }
+        (non_null + null).join(" | ")
+      end
+
+      private def flatten_and_dedupe(types)
+        flattened = types.flat_map { |t| t.union? ? t.alternatives : [t] }
+        flattened.uniq
+      end
+
+      private def null_type?(type)
+        type.name == "Null"
+      end
+    end
+
+  end
+
+  # Backwards compatibility alias (deprecated - use Stone::Type directly)
+  TypeInstance = Type
+end

data/lib/stone/type_context.rb

@@ -0,0 +1,38 @@
+module Stone
+  class TypeContext
+
+    attr_reader :llvm_module
+
+    def initialize(llvm_module = nil)
+      @llvm_module = llvm_module
+      @bindings = {}
+    end
+
+    def bind(name, type)
+      @bindings[name] = type
+    end
+
+    def lookup(name)
+      @bindings[name]
+    end
+
+    def with_llvm_module(mod)
+      new_context = self.class.new(mod)
+      new_context.instance_variable_set(:@bindings, @bindings.dup)
+      new_context
+    end
+
+    def record_type?(name)
+      return false unless @llvm_module
+
+      @llvm_module.record_type?(name)
+    end
+
+    def record_definition(name)
+      return nil unless @llvm_module
+
+      @llvm_module.record_types&.[](name)
+    end
+
+  end
+end

data/lib/stone/type_registry.rb

@@ -0,0 +1,73 @@
+require "singleton"
+
+
+module Stone
+  class TypeRegistry
+    include Singleton
+
+    def initialize
+      @types = {}
+    end
+
+    def register(type)
+      @types[type.name] = type
+      type
+    end
+
+    def register_as(name, type)
+      @types[name] = type
+      type
+    end
+
+    def lookup(name)
+      @types[name]
+    end
+    alias [] lookup
+
+    def registered?(name)
+      @types.key?(name)
+    end
+
+    def record?(name)
+      type = @types[name]
+      return false unless type
+
+      !type.primitive?
+    end
+
+    def all
+      @types.values
+    end
+
+    def primitives
+      @types.values.select(&:primitive?)
+    end
+
+    def records
+      @types.values.reject(&:primitive?)
+    end
+
+    # Convenience accessors for built-in types
+    def int
+      @types["Int"]
+    end
+
+    def bool
+      @types["Bool"]
+    end
+
+    def string
+      @types["String"]
+    end
+
+    def type
+      @types["Type"]
+    end
+
+    # Reset registry (useful for testing)
+    def reset!
+      @types.clear
+    end
+
+  end
+end

data/lib/stone/types.rb

@@ -0,0 +1,104 @@
+require "llvm/core"
+require "stone/type"
+require "stone/type_registry"
+
+# LLVM type alias for convenience
+I64 = LLVM::Int64.type
+
+
+# Bootstrap the TypeRegistry with primitive types
+module Stone
+  module Types
+  module_function
+
+    INT_MIN = -(2**63)   # -9_223_372_036_854_775_808
+    INT_MAX = 2**63 - 1  # +9_223_372_036_854_775_807
+
+    def bootstrap_registry!
+      types = create_primitive_types
+      register_all_types(types)
+      setup_property_types(types)
+      setup_type_constants(types)
+      Stone::TypeRegistry.instance
+    end
+
+    def create_primitive_types
+      {
+        int: Stone::Type.primitive(name: "Int", llvm_type: LLVM::Int64.type, min: INT_MIN, max: INT_MAX),
+        bool: Stone::Type.primitive(name: "Bool", llvm_type: LLVM::Int1.type),
+        string: Stone::Type.primitive(name: "String", llvm_type: LLVM::Int64.type),
+        type: Stone::Type.primitive(name: "Type", llvm_type: LLVM::Type.pointer),
+        null: Stone::Type.primitive(name: "Null", llvm_type: LLVM::Type.ptr),
+        # FieldList is a list-like type for record field metadata
+        # TODO: Replace with List(Field) once generics are available
+        field_list: Stone::Type.primitive(name: "FieldList", llvm_type: LLVM::Type.pointer)
+      }
+    end
+
+    def register_all_types(types)
+      registry = Stone::TypeRegistry.instance
+      types.each_value { |type| registry.register(type) }
+    end
+
+    def setup_property_types(types)
+      setup_int_properties(types)
+      setup_bool_properties(types)
+      setup_string_properties(types)
+      setup_type_properties(types)
+      setup_field_list_properties(types)
+    end
+
+    def setup_type_properties(types)
+      types[:type].property_types.merge!(
+        "as_String" => types[:string],
+        "record?" => types[:bool],
+        "primitive?" => types[:bool],
+        "kind" => types[:int],
+        "size" => types[:int],
+        "fields" => types[:field_list]
+      )
+    end
+
+    def setup_field_list_properties(types)
+      types[:field_list].property_types.merge!(
+        "first" => types[:field_list],  # .first returns the FieldList itself (list-like access)
+        "name" => types[:string],       # Field name
+        "type" => types[:type],         # Type of the field
+        "rest" => types[:field_list]    # Next FieldList or NULL
+      )
+    end
+
+    def setup_int_properties(types)
+      types[:int].property_types.merge!(
+        "positive?" => types[:bool], "negative?" => types[:bool],
+        "zero?" => types[:bool], "as_String" => types[:string]
+      )
+    end
+
+    def setup_bool_properties(types)
+      types[:bool].property_types.merge!("not" => types[:bool], "as_String" => types[:string])
+    end
+
+    def setup_string_properties(types)
+      types[:string].property_types.merge!(
+        "byte_count" => types[:int], "empty?" => types[:bool], "as_String" => types[:string]
+      )
+    end
+
+    def setup_type_constants(types)
+      # Define type constants on Stone::Type for convenient access
+      # Only define if not already defined (avoids warnings during test resets)
+      types.each_value do |type|
+        define_type_constant(type.name.to_sym, type)
+      end
+      define_type_constant(:Registry, Stone::TypeRegistry.instance)
+    end
+
+    private def define_type_constant(name, value)
+      Stone::Type.const_set(name, value) unless Stone::Type.const_defined?(name, false)
+    end
+  end
+end
+
+# Bootstrap on load
+Stone::Types.bootstrap_registry!

data/lib/stone.rb

@@ -0,0 +1,70 @@
+# Load extensions
+Dir[File.join(__dir__, "extensions", "*.rb")].each do
+  require_relative it
+end
+
+require "llvm/core"
+require "llvm/execution_engine"
+
+require "extensions/llvm_module"
+require "grammy/scanner"
+require "stone/scope"
+require "stone/error"
+require "stone/error/overflow"
+require "stone/error/reference_error"
+require "stone/error/argument_error"
+require "stone/error/type_error"
+require "stone/grammar"
+require "stone/transform"
+require "stone/ast"
+require "stone/ast/integer_literal"
+require "stone/ast/string_literal"
+require "stone/ast/reference"
+require "stone/ast/function_call"
+require "stone/ast/constant_definition"
+require "stone/ast/computed_property_definition"
+require "stone/ast/program_unit"
+
+
+module Stone
+
+  def self.parse(input)
+    Stone::Grammar.parse(input)
+  end
+
+  def self.transform(parse_tree)
+    transformer = Stone::Transform.new
+    transformer.transform(parse_tree)
+  end
+
+  # Returns an AST
+  def self.compile(input)
+    input_with_prelude = prepend_prelude(input)
+    parse_tree = parse(input_with_prelude)
+    transform(parse_tree)
+  end
+
+  def self.prepend_prelude(input)
+    "#{prelude_code}\n#{input}"
+  end
+
+  def self.prelude_code
+    @prelude_code ||= File.read(prelude_path)
+  end
+
+  def self.prelude_path
+    File.expand_path("stone/prelude.stone", __dir__)
+  end
+
+  def self.eval(input)
+    ast = compile(input)
+    ast.eval
+  end
+
+  def self.eval_with_scope(input)
+    Stone::Scope.reset_top_level!
+    result = self.eval(input)
+    [result, Stone::Scope.top_level]
+  end
+
+end