rubocop-boochtek 0.2.0 → 0.2.1

data/lib/stone/rtti.rb

@@ -0,0 +1,182 @@
+require "llvm/core"
+
+
+module Stone
+  # Runtime Type Information (RTTI) infrastructure.
+  # Generates global type constants in LLVM IR for runtime type introspection.
+  #
+  # Type kind enum:
+  #   0 = primitive (Int, Bool, String, Null)
+  #   1 = record
+  #   2 = union
+  #   3 = function
+  #   4 = type (metatype)
+  class RTTI
+
+    KIND_PRIMITIVE = 0
+    KIND_RECORD = 1
+    KIND_UNION = 2
+    KIND_FUNCTION = 3
+    KIND_TYPE = 4
+
+    def initialize(mod)
+      @mod = mod
+    end
+
+    def setup
+      define_type_struct
+      generate_primitive_type_constants
+    end
+
+    # Get or create a type constant for the given Stone type
+    def self.type_constant_for(mod, type)
+      name = type_constant_name(type)
+      mod.globals[name] || create_type_constant(mod, type)
+    end
+
+    def self.type_constant_name(type)
+      "Stone.Type.#{type.name}"
+    end
+
+    private def define_type_struct
+      @type_struct = self.class.type_struct_type
+    end
+
+    # Cache the struct type at the class level since it's the same for all modules
+    def self.type_struct_type
+      @type_struct_type ||= create_type_struct_type
+    end
+
+    def self.create_type_struct_type
+      # %Stone.Type = type { ptr, i64, i8, ptr }
+      # Fields: name (string ptr), size (bytes), kind (enum), fields (FieldList ptr)
+      LLVM::Type.struct([
+        LLVM::Type.pointer,  # name - pointer to null-terminated string
+        LLVM::Int64.type,    # size - size in bytes
+        LLVM::Int8.type,     # kind - type kind enum
+        LLVM::Type.pointer   # fields - pointer to FieldList (or null for primitives)
+      ], false)
+    end
+
+    # %Stone.FieldList = type { ptr, ptr, ptr }
+    # Fields: name (string ptr), field_type (Type ptr), tail (FieldList ptr or null)
+    def self.field_list_struct_type
+      @field_list_struct_type ||= LLVM::Type.struct([
+        LLVM::Type.pointer,  # name - pointer to null-terminated string
+        LLVM::Type.pointer,  # field_type - pointer to Type constant
+        LLVM::Type.pointer   # tail - pointer to next FieldList (or null)
+      ], false)
+    end
+
+    private def type_struct
+      @type_struct ||= self.class.type_struct_type
+    end
+
+    private def generate_primitive_type_constants
+      generate_type_constant("Int", 8, KIND_PRIMITIVE)
+      generate_type_constant("Bool", 1, KIND_PRIMITIVE)
+      generate_type_constant("String", 8, KIND_PRIMITIVE)  # pointer size
+      generate_type_constant("Null", 0, KIND_PRIMITIVE)
+      generate_type_constant("Type", 8, KIND_TYPE)  # pointer size
+    end
+
+    private def generate_type_constant(name, size, kind, fields_ptr = nil)
+      name_global = create_name_string(name)
+      fields_value = fields_ptr || LLVM::Type.pointer.null_pointer
+      values = [name_global, LLVM::Int64.from_i(size), LLVM::Int8.from_i(kind), fields_value]
+      add_type_global("Stone.Type.#{name}", values)
+    end
+
+    private def add_type_global(constant_name, values)
+      @mod.globals.add(type_struct, constant_name).tap do |global|
+        global.initializer = LLVM::ConstantStruct.named_const(type_struct, values)
+        global.linkage = :internal
+        global.global_constant = true
+      end
+    end
+
+    private def create_name_string(name)
+      string_name = "Stone.Type.#{name}.name"
+      @mod.globals[string_name] || create_string_constant(string_name, name)
+    end
+
+    private def create_string_constant(global_name, value)
+      array_type = LLVM::Type.array(LLVM::Int8.type, value.bytesize + 1)
+      @mod.globals.add(array_type, global_name).tap do |global|
+        global.initializer = LLVM::ConstantArray.string(value, true)
+        global.linkage = :private
+        global.global_constant = true
+      end
+    end
+
+    # Generate a type constant for a record type with field information
+    def self.generate_record_type_constant(mod, record_name, size_bytes, fields = [])
+      rtti = new(mod)
+      rtti.__send__(:define_type_struct)
+      fields_ptr = rtti.__send__(:generate_field_list, record_name, fields)
+      rtti.__send__(:generate_type_constant, record_name, size_bytes, KIND_RECORD, fields_ptr)
+    end
+
+    private def generate_field_list(record_name, fields)
+      return LLVM::Type.pointer.null_pointer if fields.empty?
+
+      # Generate field entries in reverse order so we can link them correctly
+      field_entries = []
+      fields.reverse_each.with_index do |field, reverse_index|
+        index = fields.length - 1 - reverse_index
+        rest_ptr = field_entries.last || LLVM::Type.pointer.null_pointer
+        entry = generate_field_list_entry(record_name, field, index, rest_ptr)
+        field_entries << entry
+      end
+
+      # Return the first field entry (which is last in our reversed list)
+      field_entries.last
+    end
+
+    private def generate_field_list_entry(record_name, field, index, rest_ptr)
+      name_global = create_field_name_string(record_name, field[:name])
+      type_ptr = field_type_constant(field)
+      values = [name_global, type_ptr, rest_ptr]
+      add_field_list_global("Stone.Field.#{record_name}.#{index}.#{field[:name]}", values)
+    end
+
+    private def field_type_constant(field)
+      field_type = Stone::AST::FieldHelpers.resolve_field_type(field) || Stone::Type::Int
+      self.class.type_constant_for(@mod, field_type)
+    end
+
+    private def add_field_list_global(constant_name, values)
+      struct = self.class.field_list_struct_type
+      @mod.globals.add(struct, constant_name).tap do |global|
+        global.initializer = LLVM::ConstantStruct.named_const(struct, values)
+        global.linkage = :internal
+        global.global_constant = true
+      end
+    end
+
+    private def create_field_name_string(record_name, field_name)
+      string_name = "Stone.Field.#{record_name}.#{field_name}.name"
+      @mod.globals[string_name] || create_string_constant(string_name, field_name)
+    end
+
+    private_class_method def self.create_type_constant(mod, type)
+      rtti = new(mod)
+      rtti.__send__(:define_type_struct)
+      size = type.size_bytes
+      kind = type_kind(type)
+      rtti.__send__(:generate_type_constant, type.name, size, kind)
+      mod.globals[type_constant_name(type)]
+    end
+
+    private_class_method def self.type_kind(type)
+      return KIND_PRIMITIVE if type.primitive?
+      return KIND_RECORD if type.record?
+      return KIND_UNION if type.union?
+      return KIND_FUNCTION if type.function?
+      return KIND_TYPE if type == Stone::Type::Type
+
+      KIND_PRIMITIVE
+    end
+
+  end
+end

