mt-lang 0.2.0

data/lib/milk_tea/core/module_loader.rb

@@ -0,0 +1,479 @@
+# frozen_string_literal: true
+
+require_relative "module_loader/errors"
+require_relative "module_path_resolver"
+require_relative "module_binder"
+require_relative "async_runtime_installer"
+require_relative "prelude_installer"
+
+module MilkTea
+  class ModuleLoader
+    Program = Data.define(:root_path, :root_analysis, :analyses_by_path, :analyses_by_module_name)
+    PLATFORM_SUFFIXES = {
+      "linux" => :linux,
+      "windows" => :windows,
+      "wasm" => :wasm,
+    }.freeze
+
+    def self.load_file(path, platform: nil)
+      new(platform:).load_file(path)
+    end
+
+    def self.check_file(path, platform: nil)
+      new(platform:).check_file(path)
+    end
+
+    def self.check_program(path, platform: nil)
+      new(platform:).check_program(path)
+    end
+
+    def self.normalize_platform_name(value)
+      return nil if value.nil? || value.to_s.strip.empty?
+
+      case value.to_s.strip.downcase
+      when "linux"
+        :linux
+      when "windows", "win", "win32"
+        :windows
+      when "wasm", "web", "html5", "browser"
+        :wasm
+      when "darwin", "macos", "osx"
+        :darwin
+      else
+        raise ArgumentError, "unknown platform #{value}; expected linux|windows|wasm|darwin"
+      end
+    end
+
+    def self.platform_suffix_for_path(path)
+      match = File.basename(path.to_s).match(/\.(linux|windows|wasm)\.mt\z/)
+      return nil unless match
+
+      PLATFORM_SUFFIXES.fetch(match[1])
+    end
+
+    def self.effective_platform_for_path(path, platform_override: nil, host_platform: nil)
+      normalized_override = normalize_platform_name(platform_override)
+      return normalized_override if normalized_override
+
+      suffix_platform = platform_suffix_for_path(path)
+      return suffix_platform if suffix_platform
+
+      manifest_platform = PackageManifest.load(path).platform
+      return manifest_platform if manifest_platform
+
+      normalize_platform_name(host_platform || default_host_platform)
+    rescue PackageManifestError
+      normalize_platform_name(host_platform || default_host_platform)
+    end
+
+    def self.resolve_source_path(path, platform: nil, error_class: nil)
+      expanded_path = File.expand_path(path.to_s)
+      normalized_platform = platform.nil? ? nil : normalize_platform_name(platform)
+      pinned_platform = platform_suffix_for_path(expanded_path)
+
+      if pinned_platform
+        if normalized_platform && normalized_platform != pinned_platform
+          raise_platform_conflict!(expanded_path, pinned_platform, normalized_platform, error_class:)
+        end
+        return expanded_path
+      end
+
+      return expanded_path unless normalized_platform && expanded_path.end_with?(".mt")
+
+      variant_path = expanded_path.sub(/\.mt\z/, ".#{normalized_platform}.mt")
+      return variant_path if File.file?(variant_path)
+
+      expanded_path
+    end
+
+    def self.default_host_platform
+      MilkTea.host_platform
+    end
+
+    def initialize(module_roots: [MilkTea.root], package_graph: nil, shared_cache: nil, source_overrides: nil, platform: nil)
+      @module_roots = module_roots.map { |root| File.expand_path(root.to_s) }
+      @ast_cache = {}
+      @parse_cache = {}
+      @analysis_cache = {}
+      @collecting_analysis_cache = {}
+      @collecting_path_errors = {}
+      @checking_paths = []
+      @platform = self.class.normalize_platform_name(platform)
+      @package_graph = package_graph
+      @package_manifest_cache = {}
+      @shared_cache = shared_cache # Hash or nil; mutated in-place to persist across calls
+      @source_overrides = normalize_source_overrides(source_overrides)
+
+      @path_resolver = ModulePathResolver.new(
+        module_roots: @module_roots,
+        platform: @platform,
+        package_graph: @package_graph,
+        source_overrides: @source_overrides,
+        package_manifest_cache: @package_manifest_cache,
+      )
+      @binder = ModuleBinder.new
+      @async_runtime_installer = AsyncRuntimeInstaller.new(
+        resolve_module_path: @path_resolver.method(:resolve_module_path),
+        check_block: ->(path, collecting) { collecting ? check_path_collecting_errors(path) : check_path(path) },
+        bind_block: @binder.method(:module_binding),
+      )
+      @prelude_installer = PreludeInstaller.new(
+        resolve_module_path: @path_resolver.method(:resolve_module_path),
+        check_block: ->(path, collecting) { collecting ? check_path_collecting_errors(path) : check_path(path) },
+        bind_block: @binder.method(:module_binding),
+      )
+    end
+
+    def load_file(path)
+      resolved_path = self.class.resolve_source_path(path, platform: @platform, error_class: ModuleLoadError)
+      @ast_cache[resolved_path] ||= parse_file(resolved_path)
+    end
+
+    def check_file(path)
+      check_program(path).root_analysis
+    end
+
+    def check_program(path)
+      Types::Registry.reset!
+      requested_path = File.expand_path(path)
+      previous_platform = @platform
+      @platform ||= self.class.platform_suffix_for_path(requested_path)
+      root_path = self.class.resolve_source_path(requested_path, platform: @platform, error_class: ModuleLoadError)
+
+      check_program_parallel(root_path)
+
+      root_analysis = @analysis_cache.fetch(root_path)
+      analyses_by_module_name = @analysis_cache.each_value.each_with_object({}) do |analysis, modules|
+        next unless analysis.module_name
+
+        modules[analysis.module_name] = analysis
+      end
+
+      Program.new(
+        root_path:,
+        root_analysis:,
+        analyses_by_path: @analysis_cache.dup.freeze,
+        analyses_by_module_name: analyses_by_module_name.freeze,
+      )
+    ensure
+      @platform = previous_platform
+    end
+
+    def check_program_parallel(root_path)
+      # Phase 1: Parse all transitive modules (sequential)
+      parse_all(root_path)
+
+      # Phase 2: Build dependency graph from parsed ASTs
+      graph = {}
+      @parse_cache.each_key do |resolved_path|
+        ast = @parse_cache[resolved_path]
+        deps = ast.imports.map do |import|
+          @path_resolver.resolve_module_path(import.path.to_s, importer_path: resolved_path, importer_module_name: ast.module_name.to_s)
+        end
+        graph[resolved_path] = deps
+      end
+
+      # Phase 3: Topological sort into independent levels
+      levels = topo_sort_levels(graph)
+
+      # Phase 4: Check each level (parallel within level, sequential across levels)
+      levels.each do |level_paths|
+        if level_paths.length == 1
+          check_path(level_paths.first)
+        else
+          check_level_parallel(level_paths)
+        end
+      end
+    end
+
+    def parse_all(resolved_path)
+      return if @parse_cache.key?(resolved_path)
+
+      if @checking_paths.include?(resolved_path)
+        raise ModuleLoadError.new("cyclic import detected", path: resolved_path)
+      end
+
+      @checking_paths << resolved_path
+      ast = load_file(resolved_path)
+      @parse_cache[resolved_path] = ast
+
+      ast.imports.each do |import|
+        import_path = @path_resolver.resolve_module_path(import.path.to_s, importer_path: resolved_path, importer_module_name: ast.module_name.to_s)
+        parse_all(import_path)
+      end
+    ensure
+      @checking_paths.pop if @checking_paths.last == resolved_path
+    end
+
+    def topo_sort_levels(graph)
+      in_degree = {}
+      graph.each_key { |node| in_degree[node] = 0 }
+      graph.each_value do |deps|
+        deps.each { |dep| in_degree[dep] = (in_degree[dep] || 0) + 1 }
+      end
+
+      levels = []
+      remaining = graph.keys.to_set
+      until remaining.empty?
+        level = remaining.select { |node| (in_degree[node] || 0) == 0 }
+        break if level.empty?
+
+        levels << level
+        level.each do |node|
+          remaining.delete(node)
+          (graph[node] || []).each { |dep| in_degree[dep] -= 1 }
+        end
+      end
+      levels
+    end
+
+    def check_level_parallel(paths)
+      threads = paths.map do |resolved_path|
+        Thread.new do
+          Thread.current[:resolved_path] = resolved_path
+          begin
+            analysis = check_path(resolved_path)
+            Thread.current[:analysis] = analysis
+          rescue ModuleLoadError, PackageLockError, SemanticError => e
+            Thread.current[:error] = e
+          end
+        end
+      end
+
+      threads.each(&:join)
+
+      paths.zip(threads).each do |resolved_path, t|
+        raise t[:error] if t[:error]
+      end
+    end
+
+    def imported_modules_for_ast(ast, importer_path: nil)
+      modules = {}
+
+      ast.imports.each do |import|
+        import_path = @path_resolver.resolve_module_path(import.path.to_s, importer_path:, importer_module_name: ast.module_name.to_s)
+        import_analysis = check_path(import_path)
+        modules[import.path.to_s] = @binder.module_binding(import_analysis)
+      end
+
+      @async_runtime_installer.install_async_runtime_dependency!(ast, modules, importer_path:, collecting_errors: false)
+      @prelude_installer.install_prelude_modules!(ast, modules, importer_path:, collecting_errors: false)
+      modules.freeze
+    end
+
+    def build_global_import_index(ast)
+      index = {}
+      current_imports = ast.imports.map { |import| import.path.to_s }.to_set
+
+      @analysis_cache.each_value do |analysis|
+        next unless analysis
+        next unless analysis.module_name
+
+        mod_name = analysis.module_name.to_s
+        next if current_imports.include?(mod_name)
+        next if mod_name == ast.module_name.to_s
+
+        types = analysis.respond_to?(:types) ? analysis.types : {}
+        types.each_key do |type_name|
+          type_str = type_name.to_s
+          index[type_str] ||= []
+          index[type_str] << mod_name unless index[type_str].include?(mod_name)
+        end
+      end
+
+      index
+    end
+
+    def imported_modules_for_ast_collecting_errors(ast, importer_path: nil)
+      modules = {}
+      errors = []
+
+      ast.imports.each do |import|
+        begin
+          import_path = @path_resolver.resolve_module_path(import.path.to_s, importer_path:, importer_module_name: ast.module_name.to_s)
+          import_analysis = check_path_collecting_errors(import_path)
+          modules[import.path.to_s] = @binder.module_binding(import_analysis)
+        rescue ModuleLoadError, PackageLockError, SemanticError => e
+          errors << ImportResolutionError.new(import:, error: e)
+        end
+      end
+
+      begin
+        @async_runtime_installer.install_async_runtime_dependency!(ast, modules, importer_path:, collecting_errors: true)
+      rescue ModuleLoadError, PackageLockError => e
+        errors << ImportResolutionError.new(import: nil, error: e)
+      end
+
+      begin
+        @prelude_installer.install_prelude_modules!(ast, modules, importer_path:, collecting_errors: true)
+      rescue ModuleLoadError, PackageLockError => e
+        errors << ImportResolutionError.new(import: nil, error: e)
+      end
+
+      ImportResolution.new(modules: modules.freeze, errors: errors.freeze)
+    end
+
+    # Errors collected per analyzed import path during collecting-mode checks.
+    # Populated by #check_path_collecting_errors; used by the CLI `check` command
+    # to surface errors in a single file's imported modules (otherwise only
+    # reported when that module is checked directly).
+    def collecting_path_errors
+      @collecting_path_errors
+    end
+
+    private
+
+    def self.raise_platform_conflict!(path, pinned_platform, active_platform, error_class: nil)
+      if error_class == ModuleLoadError
+        raise ModuleLoadError.new("source file targets platform #{pinned_platform}; active platform is #{active_platform}", path:)
+      end
+
+      message = "source file #{path} targets platform #{pinned_platform}; active platform is #{active_platform}"
+      raise(error_class || ArgumentError, message)
+    end
+    private_class_method :raise_platform_conflict!
+
+    def check_path(path)
+      resolved_path = self.class.resolve_source_path(path, platform: @platform, error_class: ModuleLoadError)
+      shared_cache_mtime = nil
+      shared_cache_mtime_checked = false
+
+      return @analysis_cache[resolved_path] if @analysis_cache.key?(resolved_path)
+
+      if use_shared_cache?
+        entry = @shared_cache[resolved_path]
+        if entry
+          shared_cache_mtime_checked = true
+          shared_cache_mtime = File.mtime(resolved_path).to_f rescue nil
+          if shared_cache_mtime && entry[:mtime] == shared_cache_mtime
+            @analysis_cache[resolved_path] = entry[:analysis]
+            return entry[:analysis]
+          end
+        end
+      end
+
+      if @checking_paths.include?(resolved_path)
+        raise ModuleLoadError.new("cyclic import detected", path: resolved_path)
+      end
+
+      @checking_paths << resolved_path
+      ast = load_file(resolved_path)
+      imported_modules = imported_modules_for_ast(ast, importer_path: resolved_path)
+
+      global_index = build_global_import_index(ast)
+      analysis = SemanticAnalyzer.check(ast, imported_modules:, path: resolved_path, global_import_index: global_index)
+      @analysis_cache[resolved_path] = analysis
+
+      if use_shared_cache?
+        mtime = if shared_cache_mtime_checked
+                  shared_cache_mtime
+                else
+                  File.mtime(resolved_path).to_f rescue nil
+                end
+        @shared_cache[resolved_path] = { mtime: mtime, analysis: analysis } if mtime
+      end
+
+      analysis
+    ensure
+      @checking_paths.pop if @checking_paths.last == resolved_path
+    end
+
+    def check_path_collecting_errors(path)
+      resolved_path = self.class.resolve_source_path(path, platform: @platform, error_class: ModuleLoadError)
+
+      return @analysis_cache[resolved_path] if @analysis_cache.key?(resolved_path)
+      return @collecting_analysis_cache[resolved_path] if @collecting_analysis_cache.key?(resolved_path)
+
+      if use_shared_cache?
+        entry = @shared_cache[resolved_path]
+        if entry
+          mtime = File.mtime(resolved_path).to_f rescue nil
+          if mtime && entry[:mtime] == mtime
+            @analysis_cache[resolved_path] = entry[:analysis]
+            return entry[:analysis]
+          end
+        end
+      end
+
+      if @checking_paths.include?(resolved_path)
+        raise ModuleLoadError.new("cyclic import detected", path: resolved_path)
+      end
+
+      @checking_paths << resolved_path
+      ast = load_file(resolved_path)
+      imported_modules = imported_modules_for_ast_collecting_errors(ast, importer_path: resolved_path).modules
+      result = SemanticAnalyzer.check_collecting_errors(ast, imported_modules:, path: resolved_path)
+      analysis = result[:analysis]
+      raise(result[:errors].first || ModuleLoadError.new("module analysis unavailable", path: resolved_path)) unless analysis
+
+      @collecting_path_errors[resolved_path] = result[:errors]
+      @collecting_analysis_cache[resolved_path] = analysis
+      analysis
+    ensure
+      @checking_paths.pop if @checking_paths.last == resolved_path
+    end
+
+    def parse_file(path)
+      source = @source_overrides.fetch(path) { File.read(path) }
+      ast = Parser.parse(source, path: path)
+      inferred_module_name = inferred_module_name_for_path(path)
+      AST::SourceFile.new(
+        module_name: AST::QualifiedName.new(inferred_module_name.split(".")),
+        module_kind: ast.module_kind,
+        imports: ast.imports,
+        directives: ast.directives,
+        declarations: ast.declarations,
+        line: ast.line,
+        node_ids: ast.node_ids,
+      )
+    rescue Errno::ENOENT
+      raise ModuleLoadError.new("source file not found", path: path)
+    rescue Errno::EISDIR
+      raise ModuleLoadError.new("expected a source file, got a directory", path: path)
+    end
+
+    def normalize_source_overrides(source_overrides)
+      return {} unless source_overrides
+
+      source_overrides.each_with_object({}) do |(path, source), overrides|
+        overrides[File.expand_path(path.to_s)] = source.to_s
+      end
+    end
+
+    def inferred_module_name_for_path(path)
+      manifest = begin
+        PackageManifest.load(path)
+      rescue PackageManifestError
+        nil
+      end
+
+      if manifest && path_within_root?(path, manifest.source_root)
+        return module_name_for_path(path, manifest.source_root)
+      end
+
+      matching_root = @module_roots
+                      .select { |root| path_within_root?(path, root) }
+                      .max_by(&:length)
+      return module_name_for_path(path, matching_root) if matching_root
+
+      File.basename(path).sub(/\.(linux|windows|wasm)\.mt\z/, ".mt").sub(/\.mt\z/, "")
+    end
+
+    def module_name_for_path(path, root)
+      relative_path = path.delete_prefix(File.expand_path(root) + File::SEPARATOR)
+      relative_path = File.basename(path) if relative_path == path
+      relative_path = relative_path.sub(/\.(linux|windows|wasm)\.mt\z/, '.mt')
+      relative_path.sub(/\.mt\z/, '').split(File::SEPARATOR).join('.')
+    end
+
+    def path_within_root?(path, root)
+      normalized_path = File.expand_path(path)
+      normalized_root = File.expand_path(root)
+      normalized_path == normalized_root || normalized_path.start_with?(normalized_root + File::SEPARATOR)
+    end
+
+    def use_shared_cache?
+      @shared_cache && @source_overrides.empty?
+    end
+  end
+end

