cocoapods 1.7.5 → 1.8.0.beta.1

data/lib/cocoapods/installer/analyzer.rb

@@ -59,6 +59,10 @@ module Pod
       #
       attr_reader :installation_options
 
+      # @return [Source::Manager] the sources manager to use when resolving dependencies
+      #
+      attr_reader :sources_manager
+
       # Initialize a new instance
       #
       # @param  [Sandbox] sandbox @see #sandbox
@@ -67,9 +71,10 @@ module Pod
       # @param  [Array<Source>] plugin_sources @see #plugin_sources
       # @param  [Boolean] has_dependencies @see #has_dependencies
       # @param  [Hash, Boolean, nil] pods_to_update @see #pods_to_update
+      # @param  [Source::Manager] sources_manager @see #sources_manager
       #
       def initialize(sandbox, podfile, lockfile = nil, plugin_sources = nil, has_dependencies = true,
-                     pods_to_update = false)
+                     pods_to_update = false, sources_manager = Source::Manager.new(config.repos_dir))
         @sandbox  = sandbox
         @podfile  = podfile
         @lockfile = lockfile
@@ -78,6 +83,7 @@ module Pod
         @pods_to_update = pods_to_update
         @installation_options = podfile.installation_options
         @podfile_dependency_cache = PodfileDependencyCache.from_podfile(podfile)
+        @sources_manager = sources_manager
         @result = nil
       end
 
@@ -117,9 +123,8 @@ module Pod
         locked_dependencies = generate_version_locking_dependencies(podfile_state)
         resolver_specs_by_target = resolve_dependencies(locked_dependencies)
         validate_platforms(resolver_specs_by_target)
-        specifications  = generate_specifications(resolver_specs_by_target)
-        targets         = generate_aggregate_targets(resolver_specs_by_target, target_inspections)
-        pod_targets     = calculate_pod_targets(targets)
+        specifications = generate_specifications(resolver_specs_by_target)
+        aggregate_targets, pod_targets = generate_targets(resolver_specs_by_target, target_inspections)
         sandbox_state   = generate_sandbox_state(specifications)
         specs_by_target = resolver_specs_by_target.each_with_object({}) do |rspecs_by_target, hash|
           hash[rspecs_by_target[0]] = rspecs_by_target[1].map(&:spec)
@@ -129,17 +134,17 @@ module Pod
         end]
         sources.each { |s| specs_by_source[s] ||= [] }
         @result = AnalysisResult.new(podfile_state, specs_by_target, specs_by_source, specifications, sandbox_state,
-                                     targets, pod_targets, @podfile_dependency_cache)
+                                     aggregate_targets, pod_targets, @podfile_dependency_cache)
       end
 
       # Updates the git source repositories.
       #
       def update_repositories
         sources.each do |source|
-          if source.git?
-            config.sources_manager.update(source.name, true)
+          if source.updateable?
+            sources_manager.update(source.name, true)
           else
-            UI.message "Skipping `#{source.name}` update because the repository is not a git source repository."
+            UI.message "Skipping `#{source.name}` update because the repository is not an updateable repository."
           end
         end
         @specs_updated = true
@@ -164,16 +169,19 @@ module Pod
           if all_dependencies_have_sources
             sources = dependency_sources
           elsif has_dependencies? && sources.empty? && plugin_sources.empty?
-            sources = ['https://github.com/CocoaPods/Specs.git'] + dependency_sources
+            sources = [Pod::TrunkSource::TRUNK_REPO_URL] + dependency_sources
           else
             sources += dependency_sources
           end
 
           result = sources.uniq.map do |source_url|
-            config.sources_manager.find_or_create_source_with_url(source_url)
+            sources_manager.find_or_create_source_with_url(source_url)
           end
           unless plugin_sources.empty?
             result.insert(0, *plugin_sources)
+            plugin_sources.each do |source|
+              sources_manager.add_source(source)
+            end
           end
           result
         end
@@ -299,7 +307,7 @@ module Pod
             host_target_uuids = Set.new(aggregate_target.user_project.host_targets_for_embedded_target(embedded_user_target).map(&:uuid))
             !aggregate_user_target_uuids.intersection(host_target_uuids).empty?
           end
-          embedded_aggregate_target.user_build_configurations.keys.each do |configuration_name|
+          embedded_aggregate_target.user_build_configurations.each_key do |configuration_name|
             pod_target_names = Set.new(aggregate_target.pod_targets_for_build_configuration(configuration_name).map(&:name))
             embedded_pod_targets = embedded_aggregate_target.pod_targets_for_build_configuration(configuration_name).select do |pod_target|
               if !pod_target_names.include?(pod_target.name) &&
