mt-lang 0.3.8 → 0.3.10

data/lib/milk_tea/core/c_backend.rb

@@ -55,13 +55,17 @@ module MilkTea
       @checked_index_alias_id = 0
       @loop_guard_id = 0
       @emitted_span_type_names = Set.new
-      @source_path = program.source_path
+      @source_path = program.path
       @current_line = nil
     end
 
     def emit
       lines = []
       constants = emitted_constants
+      all_struct_decls = emitted_aggregate_structs + collect_generic_struct_decls + collect_task_decls + collect_proc_decls + collect_dyn_decls + collect_str_buffer_decls + collect_nullable_opt_decls
+      all_variant_decls = emitted_aggregate_variants + collect_generic_variant_decls
+      all_decls_for_cycle = all_struct_decls + emitted_aggregate_unions + all_variant_decls
+      @cyclic_aggregate_pairs = build_cyclic_aggregate_pairs(all_decls_for_cycle)
       headers = @program.includes.map(&:header)
       if headers.include?("\"fs_support.h\"") || headers.include?("\"tls_support.h\"") || uses_parallel_for_helper? || uses_spawn_all_helper? || uses_detach_helper?
         lines << "#ifndef _GNU_SOURCE"
@@ -75,7 +79,7 @@ module MilkTea
       if uses_fatal_helper? || uses_format_helpers?
         headers << "<stdio.h>"
       end
-      if uses_fatal_helper? || uses_format_helpers? || uses_async_memory_helpers? || uses_foreign_temp_cstr_helpers? || uses_detach_helper?
+      if uses_fatal_helper? || uses_format_helpers? || uses_async_memory_helpers? || uses_foreign_temp_cstr_helpers? || uses_detach_helper? || uses_cyclic_variant_heap_copy?
         headers << "<stdlib.h>"
       end
       if uses_parallel_for_helper? || uses_spawn_all_helper? || uses_detach_helper?
@@ -143,9 +147,9 @@ module MilkTea
 
       opaque_decls = @program.opaques
       aggregate_decls = sort_aggregate_decls(
-        emitted_aggregate_structs + collect_generic_struct_decls + collect_task_decls + collect_proc_decls + collect_dyn_decls + collect_str_buffer_decls + collect_nullable_opt_decls,
+        all_struct_decls,
         emitted_aggregate_unions,
-        emitted_aggregate_variants + collect_generic_variant_decls,
+        all_variant_decls,
       )
 
       forward_declarations = emit_forward_declarations(opaque_decls, aggregate_decls)
@@ -208,7 +212,13 @@ module MilkTea
       end
 
       if uses_variant_equality_helper?
-        lines.concat(emit_str_equality_helper) unless uses_str_equality_helper?
+        unless uses_str_equality_helper?
+          variant_needs_str_eq = emitted_aggregate_variants.any? { |v| v.arms.any? { |a| a.fields.any? { |f| f.type.is_a?(Types::StringView) } } }
+          if variant_needs_str_eq
+            lines.concat(emit_string_type) unless uses_string_view?
+            lines.concat(emit_str_equality_helper)
+          end
+        end
         lines.concat(emit_variant_equality_helpers)
         lines << ""
       end
@@ -221,14 +231,14 @@ module MilkTea
 
       constants.each do |constant|
         @current_line = constant.line if constant.line
-        @source_path ||= constant.source_path if constant.source_path
+        @source_path ||= constant.path if constant.path
         lines << "#{constant_storage(constant.type)} #{c_declaration(constant.type, constant.linkage_name)} = #{emit_initializer(constant.value)};"
       end
       @program.globals.each do |global|
         next unless emitted_globals.include?(global)
         if global.respond_to?(:line) && global.line
           @current_line = global.line
-          @source_path ||= global.source_path if global.respond_to?(:source_path) && global.source_path
+          @source_path ||= global.path if global.respond_to?(:path) && global.path
         end
         lines << "#{global_storage(global.type)} #{c_declaration(global.type, global.linkage_name)} = #{emit_initializer(global.value)};"
       end
