VS: Use 'override' keyword for overridden methods in generator classes

The corresponding 'virtual' removed.

Source/cmGlobalVisualStudio10Generator.h

@@ -18,29 +18,31 @@ public:
                                   const std::string& platformName);
   static cmGlobalGeneratorFactory* NewFactory();
 
-  virtual bool MatchesGeneratorName(const std::string& name) const;
+  bool MatchesGeneratorName(const std::string& name) const override;
 
-  virtual bool SetSystemName(std::string const& s, cmMakefile* mf);
+  bool SetSystemName(std::string const& s, cmMakefile* mf) override;
-  virtual bool SetGeneratorPlatform(std::string const& p, cmMakefile* mf);
+  bool SetGeneratorPlatform(std::string const& p, cmMakefile* mf) override;
-  virtual bool SetGeneratorToolset(std::string const& ts, cmMakefile* mf);
+  bool SetGeneratorToolset(std::string const& ts, cmMakefile* mf) override;
 
-  virtual void GenerateBuildCommand(
+  void GenerateBuildCommand(std::vector<std::string>& makeCommand,
-    std::vector<std::string>& makeCommand, const std::string& makeProgram,
+                            const std::string& makeProgram,
-    const std::string& projectName, const std::string& projectDir,
+                            const std::string& projectName,
-    const std::string& targetName, const std::string& config, bool fast,
+                            const std::string& projectDir,
-    bool verbose,
+                            const std::string& targetName,
-    std::vector<std::string> const& makeOptions = std::vector<std::string>());
+                            const std::string& config, bool fast, bool verbose,
+                            std::vector<std::string> const& makeOptions =
+                              std::vector<std::string>()) override;
 
   ///! create the correct local generator
-  virtual cmLocalGenerator* CreateLocalGenerator(cmMakefile* mf);
+  cmLocalGenerator* CreateLocalGenerator(cmMakefile* mf) override;
 
   /**
    * Try to determine system information such as shared library
    * extension, pthreads, byte order etc.
    */
-  virtual void EnableLanguage(std::vector<std::string> const& languages,
+  void EnableLanguage(std::vector<std::string> const& languages, cmMakefile*,
-                              cmMakefile*, bool optional);
+                      bool optional) override;
-  virtual void WriteSLNHeader(std::ostream& fout);
+  void WriteSLNHeader(std::ostream& fout) override;
 
   bool IsCudaEnabled() const { return this->CudaEnabled; }
 
@@ -87,11 +89,11 @@ public:
   /** Return true if building for WindowsStore */
   bool TargetsWindowsStore() const { return this->SystemIsWindowsStore; }
 
-  virtual const char* GetCMakeCFGIntDir() const { return "$(Configuration)"; }
+  const char* GetCMakeCFGIntDir() const override { return "$(Configuration)"; }
   bool Find64BitTools(cmMakefile* mf);
 
   /** Generate an <output>.rule file path for a given command output.  */
-  virtual std::string GenerateRuleFile(std::string const& output) const;
+  std::string GenerateRuleFile(std::string const& output) const override;
 
   void PathTooLong(cmGeneratorTarget* target, cmSourceFile const* sf,
                    std::string const& sfRel);
@@ -114,7 +116,7 @@ public:
   cmIDEFlagTable const* GetNasmFlagTable() const;
 
 protected:
-  virtual void Generate();
+  void Generate() override;
   virtual bool InitializeSystem(cmMakefile* mf);
   virtual bool InitializeWindows(cmMakefile* mf);
   virtual bool InitializeWindowsCE(cmMakefile* mf);
@@ -128,7 +130,7 @@ protected:
   virtual bool SelectWindowsPhoneToolset(std::string& toolset) const;
   virtual bool SelectWindowsStoreToolset(std::string& toolset) const;
 
-  virtual const char* GetIDEVersion() { return "10.0"; }
+  const char* GetIDEVersion() override { return "10.0"; }
 
   std::string const& GetMSBuildCommand();
 
@@ -174,8 +176,8 @@ private:
   bool MSBuildCommandInitialized;
   cmVisualStudio10ToolsetOptions ToolsetOptions;
   virtual std::string FindMSBuildCommand();
-  virtual std::string FindDevEnvCommand();
+  std::string FindDevEnvCommand() override;
-  virtual std::string GetVSMakeProgram() { return this->GetMSBuildCommand(); }
+  std::string GetVSMakeProgram() override { return this->GetMSBuildCommand(); }
 
   bool PlatformToolsetNeedsDebugEnum;
 
