clang-format: format all code as Cpp11

.clang-format

@@ -5,5 +5,4 @@ AlignOperands: false
 AlwaysBreakAfterReturnType: None
 AlwaysBreakAfterDefinitionReturnType: None
 ColumnLimit: 79
-Standard: Cpp03
 ...

Source/CPack/cmCPackGenerator.cxx

@@ -313,7 +313,7 @@ int cmCPackGenerator::InstallProjectViaInstalledDirectories(
     const std::string& tempDir = tempInstallDirectory;
     for (it = installDirectoriesVector.begin();
          it != installDirectoriesVector.end(); ++it) {
-      std::vector<std::pair<std::string, std::string> > symlinkedFiles;
+      std::vector<std::pair<std::string, std::string>> symlinkedFiles;
       cmCPackLogger(cmCPackLog::LOG_DEBUG, "Find files" << std::endl);
       cmsys::Glob gl;
       std::string top = *it;
@@ -377,8 +377,7 @@ int cmCPackGenerator::InstallProjectViaInstalledDirectories(
       }
       /* rebuild symlinks in the installed tree */
       if (!symlinkedFiles.empty()) {
-        std::vector<std::pair<std::string, std::string> >::iterator
-          symlinkedIt;
+        std::vector<std::pair<std::string, std::string>>::iterator symlinkedIt;
         std::string curDir = cmSystemTools::GetCurrentWorkingDirectory();
         std::string goToDir = tempDir;
         goToDir += "/" + subdir;

Source/CTest/cmCTestRunTest.cxx

@@ -64,8 +64,8 @@ bool cmCTestRunTest::CheckOutput()
 
       // Check for TIMEOUT_AFTER_MATCH property.
       if (!this->TestProperties->TimeoutRegularExpressions.empty()) {
-        std::vector<
-          std::pair<cmsys::RegularExpression, std::string> >::iterator regIt;
+        std::vector<std::pair<cmsys::RegularExpression, std::string>>::iterator
+          regIt;
         for (regIt = this->TestProperties->TimeoutRegularExpressions.begin();
              regIt != this->TestProperties->TimeoutRegularExpressions.end();
              ++regIt) {
@@ -163,7 +163,7 @@ bool cmCTestRunTest::EndTest(size_t completed, size_t total, bool started)
   int res =
     started ? this->TestProcess->GetProcessStatus() : cmsysProcess_State_Error;
   int retVal = this->TestProcess->GetExitValue();
-  std::vector<std::pair<cmsys::RegularExpression, std::string> >::iterator
+  std::vector<std::pair<cmsys::RegularExpression, std::string>>::iterator
     passIt;
   bool forceFail = false;
   bool skipped = false;

Source/CTest/cmCTestTestHandler.cxx

@@ -994,8 +994,8 @@ void cmCTestTestHandler::UpdateForFixtures(ListOfTests& tests) const
   // tests array for tests which require that fixture and tests which are
   // setups for that fixture. They are needed at the end to populate
   // dependencies of the cleanup tests in our final list of tests.
-  std::map<std::string, std::vector<size_t> > fixtureRequirements;
-  std::map<std::string, std::vector<size_t> > setupFixturesAdded;
+  std::map<std::string, std::vector<size_t>> fixtureRequirements;
+  std::map<std::string, std::vector<size_t>> setupFixturesAdded;
 
   // Use integer index for iteration because we append to
   // the tests vector as we go
@@ -1150,7 +1150,7 @@ void cmCTestTestHandler::UpdateForFixtures(ListOfTests& tests) const
       // This cleanup test could be part of the original test list that was
       // passed in. It is then possible that no other test requires the
       // fIt fixture, so we have to check for this.
-      std::map<std::string, std::vector<size_t> >::const_iterator cIt =
+      std::map<std::string, std::vector<size_t>>::const_iterator cIt =
         fixtureRequirements.find(fixture);
       if (cIt != fixtureRequirements.end()) {
         const std::vector<size_t>& indices = cIt->second;

Source/CTest/cmCTestTestHandler.h

@@ -110,11 +110,11 @@ public:
     std::vector<std::string> Depends;
     std::vector<std::string> AttachedFiles;
     std::vector<std::string> AttachOnFail;
-    std::vector<std::pair<cmsys::RegularExpression, std::string> >
+    std::vector<std::pair<cmsys::RegularExpression, std::string>>
       ErrorRegularExpressions;
-    std::vector<std::pair<cmsys::RegularExpression, std::string> >
+    std::vector<std::pair<cmsys::RegularExpression, std::string>>
       RequiredRegularExpressions;
-    std::vector<std::pair<cmsys::RegularExpression, std::string> >
+    std::vector<std::pair<cmsys::RegularExpression, std::string>>
       TimeoutRegularExpressions;
     std::map<std::string, std::string> Measurements;
     bool IsInBasedOnREOptions;

Source/cmAlgorithms.h

@@ -120,7 +120,7 @@ struct cmIsPair
 };
 
 template <typename K, typename V>
-struct cmIsPair<std::pair<K, V> >
+struct cmIsPair<std::pair<K, V>>
 {
   enum
   {

Source/cmDepends.cxx

@@ -42,7 +42,7 @@ bool cmDepends::Write(std::ostream& makeDepends, std::ostream& internalDepends)
   std::vector<std::string> pairs;
   cmSystemTools::ExpandListArgument(srcStr, pairs);
 
-  std::map<std::string, std::set<std::string> > dependencies;
+  std::map<std::string, std::set<std::string>> dependencies;
   for (std::vector<std::string>::iterator si = pairs.begin();
        si != pairs.end();) {
     // Get the source and object file.
@@ -53,7 +53,7 @@ bool cmDepends::Write(std::ostream& makeDepends, std::ostream& internalDepends)
     std::string const& obj = *si++;
     dependencies[obj].insert(src);
   }
-  for (std::map<std::string, std::set<std::string> >::const_iterator it =
+  for (std::map<std::string, std::set<std::string>>::const_iterator it =
          dependencies.begin();
        it != dependencies.end(); ++it) {
 

Source/cmELF.h

@@ -64,7 +64,7 @@ public:
   };
 
   /** Represent entire dynamic section header */
-  typedef std::vector<std::pair<long, unsigned long> > DynamicEntryList;
+  typedef std::vector<std::pair<long, unsigned long>> DynamicEntryList;
 
   /** Get the type of the file opened.  */
   FileType GetFileType() const;

Source/cmExecuteProcessCommand.cxx

@@ -32,7 +32,7 @@ bool cmExecuteProcessCommand::InitialPass(std::vector<std::string> const& args,
     this->SetError("called with incorrect number of arguments");
     return false;
   }
-  std::vector<std::vector<const char*> > cmds;
+  std::vector<std::vector<const char*>> cmds;
   std::string arguments;
   bool doing_command = false;
   size_t command_index = 0;

Source/cmExtraCodeBlocksGenerator.cxx

@@ -63,7 +63,7 @@ cmExtraCodeBlocksGenerator::GetFactory()
 void cmExtraCodeBlocksGenerator::Generate()
 {
   // for each sub project in the project create a codeblocks project
-  for (std::map<std::string, std::vector<cmLocalGenerator*> >::const_iterator
+  for (std::map<std::string, std::vector<cmLocalGenerator*>>::const_iterator
          it = this->GlobalGenerator->GetProjectMap().begin();
        it != this->GlobalGenerator->GetProjectMap().end(); ++it) {
     // create a project file
@@ -217,7 +217,7 @@ void cmExtraCodeBlocksGenerator::CreateNewProjectFile(
   Tree tree;
 
   // build tree of virtual folders
-  for (std::map<std::string, std::vector<cmLocalGenerator*> >::const_iterator
+  for (std::map<std::string, std::vector<cmLocalGenerator*>>::const_iterator
          it = this->GlobalGenerator->GetProjectMap().begin();
        it != this->GlobalGenerator->GetProjectMap().end(); ++it) {
     // Collect all files

Source/cmExtraCodeLiteGenerator.cxx

@@ -54,13 +54,13 @@ void cmExtraCodeLiteGenerator::Generate()
   std::string workspaceFileName;
   std::string workspaceSourcePath;
 
-  const std::map<std::string, std::vector<cmLocalGenerator*> >& projectMap =
+  const std::map<std::string, std::vector<cmLocalGenerator*>>& projectMap =
     this->GlobalGenerator->GetProjectMap();
 
   // loop projects and locate the root project.
   // and extract the information for creating the worspace
   // root makefile
-  for (std::map<std::string, std::vector<cmLocalGenerator*> >::const_iterator
+  for (std::map<std::string, std::vector<cmLocalGenerator*>>::const_iterator
          it = projectMap.begin();
        it != projectMap.end(); ++it) {
     const cmMakefile* mf = it->second[0]->GetMakefile();
@@ -165,7 +165,7 @@ std::vector<std::string> cmExtraCodeLiteGenerator::CreateProjectsByProjectMaps(
 {
   std::vector<std::string> retval;
   // for each sub project in the workspace create a codelite project
-  for (std::map<std::string, std::vector<cmLocalGenerator*> >::const_iterator
+  for (std::map<std::string, std::vector<cmLocalGenerator*>>::const_iterator
          it = this->GlobalGenerator->GetProjectMap().begin();
        it != this->GlobalGenerator->GetProjectMap().end(); it++) {
 

Source/cmExtraEclipseCDT4Generator.cxx

@@ -536,7 +536,7 @@ void cmExtraEclipseCDT4Generator::CreateLinksToSubprojects(
   this->AppendLinkedResource(xml, "[Subprojects]", "virtual:/virtual",
                              VirtualFolder);
 
-  for (std::map<std::string, std::vector<cmLocalGenerator*> >::const_iterator
+  for (std::map<std::string, std::vector<cmLocalGenerator*>>::const_iterator
          it = this->GlobalGenerator->GetProjectMap().begin();
        it != this->GlobalGenerator->GetProjectMap().end(); ++it) {
     std::string linkSourceDirectory =

Source/cmExtraSublimeTextGenerator.cxx

@@ -68,7 +68,7 @@ void cmExtraSublimeTextGenerator::Generate()
     "CMAKE_SUBLIME_TEXT_2_ENV_SETTINGS");
 
   // for each sub project in the project create a sublime text 2 project
-  for (std::map<std::string, std::vector<cmLocalGenerator*> >::const_iterator
+  for (std::map<std::string, std::vector<cmLocalGenerator*>>::const_iterator
          it = this->GlobalGenerator->GetProjectMap().begin();
        it != this->GlobalGenerator->GetProjectMap().end(); ++it) {
     // create a project file

Source/cmExtraSublimeTextGenerator.h

@@ -24,7 +24,7 @@ class cmExtraSublimeTextGenerator : public cmExternalMakefileProjectGenerator
 {
 public:
   static cmExternalMakefileProjectGeneratorFactory* GetFactory();
-  typedef std::map<std::string, std::vector<std::string> > MapSourceFileFlags;
+  typedef std::map<std::string, std::vector<std::string>> MapSourceFileFlags;
   cmExtraSublimeTextGenerator();
 
   void Generate() CM_OVERRIDE;

Source/cmFindCommon.h

@@ -112,7 +112,7 @@ protected:
 
   std::vector<std::string> SearchPathSuffixes;
 
-  std::map<PathGroup, std::vector<PathLabel> > PathGroupLabelMap;
+  std::map<PathGroup, std::vector<PathLabel>> PathGroupLabelMap;
   std::vector<PathGroup> PathGroupOrder;
   std::map<std::string, PathLabel> PathLabelStringMap;
   std::map<PathLabel, cmSearchPath> LabeledPaths;

Source/cmGeneratorExpression.cxx

@@ -379,7 +379,7 @@ void cmCompiledGeneratorExpression::GetMaxLanguageStandard(
   const cmGeneratorTarget* tgt, std::map<std::string, std::string>& mapping)
 {
   typedef std::map<cmGeneratorTarget const*,
-                   std::map<std::string, std::string> >
+                   std::map<std::string, std::string>>
     MapType;
   MapType::const_iterator it = this->MaxLanguageStandard.find(tgt);
   if (it != this->MaxLanguageStandard.end()) {

Source/cmGeneratorExpression.h

@@ -143,7 +143,7 @@ private:
   mutable std::set<cmGeneratorTarget const*> AllTargetsSeen;
   mutable std::set<std::string> SeenTargetProperties;
   mutable std::map<cmGeneratorTarget const*,
-                   std::map<std::string, std::string> >
+                   std::map<std::string, std::string>>
     MaxLanguageStandard;
   mutable std::string Output;
   mutable bool HadContextSensitiveCondition;

Source/cmGeneratorExpressionContext.h

@@ -26,7 +26,7 @@ struct cmGeneratorExpressionContext
   std::set<cmGeneratorTarget const*> AllTargets;
   std::set<std::string> SeenTargetProperties;
   std::set<cmGeneratorTarget const*> SourceSensitiveTargets;
-  std::map<cmGeneratorTarget const*, std::map<std::string, std::string> >
+  std::map<cmGeneratorTarget const*, std::map<std::string, std::string>>
     MaxLanguageStandard;
   cmLocalGenerator* LG;
   std::string Config;

Source/cmGeneratorExpressionDAGChecker.cxx

@@ -58,7 +58,7 @@ void cmGeneratorExpressionDAGChecker::Initialize()
         TEST_TRANSITIVE_PROPERTY_METHOD) false)) // NOLINT(clang-tidy)
 #undef TEST_TRANSITIVE_PROPERTY_METHOD
   {
-    std::map<std::string, std::set<std::string> >::const_iterator it =
+    std::map<std::string, std::set<std::string>>::const_iterator it =
       top->Seen.find(this->Target);
     if (it != top->Seen.end()) {
       const std::set<std::string>& propSet = it->second;

Source/cmGeneratorExpressionDAGChecker.h

@@ -82,7 +82,7 @@ private:
   const cmGeneratorExpressionDAGChecker* const Parent;
   const std::string Target;
   const std::string Property;
-  std::map<std::string, std::set<std::string> > Seen;
+  std::map<std::string, std::set<std::string>> Seen;
   const GeneratorExpressionContent* const Content;
   const cmListFileBacktrace Backtrace;
   Result CheckResult;

Source/cmGeneratorExpressionEvaluator.cxx

@@ -25,13 +25,13 @@ std::string GeneratorExpressionContent::ProcessArbitraryContent(
   const cmGeneratorExpressionNode* node, const std::string& identifier,
   cmGeneratorExpressionContext* context,
   cmGeneratorExpressionDAGChecker* dagChecker,
-  std::vector<std::vector<cmGeneratorExpressionEvaluator*> >::const_iterator
+  std::vector<std::vector<cmGeneratorExpressionEvaluator*>>::const_iterator
     pit) const
 {
   std::string result;
 
   const std::vector<
-    std::vector<cmGeneratorExpressionEvaluator*> >::const_iterator pend =
+    std::vector<cmGeneratorExpressionEvaluator*>>::const_iterator pend =
     this->ParamChildren.end();
   for (; pit != pend; ++pit) {
     std::vector<cmGeneratorExpressionEvaluator*>::const_iterator it =
@@ -122,10 +122,10 @@ std::string GeneratorExpressionContent::EvaluateParameters(
 {
   const int numExpected = node->NumExpectedParameters();
   {
-    std::vector<std::vector<cmGeneratorExpressionEvaluator*> >::const_iterator
+    std::vector<std::vector<cmGeneratorExpressionEvaluator*>>::const_iterator
       pit = this->ParamChildren.begin();
     const std::vector<
-      std::vector<cmGeneratorExpressionEvaluator*> >::const_iterator pend =
+      std::vector<cmGeneratorExpressionEvaluator*>>::const_iterator pend =
       this->ParamChildren.end();
     const bool acceptsArbitraryContent =
       node->AcceptsArbitraryContentParameter();
@@ -188,5 +188,5 @@ GeneratorExpressionContent::~GeneratorExpressionContent()
 {
   cmDeleteAll(this->IdentifierChildren);
   std::for_each(this->ParamChildren.begin(), this->ParamChildren.end(),
-                cmDeleteAll<std::vector<cmGeneratorExpressionEvaluator*> >);
+                cmDeleteAll<std::vector<cmGeneratorExpressionEvaluator*>>);
 }

Source/cmGeneratorExpressionEvaluator.h

@@ -71,7 +71,7 @@ struct GeneratorExpressionContent : public cmGeneratorExpressionEvaluator
   }
 
   void SetParameters(
-    std::vector<std::vector<cmGeneratorExpressionEvaluator*> > const&
+    std::vector<std::vector<cmGeneratorExpressionEvaluator*>> const&
       parameters)
   {
     this->ParamChildren = parameters;
@@ -100,12 +100,12 @@ private:
     const cmGeneratorExpressionNode* node, const std::string& identifier,
     cmGeneratorExpressionContext* context,
     cmGeneratorExpressionDAGChecker* dagChecker,
-    std::vector<std::vector<cmGeneratorExpressionEvaluator*> >::const_iterator
+    std::vector<std::vector<cmGeneratorExpressionEvaluator*>>::const_iterator
       pit) const;
 
 private:
   std::vector<cmGeneratorExpressionEvaluator*> IdentifierChildren;
-  std::vector<std::vector<cmGeneratorExpressionEvaluator*> > ParamChildren;
+  std::vector<std::vector<cmGeneratorExpressionEvaluator*>> ParamChildren;
   const char* StartContent;
   size_t ContentLength;
 };

Source/cmGeneratorExpressionNode.cxx

@@ -1320,7 +1320,7 @@ static const struct CompileFeaturesNode : public cmGeneratorExpressionNode
     }
     context->HadHeadSensitiveCondition = true;
 
-    typedef std::map<std::string, std::vector<std::string> > LangMap;
+    typedef std::map<std::string, std::vector<std::string>> LangMap;
     static LangMap availableFeatures;
 
     LangMap testedFeatures;
@@ -1390,7 +1390,7 @@ static const char* targetPolicyWhitelist[] = {
   nullptr
 #define TARGET_POLICY_STRING(POLICY) , #POLICY
 
-    CM_FOR_EACH_TARGET_POLICY(TARGET_POLICY_STRING)
+  CM_FOR_EACH_TARGET_POLICY(TARGET_POLICY_STRING)
 
 #undef TARGET_POLICY_STRING
 };

Source/cmGeneratorExpressionParser.cxx

@@ -97,7 +97,7 @@ void cmGeneratorExpressionParser::ParseGeneratorExpression(
     return;
   }
 
-  std::vector<std::vector<cmGeneratorExpressionEvaluator*> > parameters;
+  std::vector<std::vector<cmGeneratorExpressionEvaluator*>> parameters;
   std::vector<std::vector<cmGeneratorExpressionToken>::const_iterator>
     commaTokens;
   std::vector<cmGeneratorExpressionToken>::const_iterator colonToken;

Source/cmGeneratorTarget.cxx

@@ -749,7 +749,7 @@ bool cmGeneratorTarget::IsSystemIncludeDirectory(
     config_upper = cmSystemTools::UpperCase(config);
   }
 
-  typedef std::map<std::string, std::vector<std::string> > IncludeCacheType;
+  typedef std::map<std::string, std::vector<std::string>> IncludeCacheType;
   IncludeCacheType::const_iterator iter =
     this->SystemIncludesCache.find(config_upper);
 

Source/cmGeneratorTarget.h

@@ -661,7 +661,7 @@ private:
   SourceEntriesType SourceDepends;
   mutable std::map<cmSourceFile const*, std::string> Objects;
   std::set<cmSourceFile const*> ExplicitObjectName;
-  mutable std::map<std::string, std::vector<std::string> > SystemIncludesCache;
+  mutable std::map<std::string, std::vector<std::string>> SystemIncludesCache;
 
   mutable std::string ExportMacro;
 

Source/cmGhsMultiTargetGenerator.cxx

@@ -439,7 +439,7 @@ cmGhsMultiTargetGenerator::GetObjectNames(
   cmLocalGhsMultiGenerator* const localGhsMultiGenerator,
   cmGeneratorTarget* const generatorTarget)
 {
-  std::map<std::string, std::vector<cmSourceFile*> > filenameToSource;
+  std::map<std::string, std::vector<cmSourceFile*>> filenameToSource;
   std::map<cmSourceFile*, std::string> sourceToFilename;
   for (std::vector<cmSourceFile*>::const_iterator sf = objectSources->begin();
        sf != objectSources->end(); ++sf) {
@@ -451,7 +451,7 @@ cmGhsMultiTargetGenerator::GetObjectNames(
   }
 
   std::vector<cmSourceFile*> duplicateSources;
-  for (std::map<std::string, std::vector<cmSourceFile*> >::const_iterator
+  for (std::map<std::string, std::vector<cmSourceFile*>>::const_iterator
          msvSourceI = filenameToSource.begin();
        msvSourceI != filenameToSource.end(); ++msvSourceI) {
     if (msvSourceI->second.size() > 1) {

Source/cmGlobalGenerator.h

@@ -316,7 +316,7 @@ public:
   TargetDependSet const& GetTargetDirectDepends(
     const cmGeneratorTarget* target);
 
-  const std::map<std::string, std::vector<cmLocalGenerator*> >& GetProjectMap()
+  const std::map<std::string, std::vector<cmLocalGenerator*>>& GetProjectMap()
     const
   {
     return this->ProjectMap;
@@ -468,7 +468,7 @@ protected:
   std::vector<cmLocalGenerator*> LocalGenerators;
   cmMakefile* CurrentConfigureMakefile;
   // map from project name to vector of local generators in that project
-  std::map<std::string, std::vector<cmLocalGenerator*> > ProjectMap;
+  std::map<std::string, std::vector<cmLocalGenerator*>> ProjectMap;
 
   // Set of named installation components requested by the project.
   std::set<std::string> InstallComponents;
@@ -580,7 +580,7 @@ private:
   // track targets to issue CMP0068 warning for.
   std::set<std::string> CMP0068WarnTargets;
 
-  mutable std::map<cmSourceFile*, std::set<cmGeneratorTarget const*> >
+  mutable std::map<cmSourceFile*, std::set<cmGeneratorTarget const*>>
     FilenameTargetDepends;
 
 #if defined(CMAKE_BUILD_WITH_CMAKE)

Source/cmGlobalKdevelopGenerator.cxx

@@ -49,7 +49,7 @@ void cmGlobalKdevelopGenerator::Generate()
 {
   // for each sub project in the project create
   // a kdevelop project
-  for (std::map<std::string, std::vector<cmLocalGenerator*> >::const_iterator
+  for (std::map<std::string, std::vector<cmLocalGenerator*>>::const_iterator
          it = this->GlobalGenerator->GetProjectMap().begin();
        it != this->GlobalGenerator->GetProjectMap().end(); ++it) {
     std::string outputDir = it->second[0]->GetCurrentBinaryDirectory();

Source/cmGlobalNinjaGenerator.cxx

@@ -952,7 +952,7 @@ void cmGlobalNinjaGenerator::AddDependencyToAll(const std::string& input)
 
 void cmGlobalNinjaGenerator::WriteAssumedSourceDependencies()
 {
-  for (std::map<std::string, std::set<std::string> >::iterator i =
+  for (std::map<std::string, std::set<std::string>>::iterator i =
          this->AssumedSourceDependencies.begin();
        i != this->AssumedSourceDependencies.end(); ++i) {
     cmNinjaDeps deps;
@@ -1260,7 +1260,7 @@ void cmGlobalNinjaGenerator::WriteUnknownExplicitDependencies(std::ostream& os)
   }
 
   // remove all source files we know will exist.
-  typedef std::map<std::string, std::set<std::string> >::const_iterator map_it;
+  typedef std::map<std::string, std::set<std::string>>::const_iterator map_it;
   for (map_it i = this->AssumedSourceDependencies.begin();
        i != this->AssumedSourceDependencies.end(); ++i) {
     knownDependencies.insert(this->ConvertToNinjaPath(i->first));

Source/cmGlobalNinjaGenerator.h

@@ -446,13 +446,13 @@ private:
   std::set<std::string> CombinedBuildOutputs;
 
   /// The mapping from source file to assumed dependencies.
-  std::map<std::string, std::set<std::string> > AssumedSourceDependencies;
+  std::map<std::string, std::set<std::string>> AssumedSourceDependencies;
 
   typedef std::map<std::string, cmGeneratorTarget*> TargetAliasMap;
   TargetAliasMap TargetAliases;
 
   typedef std::map<cmGeneratorTarget const*,
-                   std::set<cmGeneratorTarget const*> >
+                   std::set<cmGeneratorTarget const*>>
     TargetDependsClosureMap;
   TargetDependsClosureMap TargetDependsClosures;
 

Source/cmGlobalVisualStudio7Generator.cxx

@@ -334,7 +334,7 @@ void cmGlobalVisualStudio7Generator::OutputSLNFile(
 // output the SLN file
 void cmGlobalVisualStudio7Generator::OutputSLNFile()
 {
-  std::map<std::string, std::vector<cmLocalGenerator*> >::iterator it;
+  std::map<std::string, std::vector<cmLocalGenerator*>>::iterator it;
   for (it = this->ProjectMap.begin(); it != this->ProjectMap.end(); ++it) {
     this->OutputSLNFile(it->second[0], it->second);
   }
@@ -467,7 +467,7 @@ void cmGlobalVisualStudio7Generator::WriteFolders(std::ostream& fout)
   const char* prefix = "CMAKE_FOLDER_GUID_";
   const std::string::size_type skip_prefix = strlen(prefix);
   std::string guidProjectTypeFolder = "2150E333-8FDC-42A3-9474-1A3956D46DE8";
-  for (std::map<std::string, std::set<std::string> >::iterator iter =
+  for (std::map<std::string, std::set<std::string>>::iterator iter =
          VisualStudioFolders.begin();
        iter != VisualStudioFolders.end(); ++iter) {
     std::string fullName = iter->first;
@@ -487,7 +487,7 @@ void cmGlobalVisualStudio7Generator::WriteFolders(std::ostream& fout)
 
 void cmGlobalVisualStudio7Generator::WriteFoldersContent(std::ostream& fout)
 {
-  for (std::map<std::string, std::set<std::string> >::iterator iter =
+  for (std::map<std::string, std::set<std::string>>::iterator iter =
          VisualStudioFolders.begin();
        iter != VisualStudioFolders.end(); ++iter) {
     std::string key(iter->first);

Source/cmGlobalVisualStudio7Generator.h

@@ -156,7 +156,7 @@ protected:
 
   virtual void WriteFolders(std::ostream& fout);
   virtual void WriteFoldersContent(std::ostream& fout);
-  std::map<std::string, std::set<std::string> > VisualStudioFolders;
+  std::map<std::string, std::set<std::string>> VisualStudioFolders;
 
   // Set during OutputSLNFile with the name of the current project.
   // There is one SLN file per project.

Source/cmGlobalVisualStudioGenerator.cxx

@@ -58,7 +58,7 @@ void cmGlobalVisualStudioGenerator::AddExtraIDETargets()
   const char* no_working_dir = 0;
   std::vector<std::string> no_depends;
   cmCustomCommandLines no_commands;
-  std::map<std::string, std::vector<cmLocalGenerator*> >::iterator it;
+  std::map<std::string, std::vector<cmLocalGenerator*>>::iterator it;
   for (it = this->ProjectMap.begin(); it != this->ProjectMap.end(); ++it) {
     std::vector<cmLocalGenerator*>& gen = it->second;
     // add the ALL_BUILD to the first local generator of each project
@@ -295,7 +295,7 @@ bool cmGlobalVisualStudioGenerator::ComputeTargetDepends()
   if (!this->cmGlobalGenerator::ComputeTargetDepends()) {
     return false;
   }
-  std::map<std::string, std::vector<cmLocalGenerator*> >::iterator it;
+  std::map<std::string, std::vector<cmLocalGenerator*>>::iterator it;
   for (it = this->ProjectMap.begin(); it != this->ProjectMap.end(); ++it) {
     std::vector<cmLocalGenerator*>& gen = it->second;
     for (std::vector<cmLocalGenerator*>::iterator i = gen.begin();

Source/cmGlobalXCodeGenerator.cxx

@@ -330,7 +330,7 @@ cmLocalGenerator* cmGlobalXCodeGenerator::CreateLocalGenerator(cmMakefile* mf)
 
 void cmGlobalXCodeGenerator::AddExtraIDETargets()
 {
-  std::map<std::string, std::vector<cmLocalGenerator*> >::iterator it;
+  std::map<std::string, std::vector<cmLocalGenerator*>>::iterator it;
   // make sure extra targets are added before calling
   // the parent generate which will call trace depends
   for (it = this->ProjectMap.begin(); it != this->ProjectMap.end(); ++it) {
@@ -347,7 +347,7 @@ void cmGlobalXCodeGenerator::Generate()
   if (cmSystemTools::GetErrorOccuredFlag()) {
     return;
   }
-  std::map<std::string, std::vector<cmLocalGenerator*> >::iterator it;
+  std::map<std::string, std::vector<cmLocalGenerator*>>::iterator it;
   for (it = this->ProjectMap.begin(); it != this->ProjectMap.end(); ++it) {
     cmLocalGenerator* root = it->second[0];
     this->SetGenerationRoot(root);
@@ -1089,7 +1089,7 @@ bool cmGlobalXCodeGenerator::CreateXCodeTargets(
     // framework or bundle targets
     std::vector<cmXCodeObject*> contentBuildPhases;
     if (isFrameworkTarget || isBundleTarget || isCFBundleTarget) {
-      typedef std::map<std::string, std::vector<cmSourceFile*> >
+      typedef std::map<std::string, std::vector<cmSourceFile*>>
         mapOfVectorOfSourceFiles;
       mapOfVectorOfSourceFiles bundleFiles;
       for (std::vector<cmSourceFile*>::const_iterator i = classes.begin();
@@ -1140,7 +1140,7 @@ bool cmGlobalXCodeGenerator::CreateXCodeTargets(
     // create vector of "resource content file" build phases - only for
     // framework or bundle targets
     if (isFrameworkTarget || isBundleTarget || isCFBundleTarget) {
-      typedef std::map<std::string, std::vector<cmSourceFile*> >
+      typedef std::map<std::string, std::vector<cmSourceFile*>>
         mapOfVectorOfSourceFiles;
       mapOfVectorOfSourceFiles bundleFiles;
       for (std::vector<cmSourceFile*>::const_iterator i = classes.begin();
@@ -2924,7 +2924,7 @@ bool cmGlobalXCodeGenerator::CreateXCodeObjects(
     this->CreateObject(cmXCodeObject::XCConfigurationList);
   cmXCodeObject* buildConfigurations =
     this->CreateObject(cmXCodeObject::OBJECT_LIST);
-  typedef std::vector<std::pair<std::string, cmXCodeObject*> > Configs;
+  typedef std::vector<std::pair<std::string, cmXCodeObject*>> Configs;
   Configs configs;
   const char* defaultConfigName = "Debug";
   for (unsigned int i = 0; i < this->CurrentConfigurationTypes.size(); ++i) {

Source/cmLocalGenerator.cxx

@@ -1601,7 +1601,7 @@ void cmLocalGenerator::AddCompilerRequirementFlag(
     return;
   }
 
-  static std::map<std::string, std::vector<std::string> > langStdMap;
+  static std::map<std::string, std::vector<std::string>> langStdMap;
   if (langStdMap.empty()) {
     // Maintain sorted order, most recent first.
     langStdMap["CXX"].push_back("17");

Source/cmLocalNinjaGenerator.h

@@ -105,7 +105,7 @@ private:
 
   std::string HomeRelativeOutputPath;
 
-  typedef std::map<cmCustomCommand const*, std::set<cmGeneratorTarget*> >
+  typedef std::map<cmCustomCommand const*, std::set<cmGeneratorTarget*>>
     CustomCommandTargetMap;
   CustomCommandTargetMap CustomCommandTargets;
   std::vector<cmCustomCommand const*> CustomCommands;

Source/cmParseArgumentsCommand.cxx

@@ -70,7 +70,7 @@ bool cmParseArgumentsCommand::InitialPass(std::vector<std::string> const& args,
   // options, single values and multi values
   typedef std::map<std::string, bool> options_map;
   typedef std::map<std::string, std::string> single_map;
-  typedef std::map<std::string, std::vector<std::string> > multi_map;
+  typedef std::map<std::string, std::vector<std::string>> multi_map;
   options_map options;
   single_map single;
   multi_map multi;

Source/cmQtAutoGeneratorInitializer.cxx

@@ -858,7 +858,7 @@ void cmQtAutoGeneratorInitializer::InitializeAutogenTarget(
 
   // Extract relevant source files
   std::vector<std::string> generatedSources;
-  std::vector<std::pair<std::string, bool> > qrcSources;
+  std::vector<std::pair<std::string, bool>> qrcSources;
   {
     const std::string qrcExt = "qrc";
     std::vector<cmSourceFile*> srcFiles;
@@ -914,7 +914,7 @@ void cmQtAutoGeneratorInitializer::InitializeAutogenTarget(
     const std::string qtMajorVersion = GetQtMajorVersion(target);
     const std::string rccCommand = RccGetExecutable(target, qtMajorVersion);
     const cmFilePathChecksum fpathCheckSum(makefile);
-    for (std::vector<std::pair<std::string, bool> >::const_iterator it =
+    for (std::vector<std::pair<std::string, bool>>::const_iterator it =
            qrcSources.begin();
          it != qrcSources.end(); ++it) {
       const std::string& absFile = it->first;

Source/cmQtAutoGenerators.cxx

@@ -750,8 +750,8 @@ bool cmQtAutoGenerators::RunAutogen()
   // key = moc source filepath, value = moc output filepath
   std::map<std::string, std::string> mocsIncluded;
   std::map<std::string, std::string> mocsNotIncluded;
-  std::map<std::string, std::set<std::string> > mocDepends;
-  std::map<std::string, std::vector<std::string> > uisIncluded;
+  std::map<std::string, std::set<std::string>> mocDepends;
+  std::map<std::string, std::vector<std::string>> uisIncluded;
   // collects all headers which may need to be mocced
   std::set<std::string> mocHeaderFiles;
   std::set<std::string> uicHeaderFiles;
@@ -828,7 +828,7 @@ bool cmQtAutoGenerators::MocRequired(const std::string& contentText,
 
 void cmQtAutoGenerators::MocFindDepends(
   const std::string& absFilename, const std::string& contentText,
-  std::map<std::string, std::set<std::string> >& mocDepends)
+  std::map<std::string, std::set<std::string>>& mocDepends)
 {
   for (std::vector<MocDependFilter>::iterator fit =
          this->MocDependFilters.begin();
@@ -899,8 +899,8 @@ bool cmQtAutoGenerators::UicSkip(const std::string& absFilename) const
 bool cmQtAutoGenerators::ParseSourceFile(
   const std::string& absFilename,
   std::map<std::string, std::string>& mocsIncluded,
-  std::map<std::string, std::set<std::string> >& mocDepends,
-  std::map<std::string, std::vector<std::string> >& uisIncluded, bool relaxed)
+  std::map<std::string, std::set<std::string>>& mocDepends,
+  std::map<std::string, std::vector<std::string>>& uisIncluded, bool relaxed)
 {
   std::string contentText;
   bool success = ReadAll(contentText, absFilename);
@@ -931,7 +931,7 @@ bool cmQtAutoGenerators::ParseSourceFile(
 
 void cmQtAutoGenerators::UicParseContent(
   const std::string& absFilename, const std::string& contentText,
-  std::map<std::string, std::vector<std::string> >& uisIncluded)
+  std::map<std::string, std::vector<std::string>>& uisIncluded)
 {
   if (this->Verbose) {
     this->LogInfo("AutoUic: Checking " + absFilename);
@@ -952,7 +952,7 @@ void cmQtAutoGenerators::UicParseContent(
 bool cmQtAutoGenerators::MocParseSourceContent(
   const std::string& absFilename, const std::string& contentText,
   std::map<std::string, std::string>& mocsIncluded,
-  std::map<std::string, std::set<std::string> >& mocDepends, bool relaxed)
+  std::map<std::string, std::set<std::string>>& mocDepends, bool relaxed)
 {
   if (this->Verbose) {
     this->LogInfo("AutoMoc: Checking " + absFilename);
@@ -1148,7 +1148,7 @@ bool cmQtAutoGenerators::MocParseSourceContent(
 void cmQtAutoGenerators::MocParseHeaderContent(
   const std::string& absFilename, const std::string& contentText,
   std::map<std::string, std::string>& mocsNotIncluded,
-  std::map<std::string, std::set<std::string> >& mocDepends)
+  std::map<std::string, std::set<std::string>>& mocDepends)
 {
   // Log
   if (this->Verbose) {
@@ -1196,8 +1196,8 @@ bool cmQtAutoGenerators::ParseHeaders(
   const std::set<std::string>& uicHeaderFiles,
   const std::map<std::string, std::string>& mocsIncluded,
   std::map<std::string, std::string>& mocsNotIncluded,
-  std::map<std::string, std::set<std::string> >& mocDepends,
-  std::map<std::string, std::vector<std::string> >& uisIncluded)
+  std::map<std::string, std::set<std::string>>& mocDepends,
+  std::map<std::string, std::vector<std::string>>& uisIncluded)
 {
   bool success = true;
   // Merged header files list to read files only once
@@ -1235,7 +1235,7 @@ bool cmQtAutoGenerators::ParseHeaders(
 bool cmQtAutoGenerators::MocGenerateAll(
   const std::map<std::string, std::string>& mocsIncluded,
   const std::map<std::string, std::string>& mocsNotIncluded,
-  const std::map<std::string, std::set<std::string> >& mocDepends)
+  const std::map<std::string, std::set<std::string>>& mocDepends)
 {
   if (!this->MocEnabled()) {
     return true;
@@ -1375,7 +1375,7 @@ bool cmQtAutoGenerators::MocGenerateAll(
  */
 bool cmQtAutoGenerators::MocGenerateFile(
   const std::string& sourceFile, const std::string& mocFileName,
-  const std::map<std::string, std::set<std::string> >& mocDepends,
+  const std::map<std::string, std::set<std::string>>& mocDepends,
   bool included)
 {
   bool mocGenerated = false;
@@ -1391,7 +1391,7 @@ bool cmQtAutoGenerators::MocGenerateFile(
     generateMoc = FileAbsentOrOlder(mocFileAbs, sourceFile);
     if (!generateMoc) {
       // Test if a dependency file changed
-      std::map<std::string, std::set<std::string> >::const_iterator dit =
+      std::map<std::string, std::set<std::string>>::const_iterator dit =
         mocDepends.find(sourceFile);
       if (dit != mocDepends.end()) {
         for (std::set<std::string>::const_iterator fit = dit->second.begin();
@@ -1523,19 +1523,19 @@ bool cmQtAutoGenerators::UicFindIncludedFile(std::string& absFile,
 }
 
 bool cmQtAutoGenerators::UicGenerateAll(
-  const std::map<std::string, std::vector<std::string> >& uisIncluded)
+  const std::map<std::string, std::vector<std::string>>& uisIncluded)
 {
   if (!this->UicEnabled()) {
     return true;
   }
 
   // single map with input / output names
-  std::map<std::string, std::map<std::string, std::string> > sourceGenMap;
+  std::map<std::string, std::map<std::string, std::string>> sourceGenMap;
   {
     // Collision lookup map
     std::map<std::string, std::string> testMap;
     // Compile maps
-    for (std::map<std::string, std::vector<std::string> >::const_iterator sit =
+    for (std::map<std::string, std::vector<std::string>>::const_iterator sit =
            uisIncluded.begin();
          sit != uisIncluded.end(); ++sit) {
       const std::string& source(sit->first);
@@ -1576,7 +1576,7 @@ bool cmQtAutoGenerators::UicGenerateAll(
 
   // generate ui files
   for (std::map<std::string,
-                std::map<std::string, std::string> >::const_iterator it =
+                std::map<std::string, std::string>>::const_iterator it =
          sourceGenMap.begin();
        it != sourceGenMap.end(); ++it) {
     for (std::map<std::string, std::string>::const_iterator sit =

Source/cmQtAutoGenerators.h

@@ -62,7 +62,7 @@ private:
                    std::string* macroName = nullptr);
   void MocFindDepends(
     const std::string& absFilename, const std::string& contentText,
-    std::map<std::string, std::set<std::string> >& mocDepends);
+    std::map<std::string, std::set<std::string>>& mocDepends);
 
   bool MocSkip(const std::string& absFilename) const;
   bool UicSkip(const std::string& absFilename) const;
@@ -70,8 +70,8 @@ private:
   bool ParseSourceFile(
     const std::string& absFilename,
     std::map<std::string, std::string>& mocsIncluded,
-    std::map<std::string, std::set<std::string> >& mocDepends,
-    std::map<std::string, std::vector<std::string> >& includedUis,
+    std::map<std::string, std::set<std::string>>& mocDepends,
+    std::map<std::string, std::vector<std::string>>& includedUis,
     bool relaxed);
 
   void SearchHeadersForSourceFile(const std::string& absFilename,
@@ -83,31 +83,31 @@ private:
     const std::set<std::string>& uicHeaderFiles,
     const std::map<std::string, std::string>& mocsIncluded,
     std::map<std::string, std::string>& mocsNotIncluded,
-    std::map<std::string, std::set<std::string> >& mocDepends,
-    std::map<std::string, std::vector<std::string> >& includedUis);
+    std::map<std::string, std::set<std::string>>& mocDepends,
+    std::map<std::string, std::vector<std::string>>& includedUis);
 
   void UicParseContent(
     const std::string& fileName, const std::string& contentText,
-    std::map<std::string, std::vector<std::string> >& includedUis);
+    std::map<std::string, std::vector<std::string>>& includedUis);
 
   bool MocParseSourceContent(
     const std::string& absFilename, const std::string& contentText,
     std::map<std::string, std::string>& mocsIncluded,
-    std::map<std::string, std::set<std::string> >& mocDepends, bool relaxed);
+    std::map<std::string, std::set<std::string>>& mocDepends, bool relaxed);
 
   void MocParseHeaderContent(
     const std::string& absFilename, const std::string& contentText,
     std::map<std::string, std::string>& mocsNotIncluded,
-    std::map<std::string, std::set<std::string> >& mocDepends);
+    std::map<std::string, std::set<std::string>>& mocDepends);
 
   // -- Moc file generation
   bool MocGenerateAll(
     const std::map<std::string, std::string>& mocsIncluded,
     const std::map<std::string, std::string>& mocsNotIncluded,
-    const std::map<std::string, std::set<std::string> >& mocDepends);
+    const std::map<std::string, std::set<std::string>>& mocDepends);
   bool MocGenerateFile(
     const std::string& sourceFile, const std::string& mocFileName,
-    const std::map<std::string, std::set<std::string> >& mocDepends,
+    const std::map<std::string, std::set<std::string>>& mocDepends,
     bool included);
 
   // -- Uic file generation
@@ -115,7 +115,7 @@ private:
                            const std::string& searchPath,
                            const std::string& searchFile);
   bool UicGenerateAll(
-    const std::map<std::string, std::vector<std::string> >& includedUis);
+    const std::map<std::string, std::vector<std::string>>& includedUis);
   bool UicGenerateFile(const std::string& realName,
                        const std::string& uiInputFile,
                        const std::string& uiOutputFile);
@@ -216,7 +216,7 @@ private:
   bool RccRunFailed;
   std::vector<std::string> RccSources;
   std::map<std::string, std::string> RccOptions;
-  std::map<std::string, std::vector<std::string> > RccInputs;
+  std::map<std::string, std::vector<std::string>> RccInputs;
 };
 
 #endif

Source/cmServer.h

@@ -62,7 +62,7 @@ public:
   void OnDisconnect(cmConnection* pConnection);
 
 protected:
-  std::vector<std::unique_ptr<cmConnection> > Connections;
+  std::vector<std::unique_ptr<cmConnection>> Connections;
 
   bool ServeThreadRunning = false;
   uv_thread_t ServeThread;

Source/cmServerProtocol.cxx

@@ -591,7 +591,7 @@ public:
   std::string Language;
   std::string Flags;
   std::vector<std::string> Defines;
-  std::vector<std::pair<std::string, bool> > IncludePathList;
+  std::vector<std::pair<std::string, bool>> IncludePathList;
 };
 
 bool LanguageData::operator==(const LanguageData& other) const
@@ -686,7 +686,7 @@ static Json::Value DumpSourceFilesList(
   std::vector<cmSourceFile*> files;
   target->GetSourceFiles(files, config);
 
-  std::unordered_map<LanguageData, std::vector<std::string> > fileGroups;
+  std::unordered_map<LanguageData, std::vector<std::string>> fileGroups;
   for (cmSourceFile* file : files) {
     LanguageData fileData;
     fileData.Language = file->GetLanguage();

Source/cmTarget.cxx

@@ -714,7 +714,7 @@ void cmTarget::GetTllSignatureTraces(std::ostream& s, TLLSignature sig) const
   const char* sigString =
     (sig == cmTarget::KeywordTLLSignature ? "keyword" : "plain");
   s << "The uses of the " << sigString << " signature are here:\n";
-  typedef std::vector<std::pair<TLLSignature, cmListFileContext> > Container;
+  typedef std::vector<std::pair<TLLSignature, cmListFileContext>> Container;
   cmOutputConverter converter(this->GetMakefile()->GetStateSnapshot());
   for (Container::const_iterator it = this->TLLCommands.begin();
        it != this->TLLCommands.end(); ++it) {

Source/cmTarget.h

@@ -297,7 +297,7 @@ private:
   std::vector<cmCustomCommand> PreBuildCommands;
   std::vector<cmCustomCommand> PreLinkCommands;
   std::vector<cmCustomCommand> PostBuildCommands;
-  std::vector<std::pair<TLLSignature, cmListFileContext> > TLLCommands;
+  std::vector<std::pair<TLLSignature, cmListFileContext>> TLLCommands;
   LinkLibraryVectorType OriginalLinkLibraries;
   cmMakefile* Makefile;
   cmTargetInternalPointer Internal;

Source/cmVisualStudio10TargetGenerator.cxx

@@ -642,7 +642,7 @@ void cmVisualStudio10TargetGenerator::WriteDotNetReferences()
         this->WriteDotNetReference(*ri, "");
       }
     }
-    for (std::vector<std::pair<std::string, std::string> >::const_iterator i =
+    for (std::vector<std::pair<std::string, std::string>>::const_iterator i =
            hintReferences.begin();
          i != hintReferences.end(); ++i) {
       this->WriteDotNetReference(i->first, i->second);

Source/cmXMLWriter.h

@@ -107,7 +107,7 @@ private:
 
 private:
   std::ostream& Output;
-  std::stack<std::string, std::vector<std::string> > Elements;
+  std::stack<std::string, std::vector<std::string>> Elements;
   std::string IndentationElement;
   std::size_t Level;
   bool ElementOpen;

Tests/CompileFeatures/cxx_digit_separators.cpp

@@ -1,5 +1,6 @@
 
 int someFunc()
 {
-  int one_thousand = 1'000; return one_thousand - 1000;
+  int one_thousand = 1'000;
+  return one_thousand - 1000;
 }

Tests/CompileFeatures/cxx_raw_string_literals.cpp

@@ -1,7 +1,7 @@
 
 void someFunc()
 {
-const char p[] = R"(a\
+  const char p[] = R"(a\
 b
 c)";
 }

Tests/CompileFeatures/cxx_variadic_templates.cpp

@@ -35,7 +35,7 @@ struct eval
 };
 
 template <template <typename...> class T, typename... U>
-struct eval<T<U...> >
+struct eval<T<U...>>
 {
   enum
   {
@@ -62,11 +62,11 @@ struct D
 
 // Note: This test assumes that a compiler supporting this feature
 // supports static_assert. Add a workaround if that does not hold.
-static_assert(eval<A<> >::Matched, "A Matches");
-static_assert(eval<A<int> >::Matched, "A Matches");
-static_assert(eval<A<int, char> >::Matched, "A Matches");
-static_assert(eval<B<int> >::Matched, "B Matches");
-static_assert(eval<C<int, char> >::Matched, "C Matches");
-static_assert(eval<D<int, char> >::Matched, "D Matches");
-static_assert(eval<D<int, char, bool> >::Matched, "D Matches");
-static_assert(eval<D<int, char, bool, double> >::Matched, "D Matches");
+static_assert(eval<A<>>::Matched, "A Matches");
+static_assert(eval<A<int>>::Matched, "A Matches");
+static_assert(eval<A<int, char>>::Matched, "A Matches");
+static_assert(eval<B<int>>::Matched, "B Matches");
+static_assert(eval<C<int, char>>::Matched, "C Matches");
+static_assert(eval<D<int, char>>::Matched, "D Matches");
+static_assert(eval<D<int, char, bool>>::Matched, "D Matches");
+static_assert(eval<D<int, char, bool, double>>::Matched, "D Matches");

Tests/Cuda/.clang-format

@@ -1,9 +0,0 @@
----
-# This configuration requires clang-format 3.8 or higher.
-BasedOnStyle: Mozilla
-AlignOperands: false
-AlwaysBreakAfterReturnType: None
-AlwaysBreakAfterDefinitionReturnType: None
-ColumnLimit: 79
-Standard: Cpp11
-...

Tests/CudaOnly/.clang-format

@@ -1,9 +0,0 @@
----
-# This configuration requires clang-format 3.8 or higher.
-BasedOnStyle: Mozilla
-AlignOperands: false
-AlwaysBreakAfterReturnType: None
-AlwaysBreakAfterDefinitionReturnType: None
-ColumnLimit: 79
-Standard: Cpp11
-...