@@ -285,8 +295,6 @@ module MilkTea
       lines.join("\n").rstrip + "\n"
     end
 
-    private
-
     EQUALITY_OPERATORS = ["==", "!="].freeze
 
     include AggregateUtils

data/lib/milk_tea/core/compatibility_helpers.rb

@@ -74,8 +74,6 @@ module MilkTea
       expression.is_a?(AST::RangeExpr)
     end
 
-    private
-
     def string_literal_cstr_compatibility?(expression, expected_type)
       expression.is_a?(AST::StringLiteral) && !expression.cstring && expected_type == BUILTIN_CSTR
     end

data/lib/milk_tea/core/compile_time/const_eval.rb

@@ -4,9 +4,8 @@ require_relative "../types/layout"
 
 module MilkTea
   module ConstEval
-    module_function
 
-    def evaluate(expression, resolve_identifier:, resolve_member_access:, resolve_type_ref: nil, resolve_call: nil)
+    def self.evaluate(expression, resolve_identifier:, resolve_member_access:, resolve_type_ref: nil, resolve_call: nil)
       Evaluator.new(
         resolve_identifier:,
         resolve_member_access:,
@@ -15,7 +14,7 @@ module MilkTea
       ).evaluate(expression)
     end
 
-    def equality_result(left, right)
+    def self.equality_result(left, right)
       return left == right if left.is_a?(Numeric) && right.is_a?(Numeric)
       return left == right if left.is_a?(String) && right.is_a?(String)
       return left == right if boolean_value?(left) && boolean_value?(right)
@@ -24,13 +23,11 @@ module MilkTea
       nil
     end
 
-    def boolean_value?(value)
+    def self.boolean_value?(value)
       value == true || value == false
     end
 
     class Evaluator
-      include Layout
-
       def initialize(resolve_identifier:, resolve_member_access:, resolve_type_ref: nil, resolve_call: nil)
         @resolve_identifier = resolve_identifier
         @resolve_member_access = resolve_member_access
@@ -58,20 +55,20 @@ module MilkTea
           @resolve_call&.call(expression)
         when AST::SizeofExpr
           type = resolve_layout_type(expression.type)
-          type && size_of(type)
+          type && Layout.size_of(type)
         when AST::AlignofExpr
           type = resolve_layout_type(expression.type)
-          type && alignment_of(type)
+          type && Layout.alignment_of(type)
         when AST::OffsetofExpr
           type = resolve_layout_type(expression.type)
           if type
-            result = offset_of(type, expression.field)
+            result = Layout.offset_of(type, expression.field)
             return result if result
 
             id_expr = AST::Identifier.new(name: expression.field)
             value = @resolve_identifier&.call(id_expr)
             if value.is_a?(Types::FieldHandle)
-              return offset_of(type, value.field_name)
+              return Layout.offset_of(type, value.field_name)
             end
           end
           nil
@@ -89,8 +86,6 @@ module MilkTea
         end
       end
 
-      private
-
       def resolve_layout_type(type_ref)
         return unless @resolve_type_ref
 

data/lib/milk_tea/core/compile_time.rb

@@ -58,26 +58,24 @@ module MilkTea
         result
       end
 
-      private
-
       def evaluate_expression(expression, scopes:)
         case expression
         when AST::Identifier
           return @variables[expression.name] if @variables.key?(expression.name)
