mt-lang 0.3.17 → 0.3.20

data/lib/milk_tea/tooling/cli/commands/format.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+module MilkTea
+  class CLI
+    module CommandFormat
+      def format_command
+        parsed = parse_format_options
+        return 1 unless parsed
+
+        options = parsed[:options]
+        input_paths = parsed[:input_paths]
+
+        if input_paths.empty?
+          @err.puts("missing source file path")
+          print_usage(@err)
+          return 1
+        end
+
+        paths = expand_source_paths(input_paths)
+        return 0 if print_no_source_files_if_empty(paths, input_paths)
+
+        multiple_sources = input_paths.length > 1 || input_paths.any? { |path| File.directory?(path) }
+        if multiple_sources
+          unless options[:check] || options[:write]
+            @err.puts("format on multiple sources requires --check or --write")
+            print_usage(@err)
+            return 1
+          end
+
+          return format_paths(paths, options)
+        end
+
+        path = paths.first
+
+        source = read_source_file(path)
+        format_profile = options[:profile] ? Linter::Profile.new : nil
+        start_time = options[:profile] ? Process.clock_gettime(Process::CLOCK_MONOTONIC) : nil
+        result = Formatter.check_source(source, path: path, mode: options[:mode], max_line_length: options[:max_line_length], profile: format_profile)
+        elapsed_ms = start_time ? ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000.0).round(1) : nil
+
+        rc = if options[:check]
+          announce_file_action(path, "format-check")
+          if result.changed
+            info("needs formatting #{path}")
+            1
+          else
+            info("already formatted #{path}")
+            0
+          end
+        elsif options[:write]
+          announce_file_action(path, "format-write")
+          if result.changed
+            File.write(path, result.formatted_source)
+            info("formatted #{path}")
+          else
+            info("already formatted #{path}")
+          end
+          0
+        else
+          @out.write(result.formatted_source)
+          0
+        end
+
+        print_file_profiles([{ path:, total_ms: elapsed_ms, profile: format_profile }], "format") if options[:profile]
+        rc
+      end
+
+      def format_paths(paths, options)
+        format_profiles = []
+        if options[:check]
+          needs_fmt = []
+          paths.each do |p|
+            announce_file_action(p, "format-check")
+            format_profile = options[:profile] ? Linter::Profile.new : nil
+            start_time = options[:profile] ? Process.clock_gettime(Process::CLOCK_MONOTONIC) : nil
+            result = Formatter.check_source(read_source_file(p), path: p, mode: options[:mode], max_line_length: options[:max_line_length], profile: format_profile)
+            elapsed_ms = start_time ? ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000.0).round(1) : nil
+            format_profiles << { path: p, total_ms: elapsed_ms, profile: format_profile } if options[:profile]
+            needs_fmt << p if result.changed
+          end
+          print_file_profiles(format_profiles, "format") if options[:profile]
+          if needs_fmt.empty?
+            info("all #{paths.size} file(s) already formatted")
+            return 0
+          end
+          needs_fmt.each { |p| info("needs formatting #{p}") }
+          info("#{needs_fmt.size} file(s) need formatting")
+          return 1
+        end
+
+        # --write
+        changed = 0
+        paths.each do |p|
+          announce_file_action(p, "format-write")
+          format_profile = options[:profile] ? Linter::Profile.new : nil
+          start_time = options[:profile] ? Process.clock_gettime(Process::CLOCK_MONOTONIC) : nil
+          result = Formatter.check_source(read_source_file(p), path: p, mode: options[:mode], max_line_length: options[:max_line_length], profile: format_profile)
+          elapsed_ms = start_time ? ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000.0).round(1) : nil
+          format_profiles << { path: p, total_ms: elapsed_ms, profile: format_profile } if options[:profile]
+          if result.changed
+            File.write(p, result.formatted_source)
+            info("formatted #{p}")
+            changed += 1
+          end
+        end
+        print_file_profiles(format_profiles, "format") if options[:profile]
+        info("formatted #{changed} of #{paths.size} file(s)")
+        0
+      end
+
+      def parse_format_options
+        options = {
+          check: false,
+          write: false,
+          mode: :safe,
+          max_line_length: nil,
+          profile: false,
+        }
+        input_paths = []
+
+        until @argv.empty?
+          option = @argv.shift
+          if option.start_with?("-")
+            case option
+            when "--check"
+              options[:check] = true
+            when "--write", "-w"
+              options[:write] = true
+            when "--preserve"
+              options[:mode] = :preserve
+            when "--canonical"
+              options[:mode] = :canonical
+            when "--safe"
+              options[:mode] = :safe
+            when "--tidy"
+              options[:mode] = :tidy
+            when "--max-line-length"
+              value = @argv.shift
+              return missing_option_value(option) unless value
+
+              line_length = Integer(value, exception: false)
+              unless line_length && line_length.positive?
+                @err.puts("--max-line-length must be a positive integer")
+                print_usage(@err)
+                return nil
+              end
+
+              options[:max_line_length] = line_length
+            when "--timings"
+              options[:profile] = true
+            when "--"
+              input_paths.concat(@argv)
+              @argv.clear
+            else
+              @err.puts("unknown format option #{option}")
+              print_usage(@err)
+              return nil
+            end
+          else
+            input_paths << option
+          end
+        end
+
+        if options[:check] && options[:write]
+          @err.puts("format options --check and --write cannot be combined")
+          print_usage(@err)
+          return nil
+        end
+
+        { options:, input_paths: }
+      end
+
+      def print_file_profiles(file_profiles, label)
+        sorted = file_profiles.sort_by { |fp| -fp[:total_ms] }
+        return if sorted.empty?
+
+        @out.puts
+        if sorted.size == 1
+          entry = sorted.first
+          phases = entry[:profile]&.timings_ms&.sort_by { |_, ms| -ms }
+          phase_str = phases&.filter_map { |name, ms| "#{name}: #{format('%.1f', ms)}ms" if ms >= 0.1 }&.join(", ")
+          detail = phase_str && !phase_str.empty? ? " (#{phase_str})" : ""
+          @out.puts("#{label} profile #{entry[:path]}: #{format('%.1f', entry[:total_ms])}ms#{detail}")
+          return
+        end
+
+        @out.puts("Profile (#{label}): #{sorted.size} file(s)")
+        sorted.each do |entry|
+          phases = entry[:profile]&.timings_ms&.sort_by { |_, ms| -ms }
+          phase_str = phases&.filter_map { |name, ms| "#{name}: #{format('%.1f', ms)}ms" if ms >= 1.0 }&.join(", ")
+          detail = phase_str && !phase_str.empty? ? " (#{phase_str})" : ""
+          @out.puts("  #{entry[:path]}: #{format('%.1f', entry[:total_ms])}ms#{detail}")
+        end
+        total = sorted.sum { |fp| fp[:total_ms] }
+        @out.puts("Total: #{format('%.1f', total)}ms")
+      end
+    end
+  end
+end

