mt-lang 0.3.8 → 0.3.10

data/lib/milk_tea/core/types/layout.rb

@@ -5,19 +5,18 @@ require_relative "types"
 
 module MilkTea
   module Layout
-    module_function
 
     POINTER_SIZE = Fiddle::SIZEOF_VOIDP
 
-    def size_of(type)
+    def self.size_of(type)
       size_and_alignment(type, {})&.first
     end
 
-    def alignment_of(type)
+    def self.alignment_of(type)
       size_and_alignment(type, {})&.last
     end
 
-    def offset_of(type, field_name)
+    def self.offset_of(type, field_name)
       case type
       when Types::Struct, Types::StructInstance, Types::Span, Types::StringView, Types::Task
         fields = ordered_fields(type)
@@ -38,7 +37,7 @@ module MilkTea
       end
     end
 
-    def size_and_alignment(type, stack)
+    def self.size_and_alignment(type, stack)
       case type
       when Types::Primitive
         primitive_layout(type)
@@ -82,7 +81,7 @@ module MilkTea
       end
     end
 
-    def primitive_layout(type)
+    def self.primitive_layout(type)
       case type.name
       when "bool", "byte", "ubyte", "char"
         [1, 1]
@@ -99,7 +98,7 @@ module MilkTea
       end
     end
 
-    def generic_layout(type, stack)
+    def self.generic_layout(type, stack)
       case type.name
       when "ptr", "const_ptr", "own", "ref"
         [POINTER_SIZE, POINTER_SIZE]
@@ -120,7 +119,7 @@ module MilkTea
       end
     end
 
-    def variant_layout(type, stack:)
+    def self.variant_layout(type, stack:)
       payload_layouts = type.arm_names.filter_map do |arm_name|
         fields = type.arm(arm_name)
         next if fields.nil? || fields.empty?
@@ -134,7 +133,7 @@ module MilkTea
       struct_layout_from_infos(field_infos, packed: false, alignment: nil)
     end
 
-    def struct_layout(fields, packed:, alignment:, stack:)
+    def self.struct_layout(fields, packed:, alignment:, stack:)
       field_infos = fields.map do |field_name, field_type|
         field_layout = size_and_alignment(field_type, stack)
         return nil unless field_layout
@@ -145,7 +144,7 @@ module MilkTea
       struct_layout_from_infos(field_infos, packed:, alignment:)
     end
 
-    def union_layout(fields, packed:, alignment:, stack:)
+    def self.union_layout(fields, packed:, alignment:, stack:)
       field_infos = fields.map do |_field_name, field_type|
         field_layout = size_and_alignment(field_type, stack)
         return nil unless field_layout
@@ -156,7 +155,7 @@ module MilkTea
       union_layout_from_layouts(field_infos.map { |size, field_alignment| { size:, alignment: field_alignment } }, packed:, alignment:)
     end
 
-    def struct_layout_from_infos(field_infos, packed:, alignment:)
+    def self.struct_layout_from_infos(field_infos, packed:, alignment:)
       offsets = {}
       offset = 0
       natural_alignment = 1
@@ -177,7 +176,7 @@ module MilkTea
       }
     end
 
-    def union_layout_from_layouts(layouts, packed:, alignment:)
+    def self.union_layout_from_layouts(layouts, packed:, alignment:)
       natural_alignment = packed ? 1 : (layouts.map { |layout| layout[:alignment] }.max || 1)
       overall_alignment = [natural_alignment, alignment || 1].max
       size = layouts.map { |layout| layout[:size] }.max || 0
@@ -188,27 +187,27 @@ module MilkTea
       }
     end
 
-    def ordered_fields(type)
+    def self.ordered_fields(type)
       type.fields
     end
 
-    def packed_layout?(type)
+    def self.packed_layout?(type)
       type.respond_to?(:packed) && type.packed
     end
 
-    def explicit_alignment(type)
+    def self.explicit_alignment(type)
       type.respond_to?(:alignment) ? type.alignment : nil
     end
 