-          @checker.send(:evaluate_compile_time_const_value, expression, scopes:)
+          @checker.evaluate_compile_time_const_value(expression, scopes:)
         else
           CompileTime.evaluate(
             expression,
             resolve_identifier: ->(id_expr) {
               return @variables[id_expr.name] if @variables.key?(id_expr.name)
-              @checker.send(:evaluate_compile_time_const_value, id_expr, scopes:)
+              @checker.evaluate_compile_time_const_value(id_expr, scopes:)
             },
             resolve_member_access: ->(ma_expr) {
-              @checker.send(:evaluate_compile_time_const_value, ma_expr, scopes:)
+              @checker.evaluate_compile_time_const_value(ma_expr, scopes:)
             },
             resolve_call: ->(call_expr) {
               if call_expr.callee.is_a?(AST::Identifier)
-                func = @checker.send(:top_level_function, call_expr.callee.name)
+                func = @checker.top_level_function(call_expr.callee.name)
                 if func&.ast&.respond_to?(:const) && func.ast.const
                   begin
                     initial_vars = {}
@@ -86,17 +84,17 @@ module MilkTea
 
                       arg_expr = call_expr.arguments[idx].value
                       arg_value = case arg_expr
-                                  when AST::Identifier
-                                    @variables[arg_expr.name] || @checker.send(:evaluate_compile_time_const_value, arg_expr, scopes:)
-                                  else
-                                    CompileTime.evaluate(
-                                      arg_expr,
-                                      resolve_identifier: ->(id) { @variables[id.name] || @checker.send(:evaluate_compile_time_const_value, id, scopes:) },
-                                      resolve_member_access: ->(ma) { @checker.send(:evaluate_compile_time_const_value, ma, scopes:) },
-                                      resolve_type_ref: nil,
-                                      resolve_call: nil,
-                                    )
-                                  end
+                      when AST::Identifier
+                        @variables[arg_expr.name] || @checker.evaluate_compile_time_const_value(arg_expr, scopes:)
+                      else
+                        CompileTime.evaluate(
+                          arg_expr,
+                          resolve_identifier: ->(id) { @variables[id.name] || @checker.evaluate_compile_time_const_value(id, scopes:) },
+                          resolve_member_access: ->(ma) { @checker.evaluate_compile_time_const_value(ma, scopes:) },
+                          resolve_type_ref: nil,
+                          resolve_call: nil,
+                        )
+                      end
                       return nil unless arg_value
 
                       initial_vars[param.name] = arg_value
@@ -108,17 +106,17 @@ module MilkTea
                   end
                 end
               end
-              
+
               types = if @checker.respond_to?(:types)
-                         @checker.types
-                       else
-                         @checker.instance_variable_get(:@ctx).types
-                       end
+                @checker.types
+              else
+                @checker.instance_variable_get(:@ctx).types
+              end
               callee_name = if call_expr.callee.is_a?(AST::Specialization) && call_expr.callee.callee.respond_to?(:name)
-                              call_expr.callee.callee.name
-                            elsif call_expr.callee.respond_to?(:name)
-                              call_expr.callee.name
-                            end
+                call_expr.callee.callee.name
+              elsif call_expr.callee.respond_to?(:name)
+                call_expr.callee.name
+              end
               if callee_name && (type = types[callee_name]) && type.is_a?(Types::Struct)
                 fields = {}
                 call_expr.arguments.each do |argument|
@@ -130,8 +128,8 @@ module MilkTea
               end
 
               if call_expr.callee.is_a?(AST::Specialization) && @checker.respond_to?(:resolve_type_expression)
-                resolved = @checker.send(:resolve_type_expression, call_expr.callee)
-                if resolved && @checker.respond_to?(:array_type?) && @checker.send(:array_type?, resolved)
+                resolved = @checker.resolve_type_expression(call_expr.callee)
+                if resolved && @checker.respond_to?(:array_type?) && @checker.array_type?(resolved)
                   values = []
                   call_expr.arguments.each do |argument|
                     val = evaluate_expression(argument.value, scopes:)
@@ -141,8 +139,8 @@ module MilkTea
                   next values
                 end
               end
-              
-              @checker.send(:evaluate_compile_time_const_value, call_expr, scopes:)
+
+              @checker.evaluate_compile_time_const_value(call_expr, scopes:)
             },
           )
         end
