mt-lang 0.3.17 → 0.3.22

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
@@ -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/types.rb

@@ -822,6 +822,18 @@ module MilkTea
         self
       end
 
+      def eql?(other)
+        other.is_a?(GenericStructDefinition) && other.name == name &&
+          other.type_params == type_params && other.module_name == module_name &&
+          other.external == external && other.packed == packed && other.alignment == alignment
+      end
+
+      alias == eql?
+
+      def hash
+        [self.class, name, type_params, module_name, external, packed, alignment].hash
+      end
+
       def set_layout(packed:, alignment:)
         @packed = packed
         @alignment = alignment
@@ -853,23 +865,6 @@ module MilkTea
         name
       end
 
-      def eql?(other)
-        other.class == self.class &&
-          other.name == name &&
-          other.type_params == type_params &&
-          other.module_name == module_name &&
-          other.external == external &&
-          other.packed == packed &&
-          other.alignment == alignment &&
-          other.linkage_name == linkage_name
-      end
-
-      alias == eql?
-
-      def hash
-        [self.class, name, type_params, module_name, external, packed, alignment, linkage_name].hash
-      end
-
       def instantiate(arguments)
         raise ArgumentError, "#{name} expects #{type_params.length} type arguments, got #{arguments.length}" unless arguments.length == type_params.length
 

data/lib/milk_tea/lsp/diagnostics.rb

@@ -179,6 +179,19 @@ module MilkTea
           platform: effective_platform,
         )
         module_name = loader.send(:inferred_module_name_for_path, path) rescue nil
+
+        # Run the full two-pass program check first so that @analysis_cache
+        # has fully-checked analyses for all transitive modules. When the
+        # import resolution below encounters a cycle member, it finds the
+        # cached analysis and resolves correctly. If the program check fails
+        # (e.g. missing module), fall through to the standard resolution
+        # path so that prelude modules and regular errors are still reported.
+        begin
+          loader.check_program_collecting(path)
+        rescue ModuleLoadError, PackageLockError
+          # best-effort — standard path below handles diagnostics
+        end
+
         resolution_result = loader.imported_modules_for_ast_collecting_errors(ast, importer_path: path)
         unresolved_import_paths = []
 

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,106 @@
+# 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)
+
+        result = loader.check_program_collecting(path)
+        errors = result[:errors]
+        analysis = result[:root_analysis]
+        module_name = result[:module_name]
+
+        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
+
+        [errors, module_name, []]
+      rescue ModuleLoadError, PackageLockError => 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