mt-lang 0.3.8 → 0.3.10

data/lib/milk_tea/lsp/server.rb

@@ -255,9 +255,6 @@ module MilkTea
         raise
       end
 
-
-      private
-
       include ServerCallHierarchy
       include ServerCodeActions
       include ServerCodeLens

data/lib/milk_tea/lsp/workspace/analysis.rb

@@ -4,8 +4,6 @@ module MilkTea
   module LSP
     class Workspace
       module WorkspaceAnalysis
-        private
-
         # ── Compilation helpers ─────────────────────────────────────────────────
 
         def lex_document(uri)
@@ -127,46 +125,46 @@ module MilkTea
           def analyze_document(uri)
             path = uri_to_path(uri)
             snapshot = if path && File.file?(path)
-                         parse_result = MilkTea::Parser.parse_collecting_errors(get_content(uri), path: uri)
-                         ast = parse_result.ast
-                         return @last_good_tooling_snapshot_cache[uri] if ast.nil?
-
-                         @ast_cache[uri] = ast
-
-                         resolution = DependencyResolution.resolve(path, mode: @dependency_resolution_mode)
-                         return nil unless resolution.ok?
-
-                         effective_platform = effective_platform_for_path(path)
-                         ensure_root_platform_compatible!(path, effective_platform)
-
-                         loader = MilkTea::ModuleLoader.new(
-                           module_roots: module_roots_for_path(path, locked: resolution.locked),
-                           package_graph: package_graph_for_path(path, locked: resolution.locked),
-                           shared_cache: @shared_module_cache,
-                           source_overrides: file_backed_source_overrides,
-                           platform: effective_platform,
-                         )
-                         ast = with_inferred_module_name(ast, loader:, path:)
-                         import_resolution = loader.imported_modules_for_ast_collecting_errors(ast, importer_path: path)
-                         MilkTea::SemanticAnalyzer.tooling_snapshot(
-                           ast,
-                           imported_modules: import_resolution.modules,
-                           allow_missing_imports: true,
-                           path: path,
-                         )
-                        else
-                          ast = get_ast(uri)
-                          return @last_good_tooling_snapshot_cache[uri] if ast.nil?
-
-                           result = MilkTea::SemanticAnalyzer.check_collecting_errors(ast, path:)
-                           facts = result[:analysis]
-                           MilkTea::SemanticAnalyzer::ToolingSnapshot.new(facts:, diagnostics: (Array(result[:errors]).map { |e| e.to_diagnostic(path:) } || []).freeze)
-                        end
-              if snapshot&.facts
-                @last_good_tooling_snapshot_cache[uri] = snapshot
-                @last_good_facts_cache[uri] = snapshot.facts
-                @document_module_names[uri] = snapshot.facts.module_name
-              end
+              parse_result = MilkTea::Parser.parse_collecting_errors(get_content(uri), path: uri)
+              ast = parse_result.ast
+              return @last_good_tooling_snapshot_cache[uri] if ast.nil?
+
+              @ast_cache[uri] = ast
+
+              resolution = DependencyResolution.resolve(path, mode: @dependency_resolution_mode)
+              return nil unless resolution.ok?
+
+              effective_platform = effective_platform_for_path(path)
+              ensure_root_platform_compatible!(path, effective_platform)
+
+              loader = MilkTea::ModuleLoader.new(
+                module_roots: module_roots_for_path(path, locked: resolution.locked),
+                package_graph: package_graph_for_path(path, locked: resolution.locked),
+                shared_cache: @shared_module_cache,
+                source_overrides: file_backed_source_overrides,
+                platform: effective_platform,
+              )
+              ast = with_inferred_module_name(ast, loader:, path:)
+              import_resolution = loader.imported_modules_for_ast_collecting_errors(ast, importer_path: path)
+              MilkTea::SemanticAnalyzer.tooling_snapshot(
+                ast,
+                imported_modules: import_resolution.modules,
+                allow_missing_imports: true,
+                path: path,
+              )
+            else
+              ast = get_ast(uri)
+              return @last_good_tooling_snapshot_cache[uri] if ast.nil?
+
+                result = MilkTea::SemanticAnalyzer.check_collecting_errors(ast, path:)
+                facts = result[:analysis]
+                MilkTea::SemanticAnalyzer::ToolingSnapshot.new(facts:, diagnostics: (Array(result[:errors]).map { |e| e.to_diagnostic(path:) } || []).freeze)
+            end
+            if snapshot&.facts
+              @last_good_tooling_snapshot_cache[uri] = snapshot
+              @last_good_facts_cache[uri] = snapshot.facts
+              @document_module_names[uri] = snapshot.facts.module_name
+            end
             snapshot
           rescue MilkTea::LexError, MilkTea::SemanticError, ModuleLoadError, PackageLockError
             @last_good_tooling_snapshot_cache[uri]

