mt-lang 0.3.16 → 0.3.20

data/lib/milk_tea/core/semantic_analyzer.rb

@@ -94,6 +94,7 @@ module MilkTea
     end
     ResolvedAttributeApplication = Data.define(:binding, :argument_values)
     AttributePresenceKey = Data.define(:target, :attribute_module_name, :attribute_name)
+    CallableResolution = Data.define(:kind, :value, :receiver)
     TypeParamConstraintBinding = Data.define(:interfaces) do
       def initialize(interfaces: []) = super
     end
@@ -129,7 +130,7 @@ module MilkTea
     end
 
     class Checker
-      include CompatibilityHelpers
+      include Intrinsics
 
       attr_reader :ctx
 
@@ -185,30 +186,47 @@ module MilkTea
       end
 
       def check
-        install_builtin_types
-        install_builtin_attributes
-        install_imports
-        install_prelude_types
-        declare_named_types
-        resolve_generic_type_param_constraints
-        resolve_type_aliases
-        declare_attributes
-        resolve_aggregate_fields
-        resolve_enum_members
-        resolve_variant_arms
-        collect_emit_declarations
-        declare_top_level_values
-        check_attribute_applications
-        declare_functions
-        check_interface_conformances
-        check_top_level_values
-        finalize_top_level_const_values
-        check_top_level_static_asserts
-        check_functions
+        @completed_phases = Set.new
+
+        run_phase(:install_builtin_types)
+        run_phase(:install_builtin_attributes)
+        run_phase(:install_imports)
+        run_phase(:install_prelude_types, requires: [:install_imports])
+        run_phase(:declare_named_types, requires: [:install_builtin_types, :install_imports, :install_prelude_types])
+        run_phase(:resolve_generic_type_param_constraints, requires: [:declare_named_types])
+        run_phase(:resolve_type_aliases, requires: [:declare_named_types])
+        run_phase(:declare_attributes)
+        run_phase(:resolve_aggregate_fields, requires: [:resolve_type_aliases, :declare_named_types])
+        run_phase(:resolve_enum_members, requires: [:declare_named_types])
+        run_phase(:resolve_variant_arms, requires: [:declare_named_types])
+        run_phase(:collect_emit_declarations)
+        run_phase(:declare_top_level_values, requires: [:resolve_aggregate_fields, :resolve_type_aliases])
+        run_phase(:check_attribute_applications, requires: [:declare_attributes])
+        run_phase(:declare_functions, requires: [:resolve_aggregate_fields, :resolve_enum_members, :resolve_variant_arms])
+        run_phase(:check_interface_conformances, requires: [:declare_functions, :resolve_aggregate_fields])
+        run_phase(:check_top_level_values, requires: [:declare_top_level_values])
+        run_phase(:finalize_top_level_const_values, requires: [:check_top_level_values])
+        run_phase(:check_top_level_static_asserts, requires: [:finalize_top_level_const_values])
+        run_phase(:check_functions, requires: [:declare_functions, :resolve_aggregate_fields, :check_interface_conformances])
 
         build_analysis
       end
 
+      def run_phase(name, requires: [])
+        requires.each do |required|
+          unless @completed_phases&.include?(required)
+            raise "BUG: phase #{required} must run before #{name} — check phase ordering"
+          end
+        end
+        send(name)
+      ensure
+        @completed_phases << name if @completed_phases
+      end
+
+      def run_collecting_phase(name, requires: [])
+        catch_structural { run_phase(name, requires:) }
+      end
+
       def collect_emit_declarations
         collect_emit_from_declarations(expanded_declarations)
         @ctx.ast.declarations.grep(AST::ConstDecl).each { |decl| @ctx.const_declarations[decl.name] ||= decl }
@@ -274,23 +292,24 @@ module MilkTea
       def check_collecting_errors
         @collecting_errors = true
         @structural_errors = []
