mt-lang 0.3.8 → 0.3.10

data/lib/milk_tea/tooling/linter/flow_rules.rb

@@ -3,28 +3,26 @@
 module MilkTea
   class Linter
     module LinterFlowRules
-      private
-
       def emit_dead_assignment_warnings(stmts)
         analysis = dead_assignment_analysis(stmts)
         return unless analysis
-  
+
         graph = analysis.graph
         liveness = analysis.liveness
         readable_bindings = analysis.readable_bindings
         locally_declared = analysis.locally_declared
-  
+
         graph.each_node do |node|
           node.writes_info.each do |write|
             next if write[:origin] == :call_argument
               next if write[:origin] == :declaration
-  
+
             binding_key = write[:binding_key]
             name = write[:name]
             next unless readable_bindings.include?(binding_key)
             next unless locally_declared.include?(binding_key)
             next if liveness.live_out[node.id].include?(binding_key)
-  
+
             @warnings << Warning.new(
               path: @path,
               line: write[:line],
@@ -40,17 +38,17 @@ module MilkTea
       def emit_unreachable_warnings(stmts)
         analysis = statement_flow_analysis(stmts)
         return unless analysis
-  
+
         graph = analysis.graph
         reachable = analysis.reachability
-  
+
         graph.each_node do |node|
           next if reachable.reachable_ids.include?(node.id)
           next if node.kind == :exit
           next unless node.statement
-  
+
           statement = node.statement
-          line = statement.respond_to?(:line) ? statement.line : nil
+          line = statement.line
           @warnings << Warning.new(
             path: @path,
             line:,
@@ -65,10 +63,10 @@ module MilkTea
       # is taken from a local variable that is also written later in the same body.
       def emit_borrow_warnings(stmts)
         return if stmts.nil? || stmts.empty?
-  
+
         borrowed = collect_borrowed_names(stmts)
         return if borrowed.empty?
-  
+
         written = collect_written_names(stmts)
         (borrowed & written).each do |name|
           # Find the earliest borrow site for the warning location
@@ -87,7 +85,7 @@ module MilkTea
       end
       def cfg_binding_resolution
         return @cfg_binding_resolution if @cfg_binding_resolution_computed
-  
+
         binding_resolution = @sema_facts&.binding_resolution
         @cfg_binding_resolution = if binding_resolution
                                     ControlFlow::BindingResolution.new(
@@ -101,7 +99,7 @@ module MilkTea
       end
       def statement_flow_analysis(stmts)
         return nil if stmts.nil? || stmts.empty?
-  
+
         @statement_flow_analysis_cache[stmts.object_id] ||= begin
           binding_resolution = cfg_binding_resolution
           graph = profile_phase("flow.graph") do
@@ -118,7 +116,7 @@ module MilkTea
       end
       def dead_assignment_analysis(stmts)
         return nil if stmts.nil? || stmts.empty?
-  
+
         @dead_assignment_analysis_cache[stmts.object_id] ||= begin
           binding_resolution = cfg_binding_resolution
           graph = profile_phase("dead_assignment.graph") do
@@ -147,7 +145,7 @@ module MilkTea
       def cfg_identifier_binding_key(identifier)
         binding_resolution = cfg_binding_resolution
         return identifier.name unless binding_resolution
-  
+
         binding_resolution.identifier_binding_ids[identifier.object_id] || identifier.name
       end
       def ignored_binding_name?(name)
@@ -159,18 +157,18 @@ module MilkTea
       # Uses ConstantPropagation to detect conditions that are always true/false.
       # Skips `while true` — it is an idiomatic infinite loop.
       # Skips if conditions inside loops, since variables can change across iterations.
-  
+
       def emit_constant_condition_warnings(stmts)
         return if stmts.nil? || stmts.empty?
-  
+
         analysis = statement_flow_analysis(stmts)
         return unless analysis
-  
+
         binding_resolution = cfg_binding_resolution
         graph = analysis.graph
         cp = analysis.constant_propagation
         loop_bodies = analysis.loop_body_nodes
-  
+
         graph.each_node do |node|
           cond_expr, line, keyword_pattern, skip_node =
             case node.kind
@@ -188,9 +186,9 @@ module MilkTea
             else
               next
             end
-  
+
           next if skip_node || cond_expr.nil?
-  
+
           in_state  = cp.in_states[node.id] || {}
           const_val = ControlFlow::ConstantPropagation.constant_value_of(
             cond_expr,
@@ -199,7 +197,7 @@ module MilkTea
             strict_binding_ids: !binding_resolution.nil?
           )
           next unless const_val == true || const_val == false
-  
+
           ctx = node.kind == :while_condition ? "loop condition" : "branch condition"
           line, column, length = condition_span(cond_expr, line:, keyword_pattern:)
           @warnings << Warning.new(
@@ -218,7 +216,7 @@ module MilkTea
       # A back-edge exists when a node is reachable from its own successors.
       private def compute_loop_body_nodes(graph)
         loop_nodes = Set.new
-  
+
         # Find all back-edges: detect cycles by checking if any successor of a node
         # can reach back to that node.
         graph.each_node do |node|
@@ -230,38 +228,38 @@ module MilkTea
             end
           end
         end
-  
+
         loop_nodes
       end
-  
+
       # Returns true if target_id is reachable from start_id via forward edges.
       private def reachable_from?(graph, start_id, target_id)
         visited = Set.new
         queue = [start_id]
-  
+
         while queue.any?
           node_id = queue.shift
           return true if node_id == target_id
           next if visited.include?(node_id)
-  
+
           visited.add(node_id)
           node = graph.nodes[node_id]
           node.succs.each { |succ| queue.push(succ) }
         end
-  
+
         false
       end
-  
+
       # Mark all nodes reachable from start_id as being inside a loop.
       private def mark_reachable_nodes(graph, start_id, loop_nodes)
         visited = Set.new
         queue = [start_id]
-  
+
         while queue.any?
           node_id = queue.shift
           loop_nodes.add(node_id)
           next if visited.include?(node_id)
-  
+
           visited.add(node_id)
           node = graph.nodes[node_id]
           node.succs.each { |succ| queue.push(succ) unless visited.include?(succ) }
@@ -270,31 +268,31 @@ module MilkTea
       # ── redundant-null-check ───────────────────────────────────────────────
       # After a variable has been narrowed to non-null by a prior check,
       # a subsequent `x != nil` guard is always true.
-  
+
       def emit_redundant_null_check_warnings(stmts)
         return if stmts.nil? || stmts.empty?
-  
+
         analysis = statement_flow_analysis(stmts)
         return unless analysis
-  
+
         graph = analysis.graph
         nf = analysis.nullability
-  
+
         graph.each_node do |node|
           next unless node.kind == :if_condition
-  
+
           branch = node.statement
           next unless branch.is_a?(AST::IfBranch)
-  
+
           identifier = null_check_identifier(branch.condition)
           next unless identifier
           next if ignored_binding_name?(identifier.name)
-  
+
           nonnull = nf.nonnull_before(branch)
           next unless nonnull.include?(cfg_identifier_binding_key(identifier))
-  
+
           line, column, length = condition_span(branch.condition, line: node.line, keyword_pattern: "else if|if")
-  
+
           @warnings << Warning.new(
             path: @path,
             line:,
@@ -307,12 +305,12 @@ module MilkTea
           )
         end
       end
-  
+
       # Returns the Identifier being nil-tested if `cond` is `x != nil` or
       # `nil != x`, otherwise nil.
       def null_check_identifier(cond)
         return nil unless cond.is_a?(AST::BinaryOp) && cond.operator == "!="
-  
+
         if cond.left.is_a?(AST::Identifier) && cond.right.is_a?(AST::NullLiteral)
           cond.left
         elsif cond.left.is_a?(AST::NullLiteral) && cond.right.is_a?(AST::Identifier)
@@ -322,13 +320,13 @@ module MilkTea
       # ── loop-single-iteration ──────────────────────────────────────────────
       # A loop whose body unconditionally exits (return/break) before the
       # back-edge is taken will execute at most once.
-  
+
       def emit_loop_single_iteration_warnings(stmts)
         return if stmts.nil? || stmts.empty?
-  
+
         walk_stmts_for_loop_check(stmts)
       end
-  
+
       def walk_stmts_for_loop_check(stmts)
         stmts.each do |stmt|
           case stmt

data/lib/milk_tea/tooling/linter/imports_platform.rb

@@ -3,8 +3,6 @@
 module MilkTea
   class Linter
     module LinterImportsPlatform
-      private
-
       # ── unused-import ────────────────────────────────────────────────────
 
       def check_unused_imports(source_file)
@@ -73,7 +71,7 @@ module MilkTea
         end
         return first_export_site if first_export_site
 
-        first_declaration = source_file.declarations.find { |declaration| declaration.respond_to?(:line) && declaration.line }
+        first_declaration = source_file.declarations.find { |declaration| declaration.line }
         return declaration_anchor(first_declaration) if first_declaration
 
         { line: source_file.line || 1, column: 1, length: 1, symbol_name: nil }
@@ -128,9 +126,9 @@ module MilkTea
 
         symbol_name = declaration.respond_to?(:name) ? declaration.name : nil
         length = symbol_name.to_s.empty? ? 1 : symbol_name.to_s.length
-        line = declaration.respond_to?(:line) && declaration.line ? declaration.line : 1
+        line = declaration.line ? declaration.line : 1
 
-        if declaration.respond_to?(:column) && declaration.column
+        if declaration.column
           return { line:, column: declaration.column, length:, symbol_name: }
         end
 
@@ -314,17 +312,17 @@ module MilkTea
         unless attribute.arguments.empty?
           rendered_arguments = attribute.arguments.map do |argument|
             value = case argument.value
-                    when AST::IntegerLiteral, AST::FloatLiteral
-                      argument.value.lexeme
-                    when AST::StringLiteral
-                      argument.value.lexeme
-                    when AST::Identifier
-                      argument.value.name
-                    when AST::MemberAccess
-                      "#{argument.value.receiver.name}.#{argument.value.member}"
-                    else
-                      "..."
-                    end
+            when AST::IntegerLiteral, AST::FloatLiteral
+              argument.value.lexeme
+            when AST::StringLiteral
+              argument.value.lexeme
+            when AST::Identifier
+              argument.value.name
+            when AST::MemberAccess
+              "#{argument.value.receiver.name}.#{argument.value.member}"
+            else
+              "..."
+            end
             argument.name ? "#{argument.name} = #{value}" : value
           end
           text << "(#{rendered_arguments.join(', ')})"

data/lib/milk_tea/tooling/linter/release_rules.rb

@@ -3,8 +3,6 @@
 module MilkTea
   class Linter
     module LinterReleaseRules
-      private
-
       # Entry point — called from visit_function and proc expr in full_tier mode.
       def emit_owning_release_warnings(function_or_body)
         body = function_or_body.is_a?(Array) ? function_or_body : function_or_body.body
@@ -83,7 +81,7 @@ module MilkTea
             if type_name
               result[stmt.name] = {
                 line: stmt.line,
-                column: stmt.respond_to?(:column) ? stmt.column : nil,
+                column: stmt.column,
                 type_name: type_name,
               }
             end
@@ -289,7 +287,7 @@ module MilkTea
             if type_name
               result[stmt.name] = {
                 line: stmt.line,
-                column: stmt.respond_to?(:column) ? stmt.column : nil,
+                column: stmt.column,
                 type_name: type_name,
               }
             end
@@ -725,7 +723,7 @@ module MilkTea
       end
 
       def extract_line(stmt)
-        stmt.respond_to?(:line) ? stmt.line : nil
+        stmt.line
       end
 
       def owning_base_name(qname)

data/lib/milk_tea/tooling/linter/reserved_names.rb

@@ -3,8 +3,6 @@
 module MilkTea
   class Linter
     module LinterReservedNames
-      private
-
       def declare_reserved_value_type_module_binding(name, kind_label:, line:, column:, unavailable_names:)
         declare_reserved_module_binding(
           name,
@@ -15,7 +13,7 @@ module MilkTea
           reserved_names: RESERVED_VALUE_TYPE_NAMES,
         )
       end
-  
+
       def declare_reserved_import_alias_module_binding(name, kind_label:, line:, column:, unavailable_names:)
         declare_reserved_module_binding(
           name,
@@ -26,7 +24,7 @@ module MilkTea
           reserved_names: RESERVED_IMPORT_ALIAS_NAMES,
         )
       end
-  
+
       def declare_reserved_module_binding(name, kind_label:, line:, column:, unavailable_names:, reserved_names:)
         replacement_name = nil
         replacement_base_name = nil
@@ -37,7 +35,7 @@ module MilkTea
             unavailable_names,
           )
         end
-  
+
         binding = Binding.new(
           name:,
           line:,
@@ -52,13 +50,13 @@ module MilkTea
         register_reserved_primitive_name_fix(binding, kind_label:, replacement_name:) if replacement_name
         @module_bindings[name] = binding
       end
-  
+
       def declare_reserved_primitive_module_binding(name, kind_label:, line:, column:, unavailable_names:)
         declare_reserved_value_type_module_binding(name, kind_label:, line:, column:, unavailable_names:)
       end
       def warn_reserved_primitive_name(name, line:, column:, kind_label:, reserved_names: RESERVED_VALUE_TYPE_NAMES)
         return unless reserved_names.include?(name)
-  
+
         @warnings << Warning.new(
           path: @path,
           line:,
@@ -70,10 +68,10 @@ module MilkTea
           symbol_name: name,
         )
       end
-  
+
       def warn_large_event_capacity(event_decl, owner_name:)
         label = owner_name ? "#{owner_name}.#{event_decl.name}" : event_decl.name
-  
+
         @warnings << Warning.new(
           path: @path,
           line: event_decl.line,
@@ -85,16 +83,16 @@ module MilkTea
           symbol_name: event_decl.name,
         )
       end
-  
+
       def warn_redundant_ignored_match_binding(name, line:, column:)
         return unless name == "_"
-  
+
         span = nil
         if line && column
           source_line = @source_lines[line - 1].to_s
           span = self.class.redundant_ignored_match_binding_span(source_line, column:)
         end
-  
+
         @warnings << Warning.new(
           path: @path,
           line:,
@@ -105,7 +103,7 @@ module MilkTea
           severity: :hint,
         )
       end
-  
+
       def warn_reserved_primitive_type_params(type_params, kind_label:)
         Array(type_params).each do |type_param|
           warn_reserved_primitive_name(
@@ -120,7 +118,7 @@ module MilkTea
       def register_reserved_primitive_name_fix(binding, kind_label:, replacement_name:)
         warn_reserved_primitive_name(binding.name, line: binding.line, column: binding.column, kind_label:)
         return unless binding.line && binding.column
-  
+
         binding.fix_index = @reserved_primitive_name_fixes.length
         @reserved_primitive_name_fixes << ReservedPrimitiveNameFix.new(
           kind: kind_label,
@@ -129,7 +127,7 @@ module MilkTea
           sites: [ReservedPrimitiveNameSite.new(line: binding.line, column: binding.column, length: binding.name.length)],
         )
       end
-  
+
       def suggested_reserved_primitive_name(name, kind_label:)
         case kind_label
         when "function"
@@ -140,20 +138,20 @@ module MilkTea
           "#{name}_value"
         end
       end
-  
+
       def next_available_reserved_primitive_name(base_name, unavailable_names)
         unavailable = unavailable_names.to_set
         return base_name unless unavailable.include?(base_name)
-  
+
         suffix = 2
         loop do
           candidate = "#{base_name}_#{suffix}"
           return candidate unless unavailable.include?(candidate)
-  
+
           suffix += 1
         end
       end
-  
+
       def visible_binding_names(excluding_name: nil)
         names = visible_bindings.each_with_object(Set.new) do |binding, result|
           result << binding.name
@@ -162,24 +160,24 @@ module MilkTea
         names.delete(excluding_name) if excluding_name
         names
       end
-  
+
       def visible_bindings
         @module_bindings.values + @scopes.flat_map(&:values)
       end
-  
+
       def resolve_reserved_primitive_name_conflicts!(declared_name)
         visible_bindings.each do |binding|
           next unless binding.replacement_name == declared_name
-  
+
           replacement_name = next_available_reserved_primitive_name(
             binding.replacement_base_name || binding.replacement_name,
             visible_binding_names(excluding_name: binding.name),
           )
           next if replacement_name == binding.replacement_name
-  
+
           binding.replacement_name = replacement_name
           next unless binding.fix_index
-  
+
           fix = @reserved_primitive_name_fixes[binding.fix_index]
           @reserved_primitive_name_fixes[binding.fix_index] = fix.with(replacement_name:)
         end
@@ -187,7 +185,7 @@ module MilkTea
       def record_reserved_primitive_identifier_use(binding, identifier)
         return unless binding.fix_index
         return unless identifier&.line && identifier&.column
-  
+
         @reserved_primitive_name_fixes[binding.fix_index].sites << ReservedPrimitiveNameSite.new(
           line: identifier.line,
           column: identifier.column,