data/lib/stone/scope.rb

@@ -0,0 +1,85 @@
+module Stone
+  class Scope
+    attr_reader :parent, :definitions, :type_declarations
+
+    def initialize(parent = nil)
+      @parent = parent
+      @definitions = {}
+      @type_declarations = {}
+    end
+
+    def child
+      Scope.new(self)
+    end
+
+    def define(name, value:, location: nil)
+      @definitions[name] = {value:, location:}
+    end
+
+    def declare_type(name, type:, location: nil)
+      @type_declarations[name] = {type:, location:}
+    end
+
+    def lookup(name)
+      @definitions[name] || @parent&.lookup(name)
+    end
+
+    def lookup_local(name)
+      @definitions[name]
+    end
+
+    def lookup_type_declaration(name)
+      @type_declarations[name] || @parent&.lookup_type_declaration(name)
+    end
+
+    def defined_locally?(name)
+      @definitions.key?(name)
+    end
+
+    def type_declared_locally?(name)
+      @type_declarations.key?(name)
+    end
+
+    def declared_type(name)
+      decl = lookup_type_declaration(name)
+      decl&.dig(:type)
+    end
+
+    def type_declaration_location(name)
+      decl = lookup_type_declaration(name)
+      decl&.dig(:location)
+    end
+
+    # Resolve a type name to verify it exists in scope.
+    # Returns the type name if found, nil otherwise.
+    # Checks: built-in types, type declarations, definitions (constants).
+    # Note: lookup_type_declaration and lookup already traverse parent chain.
+    def lookup_type(name)
+      return name if builtin_type?(name)
+      return name if lookup_type_declaration(name)
+      return name if lookup(name)
+
+      nil
+    end
+
+    private def builtin_type?(name)
+      %w[Int Bool String Type Null].include?(name)
+    end
+
+    def depth
+      @parent ? @parent.depth + 1 : 0
+    end
+
+    def top_level?
+      @parent.nil?
+    end
+
+    def self.top_level
+      @top_level ||= new
+    end
+
+    def self.reset_top_level!
+      @top_level = nil
+    end
+  end
+end

