cocoapods 1.9.1 → 1.10.2

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
@@ -371,13 +408,16 @@ module Pod
                   configuration.build_settings['CODE_SIGNING_ALLOWED'] = 'YES'
                 end
                 # For macOS we do not code sign the XCTest bundle because we do not code sign the frameworks either.
-                configuration.build_settings['CODE_SIGN_IDENTITY'] = '' if target.platform == :osx
+                if target.platform == :osx
+                  configuration.build_settings['CODE_SIGN_IDENTITY'] = ''
+                elsif target.platform == :ios
+                  configuration.build_settings['CODE_SIGN_IDENTITY'] = 'iPhone Developer'
+                end
               end
 
               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 +451,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 +513,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 +689,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 +709,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 +726,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 +737,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 +786,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.
           #
@@ -792,7 +850,7 @@ module Pod
           end
 
           # Creates a build phase which links the versioned header folders
-          # of the OS X into the framework bundle's root root directory.
+          # of the OS X framework into the framework bundle's root directory.
           # This is only necessary because the way how headers are copied
           # via custom copy file build phases in combination with
           # header_mappings_dir interferes with xcodebuild's expectations
@@ -804,11 +862,16 @@ module Pod
           # @return [void]
           #
           def create_build_phase_to_symlink_header_folders(native_target)
-            return unless target.platform.name == :osx && any_header_mapping_dirs?
+            # This is required on iOS for Catalyst, which uses macOS framework layouts
+            return unless (target.platform.name == :osx || target.platform.name == :ios) && any_header_mapping_dirs?
 
             build_phase = native_target.new_shell_script_build_phase('Create Symlinks to Header Folders')
             build_phase.shell_script = <<-eos.strip_heredoc
               cd "$CONFIGURATION_BUILD_DIR/$WRAPPER_NAME" || exit 1
+              if [ ! -d Versions ]; then
+                # Not a versioned framework, so no need to do anything
+                exit 0
+              fi
 
               public_path="${PUBLIC_HEADERS_FOLDER_PATH\#\$CONTENTS_FOLDER_PATH/}"
               if [ ! -f "$public_path" ]; then
@@ -943,9 +1006,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 +1083,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 +1151,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

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

@@ -32,11 +32,12 @@ module Pod
           def integrate!
             UI.section(integration_message) do
               target_installation_result.non_library_specs_by_native_target.each do |native_target, spec|
-                add_prepare_artifacts_script_phase(native_target, spec)
                 add_embed_frameworks_script_phase(native_target, spec)
                 add_copy_resources_script_phase(native_target, spec)
                 UserProjectIntegrator::TargetIntegrator.create_or_update_user_script_phases(script_phases_for_specs(spec), native_target)
               end
+              add_copy_dsyms_script_phase(target_installation_result.native_target)
+              add_copy_xcframeworks_script_phase(target_installation_result.native_target)
               UserProjectIntegrator::TargetIntegrator.create_or_update_user_script_phases(script_phases_for_specs(target.library_specs), target_installation_result.native_target)
             end
           end
@@ -138,15 +139,12 @@ module Pod
               input_file_list_path = target.embed_frameworks_script_input_files_path_for_spec(spec)
               input_file_list_relative_path = "${PODS_ROOT}/#{input_file_list_path.relative_path_from(target.sandbox.root)}"
               input_paths_key = UserProjectIntegrator::TargetIntegrator::XCFileListConfigKey.new(input_file_list_path, input_file_list_relative_path)
-              input_paths = input_paths_by_config[input_paths_key] = [script_path]
-              framework_paths.each do |path|
-                input_paths.concat(path.all_paths)
-              end
+              input_paths_by_config[input_paths_key] = [script_path] + UserProjectIntegrator::TargetIntegrator.embed_frameworks_input_paths(framework_paths, [])
 
               output_file_list_path = target.embed_frameworks_script_output_files_path_for_spec(spec)
               output_file_list_relative_path = "${PODS_ROOT}/#{output_file_list_path.relative_path_from(target.sandbox.root)}"
               output_paths_key = UserProjectIntegrator::TargetIntegrator::XCFileListConfigKey.new(output_file_list_path, output_file_list_relative_path)
-              output_paths_by_config[output_paths_key] = UserProjectIntegrator::TargetIntegrator.framework_output_paths(framework_paths)
+              output_paths_by_config[output_paths_key] = UserProjectIntegrator::TargetIntegrator.embed_frameworks_output_paths(framework_paths, [])
             end
 
             if framework_paths.empty?
@@ -162,34 +160,18 @@ module Pod
           # @param [PBXNativeTarget] native_target
           #         the native target for which to add the prepare artifacts script
           #
-          # @param [Pod::Specification] spec
-          #         the specification to integrate
-          #
           # @return [void]
           #