@@ -326,11 +334,16 @@ module Pod
       #
       def analyze_host_targets_in_podfile(aggregate_targets, embedded_aggregate_targets)
         target_definitions_by_uuid = {}
+        cli_host_with_frameworks = []
+        cli_product_type = 'com.apple.product-type.tool'
         # Collect aggregate target definitions by uuid to later lookup host target
         # definitions and verify their compatiblity with their embedded targets
         aggregate_targets.each do |target|
-          target.user_targets.map(&:uuid).each do |uuid|
-            target_definitions_by_uuid[uuid] = target.target_definition
+          target.user_targets.each do |user_target|
+            target_definitions_by_uuid[user_target.uuid] = target.target_definition
+            if user_target.product_type == cli_product_type
+              cli_host_with_frameworks << user_target
+            end
           end
         end
         aggregate_target_user_projects = aggregate_targets.map(&:user_project)
@@ -338,9 +351,8 @@ module Pod
         host_uuid_to_embedded_target_definitions = {}
         # Search all of the known user projects for each embedded target's hosts
         embedded_aggregate_targets.each do |target|
-          host_uuids = []
-          aggregate_target_user_projects.product(target.user_targets).each do |user_project, user_target|
-            host_uuids += user_project.host_targets_for_embedded_target(user_target).map(&:uuid)
+          host_uuids = aggregate_target_user_projects.product(target.user_targets).flat_map do |user_project, user_target|
+            user_project.host_targets_for_embedded_target(user_target).map(&:uuid)
           end
           # For each host, keep track of its embedded target definitions
           # to later verify each embedded target's compatiblity with its host,
@@ -356,6 +368,12 @@ module Pod
           end
         end
 
+        unless cli_host_with_frameworks.empty?
+          UI.warn "The Podfile contains command line tool target(s) (#{cli_host_with_frameworks.map(&:name).to_sentence}) which are attempting to integrate dynamic frameworks." \
+            "\n" \
+            'This may not behave as expected, because command line tools are usually distributed as a single binary and cannot contain their own dynamic frameworks.'
+        end
+
         unless embedded_targets_missing_hosts.empty?
           embedded_targets_missing_hosts_product_types = Set.new embedded_targets_missing_hosts.flat_map(&:user_targets).map(&:symbol_type)
           target_names = embedded_targets_missing_hosts.map do |target|
@@ -404,13 +422,15 @@ module Pod
       # @param  [Array<TargetInspection>] target_inspections
       #         the user target inspections used to construct the aggregate and pod targets.
       #
-      # @return [Array<AggregateTarget>] the list of aggregate targets generated.
+      # @return [(Array<AggregateTarget>, Array<PodTarget>)] the list of aggregate targets generated,
+      #         and the list of pod targets generated.
       #
-      def generate_aggregate_targets(resolver_specs_by_target, target_inspections)
-        resolver_specs_by_target = resolver_specs_by_target.reject { |td, _| td.abstract? }
+      def generate_targets(resolver_specs_by_target, target_inspections)
+        resolver_specs_by_target = resolver_specs_by_target.reject { |td, _| td.abstract? && !td.platform }
         pod_targets = generate_pod_targets(resolver_specs_by_target, target_inspections)
-        aggregate_targets = resolver_specs_by_target.keys.map do |target_definition|
-          generate_aggregate_target(target_definition, target_inspections, pod_targets, resolver_specs_by_target)
+        pod_targets_by_target_definition = group_pod_targets_by_target_definition(pod_targets, resolver_specs_by_target)
+        aggregate_targets = resolver_specs_by_target.keys.reject(&:abstract?).map do |target_definition|
+          generate_aggregate_target(target_definition, target_inspections, pod_targets_by_target_definition)
         end
         aggregate_targets.each do |target|
           search_paths_aggregate_targets = aggregate_targets.select do |aggregate_target|
@@ -438,7 +458,7 @@ module Pod
             aggregate_target.merge_embedded_pod_targets(embedded_pod_targets)
           end
         end
-        aggregate_targets
+        [aggregate_targets, pod_targets]
       end
 
       # Setup the aggregate target for a single user target
@@ -449,18 +469,15 @@ module Pod
       # @param  [Hash{TargetDefinition => TargetInspectionResult}] target_inspections
       #         the user target inspections used to construct the aggregate and pod targets.
       #
