cmTarget: Construct with basic information up front

Avoid having partially constructed cmTarget instances around,
except for the special case of GLOBAL_TARGET construction.

Source/cmExportTryCompileFileGenerator.cxx

@@ -77,9 +77,8 @@ std::string cmExportTryCompileFileGenerator::FindTargets(
 
   CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(prop);
 
-  cmTarget dummyHead;
+  cmTarget dummyHead("try_compile_dummy_exe", cmState::EXECUTABLE,
-  dummyHead.SetType(cmState::EXECUTABLE, "try_compile_dummy_exe");
+                     cmTarget::VisibilityNormal, tgt->Target->GetMakefile());
-  dummyHead.SetMakefile(tgt->Target->GetMakefile());
 
   cmGeneratorTarget gDummyHead(&dummyHead, tgt->GetLocalGenerator());
 

Source/cmGlobalGenerator.cxx

@@ -2352,8 +2352,8 @@ cmTarget cmGlobalGenerator::CreateGlobalTarget(
   const char* workingDirectory, bool uses_terminal)
 {
   // Package
-  cmTarget target;
+  cmTarget target(name, cmState::GLOBAL_TARGET, cmTarget::VisibilityNormal,
-  target.SetType(cmState::GLOBAL_TARGET, name);
+                  CM_NULLPTR);
   target.SetProperty("EXCLUDE_FROM_ALL", "TRUE");
 
   std::vector<std::string> no_outputs;

Source/cmMakefile.cxx

@@ -1925,10 +1925,10 @@ cmTarget* cmMakefile::AddNewTarget(cmState::TargetType type,
                                    const std::string& name)
 {
   cmTargets::iterator it =
-    this->Targets.insert(cmTargets::value_type(name, cmTarget())).first;
+    this->Targets
-  cmTarget& target = it->second;
+      .insert(cmTargets::value_type(
-  target.SetType(type, name);
+        name, cmTarget(name, type, cmTarget::VisibilityNormal, this)))
-  target.SetMakefile(this);
+      .first;
   this->GetGlobalGenerator()->IndexTarget(&it->second);
   return &it->second;
 }
@@ -3710,10 +3710,10 @@ cmTarget* cmMakefile::AddImportedTarget(const std::string& name,
                                         cmState::TargetType type, bool global)
 {
   // Create the target.
-  CM_AUTO_PTR<cmTarget> target(new cmTarget);
+  CM_AUTO_PTR<cmTarget> target(
-  target->SetType(type, name);
+    new cmTarget(name, type, global ? cmTarget::VisibilityImportedGlobally
-  target->MarkAsImported(global);
+                                    : cmTarget::VisibilityImported,
-  target->SetMakefile(this);
+                 this));
 
   // Add to the set of available imported targets.
   this->ImportedTargets[name] = target.get();

Source/cmTarget.cxx

@@ -59,15 +59,22 @@ public:
   std::vector<cmListFileBacktrace> LinkImplementationPropertyBacktraces;
 };
 
-cmTarget::cmTarget()
+cmTarget::cmTarget(std::string const& name, cmState::TargetType type,
+                   Visibility vis, cmMakefile* mf)
 {
+  assert(mf || type == cmState::GLOBAL_TARGET);
   this->Makefile = CM_NULLPTR;
   this->HaveInstallRule = false;
   this->DLLPlatform = false;
   this->IsAndroid = false;
-  this->IsImportedTarget = false;
+  this->IsImportedTarget =
-  this->ImportedGloballyVisible = false;
+    (vis == VisibilityImported || vis == VisibilityImportedGlobally);
+  this->ImportedGloballyVisible = vis == VisibilityImportedGlobally;
   this->BuildInterfaceIncludesAppended = false;
+  this->SetType(type, name);
+  if (mf) {
+    this->SetMakefile(mf);
+  }
 }
 
 void cmTarget::SetType(cmState::TargetType type, const std::string& name)
@@ -1071,12 +1078,6 @@ void cmTarget::CheckProperty(const std::string& prop,
   }
 }
 
-void cmTarget::MarkAsImported(bool global)
-{
-  this->IsImportedTarget = true;
-  this->ImportedGloballyVisible = global;
-}
-
 bool cmTarget::HandleLocationPropertyPolicy(cmMakefile* context) const
 {
   if (this->IsImported()) {

Source/cmTarget.h

@@ -63,7 +63,16 @@ private:
 class cmTarget
 {
 public:
-  cmTarget();
+  enum Visibility
+  {
+    VisibilityNormal,
+    VisibilityImported,
+    VisibilityImportedGlobally
+  };
+
+  cmTarget(std::string const& name, cmState::TargetType type, Visibility vis,
+           cmMakefile* mf);
+
   enum CustomCommandType
   {
     PRE_BUILD,
@@ -76,21 +85,13 @@ public:
    */
   cmState::TargetType GetType() const { return this->TargetTypeValue; }
 
-  /**
-   * Set the target type
-   */
-  void SetType(cmState::TargetType f, const std::string& name);
-
-  void MarkAsImported(bool global = false);
-
   ///! Set/Get the name of the target
   const std::string& GetName() const { return this->Name; }
 
   /** Get a copy of this target adapted for the given directory.  */
   cmTarget CopyForDirectory(cmMakefile* mf) const;
 
-  ///! Set the cmMakefile that owns this target
+  /** Get the cmMakefile that owns this target.  */
-  void SetMakefile(cmMakefile* mf);
   cmMakefile* GetMakefile() const { return this->Makefile; }
 
 #define DECLARE_TARGET_POLICY(POLICY)                                         \
@@ -282,6 +283,9 @@ public:
   };
 
 private:
+  void SetType(cmState::TargetType f, const std::string& name);
+  void SetMakefile(cmMakefile* mf);
+
   bool HandleLocationPropertyPolicy(cmMakefile* context) const;
 
   const char* GetSuffixVariableInternal(bool implib) const;