-    def array_type?(type)
+    def self.array_type?(type)
       type.arguments.length == 2 && type.arguments[1].is_a?(Types::LiteralTypeArg) && type.arguments[1].value.is_a?(Integer)
     end
 
-    def str_buffer_type?(type)
+    def self.str_buffer_type?(type)
       type.arguments.length == 1 && type.arguments.first.is_a?(Types::LiteralTypeArg) && type.arguments.first.value.is_a?(Integer)
     end
 
-    def str_buffer_fields(type)
+    def self.str_buffer_fields(type)
       storage_capacity = type.arguments.first.value + 1
       {
         "data" => Types::Registry.generic_instance("array", [Types::Registry.primitive("char"), Types::LiteralTypeArg.new(storage_capacity)]),
@@ -217,28 +216,28 @@ module MilkTea
       }
     end
 
-    def layout_pointer_like_nullable_base?(base)
+    def self.layout_pointer_like_nullable_base?(base)
       return true if base.is_a?(Types::Function) || base.is_a?(Types::Proc) || base.is_a?(Types::Opaque)
       return true if base.is_a?(Types::Primitive) && base.name == "cstr"
 
       base.is_a?(Types::GenericInstance) && %w[ptr const_ptr own ref].include?(base.name)
     end
 
-    def nullable_opt_layout_fields(base)
+    def self.nullable_opt_layout_fields(base)
       {
         "has_value" => Types::Registry.primitive("bool"),
         "value" => base,
       }
     end
 
-    def align_up(value, alignment)
+    def self.align_up(value, alignment)
       return value if alignment <= 1
 
       remainder = value % alignment
       remainder.zero? ? value : value + alignment - remainder
     end
 
-    def with_stack(type, stack)
+    def self.with_stack(type, stack)
       return if stack[type]
 
       stack[type] = true

data/lib/milk_tea/core/types/predicates.rb

@@ -615,8 +615,6 @@ module MilkTea
         end
       end
 
-      private
-
       def char_array_text_type?(type)
         return false unless array_type?(type)
 

data/lib/milk_tea/core/types/registry.rb

@@ -6,80 +6,78 @@ module MilkTea
       @pool = {}
       @mutex = Mutex.new
 
-      module_function
-
-      def reset!
+      def self.reset!
         @mutex.synchronize { @pool.clear }
       end
 
-      def _intern(key, &construct)
+      def self._intern(key, &construct)
         @mutex.synchronize do
           @pool[key] ||= construct.call
         end
       end
 
-      def primitive(name)
+      def self.primitive(name)
         _intern([:primitive, name]) { Primitive.new(name) }
       end
 
-      def nullable(base)
+      def self.nullable(base)
         _intern([:nullable, base]) { Nullable.new(base) }
       end
 
-      def generic_instance(name, arguments)
+      def self.generic_instance(name, arguments)
         args = arguments.freeze
         _intern([:generic, name, args]) { GenericInstance.new(name, args) }
       end
 
-      def span(element_type)
+      def self.span(element_type)
         _intern([:span, element_type]) { Span.new(element_type) }
       end
 
-      def task(result_type)
+      def self.task(result_type)
         _intern([:task, result_type]) { Task.new(result_type) }
       end
 
-      def string_view
+      def self.string_view
         _intern([:string_view]) { StringView.new }
       end
 
-      def function(name, params:, return_type:, receiver_type: nil, receiver_editable: false, variadic: false, external: false)
+      def self.function(name, params:, return_type:, receiver_type: nil, receiver_editable: false, variadic: false, external: false)
         params_frozen = params.freeze
         _intern([:function, name, params_frozen, return_type, receiver_type, receiver_editable, variadic, external]) {
           Function.new(name, params: params_frozen, return_type: return_type, receiver_type: receiver_type, receiver_editable: receiver_editable, variadic: variadic, external: external)
         }
       end
 
-      def proc(params:, return_type:)
+      def self.proc(params:, return_type:)
         params_frozen = params.freeze
         _intern([:proc, params_frozen, return_type]) { Proc.new(params: params_frozen, return_type: return_type) }
       end
 
