mt-lang 0.3.8 → 0.3.10

data/lib/milk_tea/tooling/debug_info_formatter.rb

@@ -9,9 +9,7 @@ module MilkTea
       FormatString FormatTextPart FormatExprPart
     ].to_set.freeze
 
-    module_function
-
-    def format_all(content:, tokens:, ast:, parse_errors:, facts:, snapshot:, path:, semantic_entries: nil)
+    def self.format_all(content:, tokens:, ast:, parse_errors:, facts:, snapshot:, path:, semantic_entries: nil)
       sections = []
       sections << format_header(content, path)
       sections << format_tokens(tokens, semantic_entries:)
@@ -25,7 +23,7 @@ module MilkTea
 
     # ── Header ────────────────────────────────────────────────────────────────────
 
-    def format_header(content, path)
+    def self.format_header(content, path)
       lines = content.count("\n") + 1
       bytes = content.bytesize
       ["File: #{path}", "Content: #{lines} lines, #{bytes} bytes"].join("\n")
@@ -33,7 +31,7 @@ module MilkTea
 
     # ── Tokens ─────────────────────────────────────────────────────────────────────
 
-    def format_tokens(tokens, semantic_entries: nil)
+    def self.format_tokens(tokens, semantic_entries: nil)
       return '── Tokens  0 ──' if tokens.nil? || tokens.empty?
 
       max_len = tokens.reject { |t| [:newline, :indent, :dedent].include?(t.type) }
@@ -69,7 +67,7 @@ module MilkTea
       lines.join("\n")
     end
 
-    def build_sema_map(entries)
+    def self.build_sema_map(entries)
       return {} unless entries.is_a?(Array) && !entries.empty?
 
       entries.each_with_object({}) do |e, map|
@@ -80,7 +78,7 @@ module MilkTea
 
     # ── AST ────────────────────────────────────────────────────────────────────────
 
-    def format_ast(ast)
+    def self.format_ast(ast)
       return '── AST  (not available) ──' unless ast
 
       counts = %w[imports directives declarations].filter_map do |m|
@@ -93,7 +91,7 @@ module MilkTea
       buf.join("\n")
     end
 
-    def format_ast_node(node, prefix:, is_last:, buf:)
+    def self.format_ast_node(node, prefix:, is_last:, buf:)
       return if node.nil?
 
       if node.is_a?(Array)
@@ -152,11 +150,11 @@ module MilkTea
       end
     end
 
-    def compact_ast_node?(node)
+    def self.compact_ast_node?(node)
       COMPACT_AST_TYPES.include?(node.class.name.split('::').last)
     end
 
-    def compact_ast_repr(node)
+    def self.compact_ast_repr(node)
       kind = node.class.name.split('::').last
       case kind
       when 'QualifiedName'
@@ -197,17 +195,17 @@ module MilkTea
       end
     end
 
-    def type_arg_str(arg)
+    def self.type_arg_str(arg)
       return value_repr(arg) unless arg.respond_to?(:value)
 
       val = arg.value
       ast_node?(val) && compact_ast_node?(val) ? compact_ast_repr(val) : value_repr(val)
     end
 
-    def ast_node_header(node)
+    def self.ast_node_header(node)
       name_attr = node.respond_to?(:name) ? node.name : nil
-      loc = if node.respond_to?(:line) && node.line
-              col = node.respond_to?(:column) && node.column ? ", Col #{node.column}" : ''
+      loc = if node.line
+              col = node.column ? ", Col #{node.column}" : ''
               " [Ln #{node.line}#{col}]"
             else
               ''
@@ -216,21 +214,21 @@ module MilkTea
       name_attr ? "#{kind} ◆ #{name_attr}#{loc}" : "#{kind}#{loc}"
     end
 
-    def ast_node?(val)
+    def self.ast_node?(val)
       val.class.name.to_s.start_with?('MilkTea::AST::')
     rescue StandardError
       false
     end
 
-    def array_of_ast_nodes?(val)
+    def self.array_of_ast_nodes?(val)
       val.is_a?(Array) && val.any? { |e| ast_node?(e) }
     end
 
