packwerk 2.1.1 → 2.2.1

data/bin/srb

@@ -15,7 +15,7 @@ ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
 bundle_binstub = File.expand_path("../bundle", __FILE__)
 
 if File.file?(bundle_binstub)
-  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+  if /This file was generated by Bundler/.match?(File.read(bundle_binstub, 300))
     load(bundle_binstub)
   else
     abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.

data/bin/tapioca

@@ -15,7 +15,7 @@ ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
 bundle_binstub = File.expand_path("../bundle", __FILE__)
 
 if File.file?(bundle_binstub)
-  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+  if /This file was generated by Bundler/.match?(File.read(bundle_binstub, 300))
     load(bundle_binstub)
   else
     abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.

data/gemfiles/Gemfile-rails-6-0

@@ -7,7 +7,7 @@ gemspec path: ".."
 # Specify the same dependency sources as the application Gemfile
 
 gem("spring")
-gem("rails", '~> 6.0.0')
+gem("rails", "~> 6.0.0")
 gem("constant_resolver", require: false)
 gem("sorbet-runtime", require: false)
 gem("rubocop-performance", require: false)

data/gemfiles/Gemfile-rails-6-1

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+source("https://rubygems.org")
+
+gemspec path: ".."
+
+# Specify the same dependency sources as the application Gemfile
+
+gem("spring")
+gem("rails", "~> 6.1.0")
+gem("constant_resolver", require: false)
+gem("sorbet-runtime", require: false)
+gem("rubocop-performance", require: false)
+gem("rubocop-sorbet", require: false)
+gem("mocha", require: false)
+gem("rubocop-shopify", require: false)
+gem("tapioca", require: false)
+
+group :development do
+  gem("byebug", require: false)
+  gem("minitest-focus", require: false)
+end

data/lib/packwerk/application_load_paths.rb

@@ -9,7 +9,7 @@ module Packwerk
     class << self
       extend T::Sig
 
-      sig { params(root: String, environment: String).returns(T::Array[String]) }
+      sig { params(root: String, environment: String).returns(T::Hash[String, Module]) }
       def extract_relevant_paths(root, environment)
         require_application(root, environment)
         all_paths = extract_application_autoload_paths
@@ -18,36 +18,30 @@ module Packwerk
         relative_path_strings(relevant_paths)
       end
 
-      sig { returns(T::Array[String]) }
+      sig { returns(T::Hash[String, Module]) }
       def extract_application_autoload_paths
-        Rails.application.railties
-          .select { |railtie| railtie.is_a?(Rails::Engine) }
-          .push(Rails.application)
-          .flat_map do |engine|
-            paths = (engine.config.autoload_paths + engine.config.eager_load_paths + engine.config.autoload_once_paths)
-            paths.map(&:to_s).uniq
-          end
+        Rails.autoloaders.inject({}) do |h, loader|
+          h.merge(loader.root_dirs)
+        end
       end
 
       sig do
-        params(all_paths: T::Array[String], bundle_path: Pathname, rails_root: Pathname)
-          .returns(T::Array[Pathname])
+        params(all_paths: T::Hash[String, Module], bundle_path: Pathname, rails_root: Pathname)
+          .returns(T::Hash[Pathname, Module])
       end
       def filter_relevant_paths(all_paths, bundle_path: Bundler.bundle_path, rails_root: Rails.root)
         bundle_path_match = bundle_path.join("**")
         rails_root_match = rails_root.join("**")
 
         all_paths
-          .map { |path| Pathname.new(path).expand_path }
+          .transform_keys { |path| Pathname.new(path).expand_path }
           .select { |path| path.fnmatch(rails_root_match.to_s) } # path needs to be in application directory
           .reject { |path| path.fnmatch(bundle_path_match.to_s) } # reject paths from vendored gems
       end
 
-      sig { params(paths: T::Array[Pathname], rails_root: Pathname).returns(T::Array[String]) }
-      def relative_path_strings(paths, rails_root: Rails.root)
-        paths
-          .map { |path| path.relative_path_from(rails_root).to_s }
-          .uniq
+      sig { params(load_paths: T::Hash[Pathname, Module], rails_root: Pathname).returns(T::Hash[String, Module]) }
+      def relative_path_strings(load_paths, rails_root: Rails.root)
+        load_paths.transform_keys { |path| Pathname.new(path).relative_path_from(rails_root).to_s }
       end
 
       private