-      def parameter(name, type, mutable: false, passing_mode: :plain, boundary_type: nil)
+      def self.parameter(name, type, mutable: false, passing_mode: :plain, boundary_type: nil)
         _intern([:parameter, name, type, mutable, passing_mode, boundary_type]) {
           Parameter.new(name, type, mutable: mutable, passing_mode: passing_mode, boundary_type: boundary_type)
         }
       end
 
-      def tuple(element_types, field_names: nil)
+      def self.tuple(element_types, field_names: nil)
         et_frozen = element_types.freeze
         fn_frozen = field_names&.freeze
         _intern([:tuple, et_frozen, fn_frozen]) { Tuple.new(et_frozen, field_names: fn_frozen) }
       end
 
-      def soa(element_type, count:)
+      def self.soa(element_type, count:)
         _intern([:soa, element_type, count]) { SoA.new(element_type, count: count) }
       end
 
-      def simd(element_type, lane_count:)
+      def self.simd(element_type, lane_count:)
         _intern([:simd, element_type, lane_count]) { Simd.new(element_type, lane_count: lane_count) }
       end
 
-      def lifetime_ref(name)
+      def self.lifetime_ref(name)
         LifetimeRef.new(name)
       end
 
-      def dyn(interface_binding, type_arguments = [])
+      def self.dyn(interface_binding, type_arguments = [])
         Dyn.new(interface_binding, type_arguments)
       end
     end

data/lib/milk_tea/core/types/visitor.rb

@@ -188,8 +188,6 @@ module MilkTea
     end
     alias visit_function visit_proc
 
-    private
-
     def visit_children(type)
       type.children.each do |child|
         visit(child)
@@ -431,8 +429,6 @@ module MilkTea
       end
     end
 
-    private
-
     def with_context(new_context)
       old = @context
       @context = new_context

data/lib/milk_tea/dap/backends/lldb_dap.rb

@@ -91,8 +91,6 @@ module MilkTea
           @stderr_thread = nil
         end
 
-        private
-
         def next_seq
           seq = @next_seq
           @next_seq += 1

data/lib/milk_tea/dap/protocol.rb

@@ -46,7 +46,7 @@ module MilkTea
         log_error("DAP protocol write error: #{e.message}")
       end
 
-      private def log_error(message)
+      def log_error(message)
         return unless @error_output
 
         @error_output.puts(message)

data/lib/milk_tea/dap/server/breakpoints.rb

@@ -4,8 +4,6 @@ module MilkTea
   module DAP
     class Server
       module ServerBreakpoints
-        private
-
         def sync_breakpoints_to_backend
           return if @breakpoints_synced_to_backend
 

data/lib/milk_tea/dap/server/debug_map.rb

@@ -4,8 +4,6 @@ module MilkTea
   module DAP
     class Server
       module ServerDebugMap
-        private
-
         def load_debug_map(runnable_path)
           @debug_map = runnable_path ? DebugMap.load_for_binary(runnable_path) : nil
           @frame_debug_functions = {}

data/lib/milk_tea/dap/server/handlers.rb

@@ -4,8 +4,6 @@ module MilkTea
   module DAP
     class Server
       module ServerHandlers
-        private
-
         def handle_initialize(message)
           if @session.initialized?
             write_error_response(message, "initialize can only be called once")

data/lib/milk_tea/dap/server/launch.rb

@@ -4,8 +4,6 @@ module MilkTea
   module DAP
     class Server
       module ServerLaunch
-        private
-
         def request_start(message)
           if @session.launched?
             write_error_response(message, "Program already launched")

data/lib/milk_tea/dap/server/lldb_backend.rb

@@ -4,8 +4,6 @@ module MilkTea
   module DAP
     class Server
       module ServerLLDBBackend
-        private
-
         def using_lldb_backend?
           @session.backend_kind == "lldb-dap"
         end
@@ -22,14 +20,14 @@ module MilkTea
                              end
 
           @lldb_backend = if @backend_factory
