Memoize includes and defines from interface libraries.

This is similar in spirit to commit e48d8420 (Cache context-independent
includes on evaluation., 2013-02-03), but it is needed since commit
a1c4905f (Use the link information as a source of compile definitions
and includes., 2013-02-12), which changed how includes and defines
are determined. As they are now determined through the link interface,
we need to cache the result of evaluating them through that.

In the case of the includes, the result was already being cached
and then immediately disposed. Store the result as a member variable
instead to make use of the caching.

Source/cmTarget.cxx

@@ -92,6 +92,7 @@ public:
     // Others not copied here are result caches.
     this->SourceEntries = r.SourceEntries;
     }
+  ~cmTargetInternals();
   typedef cmTarget::SourceFileFlags SourceFileFlags;
   std::map<cmSourceFile const*, SourceFileFlags> SourceFlagsMap;
   bool SourceFileFlagsConstructed;
@@ -138,8 +139,35 @@ public:
   };
   std::vector<IncludeDirectoriesEntry*> IncludeDirectoriesEntries;
   std::vector<cmValueWithOrigin> LinkInterfaceIncludeDirectoriesEntries;
+
+  std::vector<IncludeDirectoriesEntry*>
+                                CachedLinkInterfaceIncludeDirectoriesEntries;
+  std::map<std::string, std::string> CachedLinkInterfaceCompileDefinitions;
+
+  std::map<std::string, bool> CacheLinkInterfaceIncludeDirectoriesDone;
+  std::map<std::string, bool> CacheLinkInterfaceCompileDefinitionsDone;
 };
 
+//----------------------------------------------------------------------------
+void deleteAndClear(
+      std::vector<cmTargetInternals::IncludeDirectoriesEntry*> &entries)
+{
+  for (std::vector<cmTargetInternals::IncludeDirectoriesEntry*>::const_iterator
+      it = entries.begin(),
+      end = entries.end();
+      it != end; ++it)
+    {
+      delete *it;
+    }
+  entries.clear();
+}
+
+//----------------------------------------------------------------------------
+cmTargetInternals::~cmTargetInternals()
+{
+  deleteAndClear(CachedLinkInterfaceIncludeDirectoriesEntries);
+}
+
 //----------------------------------------------------------------------------
 cmTarget::cmTarget()
 {
@@ -2654,20 +2682,6 @@ void cmTarget::GatherDependencies( const cmMakefile& mf,
     }
 }
 
-//----------------------------------------------------------------------------
-void deleteAndClear(
-      std::vector<cmTargetInternals::IncludeDirectoriesEntry*> &entries)
-{
-  for (std::vector<cmTargetInternals::IncludeDirectoriesEntry*>::const_iterator
-      it = entries.begin(),
-      end = entries.end();
-      it != end; ++it)
-    {
-      delete *it;
-    }
-  entries.clear();
-}
-
 //----------------------------------------------------------------------------
 void cmTarget::SetProperty(const char* prop, const char* value)
 {
@@ -2870,9 +2884,9 @@ std::vector<std::string> cmTarget::GetIncludeDirectories(const char *config)
                             config,
                             debugIncludes);
 
-  std::vector<cmTargetInternals::IncludeDirectoriesEntry*>
+  std::string configString = config ? config : "";
-                                      linkInterfaceIncludeDirectoriesEntries;
+  if (!this->Internal->CacheLinkInterfaceIncludeDirectoriesDone[configString])
-
+    {
     for (std::vector<cmValueWithOrigin>::const_iterator
         it = this->Internal->LinkInterfaceIncludeDirectoriesEntries.begin(),
         end = this->Internal->LinkInterfaceIncludeDirectoriesEntries.end();
@@ -2880,7 +2894,8 @@ std::vector<std::string> cmTarget::GetIncludeDirectories(const char *config)
       {
       {
       cmGeneratorExpression ge(lfbt);
-    cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(it->Value);
+      cmsys::auto_ptr<cmCompiledGeneratorExpression> cge =
+                                                        ge.Parse(it->Value);
       std::string result = cge->Evaluate(this->Makefile, config,
                                         false, this, 0, 0);
       if (!this->Makefile->FindTargetToUse(result.c_str()))
@@ -2890,21 +2905,32 @@ std::vector<std::string> cmTarget::GetIncludeDirectories(const char *config)
       }
       cmGeneratorExpression ge(it->Backtrace);
       cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(
-        "$<TARGET_PROPERTY:" + it->Value + ",INTERFACE_INCLUDE_DIRECTORIES>");
+          "$<TARGET_PROPERTY:" +
+                              it->Value + ",INTERFACE_INCLUDE_DIRECTORIES>");
 
-    linkInterfaceIncludeDirectoriesEntries.push_back(
+      this->Internal->CachedLinkInterfaceIncludeDirectoriesEntries.push_back(
                         new cmTargetInternals::IncludeDirectoriesEntry(cge));
       }
+    }
 
   processIncludeDirectories(this,
-                            linkInterfaceIncludeDirectoriesEntries,
+              this->Internal->CachedLinkInterfaceIncludeDirectoriesEntries,
                             includes,
                             uniqueIncludes,
                             &dagChecker,
                             config,
                             debugIncludes);
 
-  deleteAndClear(linkInterfaceIncludeDirectoriesEntries);
+  if (!this->Makefile->IsGeneratingBuildSystem())
+    {
+    deleteAndClear(
+              this->Internal->CachedLinkInterfaceIncludeDirectoriesEntries);
+    }
+  else
+    {
+    this->Internal->CacheLinkInterfaceIncludeDirectoriesDone[configString]
+                                                                      = true;
+    }
 
   return includes;
 }
@@ -2957,16 +2983,34 @@ std::string cmTarget::GetCompileDefinitions(const char *config)
       }
     }
 
+  std::string configString = config ? config : "";
+  if (!this->Internal->CacheLinkInterfaceCompileDefinitionsDone[configString])
+    {
     cmGeneratorExpression ge2(lfbt);
-  cmsys::auto_ptr<cmCompiledGeneratorExpression> cge2 = ge2.Parse(depString);
+    cmsys::auto_ptr<cmCompiledGeneratorExpression> cge2 =
-  std::string depResult = cge2->Evaluate(this->Makefile,
+                                                        ge2.Parse(depString);
+    this->Internal->CachedLinkInterfaceCompileDefinitions[configString] =
+                                                cge2->Evaluate(this->Makefile,
                                                                config,
                                                                false,
                                                                this,
                                                                &dagChecker);
-  if (!depResult.empty())
+    }
+  if (!this->Internal->CachedLinkInterfaceCompileDefinitions[configString]
+                                                                    .empty())
     {
-    result += (result.empty() ? "" : ";") + depResult;
+    result += (result.empty() ? "" : ";")
+        + this->Internal->CachedLinkInterfaceCompileDefinitions[configString];
+    }
+
+  if (!this->Makefile->IsGeneratingBuildSystem())
+    {
+    this->Internal->CachedLinkInterfaceCompileDefinitions[configString] = "";
+    }
+  else
+    {
+    this->Internal->CacheLinkInterfaceCompileDefinitionsDone[configString]
+                                                                      = true;
     }
 
   return result;