Add sorbet types to elm_19_version_resolver.rb (#11447)

* Add sorbet types to elm_19_version_resolver.rb

* Add sorbet typing to elm/update_checker/elm_19_version_resolver.rb

elm/lib/dependabot/elm/update_checker/elm_19_version_resolver.rb

@@ -15,13 +15,22 @@ module Dependabot
   module Elm
     class UpdateChecker
       class Elm19VersionResolver
+        extend T::Sig
+
         class UnrecoverableState < StandardError; end
 
+        sig do
+          params(
+            dependency: Dependabot::Dependency,
+            dependency_files: T::Array[Dependabot::DependencyFile]
+          ).void
+        end
         def initialize(dependency:, dependency_files:)
           @dependency = dependency
           @dependency_files = dependency_files
         end
 
+        sig { params(unlock_requirement: Symbol).returns(T.nilable(Dependabot::Elm::Version)) }
         def latest_resolvable_version(unlock_requirement:)
           raise "Invalid unlock setting: #{unlock_requirement}" unless %i(none own all).include?(unlock_requirement)
 
@@ -34,6 +43,7 @@ def latest_resolvable_version(unlock_requirement:)
           fetch_latest_resolvable_version(unlock_requirement)
         end
 
+        sig { returns(T::Array[Dependabot::Dependency]) }
         def updated_dependencies_after_full_unlock
           changed_deps = install_metadata
 
@@ -66,9 +76,13 @@ def updated_dependencies_after_full_unlock
 
         private
 
+        sig { returns(Dependabot::Dependency) }
         attr_reader :dependency
+
+        sig { returns(T::Array[Dependabot::DependencyFile]) }
         attr_reader :dependency_files
 
+        sig { params(unlock_requirement: Symbol).returns(T.nilable(Dependabot::Elm::Version)) }
         def fetch_latest_resolvable_version(unlock_requirement)
           changed_deps = install_metadata
 
@@ -85,6 +99,7 @@ def fetch_latest_resolvable_version(unlock_requirement)
           current_version
         end
 
+        sig { params(changed_deps: T::Hash[String, Dependabot::Elm::Version]).returns(Symbol) }
         def check_install_result(changed_deps)
           other_deps_bumped =
             changed_deps
@@ -96,6 +111,7 @@ def check_install_result(changed_deps)
           :clean_bump
         end
 
+        sig { returns(T::Hash[String, Dependabot::Elm::Version]) }
         def install_metadata
           @install_metadata ||=
             SharedHelpers.in_a_temporary_directory do
@@ -115,6 +131,7 @@ def install_metadata
             end
         end
 
+        sig { params(command: String).returns(::String) }
         def run_shell_command(command)
           start = Time.now
           stdout, process = Open3.capture2e(command)
@@ -134,6 +151,7 @@ def run_shell_command(command)
           )
         end
 
+        sig { params(error: Dependabot::DependabotError).void }
         def handle_elm_errors(error)
           if error.message.include?("OLD DEPENDENCIES") ||
              error.message.include?("BAD JSON")
@@ -144,15 +162,17 @@ def handle_elm_errors(error)
           raise error
         end
 
+        sig { void }
         def write_temporary_dependency_files
           dependency_files.each do |file|
             path = file.name
             FileUtils.mkdir_p(Pathname.new(path).dirname)
 
-            File.write(path, updated_elm_json_content(file.content))
+            File.write(path, updated_elm_json_content(T.must(file.content)))
           end
         end
 
+        sig { params(content: String).returns(String) }
         def updated_elm_json_content(content)
           json = JSON.parse(content)
 
@@ -169,6 +189,7 @@ def updated_elm_json_content(content)
           JSON.dump(json)
         end
 
+        sig { returns(T::Array[Dependabot::Dependency]) }
         def original_dependency_details
           @original_dependency_details ||=
             Elm::FileParser.new(
@@ -177,16 +198,19 @@ def original_dependency_details
             ).parse
         end
 
+        sig { returns(T.nilable(Dependabot::Elm::Version)) }
         def current_version
           return unless dependency.version
 
-          version_class.new(dependency.version)
+          T.cast(version_class.new(dependency.version), Dependabot::Elm::Version)
         end
 
+        sig { returns(T.class_of(Dependabot::Version)) }
         def version_class
           dependency.version_class
         end
 
+        sig { returns(T.class_of(Dependabot::Requirement)) }
         def requirement_class
           dependency.requirement_class
         end