Merge topic 'add-genex-evaluate-utility'

7dcf9cb83c cmGeneratorExpression: Add cmGeneratorExpression::Evaluate utility
c7c59dae82 cmCustomCommandGenerator: Replace generator expression member
c12222db86 cmGeneratorExpression: Remove Evaluate overload by parameter re-ordering
1811411fec cmGeneratorExpression: Move quiet flag to cmCompiledGeneratorExpression
edb0bbd18b cmGeneratorTarget: Remove unused virtual signature of TargetPropertyEntry

Acked-by: Kitware Robot <kwrobot@kitware.com>
Merge-request: !3852

24 files changed, 198 insertions, 274 deletions

diff --git a/Source/cmCustomCommandGenerator.cxx b/Source/cmCustomCommandGenerator.cxx
index ddb855b..7f3e052 100644
--- a/Source/cmCustomCommandGenerator.cxx
+++ b/Source/cmCustomCommandGenerator.cxx
@@ -19,7 +19,7 @@
 
 namespace {
 void AppendPaths(const std::vector<std::string>& inputs,
-                 cmGeneratorExpression& ge, cmLocalGenerator* lg,
+                 cmGeneratorExpression const& ge, cmLocalGenerator* lg,
                  std::string const& config, std::vector<std::string>& output)
 {
   for (std::string const& in : inputs) {
@@ -45,15 +45,15 @@ cmCustomCommandGenerator::cmCustomCommandGenerator(cmCustomCommand const& cc,
   , LG(lg)
   , OldStyle(cc.GetEscapeOldStyle())
   , MakeVars(cc.GetEscapeAllowMakeVars())
-  , GE(new cmGeneratorExpression(cc.GetBacktrace()))
   , EmulatorsWithArguments(cc.GetCommandLines().size())
 {
+  cmGeneratorExpression ge(cc.GetBacktrace());
+
   const cmCustomCommandLines& cmdlines = this->CC.GetCommandLines();
   for (cmCustomCommandLine const& cmdline : cmdlines) {
     cmCustomCommandLine argv;
     for (std::string const& clarg : cmdline) {
-      std::unique_ptr<cmCompiledGeneratorExpression> cge =
-        this->GE->Parse(clarg);
+      std::unique_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(clarg);
       std::string parsed_arg = cge->Evaluate(this->LG, this->Config);
       if (this->CC.GetCommandExpandLists()) {
         cmAppend(argv, cmExpandedList(parsed_arg));
@@ -72,15 +72,14 @@ cmCustomCommandGenerator::cmCustomCommandGenerator(cmCustomCommand const& cc,
     this->CommandLines.push_back(std::move(argv));
   }
 
-  AppendPaths(cc.GetByproducts(), *this->GE, this->LG, this->Config,
+  AppendPaths(cc.GetByproducts(), ge, this->LG, this->Config,
               this->Byproducts);
-  AppendPaths(cc.GetDepends(), *this->GE, this->LG, this->Config,
-              this->Depends);
+  AppendPaths(cc.GetDepends(), ge, this->LG, this->Config, this->Depends);
 
   const std::string& workingdirectory = this->CC.GetWorkingDirectory();
   if (!workingdirectory.empty()) {
     std::unique_ptr<cmCompiledGeneratorExpression> cge =
-      this->GE->Parse(workingdirectory);
+      ge.Parse(workingdirectory);
     this->WorkingDirectory = cge->Evaluate(this->LG, this->Config);
     // Convert working directory to a full path.
     if (!this->WorkingDirectory.empty()) {
@@ -93,11 +92,6 @@ cmCustomCommandGenerator::cmCustomCommandGenerator(cmCustomCommand const& cc,
   this->FillEmulatorsWithArguments();
 }
 
-cmCustomCommandGenerator::~cmCustomCommandGenerator()
-{
-  delete this->GE;
-}
-
 unsigned int cmCustomCommandGenerator::GetNumberOfCommands() const
 {
   return static_cast<unsigned int>(this->CC.GetCommandLines().size());
diff --git a/Source/cmCustomCommandGenerator.h b/Source/cmCustomCommandGenerator.h
index d614302..50f292e 100644
--- a/Source/cmCustomCommandGenerator.h
+++ b/Source/cmCustomCommandGenerator.h
@@ -10,7 +10,6 @@
 #include <vector>
 
 class cmCustomCommand;
-class cmGeneratorExpression;
 class cmLocalGenerator;
 
 class cmCustomCommandGenerator
@@ -20,7 +19,6 @@ class cmCustomCommandGenerator
   cmLocalGenerator* LG;
   bool OldStyle;
   bool MakeVars;
-  cmGeneratorExpression* GE;
   cmCustomCommandLines CommandLines;
   std::vector<std::vector<std::string>> EmulatorsWithArguments;
   std::vector<std::string> Byproducts;
@@ -34,7 +32,6 @@ class cmCustomCommandGenerator
 public:
   cmCustomCommandGenerator(cmCustomCommand const& cc, std::string config,
                            cmLocalGenerator* lg);
-  ~cmCustomCommandGenerator();
   cmCustomCommandGenerator(const cmCustomCommandGenerator&) = delete;
   cmCustomCommandGenerator& operator=(const cmCustomCommandGenerator&) =
     delete;
diff --git a/Source/cmExportFileGenerator.cxx b/Source/cmExportFileGenerator.cxx
index f9a28cd..e142560 100644
--- a/Source/cmExportFileGenerator.cxx
+++ b/Source/cmExportFileGenerator.cxx
@@ -380,7 +380,7 @@ void cmExportFileGenerator::PopulateIncludeDirectoriesInterface(
   this->ReplaceInstallPrefix(dirs);
   std::unique_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(dirs);
   std::string exportDirs =
-    cge->Evaluate(target->GetLocalGenerator(), "", false, target);
+    cge->Evaluate(target->GetLocalGenerator(), "", target);
 
   if (cge->GetHadContextSensitiveCondition()) {
     cmLocalGenerator* lg = target->GetLocalGenerator();
diff --git a/Source/cmExportTryCompileFileGenerator.cxx b/Source/cmExportTryCompileFileGenerator.cxx
index 5631d60..4027d4b 100644
--- a/Source/cmExportTryCompileFileGenerator.cxx
+++ b/Source/cmExportTryCompileFileGenerator.cxx
@@ -74,9 +74,8 @@ std::string cmExportTryCompileFileGenerator::FindTargets(
 
   cmGeneratorTarget gDummyHead(&dummyHead, tgt->GetLocalGenerator());
 
-  std::string result =
-    cge->Evaluate(tgt->GetLocalGenerator(), this->Config, false, &gDummyHead,
-                  tgt, &dagChecker, language);
+  std::string result = cge->Evaluate(tgt->GetLocalGenerator(), this->Config,
+                                     &gDummyHead, &dagChecker, tgt, language);
 
   const std::set<cmGeneratorTarget const*>& allTargets =
     cge->GetAllTargetsSeen();
diff --git a/Source/cmGeneratorExpression.cxx b/Source/cmGeneratorExpression.cxx
index f49ed2c..1f31069 100644
--- a/Source/cmGeneratorExpression.cxx
+++ b/Source/cmGeneratorExpression.cxx
@@ -21,40 +21,56 @@ cmGeneratorExpression::cmGeneratorExpression(cmListFileBacktrace backtrace)
 {
 }
 
+cmGeneratorExpression::~cmGeneratorExpression() = default;
+
 std::unique_ptr<cmCompiledGeneratorExpression> cmGeneratorExpression::Parse(
-  std::string const& input)
+  std::string input) const
 {
   return std::unique_ptr<cmCompiledGeneratorExpression>(
-    new cmCompiledGeneratorExpression(this->Backtrace, input));
+    new cmCompiledGeneratorExpression(this->Backtrace, std::move(input)));
 }
 
 std::unique_ptr<cmCompiledGeneratorExpression> cmGeneratorExpression::Parse(
-  const char* input)
+  const char* input) const
 {
   return this->Parse(std::string(input ? input : ""));
 }
 
-cmGeneratorExpression::~cmGeneratorExpression() = default;
-
-const std::string& cmCompiledGeneratorExpression::Evaluate(
-  cmLocalGenerator* lg, const std::string& config, bool quiet,
-  const cmGeneratorTarget* headTarget,
+std::string cmGeneratorExpression::Evaluate(
+  std::string input, cmLocalGenerator* lg, const std::string& config,
+  cmGeneratorTarget const* headTarget,
   cmGeneratorExpressionDAGChecker* dagChecker,
-  std::string const& language) const
+  cmGeneratorTarget const* currentTarget, std::string const& language)
 {
-  return this->Evaluate(lg, config, quiet, headTarget, headTarget, dagChecker,
+  if (Find(input) != std::string::npos) {
+    cmCompiledGeneratorExpression cge(cmListFileBacktrace(), std::move(input));
+    return cge.Evaluate(lg, config, headTarget, dagChecker, currentTarget,
                         language);
+  }
+  return input;
+}
+
+std::string cmGeneratorExpression::Evaluate(
+  const char* input, cmLocalGenerator* lg, const std::string& config,
+  cmGeneratorTarget const* headTarget,
+  cmGeneratorExpressionDAGChecker* dagChecker,
+  cmGeneratorTarget const* currentTarget, std::string const& language)
+{
+  return input ? Evaluate(std::string(input), lg, config, headTarget,
+                          dagChecker, currentTarget, language)
+               : "";
 }
 
 const std::string& cmCompiledGeneratorExpression::Evaluate(
-  cmLocalGenerator* lg, const std::string& config, bool quiet,
-  const cmGeneratorTarget* headTarget, const cmGeneratorTarget* currentTarget,
+  cmLocalGenerator* lg, const std::string& config,
+  const cmGeneratorTarget* headTarget,
   cmGeneratorExpressionDAGChecker* dagChecker,
-  std::string const& language) const
+  const cmGeneratorTarget* currentTarget, std::string const& language) const
 {
   cmGeneratorExpressionContext context(
-    lg, config, quiet, headTarget, currentTarget ? currentTarget : headTarget,
-    this->EvaluateForBuildsystem, this->Backtrace, language);
+    lg, config, this->Quiet, headTarget,
+    currentTarget ? currentTarget : headTarget, this->EvaluateForBuildsystem,
+    this->Backtrace, language);
 
   return this->EvaluateWithContext(context, dagChecker);
 }
@@ -97,9 +113,10 @@ cmCompiledGeneratorExpression::cmCompiledGeneratorExpression(
   cmListFileBacktrace backtrace, std::string input)
   : Backtrace(std::move(backtrace))
   , Input(std::move(input))
+  , EvaluateForBuildsystem(false)
+  , Quiet(false)
   , HadContextSensitiveCondition(false)
   , HadHeadSensitiveCondition(false)
-  , EvaluateForBuildsystem(false)
 {
   cmGeneratorExpressionLexer l;
   std::vector<cmGeneratorExpressionToken> tokens = l.Tokenize(this->Input);
@@ -377,10 +394,10 @@ void cmCompiledGeneratorExpression::GetMaxLanguageStandard(
 }
 
 const std::string& cmGeneratorExpressionInterpreter::Evaluate(
-  const char* expression, const std::string& property)
+  std::string expression, const std::string& property)
 {
   this->CompiledGeneratorExpression =
-    this->GeneratorExpression.Parse(expression);
+    this->GeneratorExpression.Parse(std::move(expression));
 
   // Specify COMPILE_OPTIONS to DAGchecker, same semantic as COMPILE_FLAGS
   cmGeneratorExpressionDAGChecker dagChecker(
@@ -389,6 +406,12 @@ const std::string& cmGeneratorExpressionInterpreter::Evaluate(
     nullptr);
 
   return this->CompiledGeneratorExpression->Evaluate(
-    this->LocalGenerator, this->Config, false, this->HeadTarget, &dagChecker,
+    this->LocalGenerator, this->Config, this->HeadTarget, &dagChecker, nullptr,
     this->Language);
 }
+
+const std::string& cmGeneratorExpressionInterpreter::Evaluate(
+  const char* expression, const std::string& property)
+{
+  return this->Evaluate(std::string(expression ? expression : ""), property);
+}
diff --git a/Source/cmGeneratorExpression.h b/Source/cmGeneratorExpression.h
index ef76651..de5c705 100644
--- a/Source/cmGeneratorExpression.h
+++ b/Source/cmGeneratorExpression.h
@@ -41,8 +41,22 @@ public:
   cmGeneratorExpression& operator=(cmGeneratorExpression const&) = delete;
 
   std::unique_ptr<cmCompiledGeneratorExpression> Parse(
-    std::string const& input);
-  std::unique_ptr<cmCompiledGeneratorExpression> Parse(const char* input);
+    std::string input) const;
+  std::unique_ptr<cmCompiledGeneratorExpression> Parse(
+    const char* input) const;
+
+  static std::string Evaluate(
+    std::string input, cmLocalGenerator* lg, const std::string& config,
+    cmGeneratorTarget const* headTarget = nullptr,
+    cmGeneratorExpressionDAGChecker* dagChecker = nullptr,
+    cmGeneratorTarget const* currentTarget = nullptr,
+    std::string const& language = std::string());
+  static std::string Evaluate(
+    const char* input, cmLocalGenerator* lg, const std::string& config,
+    cmGeneratorTarget const* headTarget = nullptr,
+    cmGeneratorExpressionDAGChecker* dagChecker = nullptr,
+    cmGeneratorTarget const* currentTarget = nullptr,
+    std::string const& language = std::string());
 
   enum PreprocessContext
   {
@@ -87,15 +101,10 @@ public:
     cmCompiledGeneratorExpression const&) = delete;
 
   const std::string& Evaluate(
-    cmLocalGenerator* lg, const std::string& config, bool quiet = false,
+    cmLocalGenerator* lg, const std::string& config,
     cmGeneratorTarget const* headTarget = nullptr,
-    cmGeneratorTarget const* currentTarget = nullptr,
     cmGeneratorExpressionDAGChecker* dagChecker = nullptr,
-    std::string const& language = std::string()) const;
-  const std::string& Evaluate(
-    cmLocalGenerator* lg, const std::string& config, bool quiet,
-    cmGeneratorTarget const* headTarget,
-    cmGeneratorExpressionDAGChecker* dagChecker,
+    cmGeneratorTarget const* currentTarget = nullptr,
     std::string const& language = std::string()) const;
 
   /** Get set of targets found during evaluations.  */
@@ -135,6 +144,8 @@ public:
     this->EvaluateForBuildsystem = eval;
   }
 
+  void SetQuiet(bool quiet) { this->Quiet = quiet; }
+
   void GetMaxLanguageStandard(cmGeneratorTarget const* tgt,
                               std::map<std::string, std::string>& mapping);
 
@@ -152,6 +163,8 @@ private:
   std::vector<cmGeneratorExpressionEvaluator*> Evaluators;
   const std::string Input;
   bool NeedsEvaluation;
+  bool EvaluateForBuildsystem;
+  bool Quiet;
 
   mutable std::set<cmGeneratorTarget*> DependTargets;
   mutable std::set<cmGeneratorTarget const*> AllTargetsSeen;
@@ -163,7 +176,6 @@ private:
   mutable bool HadContextSensitiveCondition;
   mutable bool HadHeadSensitiveCondition;
   mutable std::set<cmGeneratorTarget const*> SourceSensitiveTargets;
-  bool EvaluateForBuildsystem;
 };
 
 class cmGeneratorExpressionInterpreter
@@ -172,11 +184,11 @@ public:
   cmGeneratorExpressionInterpreter(cmLocalGenerator* localGenerator,
                                    std::string config,
                                    cmGeneratorTarget const* headTarget,
-                                   std::string lang = std::string())
+                                   std::string language = std::string())
     : LocalGenerator(localGenerator)
     , Config(std::move(config))
     , HeadTarget(headTarget)
-    , Language(std::move(lang))
+    , Language(std::move(language))
   {
   }
 
@@ -185,13 +197,10 @@ public:
   cmGeneratorExpressionInterpreter& operator=(
     cmGeneratorExpressionInterpreter const&) = delete;
 
+  const std::string& Evaluate(std::string expression,
+                              const std::string& property);
   const std::string& Evaluate(const char* expression,
                               const std::string& property);
-  const std::string& Evaluate(const std::string& expression,
-                              const std::string& property)
-  {
-    return this->Evaluate(expression.c_str(), property);
-  }
 
 protected:
   cmGeneratorExpression GeneratorExpression;
diff --git a/Source/cmGeneratorExpressionEvaluationFile.cxx b/Source/cmGeneratorExpressionEvaluationFile.cxx
index eb43270..aa2c1a6 100644
--- a/Source/cmGeneratorExpressionEvaluationFile.cxx
+++ b/Source/cmGeneratorExpressionEvaluationFile.cxx
@@ -37,8 +37,8 @@ void cmGeneratorExpressionEvaluationFile::Generate(
 {
   std::string rawCondition = this->Condition->GetInput();
   if (!rawCondition.empty()) {
-    std::string condResult = this->Condition->Evaluate(
-      lg, config, false, nullptr, nullptr, nullptr, lang);
+    std::string condResult =
+      this->Condition->Evaluate(lg, config, nullptr, nullptr, nullptr, lang);
     if (condResult == "0") {
       return;
     }
@@ -54,9 +54,9 @@ void cmGeneratorExpressionEvaluationFile::Generate(
   }
 
   std::string outputFileName = this->OutputFileExpr->Evaluate(
-    lg, config, false, nullptr, nullptr, nullptr, lang);
-  const std::string& outputContent = inputExpression->Evaluate(
-    lg, config, false, nullptr, nullptr, nullptr, lang);
+    lg, config, nullptr, nullptr, nullptr, lang);
+  const std::string& outputContent =
+    inputExpression->Evaluate(lg, config, nullptr, nullptr, nullptr, lang);
 
   if (cmSystemTools::FileIsFullPath(outputFileName)) {
     outputFileName = cmSystemTools::CollapseFullPath(outputFileName);
@@ -100,8 +100,8 @@ void cmGeneratorExpressionEvaluationFile::CreateOutputFile(
   gg->GetEnabledLanguages(enabledLanguages);
 
   for (std::string const& le : enabledLanguages) {
-    std::string name = this->OutputFileExpr->Evaluate(
-      lg, config, false, nullptr, nullptr, nullptr, le);
+    std::string name = this->OutputFileExpr->Evaluate(lg, config, nullptr,
+                                                      nullptr, nullptr, le);
     cmSourceFile* sf = lg->GetMakefile()->GetOrCreateSource(
       name, false, cmSourceFileLocationKind::Known);
     // Tell TraceDependencies that the file is not expected to exist
diff --git a/Source/cmGeneratorExpressionNode.cxx b/Source/cmGeneratorExpressionNode.cxx
index d524867..641cbaf 100644
--- a/Source/cmGeneratorExpressionNode.cxx
+++ b/Source/cmGeneratorExpressionNode.cxx
@@ -45,15 +45,16 @@
 std::string cmGeneratorExpressionNode::EvaluateDependentExpression(
   std::string const& prop, cmLocalGenerator* lg,
   cmGeneratorExpressionContext* context, cmGeneratorTarget const* headTarget,
-  cmGeneratorTarget const* currentTarget,
-  cmGeneratorExpressionDAGChecker* dagChecker)
+  cmGeneratorExpressionDAGChecker* dagChecker,
+  cmGeneratorTarget const* currentTarget)
 {
   cmGeneratorExpression ge(context->Backtrace);
   std::unique_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(prop);
   cge->SetEvaluateForBuildsystem(context->EvaluateForBuildsystem);
+  cge->SetQuiet(context->Quiet);
   std::string result =
-    cge->Evaluate(lg, context->Config, context->Quiet, headTarget,
-                  currentTarget, dagChecker, context->Language);
+    cge->Evaluate(lg, context->Config, headTarget, dagChecker, currentTarget,
+                  context->Language);
   if (cge->GetHadContextSensitiveCondition()) {
     context->HadContextSensitiveCondition = true;
   }
@@ -477,13 +478,13 @@ protected:
       }
 
       return this->EvaluateDependentExpression(
-        expression, context->LG, context, context->HeadTarget,
-        context->CurrentTarget, &dagChecker);
+        expression, context->LG, context, context->HeadTarget, &dagChecker,
+        context->CurrentTarget);
     }
 
     return this->EvaluateDependentExpression(
-      expression, context->LG, context, context->HeadTarget,
-      context->CurrentTarget, dagCheckerParent);
+      expression, context->LG, context, context->HeadTarget, dagCheckerParent,
+      context->CurrentTarget);
   }
 };
 
@@ -1331,7 +1332,7 @@ static const struct TargetPropertyNode : public cmGeneratorExpressionNode
 
     if (!interfacePropertyName.empty()) {
       result = this->EvaluateDependentExpression(result, context->LG, context,
-                                                 target, target, &dagChecker);
+                                                 target, &dagChecker, target);
       std::string linkedTargetsContent = getLinkedTargetsContent(
         target, interfacePropertyName, context, &dagChecker);
       if (!linkedTargetsContent.empty()) {
diff --git a/Source/cmGeneratorExpressionNode.h b/Source/cmGeneratorExpressionNode.h
index 7a36924..13e8484 100644
--- a/Source/cmGeneratorExpressionNode.h
+++ b/Source/cmGeneratorExpressionNode.h
@@ -43,8 +43,8 @@ struct cmGeneratorExpressionNode
   static std::string EvaluateDependentExpression(
     std::string const& prop, cmLocalGenerator* lg,
     cmGeneratorExpressionContext* context, const cmGeneratorTarget* headTarget,
-    const cmGeneratorTarget* currentTarget,
-    cmGeneratorExpressionDAGChecker* dagChecker);
+    cmGeneratorExpressionDAGChecker* dagChecker,
+    const cmGeneratorTarget* currentTarget);
 
   static const cmGeneratorExpressionNode* GetNode(
     const std::string& identifier);
diff --git a/Source/cmGeneratorTarget.cxx b/Source/cmGeneratorTarget.cxx
index 8e3db2b..07578cc 100644
--- a/Source/cmGeneratorTarget.cxx
+++ b/Source/cmGeneratorTarget.cxx
@@ -84,16 +84,10 @@ public:
   virtual ~TargetPropertyEntry() = default;
 
   virtual const std::string& Evaluate(
-    cmLocalGenerator* lg, const std::string& config, bool quiet = false,
-    cmGeneratorTarget const* headTarget = nullptr,
-    cmGeneratorTarget const* currentTarget = nullptr,
-    cmGeneratorExpressionDAGChecker* dagChecker = nullptr,
-    std::string const& language = std::string()) const = 0;
-  virtual const std::string& Evaluate(
-    cmLocalGenerator* lg, const std::string& config, bool quiet,
+    cmLocalGenerator* lg, const std::string& config,
     cmGeneratorTarget const* headTarget,
     cmGeneratorExpressionDAGChecker* dagChecker,
-    std::string const& language = std::string()) const = 0;
+    std::string const& language) const = 0;
 
   virtual cmListFileBacktrace GetBacktrace() const = 0;
   virtual std::string const& GetInput() const = 0;
@@ -113,23 +107,12 @@ public:
   {
   }
 
-  const std::string& Evaluate(
-    cmLocalGenerator* lg, const std::string& config, bool quiet = false,
-    cmGeneratorTarget const* headTarget = nullptr,
-    cmGeneratorTarget const* currentTarget = nullptr,
-    cmGeneratorExpressionDAGChecker* dagChecker = nullptr,
-    std::string const& language = std::string()) const override
-  {
-    return this->ge->Evaluate(lg, config, quiet, headTarget, currentTarget,
-                              dagChecker, language);
-  }
-  const std::string& Evaluate(
-    cmLocalGenerator* lg, const std::string& config, bool quiet,
-    cmGeneratorTarget const* headTarget,
-    cmGeneratorExpressionDAGChecker* dagChecker,
-    std::string const& language = std::string()) const override
+  const std::string& Evaluate(cmLocalGenerator* lg, const std::string& config,
+                              cmGeneratorTarget const* headTarget,
+                              cmGeneratorExpressionDAGChecker* dagChecker,
+                              std::string const& language) const override
   {
-    return this->ge->Evaluate(lg, config, quiet, headTarget, dagChecker,
+    return this->ge->Evaluate(lg, config, headTarget, dagChecker, nullptr,
                               language);
   }
 
@@ -161,15 +144,7 @@ public:
   {
   }
 
-  const std::string& Evaluate(cmLocalGenerator*, const std::string&, bool,
-                              cmGeneratorTarget const*,
-                              cmGeneratorTarget const*,
-                              cmGeneratorExpressionDAGChecker*,
-                              std::string const&) const override
-  {
-    return this->PropertyValue;
-  }
-  const std::string& Evaluate(cmLocalGenerator*, const std::string&, bool,
+  const std::string& Evaluate(cmLocalGenerator*, const std::string&,
                               cmGeneratorTarget const*,
                               cmGeneratorExpressionDAGChecker*,
                               std::string const&) const override
@@ -198,7 +173,7 @@ cmGeneratorTarget::TargetPropertyEntry* CreateTargetPropertyEntry(
     return new TargetPropertyEntryGenex(std::move(cge));
   }
 
-  return new TargetPropertyEntryString(propertyValue, backtrace);
+  return new TargetPropertyEntryString(propertyValue, std::move(backtrace));
 }
 
 void CreatePropertyGeneratorExpressions(
@@ -245,7 +220,7 @@ EvaluatedTargetPropertyEntry EvaluateTargetPropertyEntry(
   cmGeneratorTarget::TargetPropertyEntry* entry)
 {
   EvaluatedTargetPropertyEntry ee(entry->LinkImplItem, entry->GetBacktrace());
-  cmExpandList(entry->Evaluate(thisTarget->GetLocalGenerator(), config, false,
+  cmExpandList(entry->Evaluate(thisTarget->GetLocalGenerator(), config,
                                thisTarget, dagChecker, lang),
                ee.Values);
   if (entry->GetHadContextSensitiveCondition()) {
@@ -512,9 +487,8 @@ std::string cmGeneratorTarget::GetOutputName(
     }
 
     // Now evaluate genex and update the previously-prepared map entry.
-    cmGeneratorExpression ge;
-    std::unique_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(outName);
-    i->second = cge->Evaluate(this->LocalGenerator, config);
+    i->second =
+      cmGeneratorExpression::Evaluate(outName, this->LocalGenerator, config);
   } else if (i->second.empty()) {
     // An empty map entry indicates we have been called recursively
     // from the above block.
@@ -734,9 +708,8 @@ void handleSystemIncludesDep(cmLocalGenerator* lg,
 {
   if (const char* dirs =
         depTgt->GetProperty("INTERFACE_SYSTEM_INCLUDE_DIRECTORIES")) {
-    cmGeneratorExpression ge;
-    cmExpandList(ge.Parse(dirs)->Evaluate(lg, config, false, headTarget,
-                                          depTgt, dagChecker, language),
+    cmExpandList(cmGeneratorExpression::Evaluate(dirs, lg, config, headTarget,
+                                                 dagChecker, depTgt, language),
                  result);
   }
   if (!depTgt->IsImported() || excludeImported) {
@@ -745,9 +718,8 @@ void handleSystemIncludesDep(cmLocalGenerator* lg,
 
   if (const char* dirs =
         depTgt->GetProperty("INTERFACE_INCLUDE_DIRECTORIES")) {
-    cmGeneratorExpression ge;
-    cmExpandList(ge.Parse(dirs)->Evaluate(lg, config, false, headTarget,
-                                          depTgt, dagChecker, language),
+    cmExpandList(cmGeneratorExpression::Evaluate(dirs, lg, config, headTarget,
+                                                 dagChecker, depTgt, language),
                  result);
   }
 }
@@ -1117,9 +1089,9 @@ bool cmGeneratorTarget::IsSystemIncludeDirectory(
 
     std::vector<std::string> result;
     for (std::string const& it : this->Target->GetSystemIncludeDirectories()) {
-      cmGeneratorExpression ge;
-      cmExpandList(ge.Parse(it)->Evaluate(this->LocalGenerator, config, false,
-                                          this, &dagChecker, language),
+      cmExpandList(cmGeneratorExpression::Evaluate(it, this->LocalGenerator,
+                                                   config, this, &dagChecker,
+                                                   nullptr, language),
                    result);
     }
 
@@ -1225,7 +1197,7 @@ std::string cmGeneratorTarget::EvaluateInterfaceProperty(
 
   if (const char* p = this->GetProperty(prop)) {
     result = cmGeneratorExpressionNode::EvaluateDependentExpression(
-      p, context->LG, context, headTarget, this, &dagChecker);
+      p, context->LG, context, headTarget, &dagChecker, this);
   }
 
   if (cmLinkInterfaceLibraries const* iface =
@@ -1315,7 +1287,7 @@ void AddObjectEntries(cmGeneratorTarget const* headTarget,
 
         EvaluatedTargetPropertyEntry ee(lib, lib.Backtrace);
         cmExpandList(cge->Evaluate(headTarget->GetLocalGenerator(), config,
-                                   false, headTarget, dagChecker),
+                                   headTarget, dagChecker),
                      ee.Values);
         if (cge->GetHadContextSensitiveCondition()) {
           ee.ContextDependent = true;
@@ -2543,12 +2515,11 @@ void cmGeneratorTarget::GetAutoUicOptions(std::vector<std::string>& result,
   if (!prop) {
     return;
   }
-  cmGeneratorExpression ge;
 
   cmGeneratorExpressionDAGChecker dagChecker(this, "AUTOUIC_OPTIONS", nullptr,
                                              nullptr);
-  cmExpandList(ge.Parse(prop)->Evaluate(this->LocalGenerator, config, false,
-                                        this, &dagChecker),
+  cmExpandList(cmGeneratorExpression::Evaluate(prop, this->LocalGenerator,
+                                               config, this, &dagChecker),
                result);
 }
 
@@ -2818,7 +2789,8 @@ void cmTargetTraceDependencies::CheckCustomCommand(cmCustomCommand const& cc)
     // Check for target references in generator expressions.
     for (std::string const& cl : cCmdLine) {
       const std::unique_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(cl);
-      cge->Evaluate(this->GeneratorTarget->GetLocalGenerator(), "", true);
+      cge->SetQuiet(true);
+      cge->Evaluate(this->GeneratorTarget->GetLocalGenerator(), "");
       std::set<cmGeneratorTarget*> geTargets = cge->GetTargets();
       targets.insert(geTargets.begin(), geTargets.end());
     }
@@ -5314,9 +5286,9 @@ void cmGeneratorTarget::ExpandLinkItems(
   }
   std::vector<std::string> libs;
   std::unique_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(value);
-  cmExpandList(cge->Evaluate(this->LocalGenerator, config, false, headTarget,
-                             this, &dagChecker),
-               libs);
+  cmExpandList(
+    cge->Evaluate(this->LocalGenerator, config, headTarget, &dagChecker, this),
+    libs);
   this->LookupLinkItems(libs, cge->GetBacktrace(), items);
   hadHeadSensitiveCondition = cge->GetHadHeadSensitiveCondition();
 }
@@ -5579,18 +5551,15 @@ bool cmGeneratorTarget::ComputeOutputDir(const std::string& config,
   // Select an output directory.
   if (const char* config_outdir = this->GetProperty(configProp)) {
     // Use the user-specified per-configuration output directory.
-    cmGeneratorExpression ge;
-    std::unique_ptr<cmCompiledGeneratorExpression> cge =
-      ge.Parse(config_outdir);
-    out = cge->Evaluate(this->LocalGenerator, config);
+    out = cmGeneratorExpression::Evaluate(config_outdir, this->LocalGenerator,
+                                          config);
 
     // Skip per-configuration subdirectory.
     conf.clear();
   } else if (const char* outdir = this->GetProperty(propertyName)) {
     // Use the user-specified output directory.
-    cmGeneratorExpression ge;
-    std::unique_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(outdir);
-    out = cge->Evaluate(this->LocalGenerator, config);
+    out =
+      cmGeneratorExpression::Evaluate(outdir, this->LocalGenerator, config);
 
     // Skip per-configuration subdirectory if the value contained a
     // generator expression.
@@ -5658,18 +5627,15 @@ bool cmGeneratorTarget::ComputePDBOutputDir(const std::string& kind,
   // Select an output directory.
   if (const char* config_outdir = this->GetProperty(configProp)) {
     // Use the user-specified per-configuration output directory.
-    cmGeneratorExpression ge;
-    std::unique_ptr<cmCompiledGeneratorExpression> cge =
-      ge.Parse(config_outdir);
-    out = cge->Evaluate(this->LocalGenerator, config);
+    out = cmGeneratorExpression::Evaluate(config_outdir, this->LocalGenerator,
+                                          config);
 
     // Skip per-configuration subdirectory.
     conf.clear();
   } else if (const char* outdir = this->GetProperty(propertyName)) {
     // Use the user-specified output directory.
-    cmGeneratorExpression ge;
-    std::unique_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(outdir);
-    out = cge->Evaluate(this->LocalGenerator, config);
+    out =
+      cmGeneratorExpression::Evaluate(outdir, this->LocalGenerator, config);
 
     // Skip per-configuration subdirectory if the value contained a
     // generator expression.
@@ -5724,8 +5690,7 @@ bool cmGeneratorTarget::GetRPATH(const std::string& config,
     return false;
   }
 
-  cmGeneratorExpression ge;
-  rpath = ge.Parse(value)->Evaluate(this->LocalGenerator, config);
+  rpath = cmGeneratorExpression::Evaluate(value, this->LocalGenerator, config);
 
   return true;
 }
@@ -6386,7 +6351,7 @@ void cmGeneratorTarget::ComputeLinkImplementationLibraries(
     cmGeneratorExpression ge(*btIt);
     std::unique_ptr<cmCompiledGeneratorExpression> const cge = ge.Parse(*le);
     std::string const& evaluated =
-      cge->Evaluate(this->LocalGenerator, config, false, head, &dagChecker);
+      cge->Evaluate(this->LocalGenerator, config, head, &dagChecker);
     cmExpandList(evaluated, llibs);
     if (cge->GetHadHeadSensitiveCondition()) {
       impl.HadHeadSensitiveCondition = true;
diff --git a/Source/cmGlobalVisualStudio7Generator.cxx b/Source/cmGlobalVisualStudio7Generator.cxx
index 92316d3..7faafba 100644
--- a/Source/cmGlobalVisualStudio7Generator.cxx
+++ b/Source/cmGlobalVisualStudio7Generator.cxx
@@ -663,10 +663,8 @@ std::set<std::string> cmGlobalVisualStudio7Generator::IsPartOfDefaultBuild(
         for (std::string const& i : configs) {
           const char* propertyValue =
             target->Target->GetMakefile()->GetDefinition(propertyName);
-          cmGeneratorExpression ge;
-          std::unique_ptr<cmCompiledGeneratorExpression> cge =
-            ge.Parse(propertyValue);
-          if (cmIsOn(cge->Evaluate(target->GetLocalGenerator(), i))) {
+          if (cmIsOn(cmGeneratorExpression::Evaluate(
+                propertyValue, target->GetLocalGenerator(), i))) {
             activeConfigs.insert(i);
           }
         }
diff --git a/Source/cmGlobalVisualStudio8Generator.cxx b/Source/cmGlobalVisualStudio8Generator.cxx
index 255739d..f25d2e2 100644
--- a/Source/cmGlobalVisualStudio8Generator.cxx
+++ b/Source/cmGlobalVisualStudio8Generator.cxx
@@ -284,11 +284,9 @@ bool cmGlobalVisualStudio8Generator::DeployInhibited(
   cmGeneratorTarget const& target, const char* config) const
 {
   bool rVal = false;
-  if (const char* propStr = target.GetProperty("VS_NO_SOLUTION_DEPLOY")) {
-    cmGeneratorExpression ge;
-    std::unique_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(propStr);
-    std::string prop = cge->Evaluate(target.LocalGenerator, config);
-    rVal = cmIsOn(prop);
+  if (const char* prop = target.GetProperty("VS_NO_SOLUTION_DEPLOY")) {
+    rVal = cmIsOn(
+      cmGeneratorExpression::Evaluate(prop, target.LocalGenerator, config));
   }
   return rVal;
 }
diff --git a/Source/cmGlobalXCodeGenerator.cxx b/Source/cmGlobalXCodeGenerator.cxx
index 643cc99..2c3d3ad 100644
--- a/Source/cmGlobalXCodeGenerator.cxx
+++ b/Source/cmGlobalXCodeGenerator.cxx
@@ -2381,10 +2381,8 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmGeneratorTarget* gtgt,
         std::string attribute = prop.substr(16);
         this->FilterConfigurationAttribute(configName, attribute);
         if (!attribute.empty()) {
-          cmGeneratorExpression ge;
-          std::string processed =
-            ge.Parse(gtgt->GetProperty(prop))
-              ->Evaluate(this->CurrentLocalGenerator, configName);
+          std::string processed = cmGeneratorExpression::Evaluate(
+            gtgt->GetProperty(prop), this->CurrentLocalGenerator, configName);
           buildSettings->AddAttribute(attribute,
                                       this->CreateString(processed));
         }
@@ -3118,10 +3116,9 @@ bool cmGlobalXCodeGenerator::CreateXCodeObjects(
         std::string attribute = var.substr(22);
         this->FilterConfigurationAttribute(config.first, attribute);
         if (!attribute.empty()) {
-          cmGeneratorExpression ge;
-          std::string processed =
-            ge.Parse(this->CurrentMakefile->GetDefinition(var))
-              ->Evaluate(this->CurrentLocalGenerator, config.first);
+          std::string processed = cmGeneratorExpression::Evaluate(
+            this->CurrentMakefile->GetDefinition(var),
+            this->CurrentLocalGenerator, config.first);
           buildSettingsForCfg->AddAttribute(attribute,
                                             this->CreateString(processed));
         }
diff --git a/Source/cmInstallDirectoryGenerator.cxx b/Source/cmInstallDirectoryGenerator.cxx
index 1d8210c..259c7f7 100644
--- a/Source/cmInstallDirectoryGenerator.cxx
+++ b/Source/cmInstallDirectoryGenerator.cxx
@@ -9,8 +9,6 @@
 #include "cmStringAlgorithms.h"
 #include "cmSystemTools.h"
 
-#include <memory>
-
 cmInstallDirectoryGenerator::cmInstallDirectoryGenerator(
   std::vector<std::string> const& dirs, const char* dest,
   const char* file_permissions, const char* dir_permissions,
@@ -64,10 +62,9 @@ void cmInstallDirectoryGenerator::GenerateScriptForConfig(
   std::ostream& os, const std::string& config, Indent indent)
 {
   std::vector<std::string> dirs;
-  cmGeneratorExpression ge;
   for (std::string const& d : this->Directories) {
-    std::unique_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(d);
-    cmExpandList(cge->Evaluate(this->LocalGenerator, config), dirs);
+    cmExpandList(
+      cmGeneratorExpression::Evaluate(d, this->LocalGenerator, config), dirs);
   }
 
   // Make sure all dirs have absolute paths.
@@ -97,6 +94,6 @@ void cmInstallDirectoryGenerator::AddDirectoryInstallRule(
 std::string cmInstallDirectoryGenerator::GetDestination(
   std::string const& config) const
 {
-  cmGeneratorExpression ge;
-  return ge.Parse(this->Destination)->Evaluate(this->LocalGenerator, config);
+  return cmGeneratorExpression::Evaluate(this->Destination,
+                                         this->LocalGenerator, config);
 }
diff --git a/Source/cmInstallFilesGenerator.cxx b/Source/cmInstallFilesGenerator.cxx
index c4048d4..f5b69a5 100644
--- a/Source/cmInstallFilesGenerator.cxx
+++ b/Source/cmInstallFilesGenerator.cxx
@@ -6,8 +6,6 @@
 #include "cmInstallType.h"
 #include "cmStringAlgorithms.h"
 
-#include <memory>
-
 class cmLocalGenerator;
 
 cmInstallFilesGenerator::cmInstallFilesGenerator(
@@ -51,8 +49,8 @@ bool cmInstallFilesGenerator::Compute(cmLocalGenerator* lg)
 std::string cmInstallFilesGenerator::GetDestination(
   std::string const& config) const
 {
-  cmGeneratorExpression ge;
-  return ge.Parse(this->Destination)->Evaluate(this->LocalGenerator, config);
+  return cmGeneratorExpression::Evaluate(this->Destination,
+                                         this->LocalGenerator, config);
 }
 
 void cmInstallFilesGenerator::AddFilesInstallRule(
@@ -82,10 +80,9 @@ void cmInstallFilesGenerator::GenerateScriptForConfig(
   std::ostream& os, const std::string& config, Indent indent)
 {
   std::vector<std::string> files;
-  cmGeneratorExpression ge;
   for (std::string const& f : this->Files) {
-    std::unique_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(f);
-    cmExpandList(cge->Evaluate(this->LocalGenerator, config), files);
+    cmExpandList(
+      cmGeneratorExpression::Evaluate(f, this->LocalGenerator, config), files);
   }
   this->AddFilesInstallRule(os, config, indent, files);
 }
diff --git a/Source/cmInstallScriptGenerator.cxx b/Source/cmInstallScriptGenerator.cxx
index b7b7817..ea29455 100644
--- a/Source/cmInstallScriptGenerator.cxx
+++ b/Source/cmInstallScriptGenerator.cxx
@@ -2,7 +2,6 @@
    file Copyright.txt or https://cmake.org/licensing for details.  */
 #include "cmInstallScriptGenerator.h"
 
-#include <memory>
 #include <ostream>
 #include <vector>
 
@@ -79,11 +78,9 @@ void cmInstallScriptGenerator::GenerateScriptForConfig(
   std::ostream& os, const std::string& config, Indent indent)
 {
   if (this->AllowGenex) {
-    cmGeneratorExpression ge;
-    std::unique_ptr<cmCompiledGeneratorExpression> cge =
-      ge.Parse(this->Script);
     this->AddScriptInstallRule(os, indent,
-                               cge->Evaluate(this->LocalGenerator, config));
+                               cmGeneratorExpression::Evaluate(
+                                 this->Script, this->LocalGenerator, config));
   } else {
     this->AddScriptInstallRule(os, indent, this->Script);
   }
diff --git a/Source/cmInstallTargetGenerator.cxx b/Source/cmInstallTargetGenerator.cxx
index 90b0e1d..0cd04cc 100644
--- a/Source/cmInstallTargetGenerator.cxx
+++ b/Source/cmInstallTargetGenerator.cxx
@@ -4,7 +4,6 @@
 
 #include <cassert>
 #include <map>
-#include <memory>
 #include <set>
 #include <sstream>
 #include <utility>
@@ -375,9 +374,8 @@ void cmInstallTargetGenerator::GetInstallObjectNames(
 std::string cmInstallTargetGenerator::GetDestination(
   std::string const& config) const
 {
-  cmGeneratorExpression ge;
-  return ge.Parse(this->Destination)
-    ->Evaluate(this->Target->GetLocalGenerator(), config);
+  return cmGeneratorExpression::Evaluate(
+    this->Destination, this->Target->GetLocalGenerator(), config);
 }
 
 std::string cmInstallTargetGenerator::GetInstallFilename(
diff --git a/Source/cmJsonObjects.cxx b/Source/cmJsonObjects.cxx
index 52e28d3..79180cb 100644
--- a/Source/cmJsonObjects.cxx
+++ b/Source/cmJsonObjects.cxx
@@ -32,7 +32,6 @@
 #include <functional>
 #include <limits>
 #include <map>
-#include <memory>
 #include <set>
 #include <string>
 #include <unordered_map>
@@ -357,10 +356,8 @@ static Json::Value DumpCTestInfo(cmLocalGenerator* lg, cmTest* testInfo,
   }
 
   // Remove any config specific variables from the output.
-  cmGeneratorExpression ge;
-  auto cge = ge.Parse(command);
-  const std::string& processed = cge->Evaluate(lg, config);
-  result[kCTEST_COMMAND] = processed;
+  result[kCTEST_COMMAND] =
+    cmGeneratorExpression::Evaluate(command, lg, config);
 
   // Build up the list of properties that may have been specified
   Json::Value properties = Json::arrayValue;
@@ -369,9 +366,8 @@ static Json::Value DumpCTestInfo(cmLocalGenerator* lg, cmTest* testInfo,
     entry[kKEY_KEY] = prop.first;
 
     // Remove config variables from the value too.
-    auto cge_value = ge.Parse(prop.second);
-    const std::string& processed_value = cge_value->Evaluate(lg, config);
-    entry[kVALUE_KEY] = processed_value;
+    entry[kVALUE_KEY] =
+      cmGeneratorExpression::Evaluate(prop.second, lg, config);
     properties.append(entry);
   }
   result[kPROPERTIES_KEY] = properties;
diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx
index e059548..93e074d 100644
--- a/Source/cmLocalGenerator.cxx
+++ b/Source/cmLocalGenerator.cxx
@@ -48,7 +48,6 @@
 #include <functional>
 #include <initializer_list>
 #include <iterator>
-#include <memory>
 #include <sstream>
 #include <unordered_set>
 #include <utility>
@@ -925,10 +924,8 @@ void cmLocalGenerator::AddCompileOptions(std::vector<BT<std::string>>& flags,
       // to ON
       if (char const* jmcExprGen =
             target->GetProperty("VS_JUST_MY_CODE_DEBUGGING")) {
-        cmGeneratorExpression ge;
-        std::unique_ptr<cmCompiledGeneratorExpression> cge =
-          ge.Parse(jmcExprGen);
-        std::string isJMCEnabled = cge->Evaluate(this, config);
+        std::string isJMCEnabled =
+          cmGeneratorExpression::Evaluate(jmcExprGen, this, config);
         if (cmIsOn(isJMCEnabled)) {
           std::vector<std::string> optVec = cmExpandedList(jmc);
           std::string jmcFlags;
@@ -1710,11 +1707,8 @@ void cmLocalGenerator::AddLanguageFlags(std::string& flags,
     if (!msvcRuntimeLibraryValue) {
       msvcRuntimeLibraryValue = msvcRuntimeLibraryDefault;
     }
-    cmGeneratorExpression ge;
-    std::unique_ptr<cmCompiledGeneratorExpression> cge =
-      ge.Parse(msvcRuntimeLibraryValue);
-    std::string const msvcRuntimeLibrary =
-      cge->Evaluate(this, config, false, target);
+    std::string const msvcRuntimeLibrary = cmGeneratorExpression::Evaluate(
+      msvcRuntimeLibraryValue, this, config, target);
     if (!msvcRuntimeLibrary.empty()) {
       if (const char* msvcRuntimeLibraryOptions =
             this->Makefile->GetDefinition(
diff --git a/Source/cmLocalNinjaGenerator.cxx b/Source/cmLocalNinjaGenerator.cxx
index 0fe385f..82dc943 100644
--- a/Source/cmLocalNinjaGenerator.cxx
+++ b/Source/cmLocalNinjaGenerator.cxx
@@ -608,12 +608,10 @@ void cmLocalNinjaGenerator::AdditionalCleanFiles()
         this->Makefile->GetProperty("ADDITIONAL_CLEAN_FILES")) {
     std::vector<std::string> cleanFiles;
     {
-      cmGeneratorExpression ge;
-      auto cge = ge.Parse(prop_value);
-      cmExpandList(
-        cge->Evaluate(this,
-                      this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE")),
-        cleanFiles);
+      cmExpandList(cmGeneratorExpression::Evaluate(
+                     prop_value, this,
+                     this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE")),
+                   cleanFiles);
     }
     std::string const& binaryDir = this->GetCurrentBinaryDirectory();
     cmGlobalNinjaGenerator* gg = this->GetGlobalNinjaGenerator();
diff --git a/Source/cmLocalUnixMakefileGenerator3.cxx b/Source/cmLocalUnixMakefileGenerator3.cxx
index a7be04e..1d87e93 100644
--- a/Source/cmLocalUnixMakefileGenerator3.cxx
+++ b/Source/cmLocalUnixMakefileGenerator3.cxx
@@ -1083,12 +1083,10 @@ void cmLocalUnixMakefileGenerator3::AppendDirectoryCleanCommand(
   // Look for additional files registered for cleaning in this directory.
   if (const char* prop_value =
         this->Makefile->GetProperty("ADDITIONAL_CLEAN_FILES")) {
-    cmGeneratorExpression ge;
-    std::unique_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(prop_value);
-    cmExpandList(
-      cge->Evaluate(this,
-                    this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE")),
-      cleanFiles);
+    cmExpandList(cmGeneratorExpression::Evaluate(
+                   prop_value, this,
+                   this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE")),
+                 cleanFiles);
   }
   if (cleanFiles.empty()) {
     return;
diff --git a/Source/cmMakefileTargetGenerator.cxx b/Source/cmMakefileTargetGenerator.cxx
index 482af22..d352f8e 100644
--- a/Source/cmMakefileTargetGenerator.cxx
+++ b/Source/cmMakefileTargetGenerator.cxx
@@ -154,11 +154,10 @@ void cmMakefileTargetGenerator::WriteTargetBuildRules()
   auto evaluatedFiles =
     [this](const char* prop_value) -> std::vector<std::string> {
     std::vector<std::string> files;
-    cmGeneratorExpression ge;
-    std::unique_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(prop_value);
-    cmExpandList(cge->Evaluate(this->LocalGenerator, this->ConfigName, false,
-                               this->GeneratorTarget, nullptr, nullptr),
-                 files);
+    cmExpandList(
+      cmGeneratorExpression::Evaluate(prop_value, this->LocalGenerator,
+                                      this->ConfigName, this->GeneratorTarget),
+      files);
     return files;
   };
 
diff --git a/Source/cmNinjaTargetGenerator.cxx b/Source/cmNinjaTargetGenerator.cxx
index 2ab5adf..613e7aa 100644
--- a/Source/cmNinjaTargetGenerator.cxx
+++ b/Source/cmNinjaTargetGenerator.cxx
@@ -1317,14 +1317,11 @@ void cmNinjaTargetGenerator::AdditionalCleanFiles()
         this->GeneratorTarget->GetProperty("ADDITIONAL_CLEAN_FILES")) {
     cmLocalNinjaGenerator* lg = this->LocalGenerator;
     std::vector<std::string> cleanFiles;
-    {
-      cmGeneratorExpression ge;
-      auto cge = ge.Parse(prop_value);
-      cmExpandList(cge->Evaluate(
-                     lg, this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"),
-                     false, this->GeneratorTarget, nullptr, nullptr),
-                   cleanFiles);
-    }
+    cmExpandList(cmGeneratorExpression::Evaluate(
+                   prop_value, lg,
+                   this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"),
+                   this->GeneratorTarget),
+                 cleanFiles);
     std::string const& binaryDir = lg->GetCurrentBinaryDirectory();
     cmGlobalNinjaGenerator* gg = lg->GetGlobalNinjaGenerator();
     for (std::string const& cleanFile : cleanFiles) {
diff --git a/Source/cmVisualStudio10TargetGenerator.cxx b/Source/cmVisualStudio10TargetGenerator.cxx
index 4b83595..34aac49 100644
--- a/Source/cmVisualStudio10TargetGenerator.cxx
+++ b/Source/cmVisualStudio10TargetGenerator.cxx
@@ -1139,10 +1139,8 @@ void cmVisualStudio10TargetGenerator::WriteProjectConfigurationValues(Elem& e0)
       std::string configType;
       if (const char* vsConfigurationType =
             this->GeneratorTarget->GetProperty("VS_CONFIGURATION_TYPE")) {
-        cmGeneratorExpression ge;
-        std::unique_ptr<cmCompiledGeneratorExpression> cge =
-          ge.Parse(vsConfigurationType);
-        configType = cge->Evaluate(this->LocalGenerator, c);
+        configType = cmGeneratorExpression::Evaluate(vsConfigurationType,
+                                                     this->LocalGenerator, c);
       } else {
         switch (this->GeneratorTarget->GetType()) {
           case cmStateEnums::SHARED_LIBRARY:
@@ -2447,49 +2445,32 @@ void cmVisualStudio10TargetGenerator::WritePathAndIncrementalLinkOptions(
     if (ttype <= cmStateEnums::UTILITY) {
       if (const char* workingDir = this->GeneratorTarget->GetProperty(
             "VS_DEBUGGER_WORKING_DIRECTORY")) {
-        cmGeneratorExpression ge;
-        std::unique_ptr<cmCompiledGeneratorExpression> cge =
-          ge.Parse(workingDir);
-        std::string genWorkingDir =
-          cge->Evaluate(this->LocalGenerator, config);
-
+        std::string genWorkingDir = cmGeneratorExpression::Evaluate(
+          workingDir, this->LocalGenerator, config);
         e1.WritePlatformConfigTag("LocalDebuggerWorkingDirectory", cond,
                                   genWorkingDir);
       }
 
       if (const char* environment =
             this->GeneratorTarget->GetProperty("VS_DEBUGGER_ENVIRONMENT")) {
-        cmGeneratorExpression ge;
-        std::unique_ptr<cmCompiledGeneratorExpression> cge =
-          ge.Parse(environment);
-        std::string genEnvironment =
-          cge->Evaluate(this->LocalGenerator, config);
-
+        std::string genEnvironment = cmGeneratorExpression::Evaluate(
+          environment, this->LocalGenerator, config);
         e1.WritePlatformConfigTag("LocalDebuggerEnvironment", cond,
                                   genEnvironment);
       }
 
       if (const char* debuggerCommand =
             this->GeneratorTarget->GetProperty("VS_DEBUGGER_COMMAND")) {
-
-        cmGeneratorExpression ge;
-        std::unique_ptr<cmCompiledGeneratorExpression> cge =
-          ge.Parse(debuggerCommand);
-        std::string genDebuggerCommand =
-          cge->Evaluate(this->LocalGenerator, config);
-
+        std::string genDebuggerCommand = cmGeneratorExpression::Evaluate(
+          debuggerCommand, this->LocalGenerator, config);
         e1.WritePlatformConfigTag("LocalDebuggerCommand", cond,
                                   genDebuggerCommand);
       }
 
       if (const char* commandArguments = this->GeneratorTarget->GetProperty(
             "VS_DEBUGGER_COMMAND_ARGUMENTS")) {
-        cmGeneratorExpression ge;
-        std::unique_ptr<cmCompiledGeneratorExpression> cge =
-          ge.Parse(commandArguments);
-        std::string genCommandArguments =
-          cge->Evaluate(this->LocalGenerator, config);
-
+        std::string genCommandArguments = cmGeneratorExpression::Evaluate(
+          commandArguments, this->LocalGenerator, config);
         e1.WritePlatformConfigTag("LocalDebuggerCommandArguments", cond,
                                   genCommandArguments);
       }
@@ -3479,22 +3460,16 @@ void cmVisualStudio10TargetGenerator::WriteAntBuildOptions(
 
   if (const char* nativeLibDirectoriesExpression =
         this->GeneratorTarget->GetProperty("ANDROID_NATIVE_LIB_DIRECTORIES")) {
-    cmGeneratorExpression ge;
-    std::unique_ptr<cmCompiledGeneratorExpression> cge =
-      ge.Parse(nativeLibDirectoriesExpression);
-    std::string nativeLibDirs =
-      cge->Evaluate(this->LocalGenerator, configName);
+    std::string nativeLibDirs = cmGeneratorExpression::Evaluate(
+      nativeLibDirectoriesExpression, this->LocalGenerator, configName);
     e2.Element("NativeLibDirectories", nativeLibDirs);
   }
 
   if (const char* nativeLibDependenciesExpression =
         this->GeneratorTarget->GetProperty(
           "ANDROID_NATIVE_LIB_DEPENDENCIES")) {
-    cmGeneratorExpression ge;
-    std::unique_ptr<cmCompiledGeneratorExpression> cge =
-      ge.Parse(nativeLibDependenciesExpression);
-    std::string nativeLibDeps =
-      cge->Evaluate(this->LocalGenerator, configName);
+    std::string nativeLibDeps = cmGeneratorExpression::Evaluate(
+      nativeLibDependenciesExpression, this->LocalGenerator, configName);
     e2.Element("NativeLibDependencies", nativeLibDeps);
   }
 
@@ -3505,11 +3480,8 @@ void cmVisualStudio10TargetGenerator::WriteAntBuildOptions(
 
   if (const char* jarDirectoriesExpression =
         this->GeneratorTarget->GetProperty("ANDROID_JAR_DIRECTORIES")) {
-    cmGeneratorExpression ge;
-    std::unique_ptr<cmCompiledGeneratorExpression> cge =
-      ge.Parse(jarDirectoriesExpression);
-    std::string jarDirectories =
-      cge->Evaluate(this->LocalGenerator, configName);
+    std::string jarDirectories = cmGeneratorExpression::Evaluate(
+      jarDirectoriesExpression, this->LocalGenerator, configName);
     e2.Element("JarDirectories", jarDirectories);
   }