@@ -261,7 +259,6 @@ module MilkTea
     end
 
     class Evaluator < ConstEval::Evaluator
-      private
 
       def resolve_layout_type(type_ref)
         super
@@ -273,8 +270,8 @@ module MilkTea
 
         value = evaluate(expression)
         return value if value.is_a?(Types::Struct) || value.is_a?(Types::Primitive) ||
-                       value.is_a?(Types::Union) || value.is_a?(Types::Nullable) ||
-                       value.is_a?(Types::StructInstance)
+          value.is_a?(Types::Union) || value.is_a?(Types::Nullable) ||
+          value.is_a?(Types::StructInstance)
 
         nil
       end
@@ -282,9 +279,7 @@ module MilkTea
 
     end
 
-    module_function
-
-    def evaluate(expression, resolve_identifier:, resolve_member_access:, resolve_type_ref: nil, resolve_call: nil)
+    def self.evaluate(expression, resolve_identifier:, resolve_member_access:, resolve_type_ref: nil, resolve_call: nil)
       Evaluator.new(
         resolve_identifier:,
         resolve_member_access:,
@@ -293,7 +288,7 @@ module MilkTea
       ).evaluate(expression)
     end
 
-    def boolean_value?(value)
+    def self.boolean_value?(value)
       ConstEval.boolean_value?(value)
     end
 
@@ -357,7 +352,6 @@ module MilkTea
           Types::BUILTIN_TYPE_META_TYPE
         end
       end
-
     end
   end
 end

data/lib/milk_tea/core/control_flow/builder.rb

@@ -45,8 +45,6 @@ module MilkTea
         @graph = nil
       end
 
-      private
-
       def build_block(stmts, next_id, break_target:, continue_target:)
         current_next = next_id
         stmts.reverse_each do |stmt|
@@ -114,7 +112,7 @@ module MilkTea
             cond_id = @graph.add_node(
               kind: :if_condition,
               statement: branch,
-              line: branch.respond_to?(:line) ? branch.line : stmt.line,
+              line: branch.line || stmt.line,
               reads: branch_reads,
               reads_info: branch_reads_info,
             )
@@ -140,7 +138,7 @@ module MilkTea
               arm_body = if arm.respond_to?(:body)
                            arm.body
                          else
-                           [MilkTea::AST::ExpressionStmt.new(expression: arm.value, line: arm.value.respond_to?(:line) ? arm.value.line : nil)]
+                           [MilkTea::AST::ExpressionStmt.new(expression: arm.value, line: arm.value.line)]
                          end
               arm_entry = build_block(arm_body, next_id, break_target:, continue_target:)
               if arm.binding_name
@@ -267,7 +265,7 @@ module MilkTea
       end
 
       def add_linear_node(kind, stmt, next_id, reads: Set.new, reads_info: [], writes: Set.new, writes_info: [])
-        node_id = @graph.add_node(kind:, statement: stmt, line: stmt.respond_to?(:line) ? stmt.line : nil, reads:, reads_info:, writes:, writes_info:)
+        node_id = @graph.add_node(kind:, statement: stmt, line: stmt.line, reads:, reads_info:, writes:, writes_info:)
         @graph.add_edge(node_id, next_id)
         node_id
       end

data/lib/milk_tea/core/control_flow/constant_propagation.rb

@@ -59,7 +59,6 @@ module MilkTea
 
         a == b ? a : NAC
       end
-      private_class_method :join_lattice
 
       def self.eval_const(statement, _write, in_state, binding_resolution:, strict_binding_ids:)
         case statement
@@ -71,7 +70,6 @@ module MilkTea
           NAC
         end
       end
-      private_class_method :eval_const
 
       def self.eval_assignment_const(statement, in_state, binding_resolution:, strict_binding_ids:)
         return NAC unless statement.target.is_a?(AST::Identifier)