-      # @param  [Array<PodTarget>] pod_targets
-      #         the pod targets, which were generated.
-      #
-      # @param  [Hash{Podfile::TargetDefinition => Array<ResolvedSpecification>}] resolver_specs_by_target
-      #         the resolved specifications grouped by target.
+      # @param  [Hash{Podfile::TargetDefinition => Array<PodTarget>}] pod_targets_by_target_definition
+      #         the pod targets grouped by target.
       #
       # @return [AggregateTarget]
       #
-      def generate_aggregate_target(target_definition, target_inspections, pod_targets, resolver_specs_by_target)
+      def generate_aggregate_target(target_definition, target_inspections, pod_targets_by_target_definition)
         if installation_options.integrate_targets?
           target_inspection = target_inspections[target_definition]
-          raise "missing inspection: #{target_definition.name}" unless target_inspection
+          raise "missing inspection for #{target_definition.inspect}" unless target_inspection
           target_requires_64_bit = Analyzer.requires_64_bit_archs?(target_definition.platform, target_inspection.project.object_version)
           user_project = target_inspection.project
           client_root = target_inspection.client_root
@@ -477,8 +494,7 @@ module Pod
         end
         platform = target_definition.platform
         build_configurations = user_build_configurations.keys.concat(target_definition.all_whitelisted_configurations).uniq
-        pod_targets_for_build_configuration = filter_pod_targets_for_target_definition(target_definition, pod_targets,
-                                                                                       resolver_specs_by_target,
+        pod_targets_for_build_configuration = filter_pod_targets_for_target_definition(target_definition, pod_targets_by_target_definition,
                                                                                        build_configurations)
 
         build_type = target_definition.uses_frameworks? ? Target::BuildType.static_framework : Target::BuildType.static_library
@@ -487,21 +503,25 @@ module Pod
                             pod_targets_for_build_configuration, :build_type => build_type)
       end
 
-      # @return [Array<PodTarget>] The model representations of pod targets.
+      # Returns a filtered list of pod targets that should or should not be part of the target definition. Pod targets
+      # used by tests only are filtered.
+      #
+      # @return [Hash{TargetDefinition => Array<PodTarget>}]
       #
-      def calculate_pod_targets(aggregate_targets)
-        aggregate_target_pod_targets = aggregate_targets.flat_map(&:pod_targets).uniq
-        test_dependent_targets = aggregate_target_pod_targets.flat_map do |pod_target|
-          pod_target.test_specs.flat_map do |test_spec|
-            pod_target.recursive_test_dependent_targets(test_spec)
+      def group_pod_targets_by_target_definition(pod_targets, resolver_specs_by_target)
+        pod_targets_by_target_definition = Hash.new { |h, td| h[td] = [] }
+        pod_targets.each do |pod_target|
+          pod_target.target_definitions.each do |td|
+            pod_targets_by_target_definition[td] << pod_target
           end
         end
-        app_dependent_targets = aggregate_target_pod_targets.flat_map do |pod_target|
-          pod_target.app_specs.flat_map do |app_spec|
-            pod_target.recursive_app_dependent_targets(app_spec)
-          end
+        resolver_specs_by_target.each do |td, resolver_specs|
+          specs_by_pod_name = resolver_specs.group_by { |s| s.root.name }
+          specs_by_pod_name.reject! { |_, specs| specs.all?(&:used_by_non_library_targets_only?) }
+          pod_targets_by_target_definition[td].keep_if { |pod_target| specs_by_pod_name.key?(pod_target.pod_name) }
         end
-        (aggregate_target_pod_targets + test_dependent_targets + app_dependent_targets).uniq
+
+        pod_targets_by_target_definition
       end
 
       # Returns a filtered list of pod targets that should or should not be part of the target definition. Pod targets
@@ -510,11 +530,8 @@ module Pod
       # @param [TargetDefinition] target_definition
       #        the target definition to use as the base for filtering
       #
-      # @param [Array<PodTarget>] pod_targets
-      #        the array of pod targets to check against
-      #
-      # @param  [Hash{Podfile::TargetDefinition => Array<ResolvedSpecification>}] resolver_specs_by_target
-      #         the resolved specifications grouped by target.
+      # @param  [Hash{Podfile::TargetDefinition => Array<PodTarget>}] pod_targets_by_target_definition
+      #         the pod targets grouped by target.
       #
       # @param  [Array<String>] build_configurations
       #         The list of all build configurations the targets will be built for.