data/lib/milk_tea/tooling/cli/commands/lex.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module MilkTea
+  class CLI
+    module CommandLex
+      def lex_command
+        path = nil
+        sexpr = false
+
+        args = @argv.dup
+        @argv = []
+        until args.empty?
+          arg = args.shift
+          next if arg == "--"
+
+          if arg == "--sexpr"
+            sexpr = true
+            next
+          end
+
+          if path.nil?
+            path = arg
+          else
+            @err.puts("unknown option: #{arg}")
+            print_usage(@err)
+            return 1
+          end
+        end
+
+        unless path
+          @err.puts("missing source file path")
+          print_usage(@err)
+          return 1
+        end
+
+        tokens = Lexer.lex(read_source_file(path), path: path)
+        if sexpr
+          @out.puts(SexprDumper.dump_tokens(tokens))
+        else
+          @out.write(PP.pp(tokens, +""))
+        end
+        0
+      end
+    end
+  end
+end

data/lib/milk_tea/tooling/cli/commands/lint.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+module MilkTea
+  class CLI
+    module CommandLint
+      def lint_command
+        resolution = { locked: false, frozen: false }
+        select = nil
+        ignore = nil
+        fix = false
+        init = false
+        ignore_generated = false
+        profile = false
+        input_paths = []
+        until @argv.empty?
+          arg = @argv.shift
+          unless arg.start_with?("--")
+            input_paths << arg
+            next
+          end
+
+          flag = arg
+          case flag
+          when "--select"
+            arg = @argv.shift
+            unless arg
+              @err.puts("--select requires a comma-separated list of rule codes")
+              return 1
+            end
+            select = arg.split(",").map(&:strip).to_set
+          when "--ignore"
+            arg = @argv.shift
+            unless arg
+              @err.puts("--ignore requires a comma-separated list of rule codes")
+              return 1
+            end
+            ignore = arg.split(",").map(&:strip).to_set
+          when "--fix"
+            fix = true
+          when "--init"
+            init = true
+          when "--locked"
+            resolution[:locked] = true
+          when "--frozen"
+            resolution[:locked] = true
+            resolution[:frozen] = true
+          when "--ignore-generated"
+            ignore_generated = true
+          when "--timings"
+            profile = true
+          when "--"
+            input_paths.concat(@argv)
+            @argv.clear
+          else
+            @err.puts("unknown lint flag: #{flag}")
+            return 1
+          end
+        end
+
+        if init
+          if input_paths.empty? && !select && !ignore && !fix && !resolution[:locked] && !resolution[:frozen]
+            return init_lint_config
+          end
+
+          @err.puts("--init does not accept source paths or lint options")
+          return 1
+        end
+
+        if input_paths.empty?
+          @err.puts("missing source file path")
+          print_usage(@err)
+          return 1
+        end
+
+        paths = input_paths.flat_map do |path|
+          if File.directory?(path)
+            Dir.glob(File.join(path, "**/*.mt")).sort
+          else
+            [path]
+          end
+        end.uniq
+
+        if paths.empty?
+          label = input_paths.length == 1 ? input_paths.first : input_paths.join(", ")
+          @out.puts("no .mt files found in #{label}")
+          return 0
+        end
+
+        ensure_current_lockfiles!(paths) if resolution[:frozen]
+
+        if fix
+          lint_profiles = []
+          paths.each do |p|
+            announce_file_action(p, "lint-fix")
+            source = read_source_file(p)
+            if ignore_generated && generated_source?(source)
+              @out.puts("ignored generated #{p}")
+              next
+            end
+
+            facts = lint_sema_facts_for(source, p, locked: resolution[:locked])
+            prof = profile ? Linter::Profile.new : nil
+            start_time = profile ? Process.clock_gettime(Process::CLOCK_MONOTONIC) : nil
+
+            fixed = Linter.fix_source(
+              source,
+              path: p,
+              sema_facts: facts,
+              select:,
+              ignore:,
+              profile: prof,
+            )
+            total_ms = start_time ? ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000.0).round(1) : nil
+            lint_profiles << { path: p, profile: prof, mode: :pre_fix_scan, total_ms: } if prof
+            if fixed != source
+              File.write(p, fixed)
+              @out.puts("fixed #{p}")
+            end
+          end
+          print_lint_rule_profiles(lint_profiles) if profile
+          print_lint_file_profiles(lint_profiles) if profile
+          return 0
+        end
+
+        lint_profiles = []
+        all_warnings = paths.flat_map do |p|
+          announce_file_action(p, "lint")
+          source = read_source_file(p)
+          next [] if ignore_generated && generated_source?(source)
+
+          facts = lint_sema_facts_for(source, p, locked: resolution[:locked])
+          prof = profile ? Linter::Profile.new : nil
+          start_time = profile ? Process.clock_gettime(Process::CLOCK_MONOTONIC) : nil
+          warnings = Linter.lint_source(source, path: p, select:, ignore:, sema_facts: facts, profile: prof)
+          total_ms = start_time ? ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000.0).round(1) : nil
+          lint_profiles << { path: p, profile: prof, mode: :lint, total_ms: } if prof
+          warnings
+        end
+
+        if all_warnings.empty?
+          if input_paths.length == 1
+            info("clean #{input_paths.first}")
+          else
+            info("clean #{paths.size} file(s)")
+          end
+          print_lint_file_profiles(lint_profiles) if profile
+          return 0
+        end
+
+        all_warnings.each do |warning|
+          @out.puts("#{warning.path}:#{warning.line}: #{warning.code}: #{warning.message}")
+        end
+
+        print_lint_rule_profiles(lint_profiles) if profile
+        print_lint_file_profiles(lint_profiles) if profile
+
+        file_count = all_warnings.map(&:path).uniq.size
+        noun = all_warnings.size == 1 ? "warning" : "warnings"
+        files_str = file_count == 1 ? "1 file" : "#{file_count} files"
+        @out.puts("Found #{all_warnings.size} #{noun} in #{files_str}.")
+        1
+      end
+
+      def init_lint_config
+        path = File.join(Dir.pwd, Linter::DEFAULT_CONFIG_FILE_NAME)
+        if File.exist?(path)
+          @err.puts("lint config already exists at #{path}")
+          return 1
+        end
+
+        File.write(path, Linter.default_config_source)
+        info("created #{path}")
+        0
+      end
+
+      def print_lint_rule_profiles(lint_profiles, limit: 12)
+        lint_profiles.each do |entry|
+          profile = entry[:profile]
+          next unless profile
+
+          rows = profile.rule_breakdown(limit:, min_ms: 0.0)
+          rule_total = profile.total_time_ms(prefix: "rule.")
+          overall_total = profile.total_time_ms
+          mode_label = entry[:mode] == :pre_fix_scan ? "pre-fix scan" : "lint scan"
+          @out.puts("lint profile #{entry[:path]} (#{mode_label}): rules=#{format('%.1f', rule_total)}ms total=#{format('%.1f', overall_total)}ms")
+
+          if rows.empty?
+            @out.puts("  no rule timing data captured")
+            next
+          end
+
+          rows.each do |row|
+            share = rule_total.positive? ? ((row[:total_ms] / rule_total) * 100.0) : 0.0
+            @out.puts(
+              "  #{row[:code]}: #{row[:count]}x total=#{format('%.1f', row[:total_ms])}ms avg=#{format('%.2f', row[:avg_ms])}ms share=#{format('%.1f', share)}%"
+            )
+          end
+
+          non_rule_rows = profile.timings_ms
+            .filter_map do |name, total_ms|
+              next if name.start_with?("rule.")
+              next if total_ms < 1.0
+
+              [name, total_ms]
+            end
+            .sort_by { |_name, total_ms| -total_ms }
+            .first(5)
+            .map do |name, total_ms|
+              count = profile.counts[name]
+              "#{name}:#{count}x/#{format('%.1f', total_ms)}ms"
+            end
+
+          @out.puts("  non-rule hot phases: #{non_rule_rows.join(', ')}") unless non_rule_rows.empty?
+        end
+      end
+
+      def print_lint_file_profiles(lint_profiles)
+        file_entries = lint_profiles.filter_map do |entry|
+          total = entry[:total_ms]
+          next unless total
+
+          phases = entry[:profile]&.timings_ms&.reject { |name, _| name.start_with?("rule.") }&.sort_by { |_, ms| -ms }
+          { path: entry[:path], total_ms: total, phases: }
+        end
+        return if file_entries.empty?
+
+        sorted = file_entries.sort_by { |e| -e[:total_ms] }
+        @out.puts
+        @out.puts("Profile (lint): #{sorted.size} file(s)")
+        sorted.each do |entry|
+          phase_str = entry[:phases]&.filter_map { |name, ms| "#{name}: #{format('%.1f', ms)}ms" if ms >= 1.0 }&.join(", ")
+          detail = phase_str && !phase_str.empty? ? " (#{phase_str})" : ""
+          @out.puts("  #{entry[:path]}: #{format('%.1f', entry[:total_ms])}ms#{detail}")
+        end
+        total = sorted.sum { |e| e[:total_ms] }
+        @out.puts("Total: #{format('%.1f', total)}ms")
+      end
+
+      def lint_sema_facts_for(source, path, locked: false)
+        ast = Parser.parse(source, path: path)
+        imported_modules = make_module_loader(path, locked:, platform: ModuleLoader.default_host_platform).imported_modules_for_ast(ast, importer_path: path)
+        SemanticAnalyzer.tooling_snapshot(ast, imported_modules: imported_modules, path: path).facts
+      rescue MilkTea::LexError, MilkTea::ParseError, SemanticError, ModuleLoadError
+        nil
+      end
+    end
+  end
+end