-                             build_backend_via_factory(adapter_command)
-                           else
-                             Backends::LLDBDAP.new(
-                               adapter_command: adapter_command,
-                               on_event: method(:handle_backend_event),
-                               on_request: method(:handle_backend_request)
-                             )
-                           end
+            build_backend_via_factory(adapter_command)
+          else
+            Backends::LLDBDAP.new(
+              adapter_command: adapter_command,
+              on_event: method(:handle_backend_event),
+              on_request: method(:handle_backend_request)
+            )
+          end
           @lldb_backend.start!
         end
 

data/lib/milk_tea/dap/server/pause_diagnostics.rb

@@ -4,8 +4,6 @@ module MilkTea
   module DAP
     class Server
       module ServerPauseDiagnostics
-        private
-
         def emit_pause_diagnostic_async(body)
           return unless body.is_a?(Hash)
 
@@ -80,22 +78,22 @@ module MilkTea
           line = dap_value(frame, "line")
 
           location_source = if !source_path.empty? && !source_path.include?("`")
-                              source_path
-                            elsif !source_name.empty?
-                              source_name
-                            elsif !source_path.empty?
-                              source_path
-                            else
-                              instruction_pointer
-                            end
+            source_path
+          elsif !source_name.empty?
+            source_name
+          elsif !source_path.empty?
+            source_path
+          else
+            instruction_pointer
+          end
 
           location = if location_source.to_s.empty?
-                       "(unknown)"
-                     elsif line.to_i.positive? && !location_source.include?(":#{line}")
-                       "#{location_source}:#{line}"
-                     else
-                       location_source
-                     end
+            "(unknown)"
+          elsif line.to_i.positive? && !location_source.include?(":#{line}")
+            "#{location_source}:#{line}"
+          else
+            location_source
+          end
 
           if include_ip && !instruction_pointer.empty? && location != instruction_pointer
             "#{frame_name} @ #{location} ip=#{instruction_pointer}"

data/lib/milk_tea/dap/server/utilities.rb

@@ -6,8 +6,6 @@ module MilkTea
       module ServerUtilities
         PERF_LOG_THRESHOLD_MS = 20
 
-        private
-
         def register_handlers
           @handlers["initialize"] = method(:handle_initialize)
           @handlers["setBreakpoints"] = method(:handle_set_breakpoints)

data/lib/milk_tea/dap/server/wire.rb

@@ -4,8 +4,6 @@ module MilkTea
   module DAP
     class Server
       module ServerWire