-    def skip_child_value?(val)
+    def self.skip_child_value?(val)
       val.nil? || val == false || val == [] || val == {} || val == :private
     end
 
-    def keep_child?(val)
+    def self.keep_child?(val)
       return false if skip_child_value?(val)
       return true if val.is_a?(Array) && val.any?
       return true if ast_node?(val) || val.class.name.to_s.start_with?('MilkTea::')
@@ -238,19 +236,19 @@ module MilkTea
       true
     end
 
-    def symbol_icon(count)
+    def self.symbol_icon(count)
       count > 0 ? '◆' : '◇'
     end
 
-    def compact_array_repr(arr)
+    def self.compact_array_repr(arr)
       arr.map { |e| value_repr(e) }.join(', ')
     end
 
-    def simple_value_array?(arr)
+    def self.simple_value_array?(arr)
       arr.all? { |e| e.is_a?(String) || e.is_a?(Symbol) || e.is_a?(Numeric) || e.nil? }
     end
 
-    def value_repr(val)
+    def self.value_repr(val)
       case val
       when nil then 'nil'
       when true then 'true'
@@ -275,13 +273,13 @@ module MilkTea
 
     # ── Parse Errors ────────────────────────────────────────────────────────────────
 
-    def format_parse_errors(errors)
+    def self.format_parse_errors(errors)
       return '── Parse Errors  0 ──' if errors.nil? || errors.empty?
 
       buf = ["── Parse Errors  #{errors.length}  " + '─' * 55]
       errors.each do |e|
-        line = e.respond_to?(:line) ? e.line : '?'
-        col = e.respond_to?(:column) ? e.column : '?'
+        line = e.line || '?'
+        col = e.column || '?'
         buf << "  ERROR [Ln #{line}, Col #{col}]: #{e.message}"
       end
       buf.join("\n")
@@ -289,7 +287,7 @@ module MilkTea
 
     # ── Facts ───────────────────────────────────────────────────────────────────────
 
-    def format_facts(facts)
+    def self.format_facts(facts)
       return '── Facts  (not available) ──' unless facts
 
       counts = []
@@ -356,7 +354,7 @@ module MilkTea
       buf.join("\n")
     end
 
-    def format_function_binding(name, binding, indent:)
+    def self.format_function_binding(name, binding, indent:)
       buf = []
       buf << "#{indent}#{name}"
       buf << "#{indent}  type: #{type_repr(binding.type)}"
@@ -377,14 +375,14 @@ module MilkTea
       buf
     end
 
-    def type_repr(type)
+    def self.type_repr(type)
       return 'nil' unless type
       return type.to_s if type.respond_to?(:to_s)
 
       type.class.name&.split('::')&.last || type.class.to_s
     end
 
-    def value_binding_repr(vb)
+    def self.value_binding_repr(vb)
       mutable = vb.mutable ? 'mut' : '  '
       kind = vb.kind.to_s
       type = vb.flow_type || vb.storage_type
@@ -393,7 +391,7 @@ module MilkTea
 
     # ── Bindings ────────────────────────────────────────────────────────────────────
 
-    def format_bindings(facts)
+    def self.format_bindings(facts)
       return '── Bindings  (not available) ──' unless facts&.binding_resolution
 
       res = facts.binding_resolution
@@ -427,7 +425,7 @@ module MilkTea
 
     # ── Diagnostics ─────────────────────────────────────────────────────────────────
 
-    def format_diagnostics(snapshot)
+    def self.format_diagnostics(snapshot)
       return '── Diagnostics  (not available) ──' unless snapshot
 
       diags = snapshot.diagnostics
@@ -445,8 +443,8 @@ module MilkTea
       diags.each do |d|
         severity = d.respond_to?(:severity) ? d.severity.to_s.upcase : '?'
         code = d.respond_to?(:code) ? d.code : '?'
-        line = d.respond_to?(:line) ? d.line : '?'
-        col = d.respond_to?(:column) ? d.column : '?'
+        line = d.line || '?'
+        col = d.column || '?'
         msg = d.respond_to?(:message) ? d.message : d.to_s
         buf << "  #{severity[0]} #{severity.ljust(7)} #{code} [Ln #{line}, Col #{col}]: #{msg}"
       end