@@ -65,7 +59,7 @@ module Packwerk
         end
       end
 
-      sig { params(paths: T::Array[T.untyped]).void }
+      sig { params(paths: T::Hash[T.untyped, Module]).void }
       def assert_load_paths_present(paths)
         if paths.empty?
           raise <<~EOS

data/lib/packwerk/application_validator.rb

@@ -66,6 +66,7 @@ module Packwerk
 
       privacy_settings.each do |config_file_path, setting|
         next unless setting.is_a?(Array)
+
         constants = setting
 
         results += assert_constants_can_be_loaded(constants, config_file_path)
@@ -92,7 +93,7 @@ module Packwerk
         hash = YAML.load_file(f)
         next unless hash
 
-        known_keys = %w(enforce_privacy enforce_dependencies public_path dependencies metadata)
+        known_keys = ["enforce_privacy", "enforce_dependencies", "public_path", "dependencies", "metadata"]
         unknown_keys = hash.keys - known_keys
 
         unless unknown_keys.empty?
@@ -309,7 +310,7 @@ module Packwerk
           Result.new(
             ok: false,
             error_value: "'#{constant}', listed in the 'enforce_privacy' option in #{config_file_path}, is invalid.\n"\
-            "Private constants need to be prefixed with the top-level namespace operator `::`."
+              "Private constants need to be prefixed with the top-level namespace operator `::`."
           )
         else
           constant.try(&:constantize) && Result.new(ok: true)
@@ -324,9 +325,9 @@ module Packwerk
       Result.new(
         ok: false,
         error_value: "'#{name}', listed in #{config_file_path}, could not be resolved.\n"\
-        "This is probably because it is an autovivified namespace - a namespace module that doesn't have a\n"\
-        "file explicitly defining it. Packwerk currently doesn't support declaring autovivified namespaces as\n"\
-        "private. Add a #{explicit_filepath} file to explicitly define the constant."
+          "This is probably because it is an autovivified namespace - a namespace module that doesn't have a\n"\
+          "file explicitly defining it. Packwerk currently doesn't support declaring autovivified namespaces as\n"\
+          "private. Add a #{explicit_filepath} file to explicitly define the constant."
       )
     end
 
@@ -341,7 +342,7 @@ module Packwerk
         Result.new(
           ok: false,
           error_value: "'#{name}' is declared as private in the '#{declared_package}' package but appears to be "\
-          "defined\nin the '#{constant_package}' package. Packwerk resolved it to #{location}."
+            "defined\nin the '#{constant_package}' package. Packwerk resolved it to #{location}."
         )
       end
     end

data/lib/packwerk/association_inspector.rb

@@ -10,12 +10,12 @@ module Packwerk
     CustomAssociations = T.type_alias { T.any(T::Array[Symbol], T::Set[Symbol]) }
 
     RAILS_ASSOCIATIONS = T.let(
-      %i(
-        belongs_to
-        has_many
-        has_one
-        has_and_belongs_to_many
-      ).to_set,
+      [
+        :belongs_to,
+        :has_many,
+        :has_one,
+        :has_and_belongs_to_many,
+      ].to_set,
       CustomAssociations
     )
 
@@ -31,15 +31,16 @@ module Packwerk
         .returns(T.nilable(String))
     end
     def constant_name_from_node(node, ancestors:)
-      return unless Node.method_call?(node)
+      return unless NodeHelpers.method_call?(node)
       return unless association?(node)
 
-      arguments = Node.method_arguments(node)
+      arguments = NodeHelpers.method_arguments(node)
       return unless (association_name = association_name(arguments))
 
       if (class_name_node = custom_class_name(arguments))
-        return unless Node.string?(class_name_node)
-        Node.literal_value(class_name_node)
+        return unless NodeHelpers.string?(class_name_node)
+
+        NodeHelpers.literal_value(class_name_node)
       else
         @inflector.classify(association_name.to_s)
       end
@@ -49,23 +50,24 @@ module Packwerk
 
     sig { params(node: AST::Node).returns(T::Boolean) }
     def association?(node)
