mt-lang 0.3.16 → 0.3.20

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

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

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module MilkTea
+  class CLI
+    module CommandRun
+      def run_command
+        path, options = extract_path_and_options
+        return 1 unless path
+
+        run_and_print_result(path, options)
+      end
+
+      def app_command
+        options = parse_build_options
+        return 1 unless options
+
+        module_name = @argv.shift
+        unless module_name
+          @err.puts("missing module name")
+          print_usage(@err)
+          return 1
+        end
+
+        path = resolve_app_module(module_name)
+        unless path
+          @err.puts("run-module module not found: #{module_name}")
+          return 1
+        end
+
+        frozen = options.delete(:frozen)
+        ensure_current_lockfile!(path) if frozen
+
+        run_and_print_result(path, options)
+      end
+
+      def extract_path_and_options(allow_clean: false)
+        options = parse_build_options(allow_clean:)
+        return nil unless options
+
+        path = @argv.shift
+        unless path
+          if File.file?(File.join(Dir.pwd, "package.toml"))
+            path = Dir.pwd
+          else
+            @err.puts("missing source file path")
+            print_usage(@err)
+            return nil
+          end
+        end
+
+        [path, options]
+      end
+
+      def run_and_print_result(path, options)
+        frozen = options.delete(:frozen)
+        ensure_current_lockfile!(path) if frozen
+        locked = options.delete(:locked)
+        package_graph = package_graph_for(path, locked:)
+        preview_notice_emitted = false
+        preview_started = lambda do |message|
+          preview_notice_emitted = true
+          @out.write(message)
+          @out.flush if @out.respond_to?(:flush)
+        end
+
+        result = Run.run(
+          path,
+          module_roots: module_roots_for(path, locked:),
+          package_graph:,
+          frontend: @build_frontend,
+          preview_started:,
+          argv: @argv.dup,
+          **options.except(:timings)
+        )
+        unless @out.equal?($stdout) || preview_notice_emitted
+          @out.write(result.stdout)
+        end
+        @out.flush if @out.respond_to?(:flush)
+        @err.write(result.stderr) unless @err.equal?($stderr)
+        info("[cached]") if result.cached
+        result.exit_status
+      end
+
+      def resolve_app_module(name)
+        relative = name.tr(".", "/").sub(%r{^/}, "") + ".mt"
+
+        module_roots_for(Dir.pwd).each do |root|
+          candidate = File.join(root, "std", relative)
+          return File.expand_path(candidate) if File.file?(candidate)
+
+          candidate = File.join(root, relative)
+          return File.expand_path(candidate) if File.file?(candidate)
+        end
+
+        nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module MilkTea
+  class CLI
+    module CommandSnapshot
+      def snapshot_command
+        input_path = nil
+        theme_path = nil
+        output_path = nil
+        textmate_only = false
+
+        until @argv.empty?
+          arg = @argv.first
+          case arg
+          when "--theme", "-t"
+            @argv.shift
+            theme_path = @argv.shift
+            unless theme_path
+              @err.puts("snapshot: missing value for --theme")
+              return 1
+            end
+          when "--output", "-o"
+            @argv.shift
+            output_path = @argv.shift
+            unless output_path
+              @err.puts("snapshot: missing value for --output")
+              return 1
+            end
+          when "--textmate-only"
+            @argv.shift
+            textmate_only = true
+          else
+            if arg.start_with?("-")
+              @err.puts("snapshot: unknown option #{arg}")
+              return 1
+            end
+            unless input_path
+              input_path = @argv.shift
+            else
+              @err.puts("snapshot: unexpected argument #{@argv.shift}")
+              return 1
+            end
+          end
+        end
+
+        unless input_path
+          @err.puts("snapshot: missing source file path")
+          print_usage(@err)
+          return 1
+        end
+
+        unless File.file?(input_path)
+          @err.puts("snapshot: source file not found: #{input_path}")
+          return 1
+        end
+
+        input_path = File.expand_path(input_path)
+        theme_path = File.expand_path(theme_path) if theme_path
+        output_path = File.expand_path(output_path) if output_path
+
+        if theme_path && !File.file?(theme_path)
+          @err.puts("snapshot: theme file not found: #{theme_path}")
+          return 1
+        end
+
+        snapshot_script = MilkTea.root.join("bindings/vscode/scripts/snapshot.js").to_s
+        unless File.file?(snapshot_script)
+          @err.puts("snapshot: internal script not found at #{snapshot_script}")
+          return 1
+        end
+
+        args = ["node", snapshot_script, input_path]
+        args.push("-t", theme_path) if theme_path
+        args.push("-o", output_path) if output_path
+
+        semantic_result = nil
+        unless textmate_only
+          begin
+            semantic_result = MilkTea::LSP::Server.semantic_tokens_for_path(input_path)
+          rescue => e
+            @err.puts("snapshot: semantic analysis skipped: #{e.message}")
+          end
+        end
+
+        if semantic_result && semantic_result[:entries] && !semantic_result[:entries].empty?
+          source = File.read(input_path)
+          lines = source.split("\n", -1)
+          semantic_result[:entries].each do |entry|
+            byte_start = entry[:startChar]
+            byte_len = entry[:length]
+            line_text = lines[entry[:line]]
+            unless line_text && byte_start && byte_len
+              entry[:startChar] = 0
+              entry[:length] = 0
+              next
+            end
+            char_start = line_text.byteslice(0, byte_start).length
+            char_length = line_text.byteslice(byte_start, byte_len).length
+            char_length = line_text.length - char_start if char_start + char_length > line_text.length
+            entry[:startChar] = char_start
+            entry[:length] = char_length
+          end
+
+          temp = Tempfile.new(["mt_semantic", ".json"])
+          temp.write(JSON.generate(semantic_result[:entries]))
+          temp.close
+          args.push("-s", temp.path)
+          system(*args)
+          temp.unlink
+        else
+          system(*args)
+        end
+        $?.success? ? 0 : 1
+      end
+    end
+  end
+end