@@ -522,16 +539,11 @@ module Pod
       # @return [Hash<String => Array<PodTarget>>]
       #         the filtered list of pod targets, grouped by build configuration.
       #
-      def filter_pod_targets_for_target_definition(target_definition, pod_targets, resolver_specs_by_target, build_configurations)
+      def filter_pod_targets_for_target_definition(target_definition, pod_targets_by_target_definition, build_configurations)
         pod_targets_by_build_config = Hash.new([].freeze)
         build_configurations.each { |config| pod_targets_by_build_config[config] = [] }
 
-        pod_targets.each do |pod_target|
-          next unless pod_target.target_definitions.include?(target_definition)
-          next unless resolver_specs_by_target[target_definition].any? do |resolver_spec|
-            !resolver_spec.used_by_non_library_targets_only? && pod_target.specs.include?(resolver_spec.spec)
-          end
-
+        pod_targets_by_target_definition[target_definition].each do |pod_target|
           pod_name = pod_target.pod_name
 
           dependencies = @podfile_dependency_cache.target_definition_dependencies(target_definition).select do |dependency|
@@ -593,33 +605,17 @@ module Pod
           end
 
           pod_targets = distinct_targets.flat_map do |_root, target_definitions_by_variant|
+            target_definitions_by_variant.each_value do |target_definitions|
+              target_definitions.reject!(&:abstract?) unless target_definitions.all?(&:abstract?)
+            end
             suffixes = PodVariantSet.new(target_definitions_by_variant.keys).scope_suffixes
             target_definitions_by_variant.map do |variant, target_definitions|
               generate_pod_target(target_definitions, target_inspections, variant.specs + variant.test_specs + variant.app_specs, :build_type => variant.build_type, :scope_suffix => suffixes[variant])
             end
           end
 
-          pod_targets_by_name = pod_targets.group_by(&:pod_name).each_with_object({}) do |(name, values), hash|
-            # Sort the target by the number of activated subspecs, so that
-            # we prefer a minimal target as transitive dependency.
-            hash[name] = values.sort_by { |pt| pt.specs.count }
-          end
           all_specs = resolver_specs_by_target.values.flatten.map(&:spec).uniq.group_by(&:name)
-          pod_targets.each do |target|
-            dependencies = dependencies_for_specs(target.library_specs.to_set, target.platform, all_specs.dup).group_by(&:root)
-            target.dependent_targets = filter_dependencies(dependencies, pod_targets_by_name, target)
-            target.test_dependent_targets_by_spec_name = target.test_specs.each_with_object({}) do |test_spec, hash|
-              test_dependencies = dependencies_for_specs([test_spec], target.platform, all_specs).group_by(&:root)
-              test_dependencies.delete_if { |k| dependencies.key? k }
-              hash[test_spec.name] = filter_dependencies(test_dependencies, pod_targets_by_name, target)
-            end
-
-            target.app_dependent_targets_by_spec_name = target.app_specs.each_with_object({}) do |app_spec, hash|
-              app_dependencies = dependencies_for_specs([app_spec], target.platform, all_specs).group_by(&:root)
-              app_dependencies.delete_if { |k| dependencies.key? k }
-              hash[app_spec.name] = filter_dependencies(app_dependencies, pod_targets_by_name, target)
-            end
-          end
+          compute_pod_target_dependencies(pod_targets, all_specs)
         else
           dedupe_cache = {}
           resolver_specs_by_target.flat_map do |target_definition, specs|
@@ -629,21 +625,48 @@ module Pod
               generate_pod_target([target_definition], target_inspections, pod_specs.map(&:spec), :build_type => target_type).scoped(dedupe_cache)
             end
 