@@ -187,6 +189,6 @@ private:
   bool CudaEnabled;
 
   // We do not use the reload macros for VS >= 10.
-  virtual std::string GetUserMacrosDirectory() { return ""; }
+  std::string GetUserMacrosDirectory() override { return ""; }
 };
 #endif

Source/cmGlobalVisualStudio11Generator.h

@@ -24,15 +24,15 @@ public:
                                   const std::string& platformName);
   static cmGlobalGeneratorFactory* NewFactory();
 
-  virtual bool MatchesGeneratorName(const std::string& name) const;
+  bool MatchesGeneratorName(const std::string& name) const override;
 
-  virtual void WriteSLNHeader(std::ostream& fout);
+  void WriteSLNHeader(std::ostream& fout) override;
 
 protected:
-  virtual bool InitializeWindowsPhone(cmMakefile* mf);
+  bool InitializeWindowsPhone(cmMakefile* mf) override;
-  virtual bool InitializeWindowsStore(cmMakefile* mf);
+  bool InitializeWindowsStore(cmMakefile* mf) override;
-  virtual bool SelectWindowsPhoneToolset(std::string& toolset) const;
+  bool SelectWindowsPhoneToolset(std::string& toolset) const override;
-  virtual bool SelectWindowsStoreToolset(std::string& toolset) const;
+  bool SelectWindowsStoreToolset(std::string& toolset) const override;
 
   // Used to verify that the Desktop toolset for the current generator is
   // installed on the machine.
@@ -43,12 +43,12 @@ protected:
   bool IsWindowsPhoneToolsetInstalled() const;
   bool IsWindowsStoreToolsetInstalled() const;
 
-  virtual const char* GetIDEVersion() { return "11.0"; }
+  const char* GetIDEVersion() override { return "11.0"; }
   bool UseFolderProperty();
   static std::set<std::string> GetInstalledWindowsCESDKs();
 
   /** Return true if the configuration needs to be deployed */
-  virtual bool NeedsDeploy(cmStateEnums::TargetType type) const;
+  bool NeedsDeploy(cmStateEnums::TargetType type) const override;
 
 private:
   class Factory;

Source/cmGlobalVisualStudio12Generator.h

@@ -22,32 +22,32 @@ public:
                                   const std::string& platformName);
   static cmGlobalGeneratorFactory* NewFactory();
 
-  virtual bool MatchesGeneratorName(const std::string& name) const;
+  bool MatchesGeneratorName(const std::string& name) const override;
 
-  virtual void WriteSLNHeader(std::ostream& fout);
+  void WriteSLNHeader(std::ostream& fout) override;
 
   // in Visual Studio 2013 they detached the MSBuild tools version
   // from the .Net Framework version and instead made it have it's own
   // version number
-  virtual const char* GetToolsVersion() { return "12.0"; }
+  const char* GetToolsVersion() override { return "12.0"; }
 protected:
   bool ProcessGeneratorToolsetField(std::string const& key,
                                     std::string const& value) override;
 
-  virtual bool InitializeWindowsPhone(cmMakefile* mf);
+  bool InitializeWindowsPhone(cmMakefile* mf) override;
-  virtual bool InitializeWindowsStore(cmMakefile* mf);
+  bool InitializeWindowsStore(cmMakefile* mf) override;
-  virtual bool SelectWindowsPhoneToolset(std::string& toolset) const;
+  bool SelectWindowsPhoneToolset(std::string& toolset) const override;
-  virtual bool SelectWindowsStoreToolset(std::string& toolset) const;
+  bool SelectWindowsStoreToolset(std::string& toolset) const override;
 
   // Used to verify that the Desktop toolset for the current generator is
   // installed on the machine.
-  virtual bool IsWindowsDesktopToolsetInstalled() const;
+  bool IsWindowsDesktopToolsetInstalled() const override;
 
   // These aren't virtual because we need to check if the selected version
   // of the toolset is installed
   bool IsWindowsPhoneToolsetInstalled() const;
   bool IsWindowsStoreToolsetInstalled() const;
-  virtual const char* GetIDEVersion() { return "12.0"; }
+  const char* GetIDEVersion() override { return "12.0"; }
 private:
   class Factory;
 };

Source/cmGlobalVisualStudio14Generator.h

@@ -22,26 +22,26 @@ public:
                                   const std::string& platformName);
   static cmGlobalGeneratorFactory* NewFactory();
 