-        private
-
         def write_response(request, body)
           write_message({
             seq: @session.next_seq,

data/lib/milk_tea/dap/server.rb

@@ -90,8 +90,6 @@ module MilkTea
         @reader_thread&.join(0.2)
       end
 
-      private
-
       def start_client_reader
         return if @reader_thread&.alive?
 

data/lib/milk_tea/lsp/diagnostics.rb

@@ -77,7 +77,7 @@ module MilkTea
               imports: ast.respond_to?(:imports) ? (ast.imports || []) : [],
               directives: ast.respond_to?(:directives) ? (ast.directives || []) : [],
               declarations: ast.respond_to?(:declarations) ? (ast.declarations || []) : [],
-              line: ast.respond_to?(:line) ? ast.line : 1,
+              line: ast.line || 1,
               node_ids: ast.respond_to?(:node_ids) ? ast.node_ids : {},
             )
           end
@@ -90,14 +90,14 @@ module MilkTea
             cross_by_uri = {}
             target_path = path.is_a?(String) ? File.expand_path(path) : nil
             sema_snapshot.diagnostics.reject { |diagnostic| redundant_unknown_import_diagnostic?(diagnostic, unresolved_import_paths) }
-                           .each do |diagnostic|
-                             if target_path && diagnostic.path && File.expand_path(diagnostic.path) != target_path
-                               target_uri = path_to_uri(diagnostic.path)
-                               (cross_by_uri[target_uri] ||= []) << format_tooling_diagnostic(diagnostic, stage: 'sema')
-                             else
-                               diagnostics << format_tooling_diagnostic(diagnostic, stage: 'sema')
-                             end
-                           end
+              .each do |diagnostic|
+                if target_path && diagnostic.path && File.expand_path(diagnostic.path) != target_path
+                  target_uri = path_to_uri(diagnostic.path)
+                  (cross_by_uri[target_uri] ||= []) << format_tooling_diagnostic(diagnostic, stage: 'sema')
+                else
+                  diagnostics << format_tooling_diagnostic(diagnostic, stage: 'sema')
+                end
+              end
             sema_ms = elapsed_ms(sema_start) if sema_start
           rescue StandardError => e
             log_diagnostics_warning("Error collecting diagnostics: #{e.message}")
@@ -369,12 +369,12 @@ module MilkTea
         start_char, end_char = extract_warning_range(diagnostic, content)
 
         lsp_severity = case diagnostic.severity
-                       when :error   then 1
-                       when :warning then 2
-                       when :info    then 3
-                       when :hint    then 4
-                       else               2
-                       end
+        when :error   then 1
+        when :warning then 2
+        when :info    then 3
+        when :hint    then 4
+        else               2
+        end
         {
           range: {
             start: { line: line_index, character: start_char },
@@ -393,7 +393,7 @@ module MilkTea
       # Returns [start_char, end_char] in 0-based LSP coordinates.
       # Falls back to [0, 1] when a precise token span cannot be inferred.
       def self.extract_warning_range(warning, content)
-        if warning.respond_to?(:column) && warning.column
+        if warning.column
           start_char = [warning.column.to_i - 1, 0].max
           len = warning.respond_to?(:length) ? warning.length.to_i : 0
           len = 1 if len <= 0

data/lib/milk_tea/lsp/server/call_hierarchy.rb

@@ -4,8 +4,6 @@ module MilkTea
   module LSP
     class Server
       module ServerCallHierarchy
-        private
-
         def handle_prepare_call_hierarchy(params)
           text_document = params["textDocument"]
           position = params["position"]
@@ -176,8 +174,8 @@ module MilkTea
         end
 
         def binding_range(binding)
-          line = binding.ast.respond_to?(:line) ? binding.ast.line - 1 : 0
-          col = binding.ast.respond_to?(:column) ? binding.ast.column - 1 : 0
+          line = binding.ast.line ? binding.ast.line - 1 : 0
+          col = binding.ast.column ? binding.ast.column - 1 : 0
           length = binding.name.length
           {
             start: { line: line, character: col },
@@ -188,8 +186,8 @@ module MilkTea
         def selection_range_from_binding(binding)
           name_len = binding.name.length
           ast = binding.ast
-          line = ast.respond_to?(:line) ? ast.line - 1 : 0
-          col = ast.respond_to?(:column) ? ast.column - 1 : 0
+          line = ast.line ? ast.line - 1 : 0
+          col = ast.column ? ast.column - 1 : 0
 
           if ast.respond_to?(:name)
             name_ast = ast.name
@@ -226,11 +224,12 @@ module MilkTea
             callee_name = extract_callee_name(node.callee, facts)
             next unless callee_name
 
+            callee = node.callee
+            line_start = callee.line ? callee.line - 1 : 0
+            col_start = callee.column ? callee.column - 1 : 0
             range = {
-              start: { line: node.callee.respond_to?(:line) ? node.callee.line - 1 : 0,
-                       character: node.callee.respond_to?(:column) ? node.callee.column - 1 : 0 },
-              end: { line: node.callee.respond_to?(:line) ? node.callee.line - 1 : 0,
-                     character: (node.callee.respond_to?(:column) ? node.callee.column - 1 : 0) + callee_name.length },
+              start: { line: line_start, character: col_start },
+              end: { line: line_start, character: col_start + callee_name.length },
             }
 
             callees[callee_name] ||= []
@@ -260,8 +259,8 @@ module MilkTea
         end
 
         def token_range(token)
-          line = token.respond_to?(:line) ? token.line - 1 : 0
-          col = token.respond_to?(:column) ? token.column - 1 : 0
+          line = token.line ? token.line - 1 : 0
+          col = token.column ? token.column - 1 : 0
           len = token.respond_to?(:lexeme) ? token.lexeme.length : 0
           {
             start: { line: line, character: col },