-            pod_targets.each do |target|
-              all_specs = specs.map(&:spec).group_by(&:name)
-              dependencies = dependencies_for_specs(target.library_specs.to_set, target.platform, all_specs.dup).group_by(&:root)
-              target.dependent_targets = pod_targets.reject { |t| dependencies[t.root_spec].nil? }
-              target.test_dependent_targets_by_spec_name = target.test_specs.each_with_object({}) do |test_spec, hash|
-                test_dependencies = dependencies_for_specs(target.test_specs.to_set, target.platform, all_specs.dup).group_by(&:root)
-                test_dependencies.delete_if { |k| dependencies.key? k }
-                hash[test_spec.name] = pod_targets.reject { |t| test_dependencies[t.root_spec].nil? }
-              end
-              target.app_dependent_targets_by_spec_name = target.app_specs.each_with_object({}) do |app_spec, hash|
-                app_dependencies = dependencies_for_specs(target.app_specs.to_set, target.platform, all_specs.dup).group_by(&:root)
-                app_dependencies.delete_if { |k| dependencies.key? k }
-                hash[app_spec.name] = pod_targets.reject { |t| app_dependencies[t.root_spec].nil? }
-              end
-            end
+            compute_pod_target_dependencies(pod_targets, specs.map(&:spec).group_by(&:name))
+          end
+        end
+      end
+
+      # Compute the dependencies for the set of pod targets.
+      #
+      # @param  [Array<PodTarget>] pod_targets
+      #         pod targets.
+      #
+      # @param  [Hash{String => Array<Specification>}] all_specs
+      #         specifications grouped by name.
+      #
+      # @return [Array<PodTarget>]
+      #
+      def compute_pod_target_dependencies(pod_targets, all_specs)
+        pod_targets_by_name = pod_targets.group_by(&:pod_name).each_with_object({}) do |(name, values), hash|
+          # Sort the target by the number of activated subspecs, so that
+          # we prefer a minimal target as transitive dependency.
+          hash[name] = values.sort_by { |pt| pt.specs.count }
+        end
+
+        pod_targets.each do |target|
+          dependencies = dependencies_for_specs(target.library_specs.to_set, target.platform, all_specs).group_by(&:root)
+          target.dependent_targets = filter_dependencies(dependencies, pod_targets_by_name, target)
+          target.test_dependent_targets_by_spec_name = target.test_specs.each_with_object({}) do |test_spec, hash|
+            test_dependencies = dependencies_for_specs([test_spec], target.platform, all_specs).group_by(&:root)
+            test_dependencies.delete_if { |k, _| dependencies.key? k }
+            hash[test_spec.name] = filter_dependencies(test_dependencies, pod_targets_by_name, target)
+          end
+
+          target.app_dependent_targets_by_spec_name = target.app_specs.each_with_object({}) do |app_spec, hash|
+            app_dependencies = dependencies_for_specs([app_spec], target.platform, all_specs).group_by(&:root)
+            app_dependencies.delete_if { |k, _| dependencies.key? k }
+            hash[app_spec.name] = filter_dependencies(app_dependencies, pod_targets_by_name, target)
+          end
+
+          target.test_app_hosts_by_spec_name = target.test_specs.each_with_object({}) do |test_spec, hash|
+            next unless app_host_name = test_spec.consumer(target.platform).app_host_name
+            app_host_spec = pod_targets_by_name[Specification.root_name(app_host_name)].flat_map(&:app_specs).find { |pt| pt.name == app_host_name }
+            app_host_dependencies = { app_host_spec.root => [app_host_spec] }
+            hash[test_spec.name] = [app_host_spec, filter_dependencies(app_host_dependencies, pod_targets_by_name, target).first]
           end
         end
       end
@@ -683,6 +706,13 @@ module Pod
         specs.each do |s|
           s.dependencies(platform).each do |dep|
             all_specs[dep.name].each do |spec|
+              if spec.non_library_specification?
+                if s.test_specification? && spec.name == s.consumer(platform).app_host_name && spec.app_specification?
+                  # This needs to be handled separately, since we _don't_ want to treat this as a "normal" dependency
+                  next
+                end
+                raise Informative, "#{s} depends upon `#{spec}`, which is a `#{spec.spec_type}` spec."
+              end
               dependent_specs << spec
             end
           end
@@ -708,10 +738,10 @@ module Pod
       # @return [PodTarget]
       #
       def generate_pod_target(target_definitions, target_inspections, specs, scope_suffix: nil, build_type: nil)
-        object_version = target_inspections.values.map { |ti| ti.project.object_version }.min
+        target_inspections = target_inspections.select { |t, _| target_definitions.include?(t) }.values
+        object_version = target_inspections.map { |ti| ti.project.object_version }.min
         target_requires_64_bit = target_definitions.all? { |td| Analyzer.requires_64_bit_archs?(td.platform, object_version) }
-        if installation_options.integrate_targets?
-          target_inspections = target_inspections.select { |t, _| target_definitions.include?(t) }.values
+        if !target_inspections.empty?
           user_build_configurations = target_inspections.map(&:build_configurations).reduce({}, &:merge)
           archs = if target_requires_64_bit
                     ['$(ARCHS_STANDARD_64_BIT)']
@@ -719,7 +749,7 @@ module Pod
                     target_inspections.flat_map(&:archs).compact.uniq.sort
                   end
         else