-  virtual bool MatchesGeneratorName(const std::string& name) const;
+  bool MatchesGeneratorName(const std::string& name) const override;
 
-  virtual void WriteSLNHeader(std::ostream& fout);
+  void WriteSLNHeader(std::ostream& fout) override;
 
-  virtual const char* GetToolsVersion() { return "14.0"; }
+  const char* GetToolsVersion() override { return "14.0"; }
 protected:
-  virtual bool InitializeWindows(cmMakefile* mf);
+  bool InitializeWindows(cmMakefile* mf) override;
-  virtual bool InitializeWindowsStore(cmMakefile* mf);
+  bool InitializeWindowsStore(cmMakefile* mf) override;
-  virtual bool SelectWindowsStoreToolset(std::string& toolset) const;
+  bool SelectWindowsStoreToolset(std::string& toolset) const override;
 
   // These aren't virtual because we need to check if the selected version
   // of the toolset is installed
   bool IsWindowsStoreToolsetInstalled() const;
 
-  virtual const char* GetIDEVersion() { return "14.0"; }
+  const char* GetIDEVersion() override { return "14.0"; }
   virtual bool SelectWindows10SDK(cmMakefile* mf, bool required);
 
   // Used to verify that the Desktop toolset for the current generator is
   // installed on the machine.
-  virtual bool IsWindowsDesktopToolsetInstalled() const;
+  bool IsWindowsDesktopToolsetInstalled() const override;
 
   std::string GetWindows10SDKVersion();
 

Source/cmGlobalVisualStudio15Generator.h

@@ -22,11 +22,11 @@ public:
                                   const std::string& platformName);
   static cmGlobalGeneratorFactory* NewFactory();
 
-  virtual bool MatchesGeneratorName(const std::string& name) const;
+  bool MatchesGeneratorName(const std::string& name) const override;
 
-  virtual void WriteSLNHeader(std::ostream& fout);
+  void WriteSLNHeader(std::ostream& fout) override;
 
-  virtual const char* GetToolsVersion() { return "15.0"; }
+  const char* GetToolsVersion() override { return "15.0"; }
 
   bool SetGeneratorInstance(std::string const& i, cmMakefile* mf) override;
 
@@ -34,13 +34,13 @@ public:
 
 protected:
   bool InitializeWindows(cmMakefile* mf) override;
-  virtual bool SelectWindowsStoreToolset(std::string& toolset) const;
+  bool SelectWindowsStoreToolset(std::string& toolset) const override;
 
-  virtual const char* GetIDEVersion() { return "15.0"; }
+  const char* GetIDEVersion() override { return "15.0"; }
 
   // Used to verify that the Desktop toolset for the current generator is
   // installed on the machine.
-  virtual bool IsWindowsDesktopToolsetInstalled() const;
+  bool IsWindowsDesktopToolsetInstalled() const override;
 
   // These aren't virtual because we need to check if the selected version
   // of the toolset is installed

Source/cmGlobalVisualStudio71Generator.h

@@ -17,25 +17,24 @@ public:
                                   const std::string& platformName = "");
 
 protected:
-  virtual void WriteSLNFile(std::ostream& fout, cmLocalGenerator* root,
+  void WriteSLNFile(std::ostream& fout, cmLocalGenerator* root,
-                            std::vector<cmLocalGenerator*>& generators);
+                    std::vector<cmLocalGenerator*>& generators) override;
   virtual void WriteSolutionConfigurations(
     std::ostream& fout, std::vector<std::string> const& configs);
-  virtual void WriteProject(std::ostream& fout, const std::string& name,
+  void WriteProject(std::ostream& fout, const std::string& name,
-                            const char* path, const cmGeneratorTarget* t);
+                    const char* path, const cmGeneratorTarget* t) override;
-  virtual void WriteProjectDepends(std::ostream& fout, const std::string& name,
+  void WriteProjectDepends(std::ostream& fout, const std::string& name,
-                                   const char* path,
+                           const char* path,
-                                   cmGeneratorTarget const* t);
+                           cmGeneratorTarget const* t) override;
-  virtual void WriteProjectConfigurations(
+  void WriteProjectConfigurations(
     std::ostream& fout, const std::string& name,
     cmGeneratorTarget const& target, std::vector<std::string> const& configs,
     const std::set<std::string>& configsPartOfDefaultBuild,
-    const std::string& platformMapping = "");
+    const std::string& platformMapping = "") override;
-  virtual void WriteExternalProject(std::ostream& fout,
+  void WriteExternalProject(std::ostream& fout, const std::string& name,
-                                    const std::string& name, const char* path,
+                            const char* path, const char* typeGuid,
-                                    const char* typeGuid,
+                            const std::set<std::string>& depends) override;
-                                    const std::set<std::string>& depends);
+  void WriteSLNHeader(std::ostream& fout) override;
-  virtual void WriteSLNHeader(std::ostream& fout);
 
   // Folders are not supported by VS 7.1.
   virtual bool UseFolderProperty() { return false; }