@@ -86,24 +84,23 @@ module MilkTea
 
         begin
           v = case statement.operator
-              when "+="  then lhs.value + rhs.value
-              when "-="  then lhs.value - rhs.value
-              when "*="  then lhs.value * rhs.value
-              when "/="  then rhs.value.zero? ? (return NAC) : lhs.value / rhs.value
-              when "%="  then rhs.value.zero? ? (return NAC) : lhs.value % rhs.value
-              when "&="  then lhs.value & rhs.value
-              when "|="  then lhs.value | rhs.value
-              when "^="  then lhs.value ^ rhs.value
-              when "<<=" then lhs.value << rhs.value
-              when ">>=" then lhs.value >> rhs.value
-              else return NAC
-              end
+          when "+="  then lhs.value + rhs.value
+          when "-="  then lhs.value - rhs.value
+          when "*="  then lhs.value * rhs.value
+          when "/="  then rhs.value.zero? ? (return NAC) : lhs.value / rhs.value
+          when "%="  then rhs.value.zero? ? (return NAC) : lhs.value % rhs.value
+          when "&="  then lhs.value & rhs.value
+          when "|="  then lhs.value | rhs.value
+          when "^="  then lhs.value ^ rhs.value
+          when "<<=" then lhs.value << rhs.value
+          when ">>=" then lhs.value >> rhs.value
+          else return NAC
+          end
           ConstVal.new(v)
         rescue ZeroDivisionError, RangeError
           NAC
         end
       end
-      private_class_method :eval_assignment_const
 
       def self.eval_expr_const(expr, state, binding_resolution:, strict_binding_ids:)
         return NAC if expr.nil?
@@ -120,8 +117,9 @@ module MilkTea
           resolve_member_access: nil,
         )
         value.nil? ? NAC : ConstVal.new(value)
+      rescue CompileTime::Error
+        NAC
       end
-      private_class_method :eval_expr_const
 
       def self.constant_value_of(expr, in_state, binding_resolution: nil, strict_binding_ids: false)
         result = send(:eval_expr_const, expr, in_state, binding_resolution:, strict_binding_ids:)
@@ -137,7 +135,6 @@ module MilkTea
 
         identifier_expression.name
       end
-      private_class_method :identifier_key
     end
   end
 end

data/lib/milk_tea/core/control_flow/definite_assignment.rb

@@ -73,7 +73,6 @@ module MilkTea
         end
         universe
       end
-      private_class_method :initial_universe
     end
   end
 end

data/lib/milk_tea/core/ir.rb

@@ -2,12 +2,12 @@
 
 module MilkTea
   module IR
-    Program = Data.define(:module_name, :includes, :constants, :globals, :opaques, :structs, :unions, :enums, :variants, :static_asserts, :functions, :source_path) do
-      def initialize(module_name:, includes:, constants:, globals:, opaques:, structs:, unions:, enums:, variants:, static_asserts:, functions:, source_path: nil) = super
+    Program = Data.define(:module_name, :includes, :constants, :globals, :opaques, :structs, :unions, :enums, :variants, :static_asserts, :functions, :path) do
+      def initialize(module_name:, includes:, constants:, globals:, opaques:, structs:, unions:, enums:, variants:, static_asserts:, functions:, path: nil) = super
     end
     Include = Data.define(:header)
-    Constant = Data.define(:name, :linkage_name, :type, :value, :line, :source_path) do
-      def initialize(name:, linkage_name:, type:, value:, line: nil, source_path: nil) = super
+    Constant = Data.define(:name, :linkage_name, :type, :value, :line, :path) do
+      def initialize(name:, linkage_name:, type:, value:, line: nil, path: nil) = super
     end
     Global = Data.define(:name, :linkage_name, :type, :value)
     OpaqueDecl = Data.define(:name, :linkage_name, :forward_declarable, :source_module) do
@@ -27,8 +27,8 @@ module MilkTea
     end
     Param = Data.define(:name, :linkage_name, :type, :pointer)
 