-          def add_prepare_artifacts_script_phase(native_target, spec)
-            script_path = "${PODS_ROOT}/#{target.prepare_artifacts_script_path_for_spec(spec).relative_path_from(target.sandbox.root)}"
+          def add_copy_xcframeworks_script_phase(native_target)
+            script_path = "${PODS_ROOT}/#{target.copy_xcframeworks_script_path.relative_path_from(target.sandbox.root)}"
 
             input_paths_by_config = {}
             output_paths_by_config = {}
 
-            dependent_targets = if spec.test_specification?
-                                  target.dependent_targets_for_test_spec(spec)
-                                else
-                                  target.dependent_targets_for_app_spec(spec)
-                                end
-            host_target_spec_names = target.app_host_dependent_targets_for_spec(spec).flat_map do |pt|
-              pt.specs.map(&:name)
-            end.uniq
-            xcframeworks = dependent_targets.flat_map do |dependent_target|
-              spec_paths_to_include = dependent_target.library_specs.map(&:name)
-              spec_paths_to_include -= host_target_spec_names
-              spec_paths_to_include << spec.name if dependent_target == target
-              dependent_target.xcframeworks.values_at(*spec_paths_to_include).flatten.compact
-            end.uniq
+            xcframeworks = target.xcframeworks.values.flatten
 
             if use_input_output_paths? && !xcframeworks.empty?
-              input_file_list_path = target.prepare_artifacts_script_input_files_path_for_spec(spec)
+              input_file_list_path = target.copy_xcframeworks_script_input_files_path
               input_file_list_relative_path = "${PODS_ROOT}/#{input_file_list_path.relative_path_from(target.sandbox.root)}"
               input_paths_key = UserProjectIntegrator::TargetIntegrator::XCFileListConfigKey.new(input_file_list_path, input_file_list_relative_path)
               input_paths = input_paths_by_config[input_paths_key] = [script_path]
@@ -197,20 +179,69 @@ module Pod
               framework_paths = xcframeworks.map { |xcf| "${PODS_ROOT}/#{xcf.path.relative_path_from(target.sandbox.root)}" }
               input_paths.concat framework_paths
 
-              output_file_list_path = target.prepare_artifacts_script_output_files_path_for_spec(spec)
+              output_file_list_path = target.copy_xcframeworks_script_output_files_path
               output_file_list_relative_path = "${PODS_ROOT}/#{output_file_list_path.relative_path_from(target.sandbox.root)}"
               output_paths_key = UserProjectIntegrator::TargetIntegrator::XCFileListConfigKey.new(output_file_list_path, output_file_list_relative_path)
-              output_paths_by_config[output_paths_key] = [UserProjectIntegrator::TargetIntegrator::ARTIFACT_LIST_FILE]
+              output_paths_by_config[output_paths_key] = xcframeworks.map do |xcf|
+                "#{Target::BuildSettings::XCFRAMEWORKS_BUILD_DIR_VARIABLE}/#{xcf.name}"
+              end
             end
 
             if xcframeworks.empty?
-              UserProjectIntegrator::TargetIntegrator.remove_prepare_artifacts_script_phase_from_target(native_target)
+              UserProjectIntegrator::TargetIntegrator.remove_copy_xcframeworks_script_phase_from_target(native_target)
             else
