cocoapods 1.9.1 → 1.10.0.rc.1

data/lib/cocoapods/installer/xcode/pods_project_generator.rb

@@ -79,13 +79,14 @@ module Pod
         #
         # @param [PBXProject] project The project to configure schemes for.
         # @param [Array<PodTarget>] pod_targets The pod targets within that project to configure their schemes.
+        # @param [PodsProjectGeneratorResult] generator_result the result of the project generation
         #
         # @return [void]
         #
-        def configure_schemes(project, pod_targets)
+        def configure_schemes(project, pod_targets, generator_result)
           pod_targets.each do |pod_target|
             share_scheme = pod_target.should_build? && share_scheme_for_development_pod?(pod_target.pod_name) && sandbox.local?(pod_target.pod_name)
-            configure_schemes_for_pod_target(project, pod_target, share_scheme)
+            configure_schemes_for_pod_target(project, pod_target, share_scheme, generator_result)
           end
         end
 
@@ -143,8 +144,10 @@ module Pod
           pod_installations_to_integrate = pod_target_installation_results.values.select do |pod_target_installation_result|
             pod_target = pod_target_installation_result.target
             !pod_target_installation_result.test_native_targets.empty? ||
-                !pod_target_installation_result.app_native_targets.empty? ||
-                pod_target.contains_script_phases?
+              !pod_target_installation_result.app_native_targets.empty? ||
+              pod_target.contains_script_phases? ||
+              pod_target.framework_paths.values.flatten.any? { |paths| !paths.dsym_path.nil? } ||
+              pod_target.xcframeworks.values.any? { |xcframeworks| !xcframeworks.empty? }
           end
           return if pod_installations_to_integrate.empty?
 
@@ -218,14 +221,35 @@ module Pod
           end
         end
 
-        def configure_schemes_for_pod_target(project, pod_target, share_scheme)
+        # @param [Project] project
+        #        the project of the pod target
+        #
+        # @param [Pod::PodTarget] pod_target
+        #        the pod target for which to configure schemes
+        #
+        # @param [Boolean] share_scheme
+        #        whether the created schemes should be shared
+        #
+        # @param [PodsProjectGeneratorResult] generator_result
+        #        the project generation result
+        #
+        def configure_schemes_for_pod_target(project, pod_target, share_scheme, generator_result)
           # Ignore subspecs because they do not provide a scheme configuration due to the fact that they are always
           # merged with the root spec scheme.
           specs = [pod_target.root_spec] + pod_target.test_specs + pod_target.app_specs
+          hosted_test_specs_by_host = Hash.new do |hash, key|
+            hash[key] = []
+          end
+          pod_target.test_app_hosts_by_spec.each do |spec, (host_spec, host_target)|
+            if host_target == pod_target
+              hosted_test_specs_by_host[host_spec] << spec
+            end
+          end
+          is_custom_host = !hosted_test_specs_by_host.empty?
           specs.each do |spec|
             scheme_name = spec.spec_type == :library ? pod_target.label : pod_target.non_library_spec_label(spec)
             scheme_configuration = pod_target.scheme_for_spec(spec)
-            unless scheme_configuration.empty?
+            if !scheme_configuration.empty? || is_custom_host
               scheme_path = Xcodeproj::XCScheme.user_data_dir(project.path) + "#{scheme_name}.xcscheme"
               scheme = Xcodeproj::XCScheme.new(scheme_path)
               command_line_arguments = scheme.launch_action.command_line_arguments
@@ -241,6 +265,21 @@ module Pod
               if scheme_configuration.key?(:code_coverage)
                 scheme.test_action.code_coverage_enabled = scheme_configuration[:code_coverage]
               end
+
+              hosted_test_specs_by_host[spec].each do |hosted_spec|
+                # We are an app spec which hosts this test spec.
+                # Include the test specs's test bundle within our scheme's test action
+                native_target = generator_result.native_target_for_spec(hosted_spec)
+                testable = Xcodeproj::XCScheme::TestAction::TestableReference.new(native_target)
+                scheme.test_action.add_testable(testable)
+              end
+
+              if spec.test_specification?
+                # Default to using the test bundle to expand variables
+                native_target_for_expansion = generator_result.native_target_for_spec(spec)
+                macro_expansion = Xcodeproj::XCScheme::MacroExpansion.new(native_target_for_expansion)
+                scheme.launch_action.add_macro_expansion(macro_expansion)
+              end
               scheme.save!
             end
             Xcodeproj::XCScheme.share_scheme(project.path, scheme_name) if share_scheme