Source/cmGlobalVisualStudio7Generator.h

@@ -26,11 +26,11 @@ public:
   std::string const& GetPlatformName() const;
 
   ///! Create a local generator appropriate to this Global Generator
-  virtual cmLocalGenerator* CreateLocalGenerator(cmMakefile* mf);
+  cmLocalGenerator* CreateLocalGenerator(cmMakefile* mf) override;
 
-  virtual bool SetSystemName(std::string const& s, cmMakefile* mf);
+  bool SetSystemName(std::string const& s, cmMakefile* mf) override;
 
-  virtual bool SetGeneratorPlatform(std::string const& p, cmMakefile* mf);
+  bool SetGeneratorPlatform(std::string const& p, cmMakefile* mf) override;
 
   /**
    * Utilized by the generator factory to determine if this generator
@@ -48,19 +48,21 @@ public:
    * Try to determine system information such as shared library
    * extension, pthreads, byte order etc.
    */
-  virtual void EnableLanguage(std::vector<std::string> const& languages,
+  void EnableLanguage(std::vector<std::string> const& languages, cmMakefile*,
-                              cmMakefile*, bool optional);
+                      bool optional) override;
 
   /**
    * Try running cmake and building a file. This is used for dynamically
    * loaded commands, not as part of the usual build process.
    */
-  virtual void GenerateBuildCommand(
+  void GenerateBuildCommand(std::vector<std::string>& makeCommand,
-    std::vector<std::string>& makeCommand, const std::string& makeProgram,
+                            const std::string& makeProgram,
-    const std::string& projectName, const std::string& projectDir,
+                            const std::string& projectName,
-    const std::string& targetName, const std::string& config, bool fast,
+                            const std::string& projectDir,
-    bool verbose,
+                            const std::string& targetName,
-    std::vector<std::string> const& makeOptions = std::vector<std::string>());
+                            const std::string& config, bool fast, bool verbose,
+                            std::vector<std::string> const& makeOptions =
+                              std::vector<std::string>()) override;
 
   /**
    * Generate the DSW workspace file.
@@ -71,13 +73,13 @@ public:
   std::string GetGUID(std::string const& name);
 
   /** Append the subdirectory for the given configuration.  */
-  virtual void AppendDirectoryForConfig(const std::string& prefix,
+  void AppendDirectoryForConfig(const std::string& prefix,
-                                        const std::string& config,
+                                const std::string& config,
-                                        const std::string& suffix,
+                                const std::string& suffix,
-                                        std::string& dir);
+                                std::string& dir) override;
 
   ///! What is the configurations directory variable called?
-  virtual const char* GetCMakeCFGIntDir() const
+  const char* GetCMakeCFGIntDir() const override
   {
     return "$(ConfigurationName)";
   }
@@ -103,7 +105,7 @@ public:
   cmIDEFlagTable const* ExtraFlagTable;
 
 protected:
-  virtual void Generate();
+  void Generate() override;
   virtual const char* GetIDEVersion() = 0;
 
   std::string const& GetDevEnvCommand();
@@ -129,7 +131,7 @@ protected:
                                       cmLocalGenerator* root);
   virtual void WriteSLNFooter(std::ostream& fout);
   virtual void WriteSLNHeader(std::ostream& fout) = 0;
-  virtual std::string WriteUtilityDepend(const cmGeneratorTarget* target);
+  std::string WriteUtilityDepend(const cmGeneratorTarget* target) override;
 
   virtual void WriteTargetsToSolution(
     std::ostream& fout, cmLocalGenerator* root,
@@ -170,7 +172,7 @@ private:
   char* IntelProjectVersion;
   std::string DevEnvCommand;
   bool DevEnvCommandInitialized;
-  virtual std::string GetVSMakeProgram() { return this->GetDevEnvCommand(); }
+  std::string GetVSMakeProgram() override { return this->GetDevEnvCommand(); }
 };
 
 #define CMAKE_CHECK_BUILD_SYSTEM_TARGET "ZERO_CHECK"

