mt-lang 0.3.16 → 0.3.20

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module MilkTea
+  class CLI
+    module CommandDap
+      def dap_command
+        preferred_backend_kind = "process"
+        adapter_command = nil
+
+        until @argv.empty?
+          arg = @argv.shift
+          case arg
+          when "--log-level"
+            @argv.shift
+          when /\A--log-level=(.+)\z/
+            # accept and ignore
+          when "--backend"
+            preferred_backend_kind = @argv.shift&.downcase
+          when /\A--backend=(.+)\z/
+            preferred_backend_kind = ::Regexp.last_match(1).downcase
+          when "--adapter-path"
+            adapter_path = @argv.shift
+            adapter_command = resolve_adapter_path(adapter_path)
+            return 1 unless adapter_command
+          when /\A--adapter-path=(.+)\z/
+            adapter_path = ::Regexp.last_match(1)
+            adapter_command = resolve_adapter_path(adapter_path)
+            return 1 unless adapter_command
+          else
+            if arg.start_with?("-")
+              @err.puts("dap: unknown option #{arg}")
+              return 1
+            end
+            @err.puts("dap: unexpected argument #{arg}")
+            return 1
+          end
+        end
+
+        require "milk_tea/dap/server" unless defined?(MilkTea::DAP::Server)
+        server = MilkTea::DAP::Server.new(
+          preferred_backend_kind:,
+          adapter_command:,
+        )
+        server.run
+        0
+      end
+
+      def resolve_adapter_path(adapter_path)
+        unless adapter_path && File.file?(adapter_path)
+          @err.puts("dap: adapter path not found: #{adapter_path}")
+          return nil
+        end
+        expanded = File.expand_path(adapter_path)
+        adapter_path.end_with?(".rb") ? [RbConfig.ruby, expanded] : [expanded]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module MilkTea
+  class CLI
+    module CommandDebug
+      def debug_command
+        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!("debug", input_paths)
+
+        path = expand_source_paths(input_paths).first
+        unless path
+          @err.puts("no .mt files found in #{input_paths.join(', ')}")
+          return 1
+        end
+
+        ensure_current_lockfile!(path) if resolution[:frozen]
+
+        source = read_source_file(path)
+        resolved_path = File.expand_path(path)
+
+        tokens = MilkTea::Lexer.lex(source, path: resolved_path)
+
+        parse_result = MilkTea::Parser.parse_collecting_errors(source, path: resolved_path)
+        ast = parse_result.ast
+        parse_errors = parse_result.errors.dup
+
+        facts = nil
+        snapshot = nil
+        loader_ast = ast
+
+        if ast && parse_errors.empty?
+          begin
+            loader = make_module_loader(path, locked: resolution[:locked], platform: ModuleLoader.default_host_platform)
+            loader_ast = loader.load_file(resolved_path)
+
+            import_result = loader.send(:imported_modules_for_ast_collecting_errors, loader_ast, importer_path: resolved_path)
+            import_errors = import_result.respond_to?(:errors) ? import_result.errors : []
+            parse_errors.concat(import_errors) unless import_errors.empty?
+
+            snapshot = MilkTea::SemanticAnalyzer.tooling_snapshot(
+              loader_ast,
+              imported_modules: import_result.modules,
+              allow_missing_imports: true,
+              path: resolved_path,
+            )
+            facts = snapshot&.facts
+          rescue MilkTea::LexError, MilkTea::ParseError, ModuleLoadError, SemanticError => e
+            parse_errors << e
+          end
+        end
+
+        text = DebugInfoFormatter.format_all(
+          content: source,
+          tokens: tokens,
+          ast: loader_ast,
+          parse_errors: parse_errors,
+          facts: facts,
+          snapshot: snapshot,
+          path: resolved_path,
+        )
+
+        @out.puts(text)
+        0
+      rescue MilkTea::LexError => e
+        @err.puts(ErrorFormatter.format(e, color: error_color?(@err)))
+        1
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module MilkTea
+  class CLI
+    module CommandDeps
+      def deps_command
+        PackageManagerCLI.start(
+          @argv,
+          out: @out,
+          err: @err,
+          help_printer: method(:print_deps_help),
+          services: package_services,
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module MilkTea
+  class CLI
+    module CommandDocs
+      def docs_command
+        port = nil
+        open_flag = false
+
+        while (arg = @argv.first)
+          case arg
+          when "--port", "-p"
+            @argv.shift
+            port = @argv.shift.to_i
+            port = nil if port <= 0 || port > 65535
+          when "--open", "-o"
+            open_flag = true
+            @argv.shift
+          else
+            break
+          end
+        end
+
+        port = resolve_docs_port(port)
+
+        DocsApp.set :port, port
+        DocsApp.set :bind, "127.0.0.1"
+        DocsApp.set :environment, :production
+        DocsApp.set :server, :puma
+
+        url = "http://127.0.0.1:#{port}/"
+
+        @out.puts("Serving Milk Tea docs at #{url}")
+        @out.puts("Press Ctrl+C to stop.")
+
+        if open_flag
+          open_browser(url)
+        end
+
+        DocsApp.run!
+        0
+      rescue Interrupt
+        0
+      end
+
+      def resolve_docs_port(preferred)
+        return preferred if preferred
+
+        server = TCPServer.new("127.0.0.1", 0)
+        port = server.addr[1]
+        server.close
+        port
+      rescue StandardError
+        4567
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module MilkTea
+  class CLI
+    module CommandEmitC
+      def emit_c_command
+        args = @argv.dup
+        @argv = []
+        until args.empty?
+          arg = args.shift
+          @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!("emit-c", input_paths)
+
+        program_paths = input_paths.map { |p| resolve_program_path(p) }
+        return 1 if program_paths.include?(nil)
+
+        ensure_current_lockfiles!(input_paths) if resolution[:frozen]
+
+        multiple = program_paths.length > 1
+        program_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} --- */")
+          end
+          @out.write(CBackend.generate_c(Lowering.lower(program), emit_line_directives: false))
+          @out.puts if multiple && index < program_paths.length - 1
+        end
+        0
+      end
+
+      def resolve_program_path(path)
+        return path unless File.directory?(path)
+
+        manifest_path = File.join(path, "package.toml")
+        unless File.file?(manifest_path)
+          @err.puts("no package.toml found in #{path}")
+          return nil
+        end
+
+        manifest = PackageManifest.load(path)
+        entry_path = manifest.source_path
+        unless entry_path && File.file?(entry_path)
+          @err.puts("no build entry found for #{path}")
+          return nil
+        end
+
+        entry_path
+      rescue PackageManifestError => e
+        @err.puts("failed to load package manifest for #{path}: #{e.message}")
+        nil
+      end
+    end
+  end
+end

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