[cmake] Instead of figuring out the exact location of all of the various libraries when translating Xcode targets, just use the path already provided in LLVMConfig.cmake for the configuration that we compiled LLVM specifically for.

If we compile LLVM for <CONFIG> in build-script with Xcode as our generator,
LLVMExports.cmake will have specific IMPORTED_*_<CONFIG> variables set for all
of our targets. These variables are what we really want to splat across all
Swift Xcode build configurations.

This patch rips out the old code that determined the actual location and instead
just grabs the IMPORTED_*_<CONFIG> variables and splats it accordingly.

Author: gottesmm

cmake/modules/SwiftSharedCMakeConfig.cmake

@@ -49,41 +49,81 @@ function(get_imported_library_prefix outvar target prefix)
   endif()
 endfunction()
 
-# What this function does is go through each of the passed in imported targets
-# from LLVM/Clang and changes them to use the appropriate fully expanded paths.
-#
-# TODO: This function needs a better name.
-function(fix_imported_target_locations_for_xcode targets)
-  foreach(t ${targets})
-    if (NOT TARGET ${t})
-      message(FATAL_ERROR "${t} is not a target?!")
-    endif()
+function(check_imported_target_has_imported_configuration target config)
+  get_target_property(IMPORTED_CONFIGS_LIST ${target} IMPORTED_CONFIGURATIONS)
+  if ("${IMPORTED_CONFIGS_LIST}" STREQUAL "NOTFOUND")
+    message(FATAL_ERROR "No import configuration of ${target} specified?!")
+  endif()
 
-    get_target_property(TARGET_TYPE ${t} TYPE)
+  list(FIND "${IMPORTED_CONFIGS_LIST}" "${config}" FOUND_CONFIG)
+  if (NOT FOUND_CONFIG)
+    message(FATAL_ERROR "${target} does not have imported config '${config}'?! \
+Instead: ${IMPORTED_CONFIGS_LIST}")
+  endif()
+endfunction()
 
-    if (NOT "${TARGET_TYPE}" STREQUAL "STATIC_LIBRARY" AND
-        NOT "${TARGET_TYPE}" STREQUAL "SHARED_LIBRARY" AND
-        NOT "${TARGET_TYPE}" STREQUAL "EXECUTABLE")
-      message(FATAL_ERROR "Unsupported imported target type ${TARGET_TYPE}")
-    endif()
+function(fixup_imported_target_property_for_xcode target property real_build_type)
+  set(FULL_PROP_NAME "${property}_${real_build_type}")
+
+  # First try to lookup the value associated with the "real build type".
+  get_target_property(PROP_VALUE ${target} ${FULL_PROP_NAME})
 
-    # Ok, so at this point, we know that we have an executable, static library,
-    # or shared library.
-    #
-    # First we handle the executables.
-    if ("${TARGET_TYPE}" STREQUAL "EXECUTABLE")
-      set_target_properties(${t} PROPERTIES
-        IMPORTED_LOCATION_DEBUG "${LLVM_BINARY_OUTPUT_INTDIR}/${t}"
-        IMPORTED_LOCATION_RELEASE "${LLVM_BINARY_OUTPUT_INTDIR}/${t}")
+  # If the property is unspecified, return.
+  if ("${PROP_VALUE}" STREQUAL "NOTFOUND")
+    return()
+  endif()
+
+  # Otherwise for each cmake configuration that is not real_build_type, hardcode
+  # its value to be PROP_VALUE.
+  foreach(c ${CMAKE_CONFIGURATION_TYPES})
+    if ("${c}" STREQUAL "${real_build_type}")
       continue()
     endif()
+    set_target_properties(${target} PROPERTIES ${FULL_PROP_NAME} "${PROP_VALUE}")
+  endforeach()
+endfunction()
+
+# When building with Xcode, we only support compiling against the LLVM
+# configuration that was specified by build-script. This becomes a problem since
+# if we compile LLVM-Release and Swift-Debug, Swift is going to look in the
+# Debug, not the Release folder for LLVM's code and thus will be compiling
+# against an unintended set of libraries, if those libraries exist at all.
+#
+# Luckily, via LLVMConfig.cmake, we know the configuration that LLVM was
+# compiled in, so we can grab the imported location for that configuration and
+# splat it across the other configurations as well.
+function(fix_imported_targets_for_xcode imported_targets)
+  # This is the set of configuration specific cmake properties that are
+  # supported for imported targets in cmake 3.4.3. Sadly, beyond hacks, it seems
+  # that there is no way to dynamically query the list of set properties of a
+  # target.
+  #
+  # *NOTE* In fixup_imported_target_property_for_xcode, we add the _${CONFIG}
+  # *suffix.
+  set(imported_target_properties
+    IMPORTED_IMPLIB
+    IMPORTED_LINK_DEPENDENT_LIBRARIES
+    IMPORTED_LINK_INTERFACE_LANGUAGES
+    IMPORTED_LINK_INTERFACE_LIBRARIES
+    IMPORTED_LINK_INTERFACE_MULTIPLICITY
+    IMPORTED_LOCATION
+    IMPORTED_NO_SONAME
+    IMPORTED_SONAME)
+
+  foreach(target ${imported_targets})
+    if (NOT TARGET ${target})
+      message(FATAL_ERROR "${target} is not a target?!")
+    endif()
+
+    # First check that we actually imported the configuration that LLVM said
+    # that we did. This is just a sanity check.
+    check_imported_target_has_imported_configuration(${target} ${LLVM_BUILD_TYPE})
 
-    # Otherwise, we have libraries. Since libclang has an extra lib prefix in
-    # its target name, we have to handle it specially.
-    get_imported_library_prefix(PREFIX "${t}" "${CMAKE_${TARGET_TYPE}_PREFIX}")
-    set_target_properties(${t} PROPERTIES
-      IMPORTED_LOCATION_DEBUG "${LLVM_LIBRARY_OUTPUT_INTDIR}/${PREFIX}${t}.${CMAKE_${TARGET_TYPE}_SUFFIX}"
-      IMPORTED_LOCATION_RELEASE "${LLVM_LIBRARY_OUTPUT_INTDIR}/${PREFIX}${t}.${CMAKE_${TARGET_TYPE}_SUFFIX}")
+    # Then loop through all of the imported properties and translate.
+    foreach(property ${imported_properties})
+      fixup_imported_target_property_for_xcode(
+        ${target} ${property} ${LLVM_BUILD_TYPE})
+    endforeach()
   endforeach()
 endfunction()
 
@@ -147,7 +187,7 @@ macro(swift_common_standalone_build_config_llvm product is_cross_compiling)
   set(LLVM_LIBRARY_OUTPUT_INTDIR "${LLVM_LIBRARY_DIR}")
 
   if (XCODE)
-    fix_imported_target_locations_for_xcode("${LLVM_EXPORTED_TARGETS}")
+    fix_imported_targets_for_xcode("${LLVM_EXPORTED_TARGETS}")
   endif()
 
   if(NOT ${is_cross_compiling})
@@ -240,7 +280,7 @@ macro(swift_common_standalone_build_config_clang product is_cross_compiling)
   set(CLANG_MAIN_INCLUDE_DIR "${CLANG_MAIN_SRC_DIR}/include")
 
   if (XCODE)
-    fix_imported_target_locations_for_xcode("${CLANG_EXPORTED_TARGETS}")
+    fix_imported_targets_for_xcode("${CLANG_EXPORTED_TARGETS}")
   endif()
 
   include_directories("${CLANG_BUILD_INCLUDE_DIR}"