data/lib/milk_tea/lsp/workspace/dependency_graph.rb

@@ -100,8 +100,6 @@ module MilkTea
           end
         end
 
-        private
-
         def clear_dependency_index
           @dependency_module_name_by_uri.clear
           @dependency_imports_by_uri.clear
@@ -111,10 +109,10 @@ module MilkTea
 
         def update_dependency_index(uri, facts)
           imported_module_names = if facts
-                                    facts.imports.each_value.filter_map(&:name).to_set
-                                  else
-                                    dependency_index_imports_for(uri)
-                                  end
+            facts.imports.each_value.filter_map(&:name).to_set
+          else
+            dependency_index_imports_for(uri)
+          end
 
           if imported_module_names&.empty?
             imported_module_names = dependency_index_imports_for(uri) || Set.new
@@ -246,15 +244,11 @@ module MilkTea
           open_document_uris
         end
 
-        public
-
         def reverse_import_dependents_for(module_name)
           ensure_full_reverse_import_index
           @reverse_import_dependents[module_name]
         end
 
-        private
-
         def ensure_full_reverse_import_index
           return if @full_reverse_index_built
 

data/lib/milk_tea/lsp/workspace/utilities.rb

@@ -265,21 +265,21 @@ module MilkTea
             next unless id_tok.type == :identifier
 
             kind = case kw_tok.type