-      method_name = Node.method_name(node)
+      method_name = NodeHelpers.method_name(node)
       @associations.include?(method_name)
     end
 
     sig { params(arguments: T::Array[AST::Node]).returns(T.nilable(AST::Node)) }
     def custom_class_name(arguments)
-      association_options = arguments.detect { |n| Node.hash?(n) }
+      association_options = arguments.detect { |n| NodeHelpers.hash?(n) }
       return unless association_options
 
-      Node.value_from_hash(association_options, :class_name)
+      NodeHelpers.value_from_hash(association_options, :class_name)
     end
 
     sig { params(arguments: T::Array[AST::Node]).returns(T.any(T.nilable(Symbol), T.nilable(String))) }
     def association_name(arguments)
-      return unless Node.symbol?(arguments[0])
+      association_name_node = T.must(arguments[0])
+      return unless NodeHelpers.symbol?(association_name_node)
 
-      Node.literal_value(arguments[0])
+      NodeHelpers.literal_value(association_name_node)
     end
   end
 end

data/lib/packwerk/cache.rb

@@ -1,5 +1,5 @@
-# frozen_string_literal: true
 # typed: strict
+# frozen_string_literal: true
 
 require "digest"
 
@@ -13,31 +13,35 @@ module Packwerk
       const :file_contents_digest, String
       const :unresolved_references, T::Array[UnresolvedReference]
 