Source/cmGlobalVisualStudio8Generator.h

@@ -18,42 +18,42 @@ public:
   static cmGlobalGeneratorFactory* NewFactory();
 
   ///! Get the name for the generator.
-  virtual std::string GetName() const { return this->Name; }
+  std::string GetName() const override { return this->Name; }
 
   /** Get the name of the main stamp list file. */
   static std::string GetGenerateStampList();
 
-  virtual void EnableLanguage(std::vector<std::string> const& languages,
+  void EnableLanguage(std::vector<std::string> const& languages, cmMakefile*,
-                              cmMakefile*, bool optional);
+                      bool optional) override;
   virtual void AddPlatformDefinitions(cmMakefile* mf);
 
-  virtual bool SetGeneratorPlatform(std::string const& p, cmMakefile* mf);
+  bool SetGeneratorPlatform(std::string const& p, cmMakefile* mf) override;
 
   /**
    * Override Configure and Generate to add the build-system check
    * target.
    */
-  virtual void Configure();
+  void Configure() override;
 
   /**
    * Where does this version of Visual Studio look for macros for the
    * current user? Returns the empty string if this version of Visual
    * Studio does not implement support for VB macros.
    */
-  virtual std::string GetUserMacrosDirectory();
+  std::string GetUserMacrosDirectory() override;
 
   /**
    * What is the reg key path to "vsmacros" for this version of Visual
    * Studio?
    */
-  virtual std::string GetUserMacrosRegKeyBase();
+  std::string GetUserMacrosRegKeyBase() override;
 
   /** Return true if the target project file should have the option
       LinkLibraryDependencies and link to .sln dependencies. */
-  virtual bool NeedLinkLibraryDependencies(cmGeneratorTarget* target);
+  bool NeedLinkLibraryDependencies(cmGeneratorTarget* target) override;
 
   /** Return true if building for Windows CE */
-  virtual bool TargetsWindowsCE() const
+  bool TargetsWindowsCE() const override
   {
     return !this->WindowsCEVersion.empty();
   }
@@ -62,12 +62,12 @@ public:
   bool IsExpressEdition() const { return this->ExpressEdition; }
 
 protected:
-  virtual void AddExtraIDETargets();
+  void AddExtraIDETargets() override;
-  virtual const char* GetIDEVersion() { return "8.0"; }
+  const char* GetIDEVersion() override { return "8.0"; }
 
-  virtual std::string FindDevEnvCommand();
+  std::string FindDevEnvCommand() override;
 
-  virtual bool VSLinksDependencies() const { return false; }
+  bool VSLinksDependencies() const override { return false; }
 
   bool AddCheckTarget();
 
@@ -75,18 +75,18 @@ protected:
   virtual bool NeedsDeploy(cmStateEnums::TargetType type) const;
 
   static cmIDEFlagTable const* GetExtraFlagTableVS8();
-  virtual void WriteSLNHeader(std::ostream& fout);
+  void WriteSLNHeader(std::ostream& fout) override;
-  virtual void WriteSolutionConfigurations(
+  void WriteSolutionConfigurations(
-    std::ostream& fout, std::vector<std::string> const& configs);
+    std::ostream& fout, std::vector<std::string> const& configs) override;
-  virtual void WriteProjectConfigurations(
+  void WriteProjectConfigurations(
     std::ostream& fout, const std::string& name,
     cmGeneratorTarget const& target, std::vector<std::string> const& configs,
     const std::set<std::string>& configsPartOfDefaultBuild,
-    const std::string& platformMapping = "");
+    const std::string& platformMapping = "") override;
-  virtual bool ComputeTargetDepends();
+  bool ComputeTargetDepends() override;
-  virtual void WriteProjectDepends(std::ostream& fout, const std::string& name,
+  void WriteProjectDepends(std::ostream& fout, const std::string& name,
-                                   const char* path,
+                           const char* path,
-                                   const cmGeneratorTarget* t);
+                           const cmGeneratorTarget* t) override;
 
   bool UseFolderProperty();
 

Source/cmGlobalVisualStudio9Generator.h

@@ -21,23 +21,23 @@ public:
    * Try to determine system information such as shared library
    * extension, pthreads, byte order etc.
    */