data/lib/milk_tea/tooling/cli/commands/lower.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module MilkTea
+  class CLI
+    module CommandLower
+      def lower_command
+        sexpr = false
+        args = @argv.dup
+        @argv = []
+        until args.empty?
+          arg = args.shift
+          if arg == "--sexpr"
+            sexpr = true
+            next
+          end
+          @argv << arg
+        end
+
+        unless @argv.any?
+          @err.puts("missing source file path")
+          print_usage(@err)
+          return 1
+        end
+
+        resolution = extract_resolution_flags!
+        input_paths = @argv.dup
+        return 1 unless ensure_known_source_operands!("lower", input_paths)
+
+        paths = expand_source_paths(input_paths)
+        return 0 if print_no_source_files_if_empty(paths, input_paths)
+
+        ensure_current_lockfiles!(paths) if resolution[:frozen]
+
+        multiple = paths.length > 1
+        paths.each_with_index do |path, index|
+          program = make_module_loader(path, locked: resolution[:locked], platform: ModuleLoader.default_host_platform).check_program(path)
+          if multiple
+            @out.puts("# --- #{path} ---") unless sexpr
+          end
+          if sexpr
+            @out.puts(SexprDumper.dump_ir(Lowering.lower(program)))
+          else
+            @out.write(PrettyPrinter.format_ir(Lowering.lower(program)))
+          end
+        end
+        0
+      end
+    end
+  end
+end