-
-        catch_structural { install_builtin_types }
-        catch_structural { install_builtin_attributes }
-        catch_structural { install_imports }
-        catch_structural { install_prelude_types }
-        catch_structural { declare_named_types }
-        catch_structural { resolve_generic_type_param_constraints }
-        catch_structural { resolve_type_aliases }
-        catch_structural { declare_attributes }
-        catch_structural { resolve_aggregate_fields }
-        catch_structural { resolve_enum_members }
-        catch_structural { resolve_variant_arms }
-        catch_structural { collect_emit_declarations }
-        catch_structural { declare_top_level_values }
-        catch_structural { check_attribute_applications }
-        catch_structural { declare_functions }
-        catch_structural { check_interface_conformances }
+        @completed_phases = Set.new
+
+        run_collecting_phase(:install_builtin_types)
+        run_collecting_phase(:install_builtin_attributes)
+        run_collecting_phase(:install_imports)
+        run_collecting_phase(:install_prelude_types, requires: [:install_imports])
+        run_collecting_phase(:declare_named_types, requires: [:install_builtin_types, :install_imports, :install_prelude_types])
+        run_collecting_phase(:resolve_generic_type_param_constraints, requires: [:declare_named_types])
+        run_collecting_phase(:resolve_type_aliases, requires: [:declare_named_types])
+        run_collecting_phase(:declare_attributes)
+        run_collecting_phase(:resolve_aggregate_fields, requires: [:resolve_type_aliases, :declare_named_types])
+        run_collecting_phase(:resolve_enum_members, requires: [:declare_named_types])
+        run_collecting_phase(:resolve_variant_arms, requires: [:declare_named_types])
+        run_collecting_phase(:collect_emit_declarations)
+        run_collecting_phase(:declare_top_level_values, requires: [:resolve_aggregate_fields, :resolve_type_aliases])
+        run_collecting_phase(:check_attribute_applications, requires: [:declare_attributes])
+        run_collecting_phase(:declare_functions, requires: [:resolve_aggregate_fields, :resolve_enum_members, :resolve_variant_arms])
+        run_collecting_phase(:check_interface_conformances, requires: [:declare_functions, :resolve_aggregate_fields])
 
         errors = @structural_errors.dup
 

data/lib/milk_tea/core.rb

@@ -10,11 +10,15 @@ require_relative "core/cst"
 require_relative "core/cst_builder"
 require_relative "core/ast"
 require_relative "core/types"
-require_relative "core/binding_types"
+require_relative "core/bindings"
 require_relative "core/compile_time"
-require_relative "core/compatibility_helpers"
+require_relative "core/intrinsics"
 require_relative "core/parser"
 require_relative "core/module_roots"
+require_relative "core/module_path_resolver"
+require_relative "core/module_binder"
+require_relative "core/async_runtime_installer"
+require_relative "core/prelude_installer"
 require_relative "core/module_loader"
 require_relative "core/semantic_analyzer"
 require_relative "core/ir"