-    LocalDecl = Data.define(:name, :linkage_name, :type, :value, :line, :source_path) do
-      def initialize(name:, linkage_name:, type:, value:, line: nil, source_path: nil) = super
+    LocalDecl = Data.define(:name, :linkage_name, :type, :value, :line, :path) do
+      def initialize(name:, linkage_name:, type:, value:, line: nil, path: nil) = super
     end
     Assignment = Data.define(:target, :operator, :value)
     BlockStmt = Data.define(:body)
@@ -45,11 +45,11 @@ module MilkTea
     GotoStmt = Data.define(:label)
     LabelStmt = Data.define(:name)
     StaticAssert = Data.define(:condition, :message)
-    ReturnStmt = Data.define(:value, :line, :source_path) do
-      def initialize(value:, line: nil, source_path: nil) = super
+    ReturnStmt = Data.define(:value, :line, :path) do
+      def initialize(value:, line: nil, path: nil) = super
     end
-    ExpressionStmt = Data.define(:expression, :line, :source_path) do
-      def initialize(expression:, line: nil, source_path: nil) = super
+    ExpressionStmt = Data.define(:expression, :line, :path) do
+      def initialize(expression:, line: nil, path: nil) = super
     end
 
     Name = Data.define(:name, :type, :pointer)

data/lib/milk_tea/core/lexer/character_classes.rb

@@ -4,8 +4,6 @@ module MilkTea
   class Lexer
     # Identifier lexing plus the raw-byte character-classification helpers.
     module CharacterClasses
-      private
-
       def lex_identifier(line, index, line_number, line_offset:)
         start = index
         length = line.length
@@ -17,11 +15,11 @@ module MilkTea
         lexeme = line[start...index]
         type = Token::KEYWORDS.fetch(lexeme, :identifier)
         literal = case type
-                  when :true then true
-                  when :false then false
-                  when :null then nil
-                  else nil
-                  end
+          when :true then true
+          when :false then false
+          when :null then nil
+          else nil
+        end
 
         @tokens << token(type, lexeme, literal, line_number, start + 1, start_offset: line_offset + start, end_offset: line_offset + index)
         index

data/lib/milk_tea/core/lexer/format_strings.rb

@@ -5,8 +5,6 @@ module MilkTea
     # Format string lexing (`f"...#{expr}..."`) and the interpolation
     # scanning / format-spec splitting shared with format heredocs.
     module FormatStrings
-      private
-
       def parse_format_heredoc_parts(content, start_line:, start_column:)
         parts = []
         text = +""
@@ -182,13 +180,13 @@ module MilkTea
           end
 
           case char
-          when "(", "[", "{"
-            depth += 1
-          when ")", "]", "}"
-            depth -= 1 if depth.positive?
-          when ":"
-            suffix = source[(index + 1)..]
-            format_spec_index = index if depth.zero? && format_spec_suffix?(suffix)
+            when "(", "[", "{"
+              depth += 1
+            when ")", "]", "}"
+              depth -= 1 if depth.positive?
+            when ":"
+              suffix = source[(index + 1)..]
+              format_spec_index = index if depth.zero? && format_spec_suffix?(suffix)
           end
 
           index += 1

data/lib/milk_tea/core/lexer/heredocs.rb

@@ -5,8 +5,6 @@ module MilkTea
     # Heredoc lexing (`<<-TAG`, `c<<-TAG`, `f<<-TAG`) including content
     # dedenting, terminator detection, and recovery.
     module Heredocs
-      private
-
       def lex_heredoc(lines, line_index, index, line_number, line_offset, cstring:, format: false)
         line = lines.fetch(line_index).delete_suffix("\n").b
         prefix_length = heredoc_prefix(cstring:, format:).length
@@ -91,17 +89,18 @@ module MilkTea
             content_margin = heredoc_content_margin(content_lines)
 
             literal = if format