data/lib/milk_tea/tooling/debug_map.rb

@@ -19,7 +19,7 @@ module MilkTea
       end
     end
 
-    Function = Data.define(:name, :linkage_name, :source_path, :line, :params, :locals) do
+    Function = Data.define(:name, :linkage_name, :path, :line, :params, :locals) do
       def to_h(base_dir: nil)
         payload = {
           "name" => name,
@@ -27,7 +27,7 @@ module MilkTea
           "params" => params.map(&:to_h),
           "locals" => locals.map(&:to_h),
         }
-        serialized_source_path = DebugMap.path_for_payload(source_path, base_dir)
+        serialized_source_path = DebugMap.path_for_payload(self.path, base_dir)
         payload["sourcePath"] = serialized_source_path if serialized_source_path
         payload["line"] = line if line
         payload
@@ -57,7 +57,7 @@ module MilkTea
         Function.new(
           name: function.fetch("name"),
           linkage_name: function.fetch("cName"),
-          source_path: path_from_payload(function["sourcePath"], base_dir),
+          path: path_from_payload(function["sourcePath"], base_dir),
           line: function["line"],
           params: load_entries(function["params"]),
           locals: load_entries(function["locals"])
@@ -82,18 +82,18 @@ module MilkTea
 
     def self.from_ir(ir_program, binary_path:)
       functions = ir_program.functions.map do |function|
-        source_path = first_statement_source_path(function.body) || ir_program.source_path
+        source_path = first_statement_source_path(function.body) || ir_program.path
         Function.new(
           name: function.name.to_s,
           linkage_name: function.linkage_name.to_s,
-          source_path: source_path ? File.expand_path(source_path) : nil,
+          path: source_path ? File.expand_path(source_path) : nil,
           line: first_statement_line(function.body),
           params: function.params.map { |param| Entry.new(name: param.name.to_s, linkage_name: param.linkage_name.to_s, line: nil) },
           locals: collect_locals(function.body)
         )
       end
 
-      new(binary_path:, program_source_path: ir_program.source_path, functions:)
+      new(binary_path:, program_source_path: ir_program.path, functions:)
     end
 
     def write(path)
@@ -165,8 +165,6 @@ module MilkTea
     end
 
     class << self
-      private
-
       def load_entries(entries)
         Array(entries).map do |entry|
           Entry.new(name: entry.fetch("name"), linkage_name: entry.fetch("cName"), line: entry["line"])
@@ -199,8 +197,8 @@ module MilkTea
 
       def first_statement_source_path(statements)
         Array(statements).each do |statement|
-          if statement.respond_to?(:source_path) && statement.source_path
-            return statement.source_path
+          if statement.respond_to?(:path) && statement.path
+            return statement.path
           end
 
           nested = nested_statements(statement)

data/lib/milk_tea/tooling/docs_app.rb

@@ -88,8 +88,6 @@ module MilkTea
         html
       end
 
-      private
-
       def snapshot_script_path
         return @snapshot_script_path if defined?(@snapshot_script_path)
 

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

@@ -3,14 +3,12 @@
 module MilkTea
   class Linter
     module LinterDocTags
-      private
-
       def emit_doc_tag_warnings(source_file)
         return if @source_lines.empty?
-  
+
         each_doc_comment_definition(source_file) do |declaration, doc_lines|
           parsed = parse_doc_tag_block(doc_lines)
-  
+
           parsed[:errors].each do |error|
             @warnings << Warning.new(
               path: @path,
@@ -22,7 +20,7 @@ module MilkTea
               severity: :hint,
             )
           end
-  
+
           validate_doc_tags_for_declaration(declaration, parsed[:tags])
         end
       end
@@ -35,34 +33,34 @@ module MilkTea
             declaration
           end
         end
-  
+
         declarations.each do |declaration|
           docs = collect_doc_comment_block_for_line(declaration.line)
           next if docs.nil? || docs.empty?
-  
+
           yield declaration, docs
         end
       end
-  
+
       def collect_doc_comment_block_for_line(line)
         index = line.to_i - 2
         return nil if index.negative?
-  
+
         docs = []
         while index >= 0
           stripped = @source_lines[index].to_s.strip
           break if stripped.empty?
           break unless stripped.start_with?('##')
-  
+
           docs << {
             line: index + 1,
             text: stripped.sub(/\A##\s?/, ''),
           }
           index -= 1
         end
-  
+
         return nil if docs.empty?
-  
+
         docs.reverse
       end
       def parse_doc_tag_block(lines)
@@ -73,16 +71,16 @@ module MilkTea
           see: [],
         }
         errors = []
-  
+
         lines.each do |entry|
           text = entry[:text].to_s
           match = text.match(/\A\s*@([A-Za-z_][A-Za-z0-9_-]*)(?:\s+(.*))?\z/)
           next unless match
-  
+
           tag = match[1].to_s.downcase
           payload = match[2].to_s.strip
           column = doc_tag_column(entry[:line])
-  
+
           case tag
           when 'param'
             if payload.empty?
@@ -94,7 +92,7 @@ module MilkTea
               }
               next
             end