-  virtual void WriteSLNHeader(std::ostream& fout);
+  void WriteSLNHeader(std::ostream& fout) override;
 
   /**
    * Where does this version of Visual Studio look for macros for the
    * current user? Returns the empty string if this version of Visual
    * Studio does not implement support for VB macros.
    */
-  virtual std::string GetUserMacrosDirectory();
+  std::string GetUserMacrosDirectory() override;
 
   /**
    * What is the reg key path to "vsmacros" for this version of Visual
    * Studio?
    */
-  virtual std::string GetUserMacrosRegKeyBase();
+  std::string GetUserMacrosRegKeyBase() override;
 
 protected:
-  virtual const char* GetIDEVersion() { return "9.0"; }
+  const char* GetIDEVersion() override { return "9.0"; }
 private:
   class Factory;
   friend class Factory;

Source/cmGlobalVisualStudioGenerator.h

@@ -96,7 +96,7 @@ public:
 
   /** Return true if the generated build tree may contain multiple builds.
       i.e. "Can I build Debug and Release in the same tree?" */
-  virtual bool IsMultiConfig() const { return true; }
+  bool IsMultiConfig() const override { return true; }
 
   /** Return true if building for Windows CE */
   virtual bool TargetsWindowsCE() const { return false; }
@@ -122,8 +122,8 @@ public:
 
   bool FindMakeProgram(cmMakefile*) override;
 
-  virtual std::string ExpandCFGIntDir(const std::string& str,
+  std::string ExpandCFGIntDir(const std::string& str,
-                                      const std::string& config) const;
+                              const std::string& config) const override;
 
   void ComputeTargetObjectDirectory(cmGeneratorTarget* gt) const;
 
@@ -137,7 +137,7 @@ public:
             bool dryRun) override;
 
 protected:
-  virtual void AddExtraIDETargets();
+  void AddExtraIDETargets() override;
 
   // Does this VS version link targets to each other if there are
   // dependencies in the SLN file?  This was done for VS versions
@@ -146,7 +146,7 @@ protected:
 
   virtual const char* GetIDEVersion() = 0;
 
-  virtual bool ComputeTargetDepends();
+  bool ComputeTargetDepends() override;
   class VSDependSet : public std::set<std::string>
   {
   };

Source/cmLocalVisualStudio10Generator.h

@@ -29,13 +29,13 @@ public:
   /**
    * Generate the makefile for this directory.
    */
-  virtual void Generate();
+  void Generate() override;
-  virtual void ReadAndStoreExternalGUID(const std::string& name,
+  void ReadAndStoreExternalGUID(const std::string& name,
-                                        const char* path);
+                                const char* path) override;
 
 protected:
-  virtual const char* ReportErrorLabel() const;
+  const char* ReportErrorLabel() const override;
-  virtual bool CustomCommandUseLocal() const { return true; }
+  bool CustomCommandUseLocal() const override { return true; }
 
 private:
 };

Source/cmLocalVisualStudio7Generator.h

@@ -35,12 +35,12 @@ public:
 
   virtual ~cmLocalVisualStudio7Generator();
 
-  virtual void AddHelperCommands();
+  void AddHelperCommands() override;
 
   /**
    * Generate the makefile for this directory.
    */
-  virtual void Generate();
+  void Generate() override;
 
   enum BuildType
   {
@@ -56,12 +56,12 @@ public:
    */
   void SetBuildType(BuildType, const std::string& name);
 
-  virtual std::string GetTargetDirectory(
+  std::string GetTargetDirectory(
-    cmGeneratorTarget const* target) const;
+    cmGeneratorTarget const* target) const override;
   cmSourceFile* CreateVCProjBuildRule();
   void WriteStampFiles();
-  virtual std::string ComputeLongestObjectDirectory(
+  std::string ComputeLongestObjectDirectory(
-    cmGeneratorTarget const*) const;
+    cmGeneratorTarget const*) const override;
 
   virtual void ReadAndStoreExternalGUID(const std::string& name,
                                         const char* path);

Source/cmLocalVisualStudioGenerator.h

@@ -44,9 +44,9 @@ public:
   virtual std::string ComputeLongestObjectDirectory(
     cmGeneratorTarget const*) const = 0;
 
-  virtual void ComputeObjectFilenames(
+  void ComputeObjectFilenames(
     std::map<cmSourceFile const*, std::string>& mapping,
-    cmGeneratorTarget const* = 0);
+    cmGeneratorTarget const* = 0) override;
 
 protected:
   virtual const char* ReportErrorLabel() const;