-          user_build_configurations = {}
+          user_build_configurations = Target::DEFAULT_BUILD_CONFIGURATIONS
           archs = target_requires_64_bit ? ['$(ARCHS_STANDARD_64_BIT)'] : []
         end
         host_requires_frameworks = target_definitions.any?(&:uses_frameworks?)
@@ -748,7 +778,11 @@ module Pod
         end
       end
 
-      # Calculates and returns the platform to use for the given list of specs and target definitions.
+      # Calculates and returns the platform to use for the given list specs and target definitions.
+      #
+      # @note The platform is only determined by all library specs and ignores non library ones. Subspecs are always
+      #       integrated in the same target as the root spec therefore the max deployment target is always returned
+      #       across the specs passed.
       #
       # @param [Array<Specification>] specs
       #        the specs to inspect and calculate the platform for.
@@ -762,10 +796,11 @@ module Pod
       # @return [Platform]
       #
       def determine_platform(specs, target_definitions, host_requires_frameworks)
+        library_specs = specs.select(&:library_specification?)
         platform_name = target_definitions.first.platform.name
         default = Podfile::TargetDefinition::PLATFORM_DEFAULTS[platform_name]
-        deployment_target = specs.map do |spec|
-          Version.new(spec.deployment_target(platform_name) || default)
+        deployment_target = library_specs.map do |library_spec|
+          Version.new(library_spec.deployment_target(platform_name) || default)
         end.max
         if platform_name == :ios && host_requires_frameworks
           minimum = Version.new('8.0')
@@ -935,7 +970,7 @@ module Pod
 
         resolver_specs_by_target = nil
         UI.section "Resolving dependencies of #{UI.path(podfile.defined_in_file) || 'Podfile'}" do
-          resolver = Pod::Resolver.new(sandbox, podfile, locked_dependencies, sources, @specs_updated)
+          resolver = Pod::Resolver.new(sandbox, podfile, locked_dependencies, sources, @specs_updated, :sources_manager => sources_manager)
           resolver_specs_by_target = resolver.resolve
           resolver_specs_by_target.values.flatten(1).map(&:spec).each(&:validate_cocoapods_version)
         end

data/lib/cocoapods/installer/analyzer/target_inspector.rb

@@ -105,7 +105,7 @@ module Pod
           target = native_targets.find { |t| t.name == target_definition.name.to_s }
           unless target
             found = native_targets.map { |t| "`#{t.name}`" }.to_sentence
-            raise Informative, "Unable to find a target named `#{target_definition.name}`, did find #{found}."
+            raise Informative, "Unable to find a target named `#{target_definition.name}` in project `#{Pathname(user_project.path).basename}`, did find #{found}."
           end
           [target]
         end
@@ -156,7 +156,7 @@ module Pod
                   "Unable to determine the platform for the `#{target_definition.name}` target."
           end
 
-          UI.warn "Automatically assigning platform `#{name}` with version `#{deployment_target}` " \
+          UI.warn "Automatically assigning platform `#{Platform.string_name(name)}` with version `#{deployment_target}` " \
             "on target `#{target_definition.name}` because no platform was specified. " \
             "Please specify a platform for this target in your Podfile. See `#{PLATFORM_INFO_URL}`."
 
@@ -218,14 +218,12 @@ module Pod
         #
         def compute_swift_version_from_targets(targets)
           versions_to_targets = targets.inject({}) do |memo, target|
-            # User project may have an xcconfig that specifies the `SWIFT_VERSION`. We first check if that is true and
-            # that the xcconfig file actually exists. After the first integration the xcconfig set is most probably
+            # User project may have an xcconfig that specifies the `SWIFT_VERSION`.
+            # Xcodeproj handles that xcconfig either not being set or the file not being present on disk.
+            # After the first integration the xcconfig set is most probably
             # the one that was generated from CocoaPods. See https://github.com/CocoaPods/CocoaPods/issues/7731 for
             # more details.
-            resolve_against_xcconfig = target.build_configuration_list.build_configurations.all? do |bc|
-              !bc.base_configuration_reference.nil? && File.exist?(bc.base_configuration_reference.real_path)
-            end
-            versions = target.resolved_build_setting('SWIFT_VERSION', resolve_against_xcconfig).values
+            versions = target.resolved_build_setting('SWIFT_VERSION', true).values
             versions.each do |version|
               memo[version] = [] if memo[version].nil?
               memo[version] << target.name unless memo[version].include? target.name