data/lib/stone/transform.rb

@@ -0,0 +1,410 @@
+require "stone/ast"
+require "stone/ast/boolean_literal"
+require "stone/ast/integer_literal"
+require "stone/ast/null_literal"
+require "stone/ast/string_literal"
+require "stone/ast/reference"
+require "stone/ast/type_reference"
+require "stone/ast/type_of_expression"
+require "stone/ast/type_annotation"
+require "stone/ast/function_type_annotation"
+require "stone/ast/union_type_annotation"
+require "stone/ast/type_declaration"
+require "stone/ast/function_call"
+require "stone/ast/property_access"
+require "stone/ast/program_unit"
+require "stone/ast/constant_definition"
+require "stone/ast/computed_property_definition"
+require "stone/ast/lambda"
+require "stone/ast/block"
+require "stone/ast/record_definition"
+require "stone/ast/record_instantiation"
+require "stone/error/overflow"
+require "grammy/tree/transformation"
+
+
+module Stone
+  class Transform
+    include Grammy::Tree::Transformation
+
+    transform(:program_unit) do |node|
+      statement_list = node.find_child(:statement_list)
+      transformed_children = statement_list ? extract_all_statements(statement_list) : []
+      Stone::AST::ProgramUnit.new(transformed_children)
+    end
+
+    transform(:statement) do |node|
+      # Find the definition or expression within the statement.
+      meaningful_child = node.children.find { |child|
+        child.respond_to?(:name) && %i[definition expression].include?(child.name)
+      }
+      transform(meaningful_child) if meaningful_child
+    end
+
+    transform(:definition) do |node|
+      identifier_token = node.children.first
+      expression_node = node.find_child(:expression)
+      value_expression = transform(expression_node)
+
+      identifier_text = identifier_token.text
+
+      if identifier_text.include?("@")
+        # Computed property definition: Type@property
+        type_name, property_name = identifier_text.split("@", 2)
+        Stone::AST::ComputedPropertyDefinition.new(type_name, property_name, value_expression)
+      else
+        Stone::AST::ConstantDefinition.new(identifier_text, value_expression)
+      end
+    end
+
+    transform(:literal_boolean) do |node|
+      token = node.children.first
+      Stone::AST::BooleanLiteral.parse(token.text, token.start_location)
+    end
+
+    transform(:literal_null) do |node|
+      token = node.children.first
+      Stone::AST::NullLiteral.parse(token.text, token.start_location)
+    end
+
+    transform(:literal_string) do |node|
+      token = node.children.first
+      Stone::AST::StringLiteral.parse(token.text, token.start_location)
+    end
+
+    transform(:literal_i64) do |node|
+      token = node.children.first
+      Stone::AST::IntegerLiteral.parse(token.text, token.start_location)
+    end
+
+    transform(:reference) do |node|
+      identifier_token = node.children.first
+      Stone::AST::Reference.new(identifier_token.text)
+    end
+
+    transform(:type_reference) do |_node|
+      Stone::AST::TypeReference.new
+    end
+
+    transform(:type_of_expression) do |node|
+      expression_node = node.find_child(:expression)
+      inner_expression = transform(expression_node)
+      Stone::AST::TypeOfExpression.new(inner_expression)
+    end
+
+    transform(:primary) do |node|
+      # primary can be: literal | reference | lambda | block | parens(expression)
+      # For parenthesized expressions, find and transform the inner expression
+      expression_node = node.find_child(:expression)
+      if expression_node
+        transform(expression_node)
+      else
+        # For other primary nodes (literal, reference, etc.), let default recursion handle them
+        result = nil
+        node.children.each do |child|
+          if child.respond_to?(:name)
+            result = transform(child)
+            break if result
+          end
+        end
+        result
+      end
+    end
+
+    transform(:postfix_expression) do |node|
+      # Grammar: primary + (argument_list | property_accessor)[0..]
+      # Build up expression from left to right: primary -> func_call -> property_access -> ...
+      primary_node = node.find_child(:primary)
+      base = transform(primary_node)
+
+      # Get all postfix operations (argument_list and property_accessor nodes)
+      postfix_ops = node.children.select { |child|
+        child.respond_to?(:name) && %i[argument_list property_accessor].include?(child.name)
+      }
+
+      # Process each postfix operation
+      postfix_ops.reduce(base) do |receiver, op_node|
+        if op_node.respond_to?(:name) && op_node.name == :argument_list
+          # Function call: receiver(args)
+          arguments = extract_expressions_from(op_node)
+          # If receiver is a Reference, use its identifier as function name
+          fail "Function calls on non-reference receivers not yet supported" unless receiver.is_a?(Stone::AST::Reference)
+          Stone::AST::FunctionCall.new(receiver.identifier, arguments)
+        elsif op_node.respond_to?(:name) && op_node.name == :property_accessor
+          # Property access: receiver.property
+          # The property_accessor node contains: str(".") + identifier
+          # Find the identifier (it's the last Match that's not a dot)
+          identifier_match = op_node.children.reverse.find { |c| c.is_a?(Grammy::Match) && c.text != "." }
+          Stone::AST::PropertyAccess.new(receiver, identifier_match.text)
+        else
+          receiver
+        end
+      end
+    end
+
+    transform(:comparison_operation) do |node|
+      # Desugar comparison operations to function calls:
+      # - Binary: `5 < 3` → `<(5, 3)`
+      # - Chained: `1 < 2 < 3` → `<(1, 2, 3)`
+      boolean_operations = node.children.select { |c| c.respond_to?(:name) && c.name == :boolean_operation }
+
+      # All operators in a chain must be the same (e.g., all `<` or all `==`)
+      operators = node.children.select { |c| c.is_a?(Grammy::Match) && c.text !~ /\s/ }
+      operator_name = operators.first.text
+
+      # Verify all operators are the same
+      fail "Mixed comparison operators not allowed: use parentheses to clarify precedence" unless operators.all? { |op| op.text == operator_name }
+
+      # Collect all operands and create varargs function call
+      operands = boolean_operations.map { |expr| transform(expr) }
+      Stone::AST::FunctionCall.new(operator_name, operands)
+    end
+
+    transform(:boolean_operation) do |node|
+      # Desugar boolean operations to function calls:
+      # - Binary: `TRUE ∧ FALSE` → `∧(TRUE, FALSE)`
+      # - Chained: `TRUE ∧ FALSE ∧ TRUE` → `∧(TRUE, FALSE, TRUE)`
+      # - Zero operators: `5` → just return the postfix_expression
+      postfix_expressions = node.children.select { |c| c.respond_to?(:name) && c.name == :postfix_expression }
+
+      # All operators in a chain must be the same (e.g., all `∧` or all `∨`)
+      operators = node.children.select { |c| c.is_a?(Grammy::Match) && c.text !~ /\s/ }
+
+      # If there are no boolean operators, just return the single postfix_expression
+      next transform(postfix_expressions.first) if operators.empty?
+
+      operator_name = operators.first.text
+
+      # Verify all operators are the same
+      fail "Mixed boolean operators not allowed: use parentheses to clarify precedence" unless operators.all? { |op| op.text == operator_name }
+
+      # TODO: Consider detecting mixing of comparison and boolean operators without parentheses
+      # (e.g., `a < b ∧ c > d` parsed as `a < (b ∧ c) > d`). This is valid in the current grammar
+      # but may produce unexpected results.
+
+      # Collect all operands and create varargs function call
+      operands = postfix_expressions.map { |expr| transform(expr) }
+      Stone::AST::FunctionCall.new(operator_name, operands)
+    end
+
+    transform(:lambda) do |node|
+      parameter_list_node = node.find_child(:parameter_list)
+      block_node = node.find_child(:block)
+      block_body_node = block_node ? block_node.find_child(:statement_list) : nil
+
+      parameters = extract_parameters_from(parameter_list_node)
+      body_statements = block_body_node ? extract_all_statements(block_body_node) : []
+
+      Stone::AST::Lambda.new(parameters, body_statements)
+    end
+
+    transform(:block) do |node|
+      statement_list_node = node.find_child(:statement_list)
+      body_statements = statement_list_node ? extract_all_statements(statement_list_node) : []
+
+      Stone::AST::Block.new(body_statements)
+    end
+
+    transform(:type_declaration) do |node|
+      identifier = extract_field_name(node)
+      location = extract_location(node)
+      type_annotation_node = node.find_child(:type_annotation)
+      type_annotation = transform_type_annotation(type_annotation_node)
+
+      Stone::AST::TypeDeclaration.new(identifier, type_annotation, location:)
+    end
+
+    transform(:record_definition) do |node|
+      type_declarations = node.children.select { |child| child.respond_to?(:name) && child.name == :type_declaration }
+
+      fields = type_declarations.map { |type_decl|
+        extract_field_info(type_decl)
+      }
+
+      Stone::AST::RecordDefinition.new(fields)
+    end
+
+    private def extract_all_statements(statement_list_node)
+      statements = []
+      collect_statements(statement_list_node, statements)
+      statements
+    end
+
+    private def extract_from_children(node)
+      children = node.respond_to?(:children) ? node.children : (node if node.is_a?(Array))
+      return [] unless children
+
+      children.flat_map { |child| extract_expressions_from(child) }
+    end
+
+    private def extract_expressions_from(node)
+      return [] unless node
+      return [transform(node)] if expression_node?(node)
+
+      extract_from_children(node)
+    end
+
+    private def expression_node?(node)
+      node.respond_to?(:name) && node.name == :expression
+    end
+
+    private def extract_parameters_from(parameter_list_node)
+      return [] unless parameter_list_node
+
+      identifiers = []
+      collect_identifiers(parameter_list_node, identifiers)
+      identifiers
+    end
+
+    private def collect_identifiers(node, identifiers)
+      return unless node
+      return if add_token_identifier(node, identifiers)
+      return if recurse_into_children(node, identifiers)
+
+      add_match_identifier(node, identifiers)
+    end
+
+    private def add_token_identifier(node, identifiers)
+      return false unless token_identifier?(node)
+
+      identifiers << node.text
+      true
+    end
+
+    private def token_identifier?(node)
+      node.respond_to?(:name) && node.name == :identifier
+    end
+
+    private def recurse_into_children(node, identifiers)
+      return false unless node.respond_to?(:children) && !node.children.empty?
+
+      node.children.each do |child|
+        collect_identifiers(child, identifiers)
+      end
+      true
+    end
+
+    private def add_match_identifier(node, identifiers)
+      return if node.respond_to?(:name) # Skip ParseTree nodes without children
+      return unless valid_identifier_match?(node)
+
+      identifiers << node.to_s
+    end
+
+    private def valid_identifier_match?(node)
+      node.respond_to?(:to_s) && node.to_s.match?(/^[a-zA-Z_][a-zA-Z0-9_]*$/)
+    end
+
+    private def collect_statements(node, statements)
+      return unless node
+
+      # Look for statement, definition, or expression nodes
+      if node.respond_to?(:name) && %i[statement definition expression].include?(node.name)
+        transformed = transform(node)
+        statements << transformed if transformed
+      elsif node.respond_to?(:children)
+        node.children.each { |child| collect_statements(child, statements) }
+      end
+    end
+
+    private def extract_location(node)
+      # Find the first Match child to get the start location
+      first_match = node.children.find { |child| child.is_a?(Grammy::Match) }
+      return nil unless first_match
+      return nil unless first_match.respond_to?(:start_location)
+
+      loc = first_match.start_location
+      {line: loc.line, column: loc.column}
+    end
+
+    private def transform_type_annotation(node)
+      return nil unless node
+
+      type_union_node = node.find_child(:type_union)
+      type_union_node ? transform_type_union(type_union_node) : transform_type_term(node)
+    end
+
+    private def transform_type_union(node)
+      return nil unless node
+
+      type_terms = node.children.select { |c| c.respond_to?(:name) && c.name == :type_term }
+      wrap_in_union_if_multiple(type_terms.map { |t| transform_type_term(t) })
+    end
+
+    private def transform_type_term(node)
+      return nil unless node
+      return transform_type_function(node.find_child(:type_function)) if node.find_child(:type_function)
+      return transform_type_annotation(node.find_child(:type_annotation)) if node.find_child(:type_annotation)
+
+      type_name_node = node.find_child(:type_name)
+      type_name_node ? Stone::AST::TypeAnnotation.new(extract_identifier_from(type_name_node)) : nil
+    end
+
+    private def transform_type_function(node)
+      return nil unless node
+
+      Stone::AST::FunctionTypeAnnotation.new(
+        extract_type_params(node.find_child(:type_params)),
+        transform_type_return(node.find_child(:type_return))
+      )
+    end
+
+    private def transform_type_return(node)
+      return nil unless node
+
+      type_return_union = node.find_child(:type_return_union)
+      return transform_type_return_union(type_return_union) if type_return_union
+
+      type_annotation = node.find_child(:type_annotation)
+      type_annotation ? transform_type_annotation(type_annotation) : nil
+    end
+
+    private def transform_type_return_union(node)
+      return nil unless node
+
+      type_names = node.children.select { |c| c.respond_to?(:name) && c.name == :type_name }
+      wrap_in_union_if_multiple(type_names.map { |tn| Stone::AST::TypeAnnotation.new(extract_identifier_from(tn)) })
+    end
+
+    private def wrap_in_union_if_multiple(alternatives)
+      alternatives.length == 1 ? alternatives.first : Stone::AST::UnionTypeAnnotation.new(alternatives)
+    end
+
+    private def extract_type_params(params_node)
+      return [] unless params_node
+
+      type_annotation_nodes = params_node.children.select { |child|
+        child.respond_to?(:name) && child.name == :type_annotation
+      }
+      type_annotation_nodes.map { |node| transform_type_annotation(node) }
+    end
+
+    private def extract_identifier_from(node)
+      return nil unless node
+
+      # Find the identifier Match within the node
+      if node.is_a?(Grammy::Match)
+        node.text
+      else
+        match = node.children.find { |child| child.is_a?(Grammy::Match) }
+        match&.text
+      end
+    end
+
+    private def extract_field_info(type_decl)
+      # type_declaration: identifier + ws! + str("::") + ws! + type_annotation
+      type_annotation_node = type_decl.find_child(:type_annotation)
+      type_annotation = transform_type_annotation(type_annotation_node)
+      {name: extract_field_name(type_decl), type: type_annotation, type_name: type_annotation&.to_s}
+    end
+
+    private def extract_field_name(type_decl)
+      # Find the field name - it's the first Match with text (not whitespace or ::)
+      type_decl.children.each do |child|
+        return child.text if child.is_a?(Grammy::Match) && child.text && !child.text.strip.empty? && child.text != "::"
+      end
+      nil
+    end
+
+  end
+end