data/lib/milk_tea/tooling/cli/commands/lsp.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module MilkTea
+  class CLI
+    module CommandLsp
+      def lsp_command
+        log_level = nil
+
+        until @argv.empty?
+          arg = @argv.shift
+          case arg
+          when "--log-level"
+            log_level = @argv.shift&.downcase
+            unless log_level && %w[trace debug info warn error].include?(log_level)
+              @err.puts("lsp: invalid --log-level #{log_level.inspect} (expected trace, debug, info, warn, or error)")
+              return 1
+            end
+          when /\A--log-level=(.+)\z/
+            log_level = ::Regexp.last_match(1).downcase
+            unless %w[trace debug info warn error].include?(log_level)
+              @err.puts("lsp: invalid --log-level #{log_level.inspect} (expected trace, debug, info, warn, or error)")
+              return 1
+            end
+          when "--stdio"
+            # stdio is the only transport; accept the flag as a no-op
+          else
+            if arg.start_with?("-")
+              @err.puts("lsp: unknown option #{arg}")
+              return 1
+            end
+            @err.puts("lsp: unexpected argument #{arg}")
+            return 1
+          end
+        end
+
+        require "milk_tea/lsp/server" unless defined?(MilkTea::LSP::Server)
+        server = MilkTea::LSP::Server.new
+        server.run
+        0
+      end
+    end
+  end
+end