-      sig { returns(String) }
-      def serialize
-        to_json
-      end
-
-      sig { params(serialized_cache_contents: String).returns(CacheContents) }
-      def self.deserialize(serialized_cache_contents)
-        cache_contents_json = JSON.parse(serialized_cache_contents)
-        unresolved_references = cache_contents_json["unresolved_references"].map do |json|
-          UnresolvedReference.new(
-            json["constant_name"],
-            json["namespace_path"],
-            json["relative_path"],
-            Node::Location.new(json["source_location"]["line"], json["source_location"]["column"],)
+      class << self
+        extend T::Sig
+
+        sig { params(serialized_cache_contents: String).returns(CacheContents) }
+        def deserialize(serialized_cache_contents)
+          cache_contents_json = JSON.parse(serialized_cache_contents)
+          unresolved_references = cache_contents_json["unresolved_references"].map do |json|
+            UnresolvedReference.new(
+              json["constant_name"],
+              json["namespace_path"],
+              json["relative_path"],
+              Node::Location.new(json["source_location"]["line"], json["source_location"]["column"],)
+            )
+          end
+
+          CacheContents.new(
+            file_contents_digest: cache_contents_json["file_contents_digest"],
+            unresolved_references: unresolved_references,
           )
         end
+      end
 
-        CacheContents.new(
-          file_contents_digest: cache_contents_json["file_contents_digest"],
-          unresolved_references: unresolved_references,
-        )
+      sig { returns(String) }
+      def serialize
+        to_json
       end
     end
 
-    CACHE_SHAPE = T.type_alias do
+    CacheShape = T.type_alias do
       T::Hash[
         String,
         CacheContents
@@ -47,7 +51,7 @@ module Packwerk
     sig { params(enable_cache: T::Boolean, cache_directory: Pathname, config_path: T.nilable(String)).void }
     def initialize(enable_cache:, cache_directory:, config_path:)
       @enable_cache = enable_cache
-      @cache = T.let({}, CACHE_SHAPE)
+      @cache = T.let({}, CacheShape)
       @files_by_digest = T.let({}, T::Hash[String, String])
       @config_path = config_path
       @cache_directory = cache_directory
@@ -71,7 +75,7 @@ module Packwerk
       ).returns(T::Array[UnresolvedReference])
     end
     def with_cache(file_path, &block)
-      return block.call unless @enable_cache
+      return yield unless @enable_cache
 
       cache_location = @cache_directory.join(digest_for_string(file_path))
 
@@ -89,7 +93,7 @@ module Packwerk
       else
         Debug.out("Cache miss for #{file_path}")
 
-        unresolved_references = block.call
+        unresolved_references = yield
 
         cache_contents = CacheContents.new(
           file_contents_digest: file_contents_digest,
@@ -116,6 +120,7 @@ module Packwerk
     sig { void }
     def bust_cache_if_packwerk_yml_has_changed!
       return nil if @config_path.nil?
+
       bust_cache_if_contents_have_changed(File.read(@config_path), :packwerk_yml)
     end
 
@@ -155,14 +160,16 @@ module Packwerk
   end
 
   class Debug
-    extend T::Sig
+    class << self
+      extend T::Sig
 
-    sig { params(out: String).void }
-    def self.out(out)
-      if ENV["DEBUG_PACKWERK_CACHE"]
-        puts(out)
+      sig { params(out: String).void }
+      def out(out)
+        if ENV["DEBUG_PACKWERK_CACHE"]
+          puts(out)
+        end
       end
-    end
+  end
   end
 
   private_constant :Debug

data/lib/packwerk/cli.rb

@@ -32,8 +32,10 @@ module Packwerk
       @style = style
       @configuration = T.let(configuration || Configuration.from_path, Configuration)
       @progress_formatter = T.let(Formatters::ProgressFormatter.new(@out, style: style), Formatters::ProgressFormatter)
-      @offenses_formatter = T.let(offenses_formatter || Formatters::OffensesFormatter.new(style: @style),
-        OffensesFormatter)
+      @offenses_formatter = T.let(
+        offenses_formatter || Formatters::OffensesFormatter.new(style: @style),
+        OffensesFormatter
+      )
     end
 
     sig { params(args: T::Array[String]).returns(T.noreturn) }
@@ -65,7 +67,6 @@ module Packwerk
           Subcommands:
             init - set up packwerk
             check - run all checks
-            update - update deprecated references (deprecated, use update-deprecations instead)
             update-deprecations - update deprecated references
             validate - verify integrity of packwerk and package configuration
             help  - display help information about packwerk
@@ -122,16 +123,21 @@ module Packwerk
       result.status
     end
 
-    sig { params(relative_file_paths: T::Array[String], ignore_nested_packages: T::Boolean).returns(T::Array[String]) }
+    sig do
+      params(
+        relative_file_paths: T::Array[String],
+        ignore_nested_packages: T::Boolean
+      ).returns(FilesForProcessing::RelativeFileSet)
+    end
     def fetch_files_to_process(relative_file_paths, ignore_nested_packages)
-      absolute_files = FilesForProcessing.fetch(
+      relative_file_set = FilesForProcessing.fetch(
         relative_file_paths: relative_file_paths,
         ignore_nested_packages: ignore_nested_packages,
         configuration: @configuration
       )
       abort("No files found or given. "\
-        "Specify files or check the include and exclude glob in the config file.") if absolute_files.empty?
-      absolute_files
+        "Specify files or check the include and exclude glob in the config file.") if relative_file_set.empty?
+      relative_file_set
     end
 
     sig { params(_paths: T::Array[String]).returns(T::Boolean) }
@@ -183,7 +189,7 @@ module Packwerk
       end
 
       ParseRun.new(
-        absolute_files: fetch_files_to_process(relative_file_paths, ignore_nested_packages),
+        relative_file_set: fetch_files_to_process(relative_file_paths, ignore_nested_packages),
         configuration: @configuration,
         progress_formatter: @progress_formatter,
         offenses_formatter: @offenses_formatter

data/lib/packwerk/const_node_inspector.rb

@@ -13,7 +13,8 @@ module Packwerk
         .returns(T.nilable(String))
     end
     def constant_name_from_node(node, ancestors:)
-      return nil unless Node.constant?(node)
+      return nil unless NodeHelpers.constant?(node)
+
       parent = ancestors.first
 
       # Only process the root `const` node for namespaced constant references. For example, in the
@@ -24,8 +25,8 @@ module Packwerk
         fully_qualify_constant(ancestors)
       else
         begin
-          Node.constant_name(node)
-        rescue Node::TypeError
+          NodeHelpers.constant_name(node)
+        rescue NodeHelpers::TypeError
           nil
         end
       end
@@ -35,20 +36,20 @@ module Packwerk
 
     sig { params(parent: T.nilable(AST::Node)).returns(T::Boolean) }
     def root_constant?(parent)
-      !(parent && Node.constant?(parent))
+      !(parent && NodeHelpers.constant?(parent))
     end
 
     sig { params(node: AST::Node, parent: AST::Node).returns(T.nilable(T::Boolean)) }
     def constant_in_module_or_class_definition?(node, parent:)
-      parent_name = Node.module_name_from_definition(parent)
-      parent_name && parent_name == Node.constant_name(node)
+      parent_name = NodeHelpers.module_name_from_definition(parent)
+      parent_name && parent_name == NodeHelpers.constant_name(node)
     end
 
     sig { params(ancestors: T::Array[AST::Node]).returns(String) }
     def fully_qualify_constant(ancestors)
       # We're defining a class with this name, in which case the constant is implicitly fully qualified by its
       # enclosing namespace
-      "::" + Node.parent_module_name(ancestors: ancestors)
+      "::" + NodeHelpers.parent_module_name(ancestors: ancestors)
     end
   end
 end

data/lib/packwerk/constant_name_inspector.rb

@@ -12,9 +12,9 @@ module Packwerk
     interface!
 
     sig do
-      params(node: ::AST::Node, ancestors: T::Array[::AST::Node])
+      abstract
+        .params(node: ::AST::Node, ancestors: T::Array[::AST::Node])
         .returns(T.nilable(String))
-        .abstract
     end
     def constant_name_from_node(node, ancestors:); end
   end

data/lib/packwerk/deprecated_references.rb

@@ -7,7 +7,7 @@ module Packwerk
   class DeprecatedReferences
     extend T::Sig
 
-    ENTRIES_TYPE = T.type_alias do
+    EntriesType = T.type_alias do
       T::Hash[String, T.untyped]
     end
 
@@ -15,8 +15,8 @@ module Packwerk
     def initialize(package, filepath)
       @package = package
       @filepath = filepath
-      @new_entries = T.let({}, ENTRIES_TYPE)
-      @deprecated_references = T.let(nil, T.nilable(ENTRIES_TYPE))
+      @new_entries = T.let({}, EntriesType)
+      @deprecated_references = T.let(nil, T.nilable(EntriesType))
     end
 
     sig do
@@ -36,28 +36,43 @@ module Packwerk
     sig { params(reference: Packwerk::Reference, violation_type: Packwerk::ViolationType).returns(T::Boolean) }
     def add_entries(reference, violation_type)
       package_violations = @new_entries.fetch(reference.constant.package.name, {})
-      entries_for_file = package_violations[reference.constant.name] ||= {}
+      entries_for_constant = package_violations[reference.constant.name] ||= {}
 
-      entries_for_file["violations"] ||= []
-      entries_for_file["violations"] << violation_type.serialize
+      entries_for_constant["violations"] ||= []
+      entries_for_constant["violations"] << violation_type.serialize
 
-      entries_for_file["files"] ||= []
-      entries_for_file["files"] << reference.relative_path.to_s
+      entries_for_constant["files"] ||= []
+      entries_for_constant["files"] << reference.relative_path.to_s
 
       @new_entries[reference.constant.package.name] = package_violations
       listed?(reference, violation_type: violation_type)
     end
 
-    sig { returns(T::Boolean) }
-    def stale_violations?
+    sig { params(for_files: T::Set[String]).returns(T::Boolean) }
+    def stale_violations?(for_files)
       prepare_entries_for_dump
+
       deprecated_references.any? do |package, package_violations|
-        package_violations.any? do |constant_name, entries_for_file|
+        package_violations_for_files = {}
+        package_violations.each do |constant_name, entries_for_constant|
+          entries_for_files = for_files & entries_for_constant["files"]
+          next if entries_for_files.none?
+
+          package_violations_for_files[constant_name] = {
+            "violations" => entries_for_constant["violations"],
+            "files" => entries_for_files.to_a,
+          }
+        end
+
+        return true if package_violations_for_files.empty?
+
+        package_violations_for_files.any? do |constant_name, entries_for_constant|
           new_entries_violation_types = @new_entries.dig(package, constant_name, "violations")
           return true if new_entries_violation_types.nil?
-          if entries_for_file["violations"].all? { |type| new_entries_violation_types.include?(type) }
+
+          if entries_for_constant["violations"].all? { |type| new_entries_violation_types.include?(type) }
             stale_violations =
-              entries_for_file["files"] - Array(@new_entries.dig(package, constant_name, "files"))
+              entries_for_constant["files"] - Array(@new_entries.dig(package, constant_name, "files"))
             stale_violations.any?
           else
             return true
@@ -89,12 +104,12 @@ module Packwerk
 
     private
 
-    sig { returns(ENTRIES_TYPE) }
+    sig { returns(EntriesType) }
     def prepare_entries_for_dump
       @new_entries.each do |package_name, package_violations|
-        package_violations.each do |_, entries_for_file|
-          entries_for_file["violations"].sort!.uniq!
-          entries_for_file["files"].sort!.uniq!
+        package_violations.each do |_, entries_for_constant|
+          entries_for_constant["violations"].sort!.uniq!
+          entries_for_constant["files"].sort!.uniq!
         end
         @new_entries[package_name] = package_violations.sort.to_h
       end
@@ -102,7 +117,7 @@ module Packwerk
       @new_entries = @new_entries.sort.to_h
     end
 
-    sig { returns(ENTRIES_TYPE) }
+    sig { returns(EntriesType) }
     def deprecated_references
       @deprecated_references ||= if File.exist?(@filepath)
         load_yaml(@filepath)
@@ -111,7 +126,7 @@ module Packwerk
       end
     end
 
-    sig { params(filepath: String).returns(ENTRIES_TYPE) }
+    sig { params(filepath: String).returns(EntriesType) }
     def load_yaml(filepath)
       YAML.load_file(filepath) || {}
     rescue Psych::Exception

data/lib/packwerk/file_processor.rb

@@ -29,49 +29,51 @@ module Packwerk
       @parser_factory = T.let(parser_factory || Packwerk::Parsers::Factory.instance, Parsers::Factory)
     end
 
+    class ProcessedFile < T::Struct
+      const :unresolved_references, T::Array[UnresolvedReference], default: []
+      const :offenses, T::Array[Offense], default: []
+    end
+
     sig do
-      params(absolute_file: String).returns(
-        T::Array[
-          T.any(
-            Packwerk::UnresolvedReference,
-            Packwerk::Offense,
-          )
-        ]
-      )
+      params(relative_file: String).returns(ProcessedFile)
     end
-    def call(absolute_file)
-      parser = parser_for(absolute_file)
-      return [UnknownFileTypeResult.new(file: absolute_file)] if T.unsafe(parser).nil?
+    def call(relative_file)
+      parser = parser_for(relative_file)
+      if parser.nil?
+        return ProcessedFile.new(offenses: [UnknownFileTypeResult.new(file: relative_file)])
+      end
 
-      @cache.with_cache(absolute_file) do
-        node = parse_into_ast(absolute_file, T.must(parser))
-        return [] unless node
+      unresolved_references = @cache.with_cache(relative_file) do
+        node = parse_into_ast(relative_file, parser)
+        return ProcessedFile.new unless node
 
-        references_from_ast(node, absolute_file)
+        references_from_ast(node, relative_file)
       end
+
+      ProcessedFile.new(unresolved_references: unresolved_references)
     rescue Parsers::ParseError => e
-      [e.result]
+      ProcessedFile.new(offenses: [e.result])
     end
 
     private
 
     sig do
-      params(node: Parser::AST::Node, absolute_file: String).returns(T::Array[UnresolvedReference])
+      params(node: Parser::AST::Node, relative_file: String).returns(T::Array[UnresolvedReference])
     end
-    def references_from_ast(node, absolute_file)
+    def references_from_ast(node, relative_file)
       references = []
 
-      node_processor = @node_processor_factory.for(absolute_file: absolute_file, node: node)
+      node_processor = @node_processor_factory.for(relative_file: relative_file, node: node)
       node_visitor = Packwerk::NodeVisitor.new(node_processor: node_processor)
       node_visitor.visit(node, ancestors: [], result: references)
 
       references
     end
 
-    sig { params(absolute_file: String, parser: Parsers::ParserInterface).returns(T.untyped) }
-    def parse_into_ast(absolute_file, parser)
-      File.open(absolute_file, "r", nil, external_encoding: Encoding::UTF_8) do |file|
-        parser.call(io: file, file_path: absolute_file)
+    sig { params(relative_file: String, parser: Parsers::ParserInterface).returns(T.untyped) }
+    def parse_into_ast(relative_file, parser)
+      File.open(relative_file, "r", nil, external_encoding: Encoding::UTF_8) do |file|
+        parser.call(io: file, file_path: relative_file)
       end
     end