data/lib/milk_tea/core/module_path_resolver.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module MilkTea
+  class ModulePathResolver
+    def initialize(module_roots:, platform:, package_graph: nil, source_overrides: nil, package_manifest_cache: nil)
+      @module_roots = module_roots.map { |root| File.expand_path(root.to_s) }
+      @platform = platform
+      @package_graph = package_graph
+      @source_overrides = source_overrides || {}
+      @package_manifest_cache = package_manifest_cache || {}
+    end
+
+    def resolve_module_path(module_name, importer_path: nil, importer_module_name: nil)
+      package_candidate = resolve_package_module_path(module_name, importer_path:)
+      return package_candidate if package_candidate
+
+      relative_path = File.join(*module_name.split(".")) + ".mt"
+      blocked = false
+      candidate = @module_roots.lazy.map { |root| ModuleLoader.resolve_source_path(File.join(root, relative_path), platform: @platform) }.find do |path|
+        next false unless source_path_available?(path)
+
+        allowed = import_allowed?(module_name, importer_path, path)
+        blocked ||= !allowed
+        allowed
+      end
+      raise ModuleLoadError.new("package dependency not declared", path: module_name) if blocked
+      unless candidate
+        message = namespace_hint_for_missing_module(module_name, importer_path:, importer_module_name:) || "module not found"
+        raise ModuleLoadError.new(message, path: module_name)
+      end
+
+      File.expand_path(candidate)
+    end
+
+    def source_path_available?(path)
+      resolved_path = File.expand_path(path.to_s)
+      @source_overrides.key?(resolved_path) || File.file?(resolved_path)
+    end
+
+    private
+
+    def resolve_package_module_path(module_name, importer_path: nil)
+      return nil unless @package_graph && importer_path
+
+      importer_package = @package_graph.package_for_path(importer_path)
+      return nil unless importer_package
+
+      relative_path = File.join(*module_name.split(".")) + ".mt"
+      candidates = []
+      if package_namespace_match?(module_name, importer_package.manifest.package_name)
+        candidates << [
+          importer_package.manifest.package_name,
+          File.join(importer_package.manifest.source_root, relative_path),
+        ]
+      end
+
+      importer_package.edges.each do |edge|
+        next unless edge.node && package_namespace_match?(module_name, edge.dependency.name)
+
+        candidates << [
+          edge.dependency.name,
+          File.join(edge.node.manifest.source_root, relative_path),
+        ]
+      end
+
+      return nil if candidates.empty?
+
+      best_namespace_length = candidates.map { |namespace, _path| namespace.length }.max
+      matching_candidates = candidates.select { |namespace, _path| namespace.length == best_namespace_length }
+      if matching_candidates.length > 1
+        raise ModuleLoadError.new("ambiguous package dependency import", path: module_name)
+      end
+
+      resolved_path = ModuleLoader.resolve_source_path(matching_candidates.first.last, platform: @platform)
+      raise ModuleLoadError.new("module not found", path: module_name) unless source_path_available?(resolved_path)
+
+      File.expand_path(resolved_path)
+    end
+
+    def import_allowed?(module_name, importer_path, candidate_path)
+      if @package_graph
+        return import_allowed_by_graph?(module_name, importer_path, candidate_path)
+      end
+
+      importer_manifest = package_manifest_for_path(importer_path)
+      return true unless importer_manifest
+
+      candidate_manifest = package_manifest_for_path(candidate_path)
+      return true unless candidate_manifest
+      return true if candidate_manifest.manifest_path == importer_manifest.manifest_path
+
+      dependency = importer_manifest.dependencies.find { |entry| entry.name == candidate_manifest.package_name }
+      return false unless dependency
+
+      package_namespace_match?(module_name, dependency.name)
+    end
+
+    def import_allowed_by_graph?(module_name, importer_path, candidate_path)
+      importer_package = @package_graph.package_for_path(importer_path)
+      return true unless importer_package
+
+      candidate_package = @package_graph.package_for_path(candidate_path)
+      return true unless candidate_package
+      return true if candidate_package.manifest.manifest_path == importer_package.manifest.manifest_path
+
+      dependency = importer_package.edges.find do |edge|
+        edge.node && edge.node.manifest.package_name == candidate_package.manifest.package_name
+      end
+      return false unless dependency
+
+      package_namespace_match?(module_name, dependency.dependency.name)
+    end
+
+    def package_manifest_for_path(path)
+      return nil unless path
+
+      package_root = ModuleRoots.package_root_for_path(path)
+      return nil unless package_root
+
+      manifest_path = File.join(package_root, "package.toml")
+      return @package_manifest_cache[manifest_path] if @package_manifest_cache.key?(manifest_path)
+
+      @package_manifest_cache[manifest_path] = PackageManifest.load(path)
+    rescue PackageManifestError
+      @package_manifest_cache[manifest_path] = nil if manifest_path
+      nil
+    end
+
+    def package_namespace_match?(module_name, package_name)
+      module_name == package_name || module_name.start_with?("#{package_name}.")
+    end
+
+    def namespace_hint_for_missing_module(module_name, importer_path:, importer_module_name:)
+      return nil unless importer_path && importer_module_name
+      return nil unless entry_module_namespace_like?(importer_path, importer_module_name)
+      return nil unless module_name.start_with?("#{importer_module_name}.")
+
+      sibling_import = module_name.delete_prefix("#{importer_module_name}.")
+      sibling_path = File.join(File.dirname(importer_path), *sibling_import.split(".")) + ".mt"
+      resolved_sibling_path = ModuleLoader.resolve_source_path(sibling_path, platform: @platform)
+      return nil unless source_path_available?(resolved_sibling_path)
+
+      namespaced_path = File.join(File.dirname(importer_path), importer_module_name, *sibling_import.split(".")) + ".mt"
+      "module not found; entry module '#{importer_module_name}' does not create an import namespace for sibling files. Import '#{sibling_import}' instead, or move the module to #{namespaced_path}"
+    end
+
+    def entry_module_namespace_like?(importer_path, importer_module_name)
+      return false if importer_module_name.include?(".")
+
+      File.basename(importer_path).match?(/\Amain(?:\.(linux|windows|wasm))?\.mt\z/)
+    end
+  end
+end