data/lib/milk_tea/tooling/cli/commands/new.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module MilkTea
+  class CLI
+    module CommandNew
+      def new_command
+        name = @argv.shift
+        unless name
+          @err.puts("missing project name")
+          print_usage(@err)
+          return 1
+        end
+
+        if @argv.any?
+          @err.puts("unknown new option #{@argv.first}")
+          print_usage(@err)
+          return 1
+        end
+
+        result = ProjectScaffold.create(name)
+        info("created #{result.root_path}")
+        0
+      end
+    end
+  end
+end

data/lib/milk_tea/tooling/cli/commands/parse.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module MilkTea
+  class CLI
+    module CommandParse
+      def parse_command
+        sexpr = false
+        args = @argv.dup
+        @argv = []
+        until args.empty?
+          arg = args.shift
+          if arg == "--sexpr"
+            sexpr = true
+            next
+          end
+          @argv << arg
+        end
+
+        unless @argv.any?
+          @err.puts("missing source file path")
+          print_usage(@err)
+          return 1
+        end
+
+        resolution = extract_resolution_flags!
+        input_paths = @argv.dup
+        return 1 unless ensure_known_source_operands!("parse", input_paths)
+
+        paths = expand_source_paths(input_paths)
+        return 0 if print_no_source_files_if_empty(paths, input_paths)
+
+        ensure_current_lockfiles!(paths) if resolution[:frozen]
+
+        multiple = paths.length > 1
+        paths.each_with_index do |path, index|
+          ast = make_module_loader(path, locked: resolution[:locked], platform: ModuleLoader.default_host_platform).load_file(path)
+          if multiple
+            @out.puts("# --- #{path} ---") unless sexpr
+          end
+          if sexpr
+            @out.puts(SexprDumper.dump_ast(ast))
+          else
+            @out.write(PrettyPrinter.format_ast(ast))
+          end
+          @out.puts if multiple && index < paths.length - 1
+        end
+        0
+      end
+    end
+  end
+end