-                   when :function then 'function'
-                   when :struct  then 'struct'
-                   when :union   then 'union'
-                   when :enum    then 'enum'
-                   when :flags   then 'flags'
-                   when :variant then 'variant'
-                   when :type    then 'type_alias'
-                   when :const   then 'constant'
-                   when :let     then 'variable'
-                   when :var     then 'variable'
-                   when :event   then 'event'
-                   when :extending then 'struct'
-                   when :opaque  then 'struct'
-                   when :interface then 'interface'
-                   end
+            when :function then 'function'
+            when :struct  then 'struct'
+            when :union   then 'union'
+            when :enum    then 'enum'
+            when :flags   then 'flags'
+            when :variant then 'variant'
+            when :type    then 'type_alias'
+            when :const   then 'constant'
+            when :let     then 'variable'
+            when :var     then 'variable'
+            when :event   then 'event'
+            when :extending then 'struct'
+            when :opaque  then 'struct'
+            when :interface then 'interface'
+            end
 
             symbols << {
               name:   id_tok.lexeme,
@@ -447,10 +447,10 @@ module MilkTea
           clamped_line = [[line.to_i, 0].max, lines.length - 1].min
 
           preceding = if clamped_line.zero?
-                        ''
-                      else
-                        lines[0...clamped_line].join("\n") + "\n"
-                      end
+            ''
+          else
+            lines[0...clamped_line].join("\n") + "\n"
+          end
 
           line_text = lines[clamped_line] || ''
           target_units = [char.to_i, 0].max

data/lib/milk_tea/packages/atomic_write.rb

@@ -5,15 +5,14 @@ require "tempfile"
 
 module MilkTea
   module PackageAtomicWrite
-    module_function
 
-    def write(path, content, binmode: false)
+    def self.write(path, content, binmode: false)
       open(path, binmode:) do |file|
         file.write(content)
       end
     end
 
-    def open(path, binmode: false)
+    def self.open(path, binmode: false)
       expanded_path = File.expand_path(path)
       directory = File.dirname(expanded_path)
 
@@ -35,13 +34,13 @@ module MilkTea
       expanded_path
     end
 
-    def replace(source_path, destination_path)
+    def self.replace(source_path, destination_path)
       File.rename(source_path, destination_path)
     rescue Errno::EACCES, Errno::EEXIST, Errno::EPERM
       replace_via_backup(source_path, destination_path)
     end
 
-    def replace_via_backup(source_path, destination_path)
+    def self.replace_via_backup(source_path, destination_path)
       backup_path = "#{destination_path}.bak.#{$$}.#{Thread.current.object_id}"
 
       File.rename(destination_path, backup_path) if File.exist?(destination_path)

data/lib/milk_tea/packages/dependency_solver.rb

@@ -171,21 +171,21 @@ module MilkTea
 
       versions.each_with_object({}) do |(key, version), locked|
         normalized_key = case key
-                         when PackageSourceResolver::RegistryDependencyKey
-                           PackageSourceResolver.registry_dependency_key(
-                             parent_source_key: key.parent_source_key,
-                             dependency_name: key.dependency_name,
-                           )
-                         when Array
-                           if key.length != 2
-                             raise PackageDependencySolverError,
-                                   "registry dependency key must contain parent manifest path and dependency name"
-                           end
-
-                           PackageSourceResolver.registry_dependency_key(parent_source_key: key[0], dependency_name: key[1])
-                         else
-                           key.to_s
-                         end
+        when PackageSourceResolver::RegistryDependencyKey
+          PackageSourceResolver.registry_dependency_key(
+            parent_source_key: key.parent_source_key,
+            dependency_name: key.dependency_name,
+          )
+        when Array
+          if key.length != 2
+            raise PackageDependencySolverError,
+                  "registry dependency key must contain parent manifest path and dependency name"
+          end
+
+          PackageSourceResolver.registry_dependency_key(parent_source_key: key[0], dependency_name: key[1])
+        else
+          key.to_s
+        end
 
         locked[normalized_key] = version.to_s
       end

data/lib/milk_tea/packages/lock.rb

@@ -137,10 +137,10 @@ module MilkTea
       end
 
       root_package_id = if schema_version == 1
-                          root_package_name
-                        else
-                          required_string(config, "root_package_id", lock_path)
-                        end
+        root_package_name
+      else
+        required_string(config, "root_package_id", lock_path)
+      end
 
       [root_manifest, lock_path, root_package_name, root_package_id, schema_version, packages]
     end

data/lib/milk_tea/packages/manager_cli.rb

@@ -341,7 +341,7 @@ module MilkTea
       end
       selected_ids = Set.new
       queue = locked_packages.select { |package| requested_names.include?(package.package_name) }
-                           .map(&:instance_id)
+        .map(&:instance_id)
 
       until queue.empty?
         package_id = queue.shift

data/lib/milk_tea/packages/manifest.rb

@@ -135,9 +135,9 @@ module MilkTea
       end
 
       duplicate_basenames = asset_paths.group_by { |asset_path| File.basename(asset_path) }
-                                       .select { |_basename, paths| paths.length > 1 }
-                                       .keys
-                                       .sort
+        .select { |_basename, paths| paths.length > 1 }
+        .keys
+        .sort
       return asset_paths if duplicate_basenames.empty?
 
       raise PackageManifestError, "build.assets entries must have unique basenames: #{duplicate_basenames.join(", ")}"

data/lib/milk_tea/packages/registry_store.rb

@@ -21,10 +21,10 @@ module MilkTea
 
       xdg_data_home = env.fetch("XDG_DATA_HOME", "").to_s.strip
       base_root = if xdg_data_home.empty?
-                    File.join(home || Dir.home, ".local", "share")
-                  else
-                    File.expand_path(xdg_data_home)
-                  end
+        File.join(home || Dir.home, ".local", "share")
+      else
+        File.expand_path(xdg_data_home)
+      end
 
       File.join(base_root, "milk_tea", "registry")
     end
@@ -155,8 +155,6 @@ module MilkTea
       self.class.http_url?(@upstream_root)
     end
 
-    private
-
     def extract_package_version(package_or_identity, version)
       if package_or_identity.respond_to?(:package_name) && package_or_identity.respond_to?(:version)
         [package_or_identity.package_name, package_or_identity.version]

data/lib/milk_tea/packages/services.rb

@@ -20,22 +20,22 @@ module MilkTea
 
     def source_resolver(mode)
       @source_resolvers[mode] ||= case mode
-                                  when :reject
-                                    PackageSourceResolver.new(source_cache: source_cache)
-                                  when :cache
-                                    PackageSourceResolver.new(
-                                      source_cache: source_cache,
-                                      remote_resolution: :cache,
-                                    )
-                                  when :materialize
-                                    PackageSourceResolver.new(
-                                      source_cache: source_cache,
-                                      remote_resolution: :materialize,
-                                      source_fetcher: source_fetcher,
-                                    )
-                                  else
-                                    raise ArgumentError, "unknown dependency source resolution mode #{mode.inspect}"
-                                  end
+      when :reject
+        PackageSourceResolver.new(source_cache: source_cache)
+      when :cache
+        PackageSourceResolver.new(
+          source_cache: source_cache,
+          remote_resolution: :cache,
+        )
+      when :materialize
+        PackageSourceResolver.new(
+          source_cache: source_cache,
+          remote_resolution: :materialize,
+          source_fetcher: source_fetcher,
+        )
+      else
+        raise ArgumentError, "unknown dependency source resolution mode #{mode.inspect}"
+      end
     end
   end
 end

data/lib/milk_tea/packages/source_cache.rb

@@ -7,10 +7,10 @@ module MilkTea
     def self.default_root(env: ENV, home: nil)
       xdg_cache_home = env.fetch("XDG_CACHE_HOME", "").to_s.strip
       base_root = if xdg_cache_home.empty?
-                    File.join(home || Dir.home, ".cache")
-                  else
-                    File.expand_path(xdg_cache_home)
-                  end
+        File.join(home || Dir.home, ".cache")
+      else
+        File.expand_path(xdg_cache_home)
+      end
 
       File.join(base_root, "milk_tea", "package_sources")
     end
@@ -58,8 +58,6 @@ module MilkTea
       File.file?(manifest_path_for(source_or_identity))
     end
 
-    private
-
     def extract_identity(source_or_identity)
       if source_or_identity.respond_to?(:identity)
         source_or_identity.identity

data/lib/milk_tea/packages/source_resolver.rb

@@ -284,22 +284,22 @@ module MilkTea
     def resolve_cache_backed_dependency(identity, dependency:, parent_manifest:)
       context_label = "dependency #{dependency.name} in #{parent_manifest.manifest_path}"
       source = case @remote_resolution
-               when :reject
-                 raise PackageSourceResolverError,
-                       "#{context_label} uses #{identity.kind} resolution, but live dependency resolution only supports local path dependencies; run mtc deps lock and then use --locked or --frozen"
-               when :cache
-                 source_for_identity(identity, context_label)
-               when :materialize
-                 unless @source_fetcher
-                   raise PackageSourceResolverError,
-                         "#{context_label} requested #{identity.kind} materialization without a package source fetcher"
-                 end
-
-                 @source_fetcher.materialize_identity(package_name: dependency.name, identity:)
-                 source_for_identity(identity, context_label)
-               else
-                 raise PackageSourceResolverError, "unknown remote resolution mode #{@remote_resolution.inspect}"
-               end
+      when :reject
+        raise PackageSourceResolverError,
+              "#{context_label} uses #{identity.kind} resolution, but live dependency resolution only supports local path dependencies; run mtc deps lock and then use --locked or --frozen"
+      when :cache
+        source_for_identity(identity, context_label)
+      when :materialize
+        unless @source_fetcher
+          raise PackageSourceResolverError,
+                "#{context_label} requested #{identity.kind} materialization without a package source fetcher"
+        end
+
+        @source_fetcher.materialize_identity(package_name: dependency.name, identity:)
+        source_for_identity(identity, context_label)
+      else
+        raise PackageSourceResolverError, "unknown remote resolution mode #{@remote_resolution.inspect}"
+      end
 
       manifest = PackageManifest.load(source.local_root)
       if manifest.package_name != dependency.name
@@ -334,16 +334,16 @@ module MilkTea
 
     def source_for_identity(identity, context_label)
       local_root = if identity.is_a?(PathIdentity)
-                     identity.path
-                   else
-                     manifest_path = @source_cache.manifest_path_for(identity)
-                     unless File.file?(manifest_path)
-                       raise PackageSourceResolverError,
-                             "package source_kind #{identity.kind.inspect} in #{context_label} is not materialized in the source cache: expected #{manifest_path}"
-                     end
+        identity.path
+      else
+        manifest_path = @source_cache.manifest_path_for(identity)
+        unless File.file?(manifest_path)
+          raise PackageSourceResolverError,
+                "package source_kind #{identity.kind.inspect} in #{context_label} is not materialized in the source cache: expected #{manifest_path}"
+        end
 
-                     @source_cache.materialized_root_for(identity)
-                   end
+        @source_cache.materialized_root_for(identity)
+      end
 
       Source.new(
         identity:,
@@ -353,10 +353,10 @@ module MilkTea
 
     def registry_dependency_parent_source_key(parent_manifest:, parent_source:)
       identity = if parent_source
-                   parent_source.identity
-                 else
-                   source_for_manifest(parent_manifest).identity
-                 end
+        parent_source.identity
+      else
+        source_for_manifest(parent_manifest).identity
+      end
 
       self.class.source_key_for_identity(identity)
     end
@@ -366,21 +366,21 @@ module MilkTea
 
       versions.each_with_object({}) do |(key, version), resolved|
         normalized_key = case key
-                         when RegistryDependencyKey
-                           self.class.registry_dependency_key(
-                             parent_source_key: key.parent_source_key,
-                             dependency_name: key.dependency_name,
-                           )
-                         when Array
-                           if key.length != 2
-                             raise PackageSourceResolverError,
-                                   "registry dependency key must contain parent manifest path and dependency name"
-                           end
-
-                           self.class.registry_dependency_key(parent_source_key: key[0], dependency_name: key[1])
-                         else
-                           key.to_s
-                         end
+        when RegistryDependencyKey
+          self.class.registry_dependency_key(
+            parent_source_key: key.parent_source_key,
+            dependency_name: key.dependency_name,
+          )
+        when Array
+          if key.length != 2
+            raise PackageSourceResolverError,
+                  "registry dependency key must contain parent manifest path and dependency name"
+          end
+
+          self.class.registry_dependency_key(parent_source_key: key[0], dependency_name: key[1])
+        else
+          key.to_s
+        end
 
         resolved[normalized_key] = version.to_s
       end

data/lib/milk_tea/packages/version.rb

@@ -63,14 +63,14 @@ module MilkTea
 
       def to_s
         prefix = case operator
-                 when :eq then "="
-                 when :gt then ">"
-                 when :gte then ">="
-                 when :lt then "<"
-                 when :lte then "<="
-                 else
-                   raise PackageVersionError, "unsupported package version operator #{operator.inspect}"
-                 end
+        when :eq then "="
+        when :gt then ">"
+        when :gte then ">="
+        when :lt then "<"
+        when :lte then "<="
+        else
+          raise PackageVersionError, "unsupported package version operator #{operator.inspect}"
+        end
 
         "#{prefix}#{version}"
       end

data/lib/milk_tea/tooling/build.rb

@@ -120,20 +120,18 @@ module MilkTea
         )
       end.freeze
     end
-    private_class_method :frontend_modules
 
     def self.default_raw_bindings(root: MilkTea.root)
       require_relative "../bindings"
 
       RawBindings.default_registry(root:)
     end
-    private_class_method :default_raw_bindings
 
     def initialize(path, output_path:, cc:, keep_c_path:, raw_bindings:, module_roots: nil, package_graph: nil, frontend: nil, debug: false, profile: nil, platform: nil, bundle: false, archive: false, no_cache: false, sanitize: false, kind: :executable, debug_guards: nil)
       @kind = case kind
-              when :executable, :static, :shared then kind
-              else raise BuildError, "unknown build kind #{kind}; expected executable|static|shared"
-              end
+      when :executable, :static, :shared then kind
+      else raise BuildError, "unknown build kind #{kind}; expected executable|static|shared"
+      end
       @explicit_output_path = !output_path.nil?
       resolved_source = use_package_build_for?(path)
       if resolved_source
@@ -244,8 +242,6 @@ module MilkTea
       end
     end
 
-    private
-
     def build_static_library
       cache = @no_cache ? nil : BuildCache.new(root: MilkTea.root)
       emit_line_directives = line_directives_required?

data/lib/milk_tea/tooling/build_cache.rb

@@ -197,8 +197,6 @@ module MilkTea
       @shared_analysis_cache ||= {}
     end
 
-    private
-
     def program_dir(key)
       File.join(@cache_root, "programs", key[0, 2], key)
     end