-  
+
             name_match = payload.match(/\A([A-Za-z_][A-Za-z0-9_]*)(?:\s+(.*))?\z/)
             unless name_match
               errors << {
@@ -105,7 +103,7 @@ module MilkTea
               }
               next
             end
-  
+
             tags[:params] << {
               name: name_match[1],
               text: name_match[2].to_s.strip,
@@ -139,7 +137,7 @@ module MilkTea
             }
           end
         end
-  
+
         {
           tags: tags,
           errors: errors,
@@ -149,7 +147,7 @@ module MilkTea
         callable = declaration.respond_to?(:params) && declaration.respond_to?(:return_type)
         param_tags = Array(tags[:params])
         return_tag = tags[:returns]
-  
+
         unless callable
           ([*param_tags, return_tag].compact).each do |tag_entry|
             @warnings << Warning.new(
@@ -164,14 +162,14 @@ module MilkTea
           end
           return
         end
-  
+
         params = Array(declaration.params)
         param_names = params.map(&:name)
         param_name_set = param_names.to_set
-  
+
         param_tags.each do |tag_entry|
           next if param_name_set.include?(tag_entry[:name])
-  
+
           @warnings << Warning.new(
             path: @path,
             line: tag_entry[:line],
@@ -183,12 +181,12 @@ module MilkTea
             symbol_name: tag_entry[:name],
           )
         end
-  
+
         return unless return_tag
-  
+
         return_type_text = declaration.return_type.to_s
         return unless return_type_text == 'void'
-  
+
         @warnings << Warning.new(
           path: @path,
           line: return_tag[:line],
@@ -199,12 +197,12 @@ module MilkTea
           severity: :hint,
         )
       end
-  
+
       def doc_tag_column(line)
         text = @source_lines[line.to_i - 1].to_s
         at_index = text.index('@')
         return 1 if at_index.nil?
-  
+
         at_index + 1
       end
     end

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

@@ -5,9 +5,8 @@ module MilkTea
     FixEdit = Data.define(:start_line, :start_char, :end_line, :end_char, :new_text)
 
     module FixEngine
-      module_function
 
-      def edits_for_rule(code, lines, warning)
+      def self.edits_for_rule(code, lines, warning)
         case code
         when "prefer-let"             then prefer_let_edits(lines, warning)
         when "redundant-ignored-match-binding" then redundant_ignored_match_binding_edits(lines, warning)
@@ -24,8 +23,8 @@ module MilkTea
         end
       end
 
-      def apply_fix_edits(lines, edits)
-        edits.sort_by { |e| [-e.start_line, -e.start_char] }.reverse_each do |edit|
+      def self.apply_fix_edits(lines, edits)
+        edits.sort_by { |e| [-e.start_line, -e.start_char] }.each do |edit|
           if edit.start_line == edit.end_line
             line = lines[edit.start_line]
             next unless line
@@ -40,7 +39,7 @@ module MilkTea
         lines
       end
 
-      def edits_to_lsp_text_edits(edits, uri)
+      def self.edits_to_lsp_text_edits(edits, uri)
         edits.map do |edit|
           {
             range: {
@@ -54,7 +53,7 @@ module MilkTea
 
       # ── per-rule edit generators ──────────────────────────────────────────
 
-      def prefer_let_edits(lines, warning)
+      def self.prefer_let_edits(lines, warning)
         return [] unless warning.line
 
         line_idx = warning.line - 1
@@ -65,7 +64,7 @@ module MilkTea
         [FixEdit.new(start_line: line_idx, start_char: 0, end_line: line_idx + 1, end_char: 0, new_text: new_line)]
       end
 
-      def redundant_ignored_match_binding_edits(lines, warning)
+      def self.redundant_ignored_match_binding_edits(lines, warning)
         return [] unless warning.line && warning.column
 
         line_idx = warning.line - 1
@@ -78,7 +77,7 @@ module MilkTea
         [FixEdit.new(start_line: line_idx, start_char: span[:start_char], end_line: line_idx, end_char: span[:end_char], new_text: "")]
       end
 
-      def prefer_let_else_edits(lines, warning)
+      def self.prefer_let_else_edits(lines, warning)
         return [] unless warning.line
 
         fix = Linter.build_prefer_let_else_fix(lines, warning.line - 1, symbol_name: warning.symbol_name)
@@ -87,11 +86,11 @@ module MilkTea
         [FixEdit.new(start_line: fix[:start_line_idx], start_char: 0, end_line: fix[:end_line_idx] + 1, end_char: 0, new_text: fix[:new_text])]
       end
 
-      def prefer_var_else_edits(lines, warning)
+      def self.prefer_var_else_edits(lines, warning)
         prefer_let_else_edits(lines, warning)
       end
 
-      def redundant_bool_compare_edits(lines, warning)
+      def self.redundant_bool_compare_edits(lines, warning)
         return [] unless warning.line && warning.column && warning.length
 
         line_idx = warning.line - 1
@@ -109,7 +108,7 @@ module MilkTea
         [FixEdit.new(start_line: line_idx, start_char:, end_line: line_idx, end_char:, new_text: replacement)]
       end
 
-      def redundant_else_edits(lines, warning)
+      def self.redundant_else_edits(lines, warning)
         return [] unless warning.line
 
         diag_idx = warning.line - 1
@@ -144,7 +143,7 @@ module MilkTea
         [FixEdit.new(start_line: else_idx, start_char: 0, end_line: body_end_idx + 1, end_char: 0, new_text: new_body)]
       end
 
-      def redundant_return_edits(lines, warning)
+      def self.redundant_return_edits(lines, warning)
         return [] unless warning.line
 
         line_idx = warning.line - 1
@@ -153,7 +152,7 @@ module MilkTea
         [FixEdit.new(start_line: line_idx, start_char: 0, end_line: line_idx + 1, end_char: 0, new_text: "")]
       end
 
-      def unused_import_edits(lines, warning)
+      def self.unused_import_edits(lines, warning)
         return [] unless warning.line
 
         line_idx = warning.line - 1
@@ -162,7 +161,7 @@ module MilkTea
         [FixEdit.new(start_line: line_idx, start_char: 0, end_line: line_idx + 1, end_char: 0, new_text: "")]
       end
 
-      def trailing_list_comma_edits(lines, warning)
+      def self.trailing_list_comma_edits(lines, warning)
         return [] unless warning.line && warning.column
 
         line_idx = warning.line - 1
@@ -176,7 +175,7 @@ module MilkTea
         [FixEdit.new(start_line: line_idx, start_char: char_idx, end_line: line_idx, end_char: char_idx + 1, new_text: "")]
       end
 
-      def redundant_type_annotation_edits(lines, warning)
+      def self.redundant_type_annotation_edits(lines, warning)
         return [] unless warning.line
 
         line_idx = warning.line - 1
@@ -198,7 +197,7 @@ module MilkTea
         [FixEdit.new(start_line: line_idx, start_char: 0, end_line: line_idx + 1, end_char: 0, new_text: new_line)]
       end
 
-      def redundant_cast_edits(lines, warning)
+      def self.redundant_cast_edits(lines, warning)
         return [] unless warning.line && warning.column
 
         line_idx = warning.line - 1
@@ -208,20 +207,34 @@ module MilkTea
         start = warning.column - 1
         return [] unless start >= 0 && start < line.length
 
-        # The warning column points at the cast target type. Delete the
-        # `TargetType<-` prefix, keeping the inner expression as-is. This
-        # covers both bare (`ulong<-x`) and parenthesized (`uint<-(a - b)`)
-        # forms; type refs never contain `<`, so the first `<-` at/after the
-        # column is the cast arrow.
         arrow = line.index("<-", start)
         return [] unless arrow
 
         type_ref = line[start...arrow]
         return [] unless type_ref.match?(/\A[A-Za-z_][A-Za-z0-9_\[\]\.,\s@]*\z/)
 
-        # When the cast is inside an `unsafe:` expression, also remove the
-        # `unsafe: ` wrapper. Look backward from the cast for `unsafe:`.
+        arrow_end = arrow + 2
+
+        # When only the parentheses are redundant (the cast itself is still
+        # needed), remove just the `(` and matching `)`.
+        if warning.message&.include?("parentheses")
+          return [] unless arrow_end < line.length && line[arrow_end] == "("
+
+          open_paren = arrow_end
+          close_paren = match_paren(line, open_paren)
+          return [] unless close_paren
+
+          return [FixEdit.new(start_line: line_idx, start_char: open_paren, end_line: line_idx, end_char: open_paren + 1, new_text: ""),
+                  FixEdit.new(start_line: line_idx, start_char: close_paren, end_line: line_idx, end_char: close_paren + 1, new_text: "")]
+        end
+
+        # Cast to same type / own->ptr / widening are redundant — remove the
+        # `TargetType<-` prefix. When the inner expression is then left
+        # parenthesized with no operators, also strip the orphaned parens.
         new_start = start
+
+        # When the cast is inside an `unsafe:` expression, also remove the
+        # `unsafe: ` wrapper.
         unsafe_keyword = line.rindex("unsafe:", new_start)
         if unsafe_keyword
           prefix = line[unsafe_keyword...new_start]
@@ -230,7 +243,57 @@ module MilkTea
           end
         end
 
-        [FixEdit.new(start_line: line_idx, start_char: new_start, end_line: line_idx, end_char: arrow + 2, new_text: "")]
+        edits = [FixEdit.new(start_line: line_idx, start_char: new_start, end_line: line_idx, end_char: arrow_end, new_text: "")]
+
+        if arrow_end < line.length && line[arrow_end] == "("
+          close_paren = match_paren(line, arrow_end)
+          if close_paren && !inner_has_top_level_operators?(line[arrow_end + 1...close_paren])
+            edits << FixEdit.new(start_line: line_idx, start_char: arrow_end, end_line: line_idx, end_char: arrow_end + 1, new_text: "")
+            edits << FixEdit.new(start_line: line_idx, start_char: close_paren, end_line: line_idx, end_char: close_paren + 1, new_text: "")
+          end
+        end
+
+        edits
+      end
+
+      def self.match_paren(line, open_pos)
+        depth = 0
+        (open_pos...line.length).each do |i|
+          case line[i]
+          when "(" then depth += 1
+          when ")" then depth -= 1; return i if depth == 0
+          end
+        end
+        nil
+      end
+
+      BINARY_OP_CHARS = %w[+ - * / % & | ^ < > = ! ? :].freeze
+
+      def self.inner_has_top_level_operators?(inner)
+        depth = 0
+        i = 0
+        while i < inner.length
+          case inner[i]
+          when "(", "[", "{"
+            depth += 1
+          when ")", "]", "}"
+            depth -= 1 if depth > 0
+          when *BINARY_OP_CHARS
+            if depth == 0 && (inner[i] == "-" || inner[i] == "~") && start_of_expression?(inner, i)
+              i += 1
+              next
+            end
+            return true if depth == 0
+          end
+          i += 1
+        end
+        false
+      end
+
+      def self.start_of_expression?(inner, pos)
+        return true if pos == 0
+        prev = pos - 1
+        prev >= 0 && (inner[prev] == " " || inner[prev] == "\t" || inner[prev] == "(")
       end
     end
   end