-              UserProjectIntegrator::TargetIntegrator.create_or_update_prepare_artifacts_script_phase_to_target(
+              UserProjectIntegrator::TargetIntegrator.create_or_update_copy_xcframeworks_script_phase_to_target(
                 native_target, script_path, input_paths_by_config, output_paths_by_config)
             end
           end
 
+          # Adds a script phase that copies and strips dSYMs that are part of this target. Note this only deals with
+          # vendored dSYMs.
+          #
+          # @param [PBXNativeTarget] native_target
+          #         the native target for which to add the the copy dSYM files build phase.
+          #
+          # @return [void]
+          #
+          def add_copy_dsyms_script_phase(native_target)
+            script_path = "${PODS_ROOT}/#{target.copy_dsyms_script_path.relative_path_from(target.sandbox.root)}"
+            dsym_paths = PodTargetInstaller.dsym_paths(target)
+            bcsymbolmap_paths = PodTargetInstaller.bcsymbolmap_paths(target)
+
+            if dsym_paths.empty? && bcsymbolmap_paths.empty?
+              script_phase = native_target.shell_script_build_phases.find do |bp|
+                bp.name && bp.name.end_with?(UserProjectIntegrator::TargetIntegrator::COPY_DSYM_FILES_PHASE_NAME)
+              end
+              native_target.build_phases.delete(script_phase) if script_phase.present?
+              return
+            end
+
+            phase_name = UserProjectIntegrator::TargetIntegrator::BUILD_PHASE_PREFIX + UserProjectIntegrator::TargetIntegrator::COPY_DSYM_FILES_PHASE_NAME
+            phase = UserProjectIntegrator::TargetIntegrator.create_or_update_shell_script_build_phase(native_target, phase_name)
+            phase.shell_script = %("#{script_path}"\n)
+
+            input_paths_by_config = {}
+            output_paths_by_config = {}
+            if use_input_output_paths?
+              input_file_list_path = target.copy_dsyms_script_input_files_path
+              input_file_list_relative_path = "${PODS_ROOT}/#{input_file_list_path.relative_path_from(target.sandbox.root)}"
+              input_paths_key = UserProjectIntegrator::TargetIntegrator::XCFileListConfigKey.new(input_file_list_path, input_file_list_relative_path)
+              input_paths = input_paths_by_config[input_paths_key] = []
+              input_paths.concat([dsym_paths, *bcsymbolmap_paths].flatten.compact)
+
+              output_file_list_path = target.copy_dsyms_script_output_files_path
+              output_file_list_relative_path = "${PODS_ROOT}/#{output_file_list_path.relative_path_from(target.sandbox.root)}"
+              output_paths_key = UserProjectIntegrator::TargetIntegrator::XCFileListConfigKey.new(output_file_list_path, output_file_list_relative_path)
+              output_paths = output_paths_by_config[output_paths_key] = []
+
+              dsym_output_paths = dsym_paths.map { |dsym_path| "${DWARF_DSYM_FOLDER_PATH}/#{File.basename(dsym_path)}" }
+              bcsymbolmap_output_paths = bcsymbolmap_paths.map { |bcsymbolmap_path| "${DWARF_DSYM_FOLDER_PATH}/#{File.basename(bcsymbolmap_path)}" }
+              output_paths.concat([dsym_output_paths, *bcsymbolmap_output_paths].flatten.compact)
+            end
+
+            UserProjectIntegrator::TargetIntegrator.set_input_output_paths(phase, input_paths_by_config, output_paths_by_config)
+          end
+
           # @return [String] the message that should be displayed for the target
           #         integration.
           #

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

@@ -30,7 +30,7 @@ module Pod
         #
         attr_reader :platforms
 
-        # @return [String] Object version for the Xcode project.
+        # @return [Integer] Object version for the Xcode project.
         #
         attr_reader :object_version
 
@@ -50,7 +50,7 @@ module Pod
         # @param [Array<PodTarget>] pod_targets @see #pod_targets
         # @param [Hash{String=>Symbol}] build_configurations @see #build_configurations
         # @param [Array<Platform>] platforms @see #platforms
-        # @param [String] object_version @see #object_version
+        # @param [Integer] object_version @see #object_version
         # @param [String] podfile_path @see #podfile_path
         #
         def initialize(sandbox, path, pod_targets, build_configurations, platforms,
@@ -110,6 +110,7 @@ module Pod
               build_configuration.build_settings['TVOS_DEPLOYMENT_TARGET'] = tvos_deployment_target.to_s if tvos_deployment_target
               build_configuration.build_settings['STRIP_INSTALLED_PRODUCT'] = 'NO'
               build_configuration.build_settings['CLANG_ENABLE_OBJC_ARC'] = 'YES'
+              build_configuration.build_settings['CLANG_ANALYZER_LOCALIZABILITY_NONLOCALIZED'] = 'YES'
             end
           end
         end

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

@@ -38,7 +38,7 @@ module Pod
           #
           attr_reader :test_app_host_targets
 
-          # @return [Array<PBXNativeTarget>] app_native_targets
+          # @return [Hash{Specification => PBXNativeTarget}] app_native_targets
           #         The app native targets that were produced for this target. Can be empty if there were no app
           #         native targets created (e.g. no app specs present).
           #
@@ -58,12 +58,12 @@ module Pod
           # @param [Array<PBXNativeTarget>] test_native_targets @see #test_native_targets
           # @param [Hash{String=>Array<PBXNativeTarget>}] test_resource_bundle_targets @see #test_resource_bundle_targets
           # @param [Array<PBXNativeTarget>] test_app_host_targets @see #test_app_host_targets
-          # @param [Array<PBXNativeTarget>] app_native_targets @see #app_native_targets
+          # @param [Hash{Specification => PBXNativeTarget}] app_native_targets @see #app_native_targets
           # @param [Hash{String=>Array<PBXNativeTarget>}] app_resource_bundle_targets @see #app_resource_bundle_targets
           #
           def initialize(target, native_target, resource_bundle_targets = [], test_native_targets = [],
                          test_resource_bundle_targets = {}, test_app_host_targets = [],
-                         app_native_targets = [], app_resource_bundle_targets = {})
+                         app_native_targets = {}, app_resource_bundle_targets = {})
             @target = target
             @native_target = native_target
             @resource_bundle_targets = resource_bundle_targets
@@ -115,7 +115,7 @@ module Pod
           # @return [PBXNativeTarget] the app host target with the given target label.
           #
           def app_host_target_labelled(label)
-            app_native_targets.find do |app_native_target|
+            app_native_targets.values.find do |app_native_target|
               app_native_target.name == label
             end || test_app_host_targets.find do |app_native_target|
               app_native_target.name == label
@@ -131,9 +131,7 @@ module Pod
           end
 
           def app_native_target_from_spec(spec)
-            app_native_targets.find do |app_native_target|
-              app_native_target.name == target.app_target_label(spec)
-            end
+            app_native_targets[spec]
           end
         end
       end