-                         parse_format_heredoc_parts(value, start_line: line_number + 1, start_column: content_margin + 1)
-                       else
-                         value
-                       end
+              parse_format_heredoc_parts(value, start_line: line_number + 1, start_column: content_margin + 1)
+            else
+              value
+            end
+
             token_type = if format
-                           :fstring
-                         elsif cstring
-                           :cstring
-                         else
-                           :string
-                         end
+              :fstring
+            elsif cstring
+              :cstring
+            else
+              :string
+            end
 
             @tokens << token(token_type, lexeme, literal, line_number, index + 1, start_offset:, end_offset:)
             emit_line_newline(last_line, last_line_number, last_line_offset, last_line_has_newline)
@@ -118,17 +117,18 @@ module MilkTea
         content_margin = heredoc_content_margin(content_lines)
 
         literal = if format
-                     parse_format_heredoc_parts(value, start_line: line_number + 1, start_column: content_margin + 1)
-                   else
-                     value
-                   end
+          parse_format_heredoc_parts(value, start_line: line_number + 1, start_column: content_margin + 1)
+        else
+          value
+        end
+
         token_type = if format
-                       :fstring
-                     elsif cstring
-                       :cstring
-                     else
-                       :string
-                     end
+          :fstring
+        elsif cstring
+          :cstring
+        else
+          :string
+        end
 
         @tokens << token(token_type, lexeme, literal, line_number, index + 1, start_offset:, end_offset:)
         emit_line_newline(terminator_line, terminator_line_number, terminator_line_offset, terminator_has_newline)

data/lib/milk_tea/core/lexer/indentation.rb

@@ -4,8 +4,6 @@ module MilkTea
   class Lexer
     # Indentation-to-INDENT/DEDENT token conversion and error recovery.
     module Indentation
-      private
-
       def emit_indentation(indent, line_number, line_offset)
         if (indent % 4) != 0
           raise LexError.new("indentation must use multiples of 4 spaces", line: line_number, column: indent + 1, path: @path)

data/lib/milk_tea/core/lexer/numbers.rb

@@ -4,8 +4,6 @@ module MilkTea
   class Lexer
     # Integer and float literal lexing, including type suffixes and exponents.
     module Numbers
-      private
-
       def lex_number(line, index, line_number, line_offset:)
         start = index
         type = :integer

data/lib/milk_tea/core/lexer/recovery.rb

@@ -5,8 +5,6 @@ module MilkTea
     # Error-recovery heuristics: detecting a top-level declaration line to
     # resynchronize on after an unterminated grouping or heredoc.
     module Recovery
-      private
-
       def top_level_resync_line?(line)
         return false if line.strip.empty?
         return false if leading_space_count(line).positive?

data/lib/milk_tea/core/lexer/strings.rb

@@ -5,8 +5,6 @@ module MilkTea
     # String literal lexing (including adjacent-literal continuation),
     # character literal lexing, and escape-sequence decoding.
     module Strings
-      private
-
       def lex_string(lines, line_index, line, index, line_number, line_offset:, cstring: false)
         segment = scan_string_segment(line, index, line_number, cstring:, recover: @recovery_errors)
         consumed_lines = 1

data/lib/milk_tea/core/lexer/symbols.rb

@@ -4,8 +4,6 @@ module MilkTea
   class Lexer
     # Operator / punctuation lexing and grouping-delimiter depth tracking.
     module Symbols
-      private
-
       def lex_symbol(line, index, line_number, line_offset:)
         start = index
         lexeme = line[index, 3]

data/lib/milk_tea/core/lexer/trivia.rb

@@ -5,8 +5,6 @@ module MilkTea
     # Trivia collection (comments, blank lines, whitespace) used only when
     # lexing in :with_trivia mode for the concrete syntax tree / formatter.
     module Trivia
-      private
-
       def with_trivia?
         @mode == :with_trivia
       end