data/lib/cocoapods/installer/xcode/pods_project_generator/aggregate_target_installer.rb

@@ -6,6 +6,10 @@ module Pod
         # project and the relative support files.
         #
         class AggregateTargetInstaller < TargetInstaller
+          # @return [AggregateTarget] @see TargetInstaller#target
+          #
+          attr_reader :target
+
           # Creates the target in the Pods project and the relative support files.
           #
           # @return [TargetInstallationResult] the result of the installation of this target.
@@ -30,8 +34,7 @@ module Pod
               # cause an App Store rejection because frameworks cannot be
               # embedded in embedded targets.
               #
-              create_embed_frameworks_script if (target.includes_frameworks? || target.includes_xcframeworks?) && !target.requires_host_target?
-              create_prepare_artifacts_script if target.includes_xcframeworks? && !target.requires_host_target?
+              create_embed_frameworks_script if embed_frameworks_script_required?
               create_bridge_support_file(native_target)
               create_copy_resources_script if target.includes_resources?
               create_acknowledgements
@@ -76,6 +79,13 @@ module Pod
             super.merge(settings)
           end
 
+          # @return [Boolean] whether this target requires an `Embed Frameworks` script phase
+          #
+          def embed_frameworks_script_required?
+            includes_dynamic_xcframeworks = target.xcframeworks_by_config.values.flatten.map(&:build_type).any?(&:dynamic_framework?)
+            (target.includes_frameworks? || includes_dynamic_xcframeworks) && !target.requires_host_target?
+          end
+
           # Creates the group that holds the references to the support files
           # generated by this installer.
           #
@@ -154,33 +164,9 @@ module Pod
           #
           def create_embed_frameworks_script
             path = target.embed_frameworks_script_path
-            generator = Generator::EmbedFrameworksScript.new(target.framework_paths_by_config)
-            update_changed_file(generator, path)
-            add_file_to_support_group(path)
-          end
-
-          # Creates a script that prepares artifacts for embedding into a host target.
-          #
-          # @note   We can't use Xcode default link libraries phase, because
-          #         we need to ensure that we only copy the frameworks which are
-          #         relevant for the current build configuration.
-          #
-          # @return [void]
-          #
-          def create_prepare_artifacts_script
-            path = target.prepare_artifacts_script_path
-            generator = Generator::PrepareArtifactsScript.new(target.xcframeworks_by_config, sandbox.root, target.platform)
+            generator = Generator::EmbedFrameworksScript.new(target.framework_paths_by_config, target.xcframeworks_by_config)
             update_changed_file(generator, path)
             add_file_to_support_group(path)
-
-            target.user_build_configurations.each_key do |config|
-              if (input_file_list = target.prepare_artifacts_script_input_files_path(config))
-                add_file_to_support_group(input_file_list)
-              end
-              if (output_file_list = target.prepare_artifacts_script_output_files_path(config))
-                add_file_to_support_group(output_file_list)
-              end
-            end
           end
 
           # Generates the acknowledgement files (markdown and plist) for the target.

data/lib/cocoapods/installer/xcode/pods_project_generator/file_references_installer.rb

@@ -218,7 +218,8 @@ module Pod
               pod_name = file_accessor.spec.name
               preserve_pod_file_structure_flag = (sandbox.local?(pod_name) || preserve_pod_file_structure) && reflect_file_system_structure
               base_path = preserve_pod_file_structure_flag ? common_path(paths) : nil
-              group = pods_project.group_for_spec(pod_name, group_key)
+              actual_group_key = preserve_pod_file_structure_flag ? nil : group_key
+              group = pods_project.group_for_spec(pod_name, actual_group_key)
               paths.each do |path|
                 pods_project.add_file_reference(path, group, preserve_pod_file_structure_flag, base_path)
               end

data/lib/cocoapods/installer/xcode/pods_project_generator/pod_target_dependency_installer.rb

@@ -53,8 +53,8 @@ module Pod
 
             # Wire up app native targets.
             unless pod_target_installation_result.app_native_targets.empty?