data/lib/milk_tea/dap/lldb_dap_backend.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require "open3"
+require "thread"
+require "timeout"
+
+module MilkTea
+  module DAP
+    class LLDBDAPBackend
+      def initialize(adapter_command: ["lldb-dap"], on_event: nil, on_request: nil)
+        @adapter_command = adapter_command
+        @on_event = on_event
+        @on_request = on_request
+        @protocol = nil
+        @stdin = nil
+        @stdout = nil
+        @stderr = nil
+        @wait_thread = nil
+        @reader_thread = nil
+        @stderr_thread = nil
+        @write_mutex = Mutex.new
+        @pending_mutex = Mutex.new
+        @pending = {}
+        @next_seq = 1
+      end
+
+      def start!
+        return if running?
+
+        @stdin, @stdout, @stderr, @wait_thread = Open3.popen3(*@adapter_command)
+        @protocol = Protocol.new(input: @stdout, output: @stdin)
+
+        @reader_thread = Thread.new { read_loop }
+        @stderr_thread = Thread.new { drain_stderr }
+      end
+
+      def running?
+        !@wait_thread.nil? && @wait_thread.alive?
+      end
+
+      def request(command, arguments = {}, timeout: 5)
+        start! unless running?
+
+        seq = next_seq
+        queue = Queue.new
+        @pending_mutex.synchronize do
+          @pending[seq] = queue
+        end
+
+        @write_mutex.synchronize do
+          @protocol.write_message({
+            seq: seq,
+            type: "request",
+            command: command,
+            arguments: arguments
+          })
+        end
+
+        Timeout.timeout(timeout) { queue.pop }
+      rescue Timeout::Error
+        {
+          "type" => "response",
+          "request_seq" => seq,
+          "success" => false,
+          "message" => "backend request timed out: #{command}"
+        }
+      ensure
+        @pending_mutex.synchronize { @pending.delete(seq) }
+      end
+
+      def stop!
+        @stdin&.close
+        @stdout&.close
+        @stderr&.close
+        if @wait_thread&.alive?
+          Process.kill("TERM", @wait_thread.pid)
+        end
+      rescue StandardError
+        nil
+      ensure
+        @wait_thread&.join(0.2)
+        @reader_thread&.join(0.2)
+        @stderr_thread&.join(0.2)
+        @stdin = nil
+        @stdout = nil
+        @stderr = nil
+        @wait_thread = nil
+        @reader_thread = nil
+        @stderr_thread = nil
+      end
+
+      def next_seq
+        seq = @next_seq
+        @next_seq += 1
+        seq
+      end
+
+      def read_loop
+        loop do
+          message = @protocol.read_message
+          break if message.nil?
+
+          if message["type"] == "response"
+            queue = @pending_mutex.synchronize { @pending[message["request_seq"]] }
+            queue&.push(message)
+          elsif message["type"] == "event"
+            @on_event&.call(message)
+          elsif message["type"] == "request"
+            handle_adapter_request(message)
+          end
+        end
+      rescue StandardError
+        nil
+      ensure
+        @pending_mutex.synchronize do
+          @pending.each_value do |queue|
+            queue.push({
+              "type" => "response",
+              "success" => false,
+              "message" => "backend closed"
+            })
+          end
+          @pending.clear
+        end
+      end
+
+      def drain_stderr
+        return unless @stderr
+
+        @stderr.each_line do |_line|
+          # Intentionally ignored in this bridge layer.
+        end
+      rescue StandardError
+        nil
+      end
+
+      def handle_adapter_request(message)
+        response = @on_request&.call(message)
+        response ||= {
+          "type" => "response",
+          "request_seq" => message["seq"],
+          "success" => false,
+          "command" => message["command"],
+          "message" => "unsupported reverse request: #{message['command']}"
+        }
+
+        @write_mutex.synchronize do
+          @protocol.write_message(response)
+        end
+      end
+    end
+  end
+end

data/lib/milk_tea/dap/server/lldb_backend.rb

@@ -22,7 +22,7 @@ module MilkTea
           @lldb_backend = if @backend_factory
             build_backend_via_factory(adapter_command)
           else
-            Backends::LLDBDAP.new(
+            LLDBDAPBackend.new(
               adapter_command: adapter_command,
               on_event: method(:handle_backend_event),
               on_request: method(:handle_backend_request)

data/lib/milk_tea/dap.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 require_relative "dap/protocol"
-require_relative "dap/backends/lldb_dap"
+require_relative "dap/lldb_dap_backend"
 require_relative "dap/session"
 require_relative "dap/server"

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/lsp.rb

@@ -1,13 +1,7 @@
 # frozen_string_literal: true
 
-module MilkTea
-  module LSP
-    # LSP implementation - language server protocol support
-  end
-end
-
 require_relative 'lsp/protocol'
 require_relative 'lsp/dependency_resolution'
 require_relative 'lsp/workspace'
 require_relative 'lsp/diagnostics'
-require_relative 'lsp/server'
+require_relative 'lsp/server'

data/lib/milk_tea/{bindings/cli.rb → tooling/bindgen_cli.rb}

@@ -118,4 +118,4 @@ module MilkTea
       nil
     end
   end
-end
+end

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