mt-lang 0.3.17 → 0.3.20

data/lib/milk_tea/lsp/server/semantic_tokens.rb

@@ -556,9 +556,15 @@ module MilkTea
           next_tok&.type == :colon
         end
 
+        # Keywords whose standalone syntax is "keyword:" — they form blocks or
+        # expressions directly with a colon and no intervening token, so they are
+        # not field declarations when followed by ":".
+        STANDS_ALONE_WITH_COLON = %i[unsafe else defer parallel].to_set.freeze
+
         def keyword_field_declaration_token?(tokens, index)
           return false if match_arm_binding_token?(tokens, index)
           return false if destructure_let_binding?(tokens, index)
+          return false if STANDS_ALONE_WITH_COLON.include?(tokens[index].type)
 
           next_tok = next_non_trivia_token(tokens, index + 1)
           next_tok&.type == :colon

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module MilkTea
+  class CLI
+    module CommandBindgen
+      def bindgen_command
+        BindgenCLI.start(@argv, out: @out, err: @err, help_printer: method(:print_bindgen_help))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module MilkTea
+  class CLI
+    module CommandBuild
+      def build_command
+        path, options = extract_path_and_options(allow_clean: true)
+        return 1 unless path
+
+        if options.delete(:clean)
+          cleaned_path = Build.clean(path, output_path: options[:output_path], profile: options[:profile], platform: options[:platform], bundle: options[:bundle], archive: options[:archive])
+          info("cleaned #{cleaned_path}")
+          return 0
+        end
+
+        frozen = options.delete(:frozen)
+        ensure_current_lockfile!(path) if frozen
+        locked = options.delete(:locked)
+        bundle = options[:bundle]
+        package_graph = package_graph_for(path, locked:)
+        result = Build.build(path, module_roots: module_roots_for(path, locked:), package_graph:, frontend: @build_frontend, **options.except(:timings))
+        if bundle
+          info("built #{path} -> #{File.dirname(result.output_path)}")
+          info("entry executable #{result.output_path}")
+          info("  [cached]") if result.cached
+          info("archive #{result.archive_path}") if result.archive_path
+        elsif result.cached
+          info("built #{path} -> #{result.output_path}  [cached]")
+        else
+          info("built #{path} -> #{result.output_path}")
+        end
+        info("saved C to #{result.c_path}") if result.c_path
+        0
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module MilkTea
+  class CLI
+    module CommandCache
+      def cache_command
+        subcommand = @argv.shift
+        unless subcommand
+          @err.puts("missing cache subcommand")
+          print_command_help("cache", @err)
+          return 1
+        end
+
+        cache_root = MilkTea.data_root.join("tmp", "mtc-cache")
+
+        case subcommand
+        when "purge"
+          if File.directory?(cache_root)
+            FileUtils.rm_rf(cache_root)
+            @out.puts("purged #{cache_root}")
+          else
+            @out.puts("cache is already empty")
+          end
+          0
+        when "status"
+          unless File.directory?(cache_root)
+            @out.puts("cache directory does not exist: #{cache_root}")
+            return 0
+          end
+          program_dirs = Dir.glob(File.join(cache_root, "programs", "*", "*")).select { |d| File.directory?(d) }
+          binary_files = Dir.glob(File.join(cache_root, "binaries", "*", "*", "binary")).select { |f| File.file?(f) }
+          total_size = (program_dirs + binary_files).sum { |p|
+            File.file?(p) ? File.size(p) : Dir.glob(File.join(p, "**", "*")).sum { |f| File.file?(f) ? File.size(f) : 0 }
+          }
+          @out.puts("cache  #{program_dirs.length} programs, #{binary_files.length} binaries  (#{format_size(total_size)})")
+          @out.puts("  root  #{cache_root}")
+          0
+        else
+          @err.puts("unknown cache subcommand #{subcommand}")
+          print_command_help("cache", @err)
+          1
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module MilkTea
+  class CLI
+    module CommandCheck
+      def check_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!("check", 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]
+
+        all_diagnostics = []
+        paths.each do |path|
+          diagnostics, module_name, closure_errors = check_single_reporting_all(path, locked: resolution[:locked])
+          closure_errors = [] if paths.length > 1
+          diagnostics = sort_by_location(diagnostics)
+
+          if diagnostics.any? || closure_errors.any?
+            main_source = read_source_file(path)
+            main_abs = File.expand_path(path)
+            diagnostics.each do |d|
+              same_file = !d.respond_to?(:path) || d.path.nil? || File.expand_path(d.path) == main_abs
+              source = same_file ? main_source : nil
+              @err.puts(ErrorFormatter.format(d, source:, color: error_color?(@err)))
+            end
+            closure_errors.each do |d|
+              same_file = !d.respond_to?(:path) || d.path.nil? || File.expand_path(d.path) == main_abs
+              source = same_file ? main_source : nil
+              @err.puts(ErrorFormatter.format(d, source:, color: error_color?(@err)))
+            end
+            all_diagnostics.concat(diagnostics)
+            all_diagnostics.concat(closure_errors)
+          elsif module_name
+            info("checked #{path} as #{module_name}")
+          end
+        end
+
+        return 0 if all_diagnostics.empty?
+
+        error_count = all_diagnostics.count { |d| !d.respond_to?(:severity) || d.severity == :error }
+        warning_count = all_diagnostics.count { |d| d.respond_to?(:severity) && d.severity == :warning }
+        info_count = all_diagnostics.count { |d| d.respond_to?(:severity) && (d.severity == :info || d.severity == :hint) }
+
+        @err.puts
+        parts = []
+        parts << "#{error_count} #{error_count == 1 ? 'error' : 'errors'}" if error_count > 0
+        parts << "#{warning_count} #{warning_count == 1 ? 'warning' : 'warnings'}" if warning_count > 0
+        parts << "#{info_count} #{info_count == 1 ? 'note' : 'notes'}" if info_count > 0
+        body = parts.join("; ")
+        if error_count > 0
+          @err.puts("#{body} found")
+        elsif warning_count > 0
+          @err.puts("#{body}")
+        end
+        final_error_count = error_count + (resolution[:warnings_as_errors] ? warning_count : 0)
+        final_error_count > 0 ? 1 : 0
+      end
+
+      def check_single_reporting_all(path, locked: false)
+        loader = make_module_loader(path, locked:, platform: ModuleLoader.default_host_platform)
+        resolved_path = File.expand_path(path)
+        ast = loader.load_file(resolved_path)
+        module_name = ast.module_name.to_s
+
+        import_result = loader.imported_modules_for_ast_collecting_errors(ast, importer_path: resolved_path)
+        errors = import_result.errors.dup
+
+        analysis = nil
+        begin
+          result = SemanticAnalyzer.check_collecting_errors(ast, imported_modules: import_result.modules, path: resolved_path)
+          errors.concat(result[:errors])
+          analysis = result[:analysis]
+        rescue SemanticError => e
+          errors << e
+        end
+
+        if analysis && errors.empty?
+          source = read_source_file(path)
+          warnings = Linter.lint_source(source, path: resolved_path, sema_facts: analysis, lint_tier: :full)
+          errors.concat(warnings)
+        end
+
+        closure_errors = loader.collecting_path_errors.values.flatten.compact
+        [errors, module_name, closure_errors]
+      rescue ModuleLoadError, PackageLockError, SemanticError => e
+        [[e], nil, []]
+      end
+
+      def sort_by_location(errors)
+        errors.sort_by do |e|
+          actual = e.respond_to?(:error) ? e.error : e
+          line = actual.respond_to?(:line) ? actual.line.to_i : 0
+          column = actual.respond_to?(:column) ? actual.column.to_i : 0
+          [line, column]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module MilkTea
+  class CLI
+    module CommandBase
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module MilkTea
+  class CLI
+    module CommandCompletions
+      def completions_command
+        shell = @argv.shift
+        unless %w[bash zsh fish].include?(shell)
+          @err.puts("completions: shell must be bash, zsh, or fish")
+          print_command_help("completions", @err)
+          return 1
+        end
+
+        @out.puts(completion_script(shell))
+        0
+      end
+
+      def completion_script(shell)
+        names = COMMANDS.map(&:first)
+        case shell
+        when "bash"
+          [
+            "# mtc bash completion. Source this file or install it into your bash",
+            "# completion directory (e.g. /etc/bash_completion.d/mtc).",
+            "_mtc() {",
+            %(  local cur="${COMP_WORDS[COMP_CWORD]}"),
+            %(  if [ "${COMP_CWORD}" -eq 1 ]; then),
+            %(    COMPREPLY=( $(compgen -W "#{(names + %w[help version]).join(' ')}" -- "${cur}") )),
+            "  fi",
+            "}",
+            "complete -F _mtc mtc",
+          ].join("\n")
+        when "zsh"
+          lines = ["#compdef mtc", "# mtc zsh completion. Install onto your $fpath as _mtc.", "_mtc() {", "  local -a commands", "  commands=("]
+          COMMANDS.each { |name, summary| lines << "    '#{name}:#{summary}'" }
+          lines.concat(["  )", "  if (( CURRENT == 2 )); then", "    _describe 'mtc command' commands", "  fi", "}", %(_mtc "$@")])
+          lines.join("\n")
+        when "fish"
+          lines = ["# mtc fish completion. Install into ~/.config/fish/completions/mtc.fish."]
+          COMMANDS.each do |name, summary|
+            lines << "complete -c mtc -f -n '__fish_use_subcommand' -a #{name} -d '#{summary}'"
+          end
+          lines.join("\n")
+        end
+      end
+    end
+  end
+end

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