-              wire_app_native_targets(pod_target, native_target, pod_target_installation_result,
-                                      pod_target_installation_results, project, frameworks_group, metadata_cache)
+              wire_app_native_targets(pod_target, pod_target_installation_result, pod_target_installation_results,
+                                      project, frameworks_group, metadata_cache)
             end
           end
         end
@@ -152,15 +152,17 @@ module Pod
             target_attributes[test_native_target.uuid.to_s] = { 'TestTargetID' => app_native_target.uuid.to_s }
             project.root_object.attributes['TargetAttributes'] = target_attributes
             test_native_target.add_dependency(app_native_target)
-          else
+          elsif cached_dependency = metadata_cache.target_label_by_metadata[app_host_target_label]
             # Hit the cache
-            cached_dependency = metadata_cache.target_label_by_metadata[app_host_target_label]
             project.add_cached_subproject_reference(sandbox, cached_dependency, project.dependencies_group)
             Project.add_cached_dependency(sandbox, test_native_target, cached_dependency)
+          else
+            raise "Expected to either have an installation or cache result for #{app_host_target_label} (from pod #{app_host_pod_target_label}) " \
+              "for target #{test_native_target.name} in project #{project.project_name}"
           end
         end
 
-        def wire_app_native_targets(pod_target, native_target, installation_result, pod_target_installation_results, project, frameworks_group, metadata_cache)
+        def wire_app_native_targets(pod_target, installation_result, pod_target_installation_results, project, frameworks_group, metadata_cache)
           installation_result.app_specs_by_native_target.each do |app_native_target, app_spec|
             resource_bundle_native_targets = installation_result.app_resource_bundle_targets[app_spec.name] || []
             resource_bundle_native_targets.each do |app_resource_bundle_target|
@@ -187,7 +189,7 @@ module Pod
                 # Hit the cache
                 cached_dependency = metadata_cache.target_label_by_metadata[app_dependent_target.label]
                 project.add_cached_pod_subproject(sandbox, cached_dependency, is_local)
-                Project.add_cached_dependency(sandbox, native_target, cached_dependency)
+                Project.add_cached_dependency(sandbox, app_native_target, cached_dependency)
               end
             end
           end

data/lib/cocoapods/installer/xcode/pods_project_generator/pod_target_installer.rb

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/array'
+require 'active_support/core_ext/string/inflections'
 require 'cocoapods/xcode'
 
 module Pod
@@ -14,11 +16,15 @@ module Pod
           #
           attr_reader :umbrella_header_paths
 
+          # @return [PodTarget] @see TargetInstaller#target
+          #
+          attr_reader :target
+
           # Initialize a new instance
           #
           # @param [Sandbox] sandbox @see TargetInstaller#sandbox
           # @param [Pod::Project] project @see TargetInstaller#project
-          # @param [Target] target @see TargetInstaller#target
+          # @param [PodTarget] target @see TargetInstaller#target
           # @param [Array<Pathname>] umbrella_header_paths @see #umbrella_header_paths
           #
           def initialize(sandbox, project, target, umbrella_header_paths = nil)
@@ -42,6 +48,8 @@ module Pod
                 # PBXAggregateTarget that will be used to wire up dependencies later.
                 native_target = add_placeholder_target
                 resource_bundle_targets = add_resources_bundle_targets(library_file_accessors).values.flatten
+                create_copy_dsyms_script
+                create_copy_xcframeworks_script unless target.xcframeworks.values.all?(&:empty?)
                 create_xcconfig_file(native_target, resource_bundle_targets)
                 return TargetInstallationResult.new(target, native_target, resource_bundle_targets)
               end
@@ -57,8 +65,10 @@ module Pod
               app_resource_bundle_targets = add_resources_bundle_targets(app_file_accessors)
 
               add_files_to_build_phases(native_target, test_native_targets, app_native_targets)
-              validate_targets_contain_sources(test_native_targets + app_native_targets + [native_target])
-              validate_xcframeworks_no_mixed_linkage
+              validate_targets_contain_sources(test_native_targets + app_native_targets.values + [native_target])
+              validate_xcframeworks
+
+              create_copy_xcframeworks_script unless target.xcframeworks.values.all?(&:empty?)
 
               create_xcconfig_file(native_target, resource_bundle_targets)
               create_test_xcconfig_files(test_native_targets, test_resource_bundle_targets)
@@ -120,12 +130,13 @@ module Pod
                 target.app_specs.each do |app_spec|
                   path = target.prefix_header_path_for_spec(app_spec)
                   app_spec_consumer = app_spec.consumer(target.platform)
-                  app_native_target = app_native_target_from_spec(app_spec_consumer.spec, app_native_targets)
+                  app_native_target = app_native_targets[app_spec_consumer.spec]
                   create_prefix_header(path, app_file_accessors, target.platform, app_native_target, project_directory)
                   add_file_to_support_group(path)
                 end
               end
               create_dummy_source(native_target)
+              create_copy_dsyms_script
               clean_support_files_temp_dir
               TargetInstallationResult.new(target, native_target, resource_bundle_targets,
                                            test_native_targets, test_resource_bundle_targets, test_app_host_targets,
@@ -177,7 +188,7 @@ module Pod
           # @return [Boolean] Whether the target should build a pch file.
           #
           def skip_pch?(specs)
-            specs.any? { |spec| spec.prefix_header_file.is_a?(FalseClass) }
+            specs.any? { |spec| spec.root.prefix_header_file.is_a?(FalseClass) }
           end
 
           # True if info.plist generation should be skipped
@@ -216,9 +227,30 @@ module Pod
               settings['SWIFT_VERSION'] = target.swift_version
             end
 
+            if info_plist_bundle_id
+              settings['PRODUCT_BUNDLE_IDENTIFIER'] = info_plist_bundle_id
+            end
+
             settings
           end
 
+          # @return [String] Bundle Identifier found in the custom Info.plist entries
+          #
+          def info_plist_bundle_id
+            return @plist_bundle_id if defined?(@plist_bundle_id)
+            unless target.info_plist_entries.nil?
+              @plist_bundle_id = target.info_plist_entries['CFBundleIdentifier']
+              unless @plist_bundle_id.nil?
+                message = "The `#{target.name}` target " \
+              "sets a Bundle Identifier of `#{@plist_bundle_id}` in it's info.plist file. " \
+              'The Bundle Identifier should be set using pod_target_xcconfig: ' \
+              "s.pod_target_xcconfig = { 'PRODUCT_BUNDLE_IDENTIFIER': '#{@plist_bundle_id}' }`."
+                UI.warn message
+              end
+              @plist_bundle_id
+            end
+          end
+
           # Filters the given resource file references discarding empty paths which are
           # added by their parent directory. This will also include references to the parent [PBXVariantGroup]
           # for all resources underneath it.
@@ -285,7 +317,7 @@ module Pod
                                when :test
                                  test_native_target_from_spec(consumer.spec, test_native_targets)
                                when :app
-                                 app_native_target_from_spec(consumer.spec, app_native_targets)
+                                 app_native_targets[consumer.spec]
                                end
 
               headers = file_accessor.headers
@@ -322,6 +354,11 @@ module Pod
 
               filter_resource_file_references(file_accessor.resources.flatten) do |compile_phase_refs, resource_phase_refs|
                 native_target.add_file_references(compile_phase_refs, nil)
+
+                if target.build_as_static_framework? && consumer.spec.library_specification?
+                  resource_phase_refs = resource_phase_refs.select { |ref| Target.resource_extension_compilable?(File.extname(ref.path)) }
+                end
+
                 native_target.add_resources(resource_phase_refs)
               end
             end
@@ -377,7 +414,6 @@ module Pod
               remove_pod_target_xcconfig_overrides_from_target(target.test_spec_build_settings_by_config[test_spec.name], test_native_target)
 
               # Test native targets also need frameworks and resources to be copied over to their xctest bundle.
-              create_test_target_prepare_artifacts_script(test_spec)
               create_test_target_embed_frameworks_script(test_spec)
               create_test_target_copy_resources_script(test_spec)
 
@@ -411,10 +447,10 @@ module Pod
           # Adds the app targets for the library to the Pods project with the
           # appropriate build configurations.
           #
-          # @return [Array<PBXNativeTarget>] the app native targets created.
+          # @return [Hash{Specification => PBXNativeTarget}] the app native targets created, keyed by their app spec
           #
           def add_app_targets
-            target.app_specs.map do |app_spec|
+            target.app_specs.each_with_object({}) do |app_spec, hash|
               spec_consumer = app_spec.consumer(target.platform)
               spec_name = app_spec.parent.name
               subspec_name = target.subspec_label(app_spec)
@@ -473,7 +509,7 @@ module Pod
               create_app_target_copy_resources_script(app_spec)
               add_resources_to_target(resources, app_native_target)
 
-              app_native_target
+              hash[app_spec] = app_native_target
             end
           end
 
@@ -649,33 +685,6 @@ module Pod
             end
           end
 
-          # Creates a script that prepares artifacts for the test target.
-          #
-          # @param [Specification] test_spec
-          #        The test spec to create the script for.
-          #
-          # @return [void]
-          #
-          def create_test_target_prepare_artifacts_script(test_spec)
-            path = target.prepare_artifacts_script_path_for_spec(test_spec)
-            host_target_spec_names = target.app_host_dependent_targets_for_spec(test_spec).flat_map do |pt|
-              pt.specs.map(&:name)
-            end.uniq
-            frameworks_by_config = target.user_build_configurations.each_with_object({}) do |(config_name, config), paths_by_config|
-              paths_by_config[config_name] = target.dependent_targets_for_test_spec(test_spec, :configuration => config).flat_map do |pod_target|
-                spec_paths_to_include = pod_target.library_specs.map(&:name)
-                spec_paths_to_include -= host_target_spec_names
-                spec_paths_to_include << test_spec.name if pod_target == target
-                pod_target.xcframeworks.values_at(*spec_paths_to_include).flatten.compact.uniq
-              end
-            end
-            unless frameworks_by_config.each_value.all?(&:empty?)
-              generator = Generator::PrepareArtifactsScript.new(frameworks_by_config, target.sandbox.root, target.platform)
-              update_changed_file(generator, path)
-              add_file_to_support_group(path)
-            end
-          end
-
           # Creates a script that embeds the frameworks to the bundle of the test target.
           #
           # @param [Specification] test_spec
@@ -696,8 +705,16 @@ module Pod
                 pod_target.framework_paths.values_at(*spec_paths_to_include).flatten.compact.uniq
               end
             end
-            unless framework_paths_by_config.each_value.all?(&:empty?)
-              generator = Generator::EmbedFrameworksScript.new(framework_paths_by_config)
+            xcframeworks_by_config = target.user_build_configurations.each_with_object({}) do |(config_name, config), paths_by_config|
+              paths_by_config[config_name] = target.dependent_targets_for_test_spec(test_spec, :configuration => config).flat_map do |pod_target|
+                spec_paths_to_include = pod_target.library_specs.map(&:name)
+                spec_paths_to_include -= host_target_spec_names
+                spec_paths_to_include << test_spec.name if pod_target == target
+                pod_target.xcframeworks.values_at(*spec_paths_to_include).flatten.compact.uniq
+              end
+            end
+            unless framework_paths_by_config.each_value.all?(&:empty?) && xcframeworks_by_config.each_value.all?(&:empty?)
+              generator = Generator::EmbedFrameworksScript.new(framework_paths_by_config, xcframeworks_by_config)
               update_changed_file(generator, path)
               add_file_to_support_group(path)
             end
@@ -705,8 +722,8 @@ module Pod
 
           # Generates the contents of the xcconfig file used for each app target type and saves it to disk.
           #
-          # @param  [Array<PBXNativeTarget>] app_native_targets
-          #         the app native target to link the xcconfig file into.
+          # @param  [Hash{Specification => PBXNativeTarget}] app_native_targets
+          #         the app native targets to link the xcconfig file into.
           #
           # @param  [Hash{String=>Array<PBXNativeTarget>}] app_resource_bundle_targets
           #         the additional app resource bundle targets to link the xcconfig file into.
@@ -716,7 +733,7 @@ module Pod
           def create_app_xcconfig_files(app_native_targets, app_resource_bundle_targets)
             target.app_specs.each do |app_spec|
               spec_consumer = app_spec.consumer(target.platform)
-              app_native_target = app_native_target_from_spec(spec_consumer.spec, app_native_targets)
+              app_native_target = app_native_targets[spec_consumer.spec]
 
               target.user_config_names_by_config_type.each do |config, names|
                 path = target.xcconfig_path("#{target.subspec_label(app_spec)}.#{config}")
@@ -765,20 +782,57 @@ module Pod
           def create_app_target_embed_frameworks_script(app_spec)
             path = target.embed_frameworks_script_path_for_spec(app_spec)
             framework_paths_by_config = target.user_build_configurations.each_with_object({}) do |(config_name, config), paths_by_config|
-              pod_targets = target.dependent_targets_for_app_spec(app_spec, :configuration => config)
-              paths_by_config[config_name] = pod_targets.flat_map do |pod_target|
+              paths_by_config[config_name] = target.dependent_targets_for_app_spec(app_spec, :configuration => config).flat_map do |pod_target|
                 spec_paths_to_include = pod_target.library_specs.map(&:name)
                 spec_paths_to_include << app_spec.name if pod_target == target
                 pod_target.framework_paths.values_at(*spec_paths_to_include).flatten.compact.uniq
               end
             end
-            unless framework_paths_by_config.each_value.all?(&:empty?)
-              generator = Generator::EmbedFrameworksScript.new(framework_paths_by_config)
+            xcframeworks_by_config = target.user_build_configurations.each_with_object({}) do |(config_name, config), paths_by_config|
+              paths_by_config[config_name] = target.dependent_targets_for_app_spec(app_spec, :configuration => config).flat_map do |pod_target|
+                spec_paths_to_include = pod_target.library_specs.map(&:name)
+                spec_paths_to_include << app_spec.name if pod_target == target
+                pod_target.xcframeworks.values_at(*spec_paths_to_include).flatten.compact.uniq
+              end
+            end
+
+            unless framework_paths_by_config.each_value.all?(&:empty?) && xcframeworks_by_config.each_value.all?(&:empty?)
+              generator = Generator::EmbedFrameworksScript.new(framework_paths_by_config, xcframeworks_by_config)
+              update_changed_file(generator, path)
+              add_file_to_support_group(path)
+            end
+          end
+
+          # Creates a script that copies and strips vendored dSYMs and bcsymbolmaps.
+          #
+          # @return [void]
+          #
+          def create_copy_dsyms_script
+            dsym_paths = PodTargetInstaller.dsym_paths(target)
+            bcsymbolmap_paths = PodTargetInstaller.bcsymbolmap_paths(target)
+            path = target.copy_dsyms_script_path
+            unless dsym_paths.empty? && bcsymbolmap_paths.empty?
+              generator = Generator::CopydSYMsScript.new(dsym_paths, bcsymbolmap_paths)
               update_changed_file(generator, path)
               add_file_to_support_group(path)
             end
           end
 
+          # Creates a script that copies the appropriate xcframework slice to the build dir.
+          #
+          # @note   We can't use Xcode default link libraries phase, because
+          #         we need to ensure that we only copy the frameworks which are
+          #         relevant for the current build configuration.
+          #
+          # @return [void]
+          #
+          def create_copy_xcframeworks_script
+            path = target.copy_xcframeworks_script_path
+            generator = Generator::CopyXCFrameworksScript.new(target.xcframeworks.values.flatten, sandbox.root, target.platform)
+            update_changed_file(generator, path)
+            add_file_to_support_group(path)
+          end
+
           # Manually add `libswiftSwiftOnoneSupport.dylib` as it seems there is an issue with tests that do not include it for Debug configurations.
           # Possibly related to Swift module optimization.
           #
@@ -943,9 +997,18 @@ module Pod
           end
 
           def project_file_references_array(files, file_type)
+            error_message_for_missing_reference = lambda do |sf, target|
+              "Unable to find #{file_type} ref for `#{sf.basename}` for target `#{target.name}`."
+            end
             files.map do |sf|
-              project.reference_for_path(sf).tap do |ref|
-                raise Informative, "Unable to find #{file_type} ref for `#{sf.basename}` for target `#{target.name}`." unless ref
+              begin
+                project.reference_for_path(sf).tap do |ref|
+                  raise Informative, error_message_for_missing_reference.call(sf, target) unless ref
+                end
+              rescue Errno::ENOENT
+                # Normalize the error for Ruby < 2.7. Ruby 2.7 can crash on a different call of real path compared
+                # to older versions. This ensures that the error message is consistent.
+                raise Informative, error_message_for_missing_reference.call(sf, target)
               end
             end
           end
@@ -1011,13 +1074,6 @@ module Pod
             end
           end
 
-          def app_native_target_from_spec(spec, app_native_targets)
-            app_target_label = target.app_target_label(spec)
-            app_native_targets.find do |app_native_target|
-              app_native_target.name == app_target_label
-            end
-          end
-
           # Adds a placeholder native target for the library to the Pods project with the
           # appropriate build configurations.
           #
@@ -1086,19 +1142,80 @@ module Pod
             end
           end
 
-          # Raises if a vendored xcframework contains frameworks of mixed linkage
+          # Raises if a vendored xcframework contains frameworks of mixed linkage or mixed packaging
           #
-          def validate_xcframeworks_no_mixed_linkage
+          def validate_xcframeworks
             target.xcframeworks.each_value do |xcframeworks|
               xcframeworks.each do |xcframework|
-                dynamic_slices, static_slices = xcframework.slices.partition { |slice| Pod::Xcode::LinkageAnalyzer.dynamic_binary?(slice.path) }
+                if xcframework.slices.empty?
+                  raise Informative, "Unable to install vendored xcframework `#{xcframework.name}` for Pod `#{target.label}` because it does not contain any binaries."
+                end
+                if xcframework.build_type.dynamic_library?
+                  raise Informative, <<-MSG.strip_heredoc
+                    Unable to install vendored xcframework `#{xcframework.name}` for Pod `#{target.label}` because it contains dynamic libraries which are not supported.
+                    Use dynamic frameworks for dynamic linking instead.
+                  MSG
+                end
+                if xcframework.build_type.static_library?
+                  binary_names = xcframework.slices.map { |slice| File.basename(slice.binary_path, File.extname(slice.binary_path)) }.uniq
+                  if binary_names.size > 1
+                    raise Informative, <<-MSG.strip_heredoc
+                      Unable to install vendored xcframework `#{xcframework.name}` for Pod `#{target.label}` because it contains static libraries
+                      with differing binary names: #{binary_names.to_sentence}.
+                    MSG
+                  end
+                end
+                dynamic_slices, static_slices = xcframework.slices.partition(&:dynamic?)
                 if !dynamic_slices.empty? && !static_slices.empty?
                   raise Informative, "Unable to install vendored xcframework `#{xcframework.name}` for Pod `#{target.label}`, because it contains both static and dynamic frameworks."
                 end
+                library_slices, framework_slices = xcframework.slices.partition(&:library?)
+                if !library_slices.empty? && !framework_slices.empty?
+                  raise Informative, "Unable to install vendored xcframework `#{xcframework.name}` for Pod `#{target.label}`, because it contains both libraries and frameworks."
+                end
               end
             end
           end
+
           #-----------------------------------------------------------------------#
+
+          class << self
+            # @param [PodTarget] target the target to be installed
+            #
+            # @return [Array<String>] the dSYM paths for the given target
+            #
+            def dsym_paths(target)
+              dsym_paths = target.framework_paths.values.flatten.reject { |fmwk_path| fmwk_path.dsym_path.nil? }.map(&:dsym_path)
+              dsym_paths.concat(target.xcframeworks.values.flatten.flat_map { |xcframework| xcframework_dsyms(xcframework.path) })
+              dsym_paths
+            end
+
+            # @param [PodTarget] target the target to be installed
+            #
+            # @return [Array<String>] the bcsymbolmap paths for the given target
+            #
+            def bcsymbolmap_paths(target)
+              target.framework_paths.values.flatten.reject do |fmwk_path|
+                fmwk_path.bcsymbolmap_paths.nil?
+              end.flat_map(&:bcsymbolmap_paths)
+            end
+
+            # @param  [Pathname] xcframework_path
+            #         the base path of the .xcframework bundle
+            #
+            # @return [Array<Pathname>] all found .dSYM paths
+            #
+            def xcframework_dsyms(xcframework_path)
+              basename = File.basename(xcframework_path, '.xcframework')
+              dsym_basename = basename + '.dSYMs'
+              path = xcframework_path.dirname + dsym_basename
+              if File.directory?(path)
+                Dir.glob(path + '*.dSYM')
+              else
+                []
+              end
+            end
+          end
         end
       end
     end