Allow add_dependencies() on imported targets (#10395)

Imported targets do not themselves build, but we can follow dependencies
through them to find real targets.  This allows imported targets to
depend on custom targets that provide the underlying files at build
time.

Source/cmAddDependenciesCommand.cxx

@@ -24,11 +24,7 @@ bool cmAddDependenciesCommand
     }
 
   std::string target_name = args[0];
-
-  cmTarget* target = 
-    this->GetMakefile()->GetLocalGenerator()->
-    GetGlobalGenerator()->FindTarget(0, target_name.c_str());
-  if(target)
+  if(cmTarget* target = this->Makefile->FindTargetToUse(target_name.c_str()))
     {
     std::vector<std::string>::const_iterator s = args.begin();
     ++s; // skip over target_name

Source/cmAddDependenciesCommand.h

@@ -62,6 +62,8 @@ public:
       "top-level target is one created by ADD_EXECUTABLE, ADD_LIBRARY, "
       "or ADD_CUSTOM_TARGET.  Adding dependencies with this command "
       "can be used to make sure one target is built before another target.  "
+      "Dependencies added to an IMPORTED target are followed transitively "
+      "in its place since the target itself does not build.  "
       "See the DEPENDS option of ADD_CUSTOM_TARGET "
       "and ADD_CUSTOM_COMMAND for adding file-level dependencies in custom "
       "rules.  See the OBJECT_DEPENDS option in "

Source/cmComputeTargetDepends.cxx

@@ -246,13 +246,7 @@ void cmComputeTargetDepends::AddTargetDepend(int depender_index,
 
   // Check the target's makefile first.
   cmTarget* dependee =
-    depender->GetMakefile()->FindTarget(dependee_name);
-
-  // Then search globally.
-  if(!dependee)
-    {
-    dependee = this->GlobalGenerator->FindTarget(0, dependee_name);
-    }
+    depender->GetMakefile()->FindTargetToUse(dependee_name);
 
   // Skip targets that will not really be linked.  This is probably a
   // name conflict between an external library and an executable
@@ -264,25 +258,42 @@ void cmComputeTargetDepends::AddTargetDepend(int depender_index,
     dependee = 0;
     }
 
-  // If not found then skip then the dependee.
-  if(!dependee)
+  if(dependee)
     {
-    return;
+    this->AddTargetDepend(depender_index, dependee, linking);
     }
+}
 
-  // No imported targets should have been found.
-  assert(!dependee->IsImported());
+//----------------------------------------------------------------------------
+void cmComputeTargetDepends::AddTargetDepend(int depender_index,
+                                             cmTarget* dependee,
+                                             bool linking)
+{
+  if(dependee->IsImported())
+    {
+    // Skip imported targets but follow their utility dependencies.
+    std::set<cmStdString> const& utils = dependee->GetUtilities();
+    for(std::set<cmStdString>::const_iterator i = utils.begin();
+        i != utils.end(); ++i)
+      {
+      cmTarget* transitive_dependee =
+        dependee->GetMakefile()->FindTargetToUse(i->c_str());
+      this->AddTargetDepend(depender_index, transitive_dependee, false);
+      }
+    }
+  else
+    {
+    // Lookup the index for this target.  All targets should be known by
+    // this point.
+    std::map<cmTarget*, int>::const_iterator tii =
+      this->TargetIndex.find(dependee);
+    assert(tii != this->TargetIndex.end());
+    int dependee_index = tii->second;
 
-  // Lookup the index for this target.  All targets should be known by
-  // this point.
-  std::map<cmTarget*, int>::const_iterator tii =
-    this->TargetIndex.find(dependee);
-  assert(tii != this->TargetIndex.end());
-  int dependee_index = tii->second;
-
-  // Add this entry to the dependency graph.
-  this->InitialGraph[depender_index].push_back(
-    cmGraphEdge(dependee_index, !linking));
+    // Add this entry to the dependency graph.
+    this->InitialGraph[depender_index].push_back(
+      cmGraphEdge(dependee_index, !linking));
+    }
 }
 
 //----------------------------------------------------------------------------

Source/cmComputeTargetDepends.h

@@ -46,6 +46,7 @@ private:
   void CollectTargetDepends(int depender_index);
   void AddTargetDepend(int depender_index, const char* dependee_name,
                        bool linking);
+  void AddTargetDepend(int depender_index, cmTarget* dependee, bool linking);
   bool ComputeFinalDepends(cmComputeComponentGraph const& ccg);
 
   cmGlobalGenerator* GlobalGenerator;

Tests/ExportImport/Import/A/CMakeLists.txt

@@ -75,6 +75,22 @@ foreach(c DEBUG RELWITHDEBINFO)
   set_property(TARGET imp_testExe1b PROPERTY COMPILE_DEFINITIONS_${c} EXE_DBG)
 endforeach(c)
 
+# Create a custom target to generate a header for the libraries below.
+include_directories(${CMAKE_CURRENT_BINARY_DIR})
+add_custom_command(
+  OUTPUT testLib2.h
+  VERBATIM COMMAND
+  ${CMAKE_COMMAND} -E echo "extern int testLib2(void);" > testLib2.h
+  )
+add_custom_target(hdr_testLib2 DEPENDS testLib2.h)
+
+# Drive the header generation through an indirect chain of imported
+# target dependencies.
+add_library(dep_testLib2 UNKNOWN IMPORTED)
+add_dependencies(dep_testLib2 hdr_testLib2)
+add_dependencies(bld_testLib2 dep_testLib2)
+add_dependencies(exp_testLib2 dep_testLib2)
+
 # Create a library to be linked by another directory in this project
 # to test transitive linking to otherwise invisible imported targets.
 add_library(imp_lib1 STATIC imp_lib1.c)

Tests/ExportImport/Import/A/imp_lib1.c

@@ -1,4 +1,4 @@
-extern int testLib2(void);
+#include "testLib2.h"
 
 int imp_lib1(void)
 {