[clang-tidy-vs] Visual Studio plugin extended

[• jutocz]

Summary

Extending clang-tidy Visual Studio plugin functionality:

• Added running clang-tidy directly from VS and displaying results in output window (output uses .clang-tidy-vsfilters file for filtering clang-tidy output message)
• Added highlighting places in code where validation warnings/errors were found
• Added intelisense quick info description for highlighted warnings in code (MEF component)
• Added VS toolbar for running clang-tidy
• Added new icon for buttons
• Modified project and manifest to reflect all changes and improve debugging capabilities
• Limited VS compatibility to VS2015 and higher (due to MEF component requirements)

[zturner]

Looks like some very nice improvements. But since I'm not familiar with the various interfaces you've implemented and what parts of the IDE they extend / customize, it's hard to give a thorough review. Can you address the comments I've outlined here, and then I can look again?

clang-tidy-vs/CMakeLists.txt

24–28

I don't have much experience with Nuget, but from what I can tell you're using this to ensure the existence of VSSDK? If that's the case, I'd rather just document VSSDK as a dependency and fail to work if it's not present. Because otherwise, if someone installs VSSDK as part of the normal visual studio installation, they will still require nuget in the path or CMake configuration, which is not ideal since most people working on a vsix know they need VSSDK installed.

but if I've misunderstood what you're using it for, let me know.

clang-tidy-vs/ClangTidy/ClangTidy.csproj

39–40

What does this line do?

82–95

I don't think any of these new references are needed. Granted they were probably added automatically by the IDE, but if we don't need them, let's just remove them.

clang-tidy-vs/ClangTidy/ClangTidyPackage.cs

26

Can remove this.

clang-tidy-vs/ClangTidy/ClassifierAndTagger/Classifier.cs

2

Is this a UTF-8 BOM? Regardless, can you remove it? (It appears in some more files as well, please remove it from those too)

11–14

Can you put a better comment here? I'm not familiar with this area of the VSSDK so it would be nice if there a short summary of how this is relevant to the clang-tidy extension. I gather that it's somehow related to the text that is visible in the current editor window, but some additional explanation would be nice here.

clang-tidy-vs/ClangTidy/ClassifierAndTagger/ClassifierProvider.cs

16

Same here.

clang-tidy-vs/ClangTidy/ClassifierAndTagger/QuickInfoController.cs

9

And here (Perhaps just assume this applies to all of the remaining VSSDK interface implementations)

clang-tidy-vs/ClangTidy/Resources/VSOutputFilter.yaml

16 ↗

(On Diff #91695)

Missing newline here.

[• jutocz]

clang-tidy-vs/CMakeLists.txt

24–28

You are right. I was looking at clang-format VS plugin to see if there are some useful cmake commands for it (like adding timestamp to version for easier testing). Nuget is not really essential in here, though other plugin does require it.

clang-tidy-vs/ClangTidy/ClangTidy.csproj

39–40

Automatically added. I'll get rid of it.

82–95

I'll check all of them so we have only those that are needed.

clang-tidy-vs/ClangTidy/ClangTidyPackage.cs

26

You are right. I'll check other includes and remove them if they are not needed.

clang-tidy-vs/ClangTidy/ClassifierAndTagger/Classifier.cs

2

I'll remove it.

11–14

Sure, I'll add better comments for all VSSDK interface implementations.

[• jutocz]

clang-tidy-vs/ClangTidy/ClassifierAndTagger/Classifier.cs

2

After investigating this matter I found out Visual Studio automatically sets file encoding to utf-8 BOM... so all files in clang-tidy-vs solution use this encoding.
If we want to change this, we would have to change encoding for all files manually, but still other source files added to solution through VS will use BOM encoding (as it's default for VS).

What do you think?

[• jutocz]

I've updated patch adding better comments and doing some cosmetic work.

As to nuget I'm not quite sure how it should work. Right now I've left nuget in script, because otherwise when LLVM solution tries to build plugin, it fails due to missing packages (YamlDotNet and StrongNameSigner). With nuget in script those packages are restored by cmake using nuget restore command. Otherwise user has to launch plugin solution and restore packages, then return to LLVM, so the whole solution compiles without errors.

I've removed other nuget VSSDK packages I had added the last time, so the user needs to have VSSDK installed to make it all work.

[• jutocz]

Updating diff with:

• added synchronization for results container using multiple readers, single writer lock (ReaderWriterLockSlim)
• removing .vsixmanifest file - it's generated by cmake using source.extension.vsixmanifest.in
• added config files (.clang-tidy.vsfilters) for filtering/modifying clang-tidy output message in Visual Studio's output

[zturner]

It's hard for me to review on correctness since I'm not familiar with these APIs (and I don't think anyone else is either) but from a functionality standpoint I think these are great changes and I don't see anything glaringly wrong, so lgtm unless someone else has objections.

clang-tidy-vs/ClangTidy/ThreadRunner/ClangTidyRunner.cs

27

Not critical, but will this display the clang-tidy output in a separate category in the output window? By default there is "Build", "Debug", "Build Order". Which category will this be displayed under? Should we have our own category for "Clang Tidy"?

121

seems like this would be better using C# async and yield, but this gets the job done in any case.

[• jutocz]

About correctness: I made these changes so programmers in my company may start using clang-tidy in everyday's work... and so far nobody complained.
If we continue using this extension in here, I hope to continue improving it.

And I'd be glad to hear any suggestions now or in the future.

clang-tidy-vs/ClangTidy/ThreadRunner/ClangTidyRunner.cs

27

Yes, there is a new "Clang Tidy" category in output window for displaying all info from our extension. Category appears in output window and becomes active whenever user runs clang-tidy check.

121

Do you mean replacing use of BackgroundWorker? Or replacing while loop with use of async + await?

[• jutocz]

Nobody seems to have any objections... So I need help with committing changes. Also there are binary file changes. So how should I proceed?

[alexfh]

Re: binary files. Are you using git? Then, I think, you need to do something similar to https://reviews.llvm.org/D31763: add a .gitattributes file containing "*.png binary" and use arcanist to upload the patch (not sure if Phab's web-interface can allow uploading patches with binary files). I also don't know whether git-svn will handle "svn propset svn:mime-type application/octet-stream ...", but that's a problem of whoever will submit the patch for you (Zachary, probably, since it makes sense to at least build the new code and I don't have Windows and MSVS).

clang-tidy-vs/ClangTidy/ClassifierAndTagger/Classifier.cs

2

So, utf8 BOM is only added for new files and not on each save from MSVS? Then please remove BOMs, since they are somewhat poorly supported by some tools (e.g. Phabricator ;).

[alexfh]

Juliusz, are you going to upload a complete patch?

[mloskot]

In D30930#806425, @alexfh wrote:

Juliusz, are you going to upload a complete patch?

@jutocz Any update on this?

[alexfh]

Any update on this?

[shafik]

I am closing this since the author has ignored several pings

[JDevlieghere]

In D30930#4649626, @shafik wrote:

I am closing this since the author has ignored several pings

What's the benefit of closing a review that hans't been touched in 6 years? Is there an effort to close reviews on Phabricator before it goes into read-only mode or something?

[shafik]

In D30930#4649757, @JDevlieghere wrote:

In D30930#4649626, @shafik wrote:

I am closing this since the author has ignored several pings

What's the benefit of closing a review that hans't been touched in 6 years? Is there an effort to close reviews on Phabricator before it goes into read-only mode or something?

Apologies for the extra noise but a few of us are going through old phab PRs that are accepted. It would be a shame to lose good changes because someone got pulled away during an old review. Several authors we reached out to have said they will try and land things before phab is closed for business which is excellent.

Other PRs I don't know the area well enough, so I leave a comment on them so folks who know can determine for sure if they are really relevant or not and they want to make and effort to land them.

Otherwise I close it so that it is off the queue of accepted PRs and someone does not go over a PR I already spent time looking at.

[JDevlieghere]

In D30930#4649788, @shafik wrote:

In D30930#4649757, @JDevlieghere wrote:

In D30930#4649626, @shafik wrote:

I am closing this since the author has ignored several pings

What's the benefit of closing a review that hans't been touched in 6 years? Is there an effort to close reviews on Phabricator before it goes into read-only mode or something?

Apologies for the extra noise but a few of us are going through old phab PRs that are accepted. It would be a shame to lose good changes because someone got pulled away during an old review. Several authors we reached out to have said they will try and land things before phab is closed for business which is excellent.

Other PRs I don't know the area well enough, so I leave a comment on them so folks who know can determine for sure if they are really relevant or not and they want to make and effort to land them.

Otherwise I close it so that it is off the queue of accepted PRs and someone does not go over a PR I already spent time looking at.

Thanks for the context, that makes sense!

clang-tidy-vs/.gitignore

 obj/
 bin/
 .vs/
 Key.snk
 clang-tidy.exe
 packages/
 *.csproj.user
+*.suo
+*.vsixmanifest
 No newline at end of file

clang-tidy-vs/CMakeLists.txt

 option(BUILD_CLANG_TIDY_VS_PLUGIN "Build clang-tidy VS plugin" OFF)
 if (BUILD_CLANG_TIDY_VS_PLUGIN)
   add_custom_target(clang_tidy_exe_for_vsix
       ${CMAKE_COMMAND} -E copy_if_different
       "${LLVM_TOOLS_BINARY_DIR}/clang-tidy.exe"
       "${CMAKE_CURRENT_SOURCE_DIR}/ClangTidy/clang-tidy.exe"
       DEPENDS clang-tidy)
 
   add_custom_target(clang_tidy_license
       ${CMAKE_COMMAND} -E copy_if_different
       "${CLANG_SOURCE_DIR}/LICENSE.TXT"
       "${CMAKE_CURRENT_SOURCE_DIR}/ClangTidy/license.txt")
 
+  # Build number added to Clang version to ensure that new VSIX can be upgraded
+  string(TIMESTAMP CLANG_TIDY_VSIX_BUILD %y%m%d%H%M UTC)
+
   if (NOT CLANG_TIDY_VS_VERSION)
-    set(CLANG_TIDY_VS_VERSION "${LLVM_VERSION_MAJOR}.${LLVM_VERSION_MINOR}.${LLVM_VERSION_PATCH}")
+    set(CLANG_TIDY_VS_VERSION "${LLVM_VERSION_MAJOR}.${LLVM_VERSION_MINOR}.${LLVM_VERSION_PATCH}.${CLANG_TIDY_VSIX_BUILD}")
   endif()
 
   configure_file("source.extension.vsixmanifest.in"
       "${CMAKE_CURRENT_SOURCE_DIR}/ClangTidy/source.extension.vsixmanifest")
 
+  find_program(NUGET_EXE nuget PATHS ${NUGET_EXE_DIR})
+  if (NOT NUGET_EXE)
+    message(FATAL_ERROR "Could not find nuget.exe. Download from https://www.nuget.org/nuget.exe"
+                        " and add parent directory to PATH or pass it via NUGET_EXE_DIR var.")
+  endif()
+
   add_custom_target(clang_tidy_vsix ALL
-      devenv "${CMAKE_CURRENT_SOURCE_DIR}/ClangTidy.sln" /Build Release
+      COMMAND ${NUGET_EXE} restore "${CMAKE_CURRENT_SOURCE_DIR}/ClangTidy.sln"
+      COMMAND devenv "${CMAKE_CURRENT_SOURCE_DIR}/ClangTidy.sln" /Build Release
       DEPENDS clang_tidy_exe_for_vsix "${CMAKE_CURRENT_SOURCE_DIR}/ClangTidy/source.extension.vsixmanifest"
       COMMAND ${CMAKE_COMMAND} -E copy_if_different
       "${CMAKE_CURRENT_SOURCE_DIR}/ClangTidy/bin/Release/ClangTidy.vsix"
       "${LLVM_TOOLS_BINARY_DIR}/ClangTidy.vsix"
       DEPENDS clang_tidy_exe_for_vsix clang_tidy_license)
 endif()

clang-tidy-vs/ClangTidy/ClangTidy.csproj

<PropertyGroup>
     <UpdateRequired>false</UpdateRequired>
     <MapFileExtensions>true</MapFileExtensions>
     <ApplicationRevision>0</ApplicationRevision>
     <ApplicationVersion>1.0.0.%2a</ApplicationVersion>
     <IsWebBootstrapper>false</IsWebBootstrapper>
     <UseApplicationTrust>false</UseApplicationTrust>
     <BootstrapperEnabled>true</BootstrapperEnabled>
     <TargetFrameworkProfile />
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
     <DebugType>full</DebugType>
     <Optimize>false</Optimize>
     <OutputPath>bin\Debug\</OutputPath>
     <DefineConstants>DEBUG;TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>0</WarningLevel>
     <Prefer32Bit>false</Prefer32Bit>
     <PlatformTarget>AnyCPU</PlatformTarget>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <DebugType>pdbonly</DebugType>
     <Optimize>true</Optimize>
     <OutputPath>bin\Release\</OutputPath>
     <DefineConstants>TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <RunCodeAnalysis>true</RunCodeAnalysis>
     <Prefer32Bit>false</Prefer32Bit>
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="envdte, Version=8.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
+      <EmbedInteropTypes>True</EmbedInteropTypes>
+    </Reference>
     <Reference Include="Microsoft.CSharp" />
     <Reference Include="Microsoft.VisualStudio.CoreUtility, Version=14.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
     <Reference Include="Microsoft.VisualStudio.Editor, Version=14.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
+    <Reference Include="Microsoft.VisualStudio.Language.Intellisense, Version=14.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
     <Reference Include="Microsoft.VisualStudio.OLE.Interop" />
     <Reference Include="Microsoft.VisualStudio.Settings.14.0, Version=14.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=x86" />
     <Reference Include="Microsoft.VisualStudio.Shell.14.0, Version=14.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
     <Reference Include="Microsoft.VisualStudio.Shell.Immutable.10.0, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
     <Reference Include="Microsoft.VisualStudio.Shell.Immutable.14.0, Version=14.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
     <Reference Include="Microsoft.VisualStudio.Shell.Interop" />
-    <Reference Include="Microsoft.VisualStudio.TextManager.Interop" />
+    <Reference Include="Microsoft.VisualStudio.Shell.Interop.8.0, Version=8.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
+    <Reference Include="Microsoft.VisualStudio.Text.Data, Version=14.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
+    <Reference Include="Microsoft.VisualStudio.Text.Logic, Version=14.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
+    <Reference Include="Microsoft.VisualStudio.Text.UI, Version=14.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
+    <Reference Include="Microsoft.VisualStudio.Text.UI.Wpf, Version=14.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
     <Reference Include="Microsoft.VisualStudio.TextManager.Interop" />
     <Reference Include="Microsoft.VisualStudio.Utilities, Version=14.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
+    <Reference Include="PresentationCore" />
     <Reference Include="System" />
+    <Reference Include="System.ComponentModel.Composition" />
     <Reference Include="System.Core" />
     <Reference Include="System.Data" />
     <Reference Include="System.Design" />
     <Reference Include="System.Drawing" />
     <Reference Include="System.Windows.Forms" />
-    <Reference Include="System.Xml" />
-    <Reference Include="System.Xml.Linq" />
     <Reference Include="YamlDotNet, Version=3.3.0.0, Culture=neutral, processorArchitecture=MSIL">
       <HintPath>..\packages\YamlDotNet.3.3.0\lib\net35\YamlDotNet.dll</HintPath>
       <Private>True</Private>
     </Reference>
     <Reference Include="YamlDotNet.Dynamic, Version=3.2.0.0, Culture=neutral, processorArchitecture=MSIL">
       <HintPath>..\packages\YamlDotNet.Dynamic.3.2.3\lib\net40\YamlDotNet.Dynamic.dll</HintPath>
       <Private>True</Private>
     </Reference>
   </ItemGroup>
   <ItemGroup>
-    <COMReference Include="EnvDTE">
-      <Guid>{80CC9F66-E7D8-4DDD-85B6-D9E6CD0E93E2}</Guid>
-      <VersionMajor>8</VersionMajor>
-      <VersionMinor>0</VersionMinor>
-      <Lcid>0</Lcid>
-      <WrapperTool>primary</WrapperTool>
-      <Isolated>False</Isolated>
-      <EmbedInteropTypes>False</EmbedInteropTypes>
-    </COMReference>
-    <COMReference Include="EnvDTE100">
-      <Guid>{26AD1324-4B7C-44BC-84F8-B86AED45729F}</Guid>
-      <VersionMajor>10</VersionMajor>
-      <VersionMinor>0</VersionMinor>
-      <Lcid>0</Lcid>
-      <WrapperTool>primary</WrapperTool>
-      <Isolated>False</Isolated>
-      <EmbedInteropTypes>False</EmbedInteropTypes>
-    </COMReference>
-    <COMReference Include="EnvDTE80">
-      <Guid>{1A31287A-4D7D-413E-8E32-3B374931BD89}</Guid>
-      <VersionMajor>8</VersionMajor>
-      <VersionMinor>0</VersionMinor>
-      <Lcid>0</Lcid>
-      <WrapperTool>primary</WrapperTool>
-      <Isolated>False</Isolated>
-      <EmbedInteropTypes>False</EmbedInteropTypes>
-    </COMReference>
-    <COMReference Include="EnvDTE90">
-      <Guid>{2CE2370E-D744-4936-A090-3FFFE667B0E1}</Guid>
-      <VersionMajor>9</VersionMajor>
-      <VersionMinor>0</VersionMinor>
-      <Lcid>0</Lcid>
-      <WrapperTool>primary</WrapperTool>
-      <Isolated>False</Isolated>
-      <EmbedInteropTypes>False</EmbedInteropTypes>
-    </COMReference>
     <COMReference Include="Microsoft.VisualStudio.CommandBars">
       <Guid>{1CBA492E-7263-47BB-87FE-639000619B15}</Guid>
       <VersionMajor>8</VersionMajor>
       <VersionMinor>0</VersionMinor>
       <Lcid>0</Lcid>
       <WrapperTool>primary</WrapperTool>
       <Isolated>False</Isolated>
       <EmbedInteropTypes>False</EmbedInteropTypes>
     </COMReference>
     <COMReference Include="stdole">
       <Guid>{00020430-0000-0000-C000-000000000046}</Guid>
       <VersionMajor>2</VersionMajor>
       <VersionMinor>0</VersionMinor>
       <Lcid>0</Lcid>
       <WrapperTool>primary</WrapperTool>
       <Isolated>False</Isolated>
       <EmbedInteropTypes>False</EmbedInteropTypes>
     </COMReference>
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="ThreadRunner\BackgroundThreadWorker.cs" />
     <Compile Include="CategoryVerb.cs" />
     <Compile Include="CheckDatabase.cs" />
     <Compile Include="CheckTree.cs" />
     <Compile Include="ClangTidyCheckAttribute.cs" />
     <Compile Include="ClangTidyConfigurationPage.cs">
       <SubType>Component</SubType>
     </Compile>
     <Compile Include="ClangTidyProperties.cs">
       <SubType>Component</SubType>
     </Compile>
+    <Compile Include="ThreadRunner\ClangTidyRunner.cs" />
+    <Compile Include="ClassifierAndTagger\QuickInfoControllerProvider.cs" />
+    <Compile Include="ClassifierAndTagger\QuickInfoController.cs" />
+    <Compile Include="ClassifierAndTagger\QuickInfoSourceProvider.cs" />
+    <Compile Include="ClassifierAndTagger\QuickInfoSource.cs" />
+    <Compile Include="ThreadRunner\OutputFilterDatabase.cs" />
+    <Compile Include="ThreadRunner\ValidationResultFormatter.cs" />
+    <Compile Include="ClassifierAndTagger\Classifier.cs" />
+    <Compile Include="ClassifierAndTagger\ClassifierProvider.cs" />
+    <Compile Include="ClassifierAndTagger\ValidationTagger.cs" />
+    <Compile Include="ClassifierAndTagger\ValidationTaggerProvider.cs" />
     <Compile Include="DynamicPropertyConverter.cs" />
     <Compile Include="DynamicPropertyDescriptor.cs" />
     <Compile Include="ForwardingPropertyDescriptor.cs" />
     <Compile Include="Guids.cs" />
     <Compile Include="DynamicPropertyComponent.cs">
       <SubType>Component</SubType>
     </Compile>
     <Compile Include="DynamicPropertyComponent.Designer.cs" />
<EmbeddedResource Include="VSPackage.resx">
       <MergeWithCTO>true</MergeWithCTO>
       <ManifestResourceName>VSPackage</ManifestResourceName>
     </EmbeddedResource>
   </ItemGroup>
   <ItemGroup>
     <None Include="Key.snk" />
     <None Include="packages.config" />
     <None Include="Resources\ClangTidyChecks.yaml" />
+    <Content Include="Resources\.clang-tidy-vsfilters">
+      <IncludeInVSIX>true</IncludeInVSIX>
+    </Content>
     <None Include="source.extension.vsixmanifest">
       <SubType>Designer</SubType>
     </None>
   </ItemGroup>
   <ItemGroup>
     <VSCTCompile Include="ClangTidy.vsct">
       <ResourceName>Menus.ctmenu</ResourceName>
       <SubType>Designer</SubType>
     </VSCTCompile>
   </ItemGroup>
   <ItemGroup>
-    <None Include="Resources\Images_32bit.bmp" />
-  </ItemGroup>
-  <ItemGroup>
     <Content Include="clang-tidy.exe">
       <IncludeInVSIX>true</IncludeInVSIX>
     </Content>
     <Content Include="license.txt">
       <IncludeInVSIX>true</IncludeInVSIX>
     </Content>
+    <None Include="Resources\ButtonTidy.png" />
     <Content Include="Resources\Package.ico" />
   </ItemGroup>
   <ItemGroup>
     <BootstrapperPackage Include=".NETFramework,Version=v4.0">
       <Visible>False</Visible>
       <ProductName>Microsoft .NET Framework 4 %28x86 and x64%29</ProductName>
       <Install>true</Install>
     </BootstrapperPackage>
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
   <PropertyGroup>
     <VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">10.0</VisualStudioVersion>
     <VSToolsPath Condition="'$(VSToolsPath)' == ''">$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)</VSToolsPath>
   </PropertyGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
   <Import Project="$(VSToolsPath)\VSSDK\Microsoft.VsSDK.targets" Condition="'$(VSToolsPath)' != ''" />
   <Import Project="$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v10.0\VSSDK\Microsoft.VsSDK.targets" Condition="false" />
   <PropertyGroup>
-    <PreBuildEvent>if not exist $(ProjectDir)Key.snk ("$(SDKToolsPath)\sn.exe" -k $(ProjectDir)Key.snk)</PreBuildEvent>
+    <PreBuildEvent>if not exist $(ProjectDir)Key.snk ("$(FrameworkSDKDir)Bin\NETFX 4.6 Tools\sn.exe" -k $(ProjectDir)Key.snk)</PreBuildEvent>
   </PropertyGroup>
   <Target Name="BeforeBuild">
     <Exec ContinueOnError="false" Command="&quot;..\packages\Brutal.Dev.StrongNameSigner.1.8.0\tools\StrongNameSigner.Console.exe&quot; -in &quot;..\packages&quot; -l Summary" />
   </Target>
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
   <Target Name="AfterBuild">
   </Target>
   -->
 </Project>
 No newline at end of file

clang-tidy-vs/ClangTidy/ClangTidy.vsct

<CommandTable xmlns="http://schemas.microsoft.com/VisualStudio/2005-10-18/CommandTable" xmlns:xs="http://www.w3.org/2001/XMLSchema">
 
   <!--This is the file that defines the IDs for all the commands exposed by VisualStudio. -->
   <Extern href="stdidcmd.h"/>
 
   <!--This header contains the command ids for the menus provided by the shell. -->
   <Extern href="vsshlids.h"/>
 
 
-
-
   <!--The Commands section is where we the commands, menus and menu groups are defined.
       This section uses a Guid to identify the package that provides the command defined inside it. -->
   <Commands package="guidClangTidyPkg">
     <!-- Inside this section we have different sub-sections: one for the menus, another  
     for the menu groups, one for the buttons (the actual commands), one for the combos 
     and the last one for the bitmaps used. Each element is identified by a command id that  
     is a unique pair of guid and numeric identifier; the guid part of the identifier is usually  
     called "command set" and is used to group different command inside a logically related  
     group; your package should define its own command set in order to avoid collisions  
     with command ids defined by other packages. -->
 
+    <Menus>
+      <Menu guid="guidClangTidyCmdSet" id="Toolbar"
+          type="Toolbar" >
+        <CommandFlag>DefaultDocked</CommandFlag>
+        <Strings>
+          <ButtonText>ClangTidy</ButtonText>
+          <CommandName>Clang Tidy</CommandName>
+        </Strings>
+      </Menu>
+    </Menus>
     
     <!-- In this section you can define new menu groups. A menu group is a container for 
          other menus or buttons (commands); from a visual point of view you can see the 
          group as the part of a menu contained between two lines. The parent of a group 
          must be a menu. -->
     <Groups>
 
       <Group guid="guidClangTidyCmdSet" id="MyMenuGroup" priority="0x0600">
         <Parent guid="guidSHLMainMenu" id="IDM_VS_MENU_TOOLS"/>
       </Group>
-      
-
+      <Group guid="guidClangTidyCmdSet" id="ToolbarGroup"
+            priority="0x0000">
+        <Parent guid="guidClangTidyCmdSet" id="Toolbar"/>
+      </Group>
 
     </Groups>
     
     <!--Buttons section. -->
     <!--This section defines the elements the user can interact with, like a menu command or a button 
         or combo box in a toolbar. -->
     <Buttons>
       <!--To define a menu group you have to specify its ID, the parent menu and its display priority. 
           The command is visible and enabled by default. If you need to change the visibility, status, etc, you can use
           the CommandFlag node.
           You can add more than one CommandFlag node e.g.:
               <CommandFlag>DefaultInvisible</CommandFlag>
               <CommandFlag>DynamicVisibility</CommandFlag>
           If you do not want an image next to your command, remove the Icon node /> -->
 
       <Button guid="guidClangTidyCmdSet" id="cmdidClangTidy" priority="0x0100" type="Button">
         <Parent guid="guidClangTidyCmdSet" id="MyMenuGroup" />
-        <Icon guid="guidImages" id="bmpPic1" />
+        <Icon guid="guidTidyImage" id="bmpTidy" />
         <Strings>
-          <ButtonText>ClangTidy</ButtonText>
+          <ButtonText>Clang Tidy</ButtonText>
         </Strings>
       </Button>
 
-
+      <Button guid="guidClangTidyCmdSet" id="cmdidClangTidy" priority="0x0100" type="Button">
+        <Parent guid="guidClangTidyCmdSet" id="ToolbarGroup" />
+        <Icon guid="guidTidyImage" id="bmpTidy" />
+        <Strings>
+          <ButtonText>Clang Tidy</ButtonText>
+        </Strings>
+      </Button>
 
     </Buttons>
    
     <!--The bitmaps section is used to define the bitmaps that are used for the commands.-->
     <Bitmaps>
       <!--  The bitmap id is defined in a way that is a little bit different from the others: 
             the declaration starts with a guid for the bitmap strip, then there is the resource id of the 
             bitmap strip containing the bitmaps and then there are the numeric ids of the elements used 
             inside a button definition. An important aspect of this declaration is that the element id 
-            must be the actual index (1-based) of the bitmap inside the bitmap strip. -->
-      <Bitmap guid="guidImages" href="Resources\Images_32bit.bmp" usedList="bmpPic1, bmpPic2, bmpPicSearch, bmpPicX, bmpPicArrows"/>
+            must be the actual index (1-based) of the bitmap inside the bitmap strip. -->    
+      <Bitmap guid="guidTidyImage" href="Resources\ButtonTidy.png" usedList="bmpTidy"/>
       
     </Bitmaps>
  
   </Commands>
 
 
   <KeyBindings>
     <KeyBinding guid="guidClangTidyCmdSet" id="cmdidClangTidy" editor="guidTextEditor" key1="R" mod1="Control" key2="T" mod2="Control"/>
   </KeyBindings>
 
 
 
   <Symbols>
     <!-- This is the package guid. -->
     <GuidSymbol name="guidClangTidyPkg" value="{AE4956BE-3DB8-430E-BBAB-7E2E9A014E9C}" />
     
     <!-- This is the guid used to group the menu commands together -->
     <GuidSymbol name="guidClangTidyCmdSet" value="{9E0F0493-6493-46DE-AEE1-ACD8F60F265E}">
       <IDSymbol name="MyMenuGroup" value="0x1020" />
       <IDSymbol name="cmdidClangTidy" value="0x0100" />
+      <IDSymbol name="Toolbar" value="0x1000" />
+      <IDSymbol name="ToolbarGroup" value="0x1050" />
     </GuidSymbol>
 
     <GuidSymbol name="guidTextEditor" value="{E10FAD35-7FB8-4991-A269-EF88F12166C9}" />
    
-
-    <GuidSymbol name="guidImages" value="{942F126F-942D-428A-84B4-4AC7C523D0B2}" >
-      <IDSymbol name="bmpPic1" value="1" />
-      <IDSymbol name="bmpPic2" value="2" />
-      <IDSymbol name="bmpPicSearch" value="3" />
-      <IDSymbol name="bmpPicX" value="4" />
-      <IDSymbol name="bmpPicArrows" value="5" />
+    <GuidSymbol name="guidTidyImage" value="{1DDC3C3F-C9FC-4A57-A920-319695E6750C}" >
+      <IDSymbol name="bmpTidy" value="1" />
     </GuidSymbol>
   </Symbols>
 
 </CommandTable>

clang-tidy-vs/ClangTidy/ClangTidyPackage.cs

 using Microsoft.VisualStudio.TextManager.Interop;
 using System;
 using System.Collections;
 using System.ComponentModel;
 using System.ComponentModel.Design;
 using System.IO;
 using System.Runtime.InteropServices;
 using System.Windows.Forms;
-using System.Xml.Linq;
 
 namespace LLVM.ClangTidy
 {
     [PackageRegistration(UseManagedResourcesOnly = true)]
     [InstalledProductRegistration("#110", "#112", "1.0", IconResourceID = 400)]
     [ProvideMenuResource("Menus.ctmenu", 1)]
     [Guid(GuidList.guidClangTidyPkgString)]
     [ProvideOptionPage(typeof(ClangTidyConfigurationPage), "LLVM/Clang", "ClangTidy", 0, 0, true)]
     public sealed class ClangTidyPackage : Package
public sealed class ClangTidyPackage : Package
                 var menuItem = new MenuCommand(MenuItemCallback, menuCommandID);
                 commandService.AddCommand(menuItem);
             }
         }
         #endregion
 
         private void MenuItemCallback(object sender, EventArgs args)
         {
+            ClangTidyRunner.RunClangTidyProcess();
         }
     }
 }

clang-tidy-vs/ClangTidy/ClassifierAndTagger/Classifier.cs

+´╗┐using System;
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.VisualStudio.Text.Classification;
+using Microsoft.VisualStudio.Text.Tagging;
+using Microsoft.VisualStudio.Text;
+
+namespace LLVM.ClangTidy
+{
+    /// <summary>
+    /// This class assigns classification types to given text by implicitly asking ValidationTagger 
+    /// for text spans containing clang-tidy validation warnings in given text buffer.
+    /// Generally, the span in question is the displayed portion of the file currently open in the Editor.
+    /// </summary>
+    class Classifier : IClassifier
+    {
+        private IClassificationType ClassificationType;
+        private ITagAggregator<ValidationTag> Tagger;
+        private static Classifier ActiveClassifier = null;
+        private SnapshotSpan CurrentSpan;
+
+        internal Classifier(ITagAggregator<ValidationTag> tagger, IClassificationType classificationType)
+        {
+            Tagger = tagger;
+            ClassificationType = classificationType;
+        }
+
+        /// <summary>
+        /// Get every ValidationTag instance within the given span.
+        /// Usually a single SnapshotSpan is the content of one of the visible lines or 
+        /// selections of text in the text editor and a Snapshot is the content of the
+        /// whole file opened in editor window.
+        /// </summary>
+        /// <param name="span">The span of text that will be searched for validation tags</param>
+        /// <returns>A list of every relevant tag in the given span</returns>
+        public IList<ClassificationSpan> GetClassificationSpans(SnapshotSpan span)
+        {
+            ActiveClassifier = this;
+
+            // After clang-tidy returns new results, tags will be automatically created only for 
+            //   newly appearing text lines or focused code window.
+            // To force-refresh tags in current window, store single span for the whole file and 
+            //   call Invalidate() on this span when clang-tidy results are ready.
+            if (CurrentSpan == null || CurrentSpan.Snapshot != span.Snapshot)
+            {
+                CurrentSpan = new SnapshotSpan(span.Snapshot, 0, span.Snapshot.Length);
+            }
+
+            IList<ClassificationSpan> classifiedSpans = new List<ClassificationSpan>();
+
+            var tags = Tagger.GetTags(span);
+
+            foreach (IMappingTagSpan<ValidationTag> tagSpan in tags)
+            {
+                var validationSpan = tagSpan.Span.GetSpans(span.Snapshot).First();
+                classifiedSpans.Add(new ClassificationSpan(validationSpan, ClassificationType));
+            }
+
+            return classifiedSpans;
+        }
+
+        /// <summary>
+        /// Create an event for when the Classification changes
+        /// </summary>
+        public event EventHandler<ClassificationChangedEventArgs> ClassificationChanged;
+
+        /// <summary>
+        /// Force refresh a span stored on last update (assume it corresponds to currently active document)
+        /// </summary>
+        public void Invalidate()
+        {
+            ClassificationChanged?.Invoke(this, new ClassificationChangedEventArgs(CurrentSpan));
+        }
+
+        static public void InvalidateActiveClassifier()
+        {
+            if (ActiveClassifier != null)
+                ActiveClassifier.Invalidate();
+        }
+    }
+}

clang-tidy-vs/ClangTidy/ClassifierAndTagger/ClassifierProvider.cs

+´╗┐using System.ComponentModel.Composition;
+using Microsoft.VisualStudio.Text.Classification;
+using Microsoft.VisualStudio.Utilities;
+using Microsoft.VisualStudio.Text.Tagging;
+using Microsoft.VisualStudio.Text;
+using System.Windows.Media;
+
+namespace LLVM.ClangTidy
+{
+    /// <summary>
+    /// This class creates Classifier that will search for clang-tidy validation warnings in the
+    /// visible text. Results will be highlighted in code using ValidationWarningFormat classification.
+    /// Export a <see cref="IClassifierProvider"/>
+    /// </summary>
+    [Export(typeof(IClassifierProvider))]
+    [ContentType("code")]
+    internal class ClassifierProvider : IClassifierProvider
+    {
+        [Export(typeof(ClassificationTypeDefinition))]
+        [Name("clang-tidy-validation")]
+        internal ClassificationTypeDefinition ValidationClassificationType = null;
+
+        [Import]
+        internal IClassificationTypeRegistryService ClassificationRegistry = null;
+
+        [Import]
+        internal IBufferTagAggregatorFactoryService TagAggregatorFactory = null;
+
+        public IClassifier GetClassifier(ITextBuffer buffer)
+        {
+            IClassificationType classificationType = ClassificationRegistry.GetClassificationType("clang-tidy-validation");
+
+            var tagAggregator = TagAggregatorFactory.CreateTagAggregator<ValidationTag>(buffer);
+            return new Classifier(tagAggregator, classificationType);
+        }
+    }
+
+    /// <summary>
+    /// Set the display values for the classification
+    /// </summary>
+    [Export(typeof(EditorFormatDefinition))]
+    [ClassificationType(ClassificationTypeNames = "clang-tidy-validation")]
+    [Name("clang-tidy validation")]
+    [UserVisible(false)]
+    [Order(After = Priority.High)]
+    internal sealed class ValidationWarningFormat : ClassificationFormatDefinition
+    {
+        public ValidationWarningFormat()
+        {
+            DisplayName = "clang-tidy validation failed";
+            BackgroundOpacity = 0.3f;
+            BackgroundColor = Colors.Red;
+        }
+    }
+}

clang-tidy-vs/ClangTidy/ClassifierAndTagger/QuickInfoController.cs

+´╗┐using System.Collections.Generic;
+using Microsoft.VisualStudio.Language.Intellisense;
+using Microsoft.VisualStudio.Text;
+using Microsoft.VisualStudio.Text.Editor;
+
+namespace LLVM.ClangTidy
+{
+    /// <summary>
+    /// This class allows augmentations of Intellisense quick info when 
+    /// a user hovers his mouse over one of clang-tidy validation warnings in code.
+    /// Quick info content augmentations are performed in QuickInfoSource.
+    /// </summary>
+    internal class QuickInfoController : IIntellisenseController
+    {
+        private ITextView TextView;
+        private IList<ITextBuffer> SubjectBuffers;
+        private QuickInfoControllerProvider Provider;
+        private IQuickInfoSession Session;
+
+        internal QuickInfoController(ITextView textView, IList<ITextBuffer> subjectBuffers, QuickInfoControllerProvider provider)
+        {
+            TextView = textView;
+            SubjectBuffers = subjectBuffers;
+            Provider = provider;
+
+            TextView.MouseHover += OnTextViewMouseHover;
+        }
+
+        private void OnTextViewMouseHover(object sender, MouseHoverEventArgs e)
+        {
+            SnapshotPoint? point = GetMousePosition(new SnapshotPoint(TextView.TextSnapshot, e.Position));
+
+            if (point != null)
+            {
+                ITrackingPoint triggerPoint = point.Value.Snapshot.CreateTrackingPoint(point.Value.Position,
+                    PointTrackingMode.Positive);
+
+                // Find the broker for this buffer
+                if (!Provider.QuickInfoBroker.IsQuickInfoActive(TextView))
+                {
+                    Session = Provider.QuickInfoBroker.CreateQuickInfoSession(TextView, triggerPoint, true);
+                    Session.Start();
+                }
+            }
+        }
+
+        public void Detach(ITextView textView)
+        {
+            if (TextView == textView)
+            {
+                TextView.MouseHover -= this.OnTextViewMouseHover;
+                TextView = null;
+            }
+        }
+
+        private SnapshotPoint? GetMousePosition(SnapshotPoint topPosition)
+        {
+            // Map this point down to the appropriate subject buffer.
+            return TextView.BufferGraph.MapDownToFirstMatch
+                (
+                topPosition,
+                PointTrackingMode.Positive,
+                snapshot => SubjectBuffers.Contains(snapshot.TextBuffer),
+                PositionAffinity.Predecessor
+                );
+        }
+
+        public void ConnectSubjectBuffer(ITextBuffer subjectBuffer)
+        {
+        }
+
+        public void DisconnectSubjectBuffer(ITextBuffer subjectBuffer)
+        {
+        }
+    }
+}

clang-tidy-vs/ClangTidy/ClassifierAndTagger/QuickInfoControllerProvider.cs

+´╗┐using System.Collections.Generic;
+using System.ComponentModel.Composition;
+using Microsoft.VisualStudio.Language.Intellisense;
+using Microsoft.VisualStudio.Text;
+using Microsoft.VisualStudio.Text.Editor;
+using Microsoft.VisualStudio.Utilities;
+
+namespace LLVM.ClangTidy
+{
+    /// <summary>
+    /// This class creates QuickInfoControllerProvider to be used for 
+    /// augmenting Intellisense quick info when hovering over clang-tidy 
+    /// validation warnings in code.
+    /// </summary>
+    [Export(typeof(IIntellisenseControllerProvider))]
+    [Name("ClangTidy QuickInfo Controller")]
+    [ContentType("text")]
+    internal class QuickInfoControllerProvider : IIntellisenseControllerProvider
+    {
+        [Import]
+        internal IQuickInfoBroker QuickInfoBroker { get; set; }
+
+        public IIntellisenseController TryCreateIntellisenseController(ITextView textView, IList<ITextBuffer> subjectBuffers)
+        {
+            return new QuickInfoController(textView, subjectBuffers, this);
+        }
+    }
+}

clang-tidy-vs/ClangTidy/ClassifierAndTagger/QuickInfoSource.cs

+´╗┐using System;
+using System.Collections.Generic;
+using Microsoft.VisualStudio.Language.Intellisense;
+using Microsoft.VisualStudio.Text;
+using Microsoft.VisualStudio.Text.Tagging;
+using System.Linq;
+
+namespace LLVM.ClangTidy
+{
+    /// <summary>
+    /// This class searches for clang-tidy validation warnings (implicitly using 
+    /// ValidationTagger's functionality) in a text span provided by QuickInfoController.
+    /// Results are augmented for Intellisense quick info using the message stored in 
+    /// ValidationTag by ValidationTagger.
+    /// </summary>
+    internal class QuickInfoSource : IQuickInfoSource
+    {
+        private ITagAggregator<ValidationTag> Aggregator;
+        private ITextBuffer Buffer;
+        private bool IsDisposed = false;
+
+        public QuickInfoSource(ITextBuffer buffer, ITagAggregator<ValidationTag> aggregator)
+        {
+            Aggregator = aggregator;
+            Buffer = buffer;
+        }
+
+        public void AugmentQuickInfoSession(IQuickInfoSession session, IList<object> quickInfoContent, out ITrackingSpan applicableToSpan)
+        {
+            applicableToSpan = null;
+
+            if (IsDisposed)
+                throw new ObjectDisposedException("QuickInfoSource");
+
+            var triggerPoint = (SnapshotPoint)session.GetTriggerPoint(Buffer.CurrentSnapshot);
+
+            if (triggerPoint == null)
+                return;
+
+            foreach (IMappingTagSpan<ValidationTag> curTag in Aggregator.GetTags(new SnapshotSpan(triggerPoint, triggerPoint)))
+            {
+                var tagSpan = curTag.Span.GetSpans(Buffer).First();
+                applicableToSpan = Buffer.CurrentSnapshot.CreateTrackingSpan(tagSpan, SpanTrackingMode.EdgeExclusive);
+                quickInfoContent.Add(curTag.Tag.validationMessage);
+            }
+        }
+
+        public void Dispose()
+        {
+            if (!IsDisposed)
+            {
+                GC.SuppressFinalize(this);
+                IsDisposed = true;
+            }
+        }
+    }
+}

clang-tidy-vs/ClangTidy/ClassifierAndTagger/QuickInfoSourceProvider.cs

+´╗┐using Microsoft.VisualStudio.Language.Intellisense;
+using Microsoft.VisualStudio.Text;
+using Microsoft.VisualStudio.Text.Tagging;
+using System.ComponentModel.Composition;
+using Microsoft.VisualStudio.Utilities;
+
+namespace LLVM.ClangTidy
+{
+    /// <summary>
+    /// QuickInfoSourceProvider creates QuickInfoSource for text buffers currently 
+    /// processed by Intellisense quick info. In this case the text buffer is provided 
+    /// by QuickInfoController.
+    /// </summary>
+    [Export(typeof(IQuickInfoSourceProvider))]
+    [ContentType("code")]
+    [Name("ClangTidy QuickInfo Source")]
+    //[Order(Before = "Default Quick Info Presenter")]
+    internal class QuickInfoSourceProvider : IQuickInfoSourceProvider
+    {
+        [Import]
+        IBufferTagAggregatorFactoryService AggService = null;
+
+        public IQuickInfoSource TryCreateQuickInfoSource(ITextBuffer textBuffer)
+        {
+            return new QuickInfoSource(textBuffer, AggService.CreateTagAggregator<ValidationTag>(textBuffer));
+        }
+    }
+}

clang-tidy-vs/ClangTidy/ClassifierAndTagger/ValidationTagger.cs

+´╗┐using System;
+using System.Collections.Generic;
+using Microsoft.VisualStudio.Text;
+using Microsoft.VisualStudio.Text.Tagging;
+
+namespace LLVM.ClangTidy
+{
+    /// <summary>
+    /// Validation tag for ITagger holding clang-tidy validation warning message.
+    /// </summary>
+    internal class ValidationTag : ITag
+    {
+        public string validationMessage { get; private set; }
+        internal ValidationTag(string message)
+        {
+            validationMessage = message;
+        }
+    }
+
+    /// <summary>
+    /// This class implements ITagger for ValidationTag. It is responsible for creating
+    /// ValidationTag TagSpans for all clang-tidy results inside given code spans. 
+    /// ValidationTags are then used by Classifier for highlighting the code using ValidationWarningFormat 
+    /// settings and by QuickInfoSource that will augment Intellisense info for appropriate code.
+    /// </summary>
+    internal class ValidationTagger : ITagger<ValidationTag>
+    {
+        ITextBuffer Buffer;
+
+        internal ValidationTagger(ITextBuffer buffer)
+        {
+            Buffer = buffer;
+        }
+
+        public event EventHandler<SnapshotSpanEventArgs> TagsChanged
+        {
+            add { }
+            remove { }
+        }
+
+        /// <summary>
+        /// This method creates ValidationTag TagSpans over a set of SnapshotSpans.
+        /// </summary>
+        /// <param name="spans">A set of spans we want to get tags for.</param>
+        /// <returns>The list of ValidationTag TagSpans.</returns>
+        //IEnumerable<ITagSpan<ValidationTag>> ITagger<ValidationTag>.GetTags(NormalizedSnapshotSpanCollection spans)
+        public IEnumerable<ITagSpan<ValidationTag>> GetTags(NormalizedSnapshotSpanCollection spans)
+        {
+            foreach (SnapshotSpan curSpan in spans)
+            {
+                ValidationResultFormatter.ValidationResultsLock.EnterReadLock();
+
+                foreach (ValidationResultFormatter.SingleValidationResult res in ValidationResultFormatter.ValidationResults)
+                {
+                    // Check if clang-tidy validation result is inside given span (file and line number comparison)
+                    if (res.Line >= curSpan.Start.GetContainingLine().LineNumber && res.Line <= curSpan.End.GetContainingLine().LineNumber &&
+                        string.Compare(res.File, curSpan.Snapshot.TextBuffer.Properties.GetProperty<ITextDocument>(typeof(ITextDocument)).FilePath, true) == 0)
+                    {
+                        // Check if found line contains code stored during the last validation
+                        var resultLine = curSpan.Snapshot.GetLineFromLineNumber(res.Line);
+                        if (resultLine.GetText().Contains(res.CodeLine))
+                        {
+                            var validationKeywordSpan = new SnapshotSpan(curSpan.Snapshot,
+                                resultLine.Start.Position + res.Column,
+                                res.HighlightSymbol.Length);
+
+                            yield return new TagSpan<ValidationTag>(validationKeywordSpan, new ValidationTag(res.Description));
+                        }
+                    }
+                }
+
+                ValidationResultFormatter.ValidationResultsLock.ExitReadLock();
+            }
+        }
+    }
+}

clang-tidy-vs/ClangTidy/ClassifierAndTagger/ValidationTaggerProvider.cs

+´╗┐using System;
+using System.ComponentModel.Composition;
+using Microsoft.VisualStudio.Text;
+using Microsoft.VisualStudio.Text.Tagging;
+using Microsoft.VisualStudio.Utilities;
+
+namespace LLVM.ClangTidy
+{
+    /// <summary>
+    /// Export a <see cref="ITaggerProvider"/>
+    /// This class creates ValidationTagger for given text buffer allowing other 
+    /// MEF components to use ValidationTagger's functionality of searching for text 
+    /// spans containing clang-tidy warnings.
+    /// </summary>
+    [Export(typeof(ITaggerProvider))]
+    [ContentType("code")]
+    [TagType(typeof(ValidationTag))]
+    class ValidationTaggerProvider : ITaggerProvider
+    {
+        /// <summary>
+        /// Creates an instance of our custom ValidationTagger for a given buffer.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="buffer">The buffer we are creating the tagger for.</param>
+        /// <returns>An instance of our custom ValidationTagger.</returns>
+        public ITagger<T> CreateTagger<T>(ITextBuffer buffer) where T : ITag
+        {
+            if (buffer == null)
+            {
+                throw new ArgumentNullException("buffer");
+            }
+
+            return new ValidationTagger(buffer) as ITagger<T>;
+        }
+    }
+}

clang-tidy-vs/ClangTidy/Guids.cs

 ´╗┐using System;
 
 namespace LLVM.ClangTidy
 {
     static class GuidList
     {
         public const string guidClangTidyPkgString = "AE4956BE-3DB8-430E-BBAB-7E2E9A014E9C";
         public const string guidClangTidyCmdSetString = "9E0F0493-6493-46DE-AEE1-ACD8F60F265E";
+        public const string guidClangTidyOutputWndString = "726ACC5D-E657-47A1-889C-432FDF7A67FD";
 
         public static readonly Guid guidClangTidyCmdSet = new Guid(guidClangTidyCmdSetString);
     };
 }

clang-tidy-vs/ClangTidy/Resources.Designer.cs

internal class Resources {
                 return resourceCulture;
             }
             set {
                 resourceCulture = value;
             }
         }
         
         /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap ButtonTidy {
+            get {
+                object obj = ResourceManager.GetObject("ButtonTidy", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
         ///   Looks up a localized string similar to ---
         ///Checks:
-        ///Checks:
-        ///  - Name:        cert-dcl54-cpp
+        ///   # This file should be updated when new checks are added, and eventually we should
+        ///   # generate this file automatically from the .rst files in clang-tidy.
+        ///  - Category:    CERT Secure Coding Standards
         ///    Label:       Overloaded allocation function pairs
         ///    Description: Checks for violations of CERT DCL54-CPP - Overload allocation and deallocation functions as a pair in the same scope
-        ///    Category:    CERT Secure Coding Standards
-        ///  - Name:        cppcoreguidelines-interfaces-global-init
-        ///    Label:       I.22 - Complex Global Initializers
-        ///    Description: Checks for violations of Core Guideline I.22 - Avoid complex initializers of global object [rest of string was truncated]&quot;;.
+        ///    Name:        cert-dcl54-cpp
+        ///  - Category:    C++ Core Guidelines
+        ///    Label:       I.22 - Comple [rest of string was truncated]&quot;;.
         /// </summary>
         internal static string ClangTidyChecks {
             get {
                 return ResourceManager.GetString("ClangTidyChecks", resourceCulture);
             }
         }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Icon similar to (Icon).
+        /// </summary>
+        internal static System.Drawing.Icon Package {
+            get {
+                object obj = ResourceManager.GetObject("Package", resourceCulture);
+                return ((System.Drawing.Icon)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to ---
+        ///Filters:
+        ///  # Format output allowing VS internal auto navigation to source code line and column
+        ///  - Pattern:     &quot;:(\\d+):(\\d+)&quot;
+        ///    Replacement: &quot;($1,$2)&quot;
+        /// </summary>
+        internal static string VSOutputFilters {
+            get {
+                return ResourceManager.GetString("VSOutputFilters", resourceCulture);
+            }
+        }
     }
 }

clang-tidy-vs/ClangTidy/Resources.resx

<root>
   </resheader>
   <resheader name="reader">
     <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </resheader>
   <resheader name="writer">
     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </resheader>
   <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
+  <data name="ButtonTidy" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>Resources\ButtonTidy.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
   <data name="ClangTidyChecks" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>Resources\ClangTidyChecks.yaml;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252</value>
   </data>
+  <data name="Package" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>Resources\Package.ico;System.Drawing.Icon, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="VSOutputFilters" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>Resources\.clang-tidy-vsfilters;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252</value>
+  </data>
 </root>
 No newline at end of file

clang-tidy-vs/ClangTidy/Resources/.clang-tidy-vsfilters

+---
+Filters:
+  # Format output allowing VS internal auto navigation to source code line and column
+  - Pattern:     ":(\\d+):(\\d+)"
+    Replacement: "($1,$2)"
+

clang-tidy-vs/ClangTidy/ThreadRunner/BackgroundThreadWorker.cs

+´╗┐using System;
+using System.Diagnostics;
+using System.Text;
+
+namespace LLVM.ClangTidy
+{
+    /// <summary>
+    /// Thread worker's results returned when event ThreadDone fires.
+    /// </summary>
+    internal class OutputEventArgs : EventArgs
+    {
+        public readonly string Output;
+
+        public OutputEventArgs(string output)
+        {
+            Output = output;
+        }
+    }
+
+    /// <summary>
+    /// Class responsible for launching clang-tidy.exe process and returning
+    /// it's results as OutputEventArgs.
+    /// </summary>
+    public class BackgroundThreadWorker
+    {
+        public event EventHandler ThreadDone;
+        private string ExeName;
+        private string Arguments;
+
+        public BackgroundThreadWorker(String exeName, String arguments)
+        {
+            ExeName = exeName;
+            Arguments = arguments;
+        }
+
+        public void Run()
+        {
+            string result = RunExternalExe(ExeName, Arguments);
+            ThreadDone?.Invoke(this, new OutputEventArgs(result));
+        }
+
+        /// <summary>
+        /// Run external clang-tidy executable and return results.
+        /// </summary>
+        private string RunExternalExe(string filename, string arguments = null)
+        {
+            var process = new System.Diagnostics.Process();
+
+            process.StartInfo.FileName = filename;
+            if (!string.IsNullOrEmpty(arguments))
+            {
+                process.StartInfo.Arguments = arguments;
+            }
+
+            process.StartInfo.CreateNoWindow = true;
+            process.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
+            process.StartInfo.UseShellExecute = false;
+
+            process.StartInfo.RedirectStandardError = true;
+            process.StartInfo.RedirectStandardOutput = true;
+
+            var stdOutput = new StringBuilder();
+            process.OutputDataReceived += (sender, args) => stdOutput.AppendLine(args.Data);
+
+            string stdError = null;
+            try
+            {
+                process.Start();
+                process.BeginOutputReadLine();
+                stdError = process.StandardError.ReadToEnd();
+                process.WaitForExit();
+            }
+            catch (Exception e)
+            {
+                throw new Exception("error while executing " + FormatErrorMsg(filename, arguments) + ": " + e.Message, e);
+            }
+
+            if (process.ExitCode == 0)
+            {
+                return stdOutput.ToString();
+            }
+            else
+            {
+                var message = new StringBuilder();
+
+                if (!string.IsNullOrEmpty(stdError))
+                {
+                    message.AppendLine(stdError);
+                }
+
+                if (stdOutput.Length != 0)
+                {
+                    message.AppendLine("Std output:");
+                    message.AppendLine(stdOutput.ToString());
+                }
+
+                throw new Exception(FormatErrorMsg(filename, arguments) + 
+                    " finished with exit code = " + process.ExitCode + ": " + message);
+            }
+        }
+
+        private string FormatErrorMsg(string filename, string arguments)
+        {
+            return "'" + filename +
+                ((string.IsNullOrEmpty(arguments)) ? string.Empty : " " + arguments) + "'";
+        }
+    }
+}

clang-tidy-vs/ClangTidy/ThreadRunner/ClangTidyRunner.cs

+´╗┐using System;
+using System.ComponentModel;
+using Microsoft.VisualStudio.Shell;
+using Microsoft.VisualStudio.Shell.Interop;
+using EnvDTE;
+
+namespace LLVM.ClangTidy
+{
+    /// <summary>
+    /// Launches clang-tidy.exe, waits for results and displays them in output window.
+    /// </summary>
+    public static class ClangTidyRunner
+    {
+        private static readonly string ClangTidyExeName = "clang-tidy.exe";
+        private static Guid OutputWindowGuid = new Guid(GuidList.guidClangTidyOutputWndString);
+        private static readonly string OutputWindowTitle = "Clang Tidy";
+        private static IVsOutputWindowPane OutputWindowPane;
+        private static string ExtensionDirPath;
+        private static BackgroundWorker InfoWorker;
+        private static volatile bool IsUpdateInProgress = false;
+        private static string CheckedDocumentFullPath;
+
+        static ClangTidyRunner()
+        {
+            var outWindow = Package.GetGlobalService(typeof(SVsOutputWindow)) as IVsOutputWindow;
+            outWindow.CreatePane(ref OutputWindowGuid, OutputWindowTitle, 1, 1);
+            outWindow.GetPane(ref OutputWindowGuid, out OutputWindowPane);
+
+            ExtensionDirPath = Utility.GetVsixInstallPath();
+        }
+
+        public static void RunClangTidyProcess()
+        {
+            PrepareOutputWindow();
+
+            string activeDocumentFullPath = Utility.GetActiveSourceFileFullPath(true);
+
+            if (activeDocumentFullPath != null)
+            {
+                if (!IsUpdateInProgress)
+                {
+                    IsUpdateInProgress = true;
+                    CheckedDocumentFullPath = activeDocumentFullPath;
+
+                    StartBackgroundInfoWorker();
+
+                    string arguments = "-header-filter=" + Utility.GetActiveSourceFileHeaderName();
+                    arguments += " " + CheckedDocumentFullPath;
+
+                    OutputWindowPane.OutputStringThreadSafe(">> Running " + ClangTidyExeName +
+                        " with arguments: '" + arguments + "'\n");
+
+                    BackgroundThreadWorker worker = new BackgroundThreadWorker(ExtensionDirPath +
+                        "\\" + ClangTidyExeName, arguments);
+                    worker.ThreadDone += HandleThreadFinished;
+
+                    System.Threading.Thread workerThread = new System.Threading.Thread(worker.Run);
+                    workerThread.Start();
+                }
+            }
+            else
+            {
+                OutputWindowPane.OutputStringThreadSafe(">> No source file available!");
+            }
+        }
+
+        /// <summary>
+        /// Executed when ThreadDone event fires for thread responsible for launching clang-tidy thread.
+        /// </summary>
+        private static void HandleThreadFinished(object sender, EventArgs out_args)
+        {
+            InfoWorker.CancelAsync();
+
+            ValidationResultFormatter.AcquireTagsFromOutput((out_args as OutputEventArgs).Output);
+
+            // Wait for info worker thread to finish
+            while (InfoWorker.CancellationPending) { System.Threading.Thread.Sleep(50); }
+
+            OutputWindowPane.OutputStringThreadSafe("\n");
+            OutputWindowPane.OutputStringThreadSafe(
+                ValidationResultFormatter.FormatOutputWindowMessage((out_args as OutputEventArgs).Output, CheckedDocumentFullPath));
+            OutputWindowPane.OutputStringThreadSafe(">> Finished");
+
+            Classifier.InvalidateActiveClassifier();
+
+            IsUpdateInProgress = false;
+        }
+
+        /// <summary>
+        /// Background worker is a simple thread responsible for updating output window 
+        /// (tell user something is happening in background) while clang-tidy thread does it's job.
+        /// </summary>
+        private static bool StartBackgroundInfoWorker()
+        {
+            if (InfoWorker != null && (InfoWorker.IsBusy || InfoWorker.CancellationPending))
+            {
+                throw new Exception("while trying to start new worker thread another worker thread found running!");
+            }
+
+            if (InfoWorker == null)
+            {
+                InfoWorker = new BackgroundWorker();
+                InfoWorker.WorkerReportsProgress = true;
+                InfoWorker.WorkerSupportsCancellation = true;
+
+                InfoWorker.DoWork += new DoWorkEventHandler(BackgroundWorkerDoWork);
+                InfoWorker.ProgressChanged += new ProgressChangedEventHandler(BackgroundWorkerUpdateProgress);
+            }
+
+            InfoWorker.RunWorkerAsync();
+
+            return true;
+        }
+
+        private static void BackgroundWorkerDoWork(object sender, DoWorkEventArgs args)
+        {
+            var worker = sender as BackgroundWorker;
+            const int sleepDuration = 500;
+            float executionDuration = 0.0f;
+
+            while (!worker.CancellationPending)
+            {
+                System.Threading.Thread.Sleep(sleepDuration);
+                executionDuration += (float)sleepDuration / 1000.0f;
+
+                // Do not report update progress for short tasks.
+                if (executionDuration > 1.0f)
+                    worker.ReportProgress((int)executionDuration);
+            }
+        }
+
+        /// <summary>
+        /// Just put comma every now and then to ensure the user clang-tidy is still working
+        /// </summary>
+        private static void BackgroundWorkerUpdateProgress(object sender, ProgressChangedEventArgs args)
+        {
+            OutputWindowPane.OutputStringThreadSafe(".");
+        }
+
+        private static void PrepareOutputWindow()
+        {
+            OutputWindowPane.Clear();
+            OutputWindowPane.Activate();
+
+            // Force output window to front
+            var dte = Package.GetGlobalService(typeof(SDTE)) as DTE;
+            dte.ExecuteCommand("View.Output");
+        }
+    }
+}

clang-tidy-vs/ClangTidy/ThreadRunner/OutputFilterDatabase.cs

+´╗┐using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using YamlDotNet.Serialization;
+using YamlDotNet.Serialization.NamingConventions;
+
+namespace LLVM.ClangTidy
+{
+    public class FilterInfo
+    {
+        [YamlAlias("Pattern")]
+        public string Pattern { get; set; }
+
+        [YamlAlias("Replacement")]
+        public string Replacement { get; set; }
+
+        [YamlAlias("Multiline")]
+        public bool Multiline { get; set; } = false;
+    }
+
+    /// <summary>
+    /// Reads the list of output window regex filters from Yaml
+    /// There are basic filters defined in this C# solution and optional filters.
+    /// Optional filters are searched for upwards in file system hierarchy starting
+    /// from folder where currently validated source file is placed.
+    /// </summary>
+    public static class OutputFilterDatabase
+    {
+        static List<FilterInfo> BasicFilters = new List<FilterInfo>();
+        static string FiltersFileName = ".clang-tidy-vsfilters";
+
+        class FilterRoot
+        {
+            [YamlAlias("Filters")]
+            public FilterInfo[] Filters { get; set; }
+        }
+
+        static OutputFilterDatabase()
+        {
+            string basicConfigPath = Path.Combine(Utility.GetVsixInstallPath(), "Resources", FiltersFileName);
+            if (File.Exists(basicConfigPath))
+                ReadConfigFile(basicConfigPath, ref BasicFilters);
+        }
+
+        /// <summary>
+        /// Returns filters valid for source file currently validated by clang-tidy
+        /// </summary>
+        public static IEnumerable<FilterInfo> GetFilters(string validatedFilePath)
+        {
+            var customFilters = BasicFilters;
+
+            ReadCustomConfigFiles(validatedFilePath, ref customFilters);
+
+            return customFilters;
+        }
+
+        private static void ReadCustomConfigFiles(string validatedFilePath, ref List<FilterInfo> filters)
+        {
+            foreach (string P in Utility.SplitPath(validatedFilePath))
+            {
+                string configFile = Path.Combine(P, FiltersFileName);
+                if (!File.Exists(configFile))
+                    continue;
+
+                ReadConfigFile(configFile, ref filters);
+            }
+        }
+
+        private static void ReadConfigFile(string filePath, ref List<FilterInfo> filters)
+        {
+            using (StreamReader Reader = new StreamReader(filePath))
+            {
+                var D = new Deserializer(namingConvention: new PascalCaseNamingConvention());
+                var Root = D.Deserialize<FilterRoot>(Reader);
+
+                foreach (var filter in Root.Filters)
+                {
+                    if (filter.Replacement == null)
+                        filter.Replacement = "";
+                }
+
+                filters.AddRange(Root.Filters);
+            }
+        }
+    }
+}

clang-tidy-vs/ClangTidy/ThreadRunner/ValidationResultFormatter.cs

+´╗┐using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Text.RegularExpressions;
+using System.Threading;
+
+namespace LLVM.ClangTidy
+{
+    static public class ValidationResultFormatter
+    {
+        public class SingleValidationResult
+        {
+            public string File;
+            public int Line;
+            public int Column;
+            public string Classification;
+            public string Description;
+            public string TidyCheckName;
+            public string CodeLine;
+            public string HighlightSymbol;
+        }
+
+        static public ReaderWriterLockSlim ValidationResultsLock = new ReaderWriterLockSlim();
+        static public List<SingleValidationResult> ValidationResults { private set; get; } = new List<SingleValidationResult>();
+
+        /// <summary>
+        /// Use filters/replacement patterns (read from yaml file) to format (or remove) lines in output.
+        /// </summary>
+        public static string FormatOutputWindowMessage(string message, string checkedFile)
+        {
+            foreach (var filter in OutputFilterDatabase.GetFilters(checkedFile))
+            {
+                var rgx = new Regex(filter.Pattern, filter.Multiline ? RegexOptions.Multiline : RegexOptions.None);
+                message = rgx.Replace(message, filter.Replacement);
+            }
+
+            return message;
+        }
+
+        /// <summary>
+        /// Parse clang-tidy output to acquire list of errors and warnings in usable format.
+        /// </summary>
+        public static void AcquireTagsFromOutput(string message)
+        {
+            ValidationResults.Clear();
+
+            // Clang-tidy output pattern is as goes: 
+            // (file name full path):(line):(column): (warning/error): (description) [clang-tidy check name]
+            //     (indented code line)
+            //                   (^ character pointing at warning/error in code line)
+            string pattern = @"(.*):(\d+):(\d+):\s(.*):\s(.*)\s\[(.*)\]\r\n(.*)\r";
+
+            ValidationResultsLock.EnterWriteLock();
+
+            var matches = Regex.Matches(message, pattern);
+            foreach (Match match in matches)
+            {
+                if (match.Groups.Count == 8)
+                {
+                    SingleValidationResult res = new SingleValidationResult();
+                    res.File = match.Groups[1].Value;
+                    // use Microsoft's favorite backslashes in paths instead of standard slashes
+                    res.File = res.File.Replace('/', '\\'); 
+                    int.TryParse(match.Groups[2].Value, out res.Line);
+                    int.TryParse(match.Groups[3].Value, out res.Column);
+                    // line and column number start from 1 but in MEF components numbering starts with 0
+                    res.Line -= 1;
+                    res.Column -= 1;
+                    res.Classification = match.Groups[4].Value;
+                    res.Description = match.Groups[5].Value;
+                    res.TidyCheckName = match.Groups[6].Value;
+                    res.CodeLine = match.Groups[7].Value;
+                    // Extract symbol where warning/error is present using given column number 
+                    // as start and searching for ending delimiter
+                    res.HighlightSymbol = res.CodeLine.Substring(res.Column);
+                    res.HighlightSymbol = Regex.Match(res.HighlightSymbol, @"^([a-zA-z0-9_]+)").ToString();
+
+                    ValidationResults.Add(res);
+                }
+            }
+
+            ValidationResultsLock.ExitWriteLock();
+        }
+    }
+}

clang-tidy-vs/ClangTidy/Utility.cs

-´╗┐using System;
+´╗┐using EnvDTE;
+using Microsoft.VisualStudio.Shell;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Reflection;
 using System.Text;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 
 namespace LLVM.ClangTidy
 {
     static class Utility
     {
static class Utility
             return File.Exists(ClangTidy);
         }
 
         public static bool MatchWildcardString(string Value, string Pattern)
         {
             string RE = Regex.Escape(Pattern).Replace(@"\*", ".*");
             return Regex.IsMatch(Value, RE);
         }
+
+        public static string GetActiveSourceFileFullPath(bool searchForCppFile)
+        {
+            DTE dte = Package.GetGlobalService(typeof(DTE)) as DTE;
+
+            if (dte.ActiveDocument != null)
+            {
+                string filePath = dte.ActiveDocument.FullName;
+                if (searchForCppFile && !filePath.EndsWith(".cpp"))
+                {
+                    string cppFilePath = Regex.Replace(filePath, @"\..*$", ".cpp");
+                    if (File.Exists(cppFilePath))
+                        return cppFilePath;
+                }
+
+                return filePath;
+            }
+            else
+                return null;
+        }
+
+        public static string GetActiveSourceFileName()
+        {
+            DTE dte = Package.GetGlobalService(typeof(DTE)) as DTE;
+
+            if (dte.ActiveDocument != null)
+                return dte.ActiveDocument.Name;
+            else
+                return null;
+        }
+
+        public static string GetActiveSourceFileHeaderName()
+        {
+            string file_name = GetActiveSourceFileName();
+
+            if (!string.IsNullOrEmpty(file_name))
+            {
+                file_name = Regex.Replace(file_name, @"\..*$", ".h");
+            }
+
+            return file_name;
+        }
+
+        public static string GetVsixInstallPath()
+        {
+            string code_base = Assembly.GetExecutingAssembly().CodeBase;
+            UriBuilder uri = new UriBuilder(code_base);
+            string path = Uri.UnescapeDataString(uri.Path);
+            return Path.GetDirectoryName(path);
+        }
     }
 }

clang-tidy-vs/ClangTidy/source.extension.vsixmanifest

-´╗┐<?xml version="1.0" encoding="utf-8"?>
-<Vsix Version="1.0" xmlns="http://schemas.microsoft.com/developer/vsx-schema/2010">
-  <Identifier Id="405594C3-042A-4155-B9A6-E25DAB8B1924">
-    <Name>ClangFormat</Name>
-    <Author>LLVM</Author>
-    <Version>4.0.0</Version>
-    <Description xml:space="preserve">A static analysis tool for C/C++ code.</Description>
-    <Locale>1033</Locale>
-    <MoreInfoUrl>http://clang.llvm.org/extra/clang-tidy/</MoreInfoUrl>
-    <License>license.txt</License>
-    <InstalledByMsi>false</InstalledByMsi>
-    <SupportedProducts>
-      <VisualStudio Version="10.0">
-        <Edition>Pro</Edition>
-      </VisualStudio>
-      <VisualStudio Version="11.0">
-        <Edition>Pro</Edition>
-      </VisualStudio>
-      <VisualStudio Version="12.0">
-        <Edition>Pro</Edition>
-      </VisualStudio>
-      <VisualStudio Version="14.0">
-        <Edition>Pro</Edition>
-      </VisualStudio>
-    </SupportedProducts>
-    <SupportedFrameworkRuntimeEdition MinVersion="4.0" MaxVersion="4.0" />
-  </Identifier>
-  <References>
-        <Reference Id="Microsoft.VisualStudio.MPF" MinVersion="10.0">
-            <Name>Visual Studio MPF</Name>
-        </Reference>
-  </References>
-  <Content>
-    <VsPackage>|%CurrentProject%;PkgdefProjectOutputGroup|</VsPackage>
-  </Content>
-</Vsix>

clang-tidy-vs/README.txt

 This directory contains a VSPackage project to generate a Visual Studio extension
 for clang-tidy.
 
 Build prerequisites are:
-- Visual Studio 2013 Professional
-- Visual Studio 2013 SDK
-- Visual Studio 2010 Professional (?)
-- Visual Studio 2010 SDK (?)
+- Visual Studio 2015 Professional
+- Visual Studio 2015 SDK
 
 The extension is built using CMake by setting BUILD_CLANG_TIDY_VS_PLUGIN=ON
 when configuring a Clang build, and building the clang_tidy_vsix target.
 
 The CMake build will copy clang-tidy.exe and LICENSE.TXT into the ClangTidy/
 directory so they can be bundled with the plug-in, as well as creating
 ClangTidy/source.extension.vsixmanifest. Once the plug-in has been built with
 CMake once, it can be built manually from the ClangTidy.sln solution in Visual
 Studio.
+
+===========
+ Debugging
+===========
+
+Open ClangFormat.sln in Visual Studio, then:
+
+- Make sure the "Debug" target is selected
+- Open the ClangTidy project properties
+- Select the Debug tab
+- Set "Start external program:" to where your devenv.exe is installed. Typically
+  it's "C:\Program Files (x86)\Microsoft Visual Studio 14.0\Common7\IDE\devenv.exe"
+- Set "Command line arguments" to: /rootsuffix Exp
+- You can now set breakpoints if you like
+- Press F5 to build and run with debugger
+
+If all goes well, a new instance of Visual Studio will be launched in a special
+mode where it uses the experimental hive instead of the normal configuration hive.
+By default, when you build a VSIX project in Visual Studio, it auto-registers the
+extension in the experimental hive, allowing you to test it. In the new Visual Studio
+instance, open or create a C++ solution, and you should now see the Clang Format
+entries in the Tool menu. You can test it out, and any breakpoints you set will be
+hit where you can debug as usual.

clang-tidy-vs/source.extension.vsixmanifest.in

 ´╗┐<?xml version="1.0" encoding="utf-8"?>
-<Vsix Version="1.0" xmlns="http://schemas.microsoft.com/developer/vsx-schema/2010">
-  <Identifier Id="405594C3-042A-4155-B9A6-E25DAB8B1924">
-    <Name>ClangTidy</Name>
-    <Author>LLVM</Author>
-    <Version>@CLANG_TIDY_VS_VERSION@</Version>
+<PackageManifest Version="2.0.0" xmlns:d="http://schemas.microsoft.com/developer/vsx-schema-design/2011" xmlns="http://schemas.microsoft.com/developer/vsx-schema/2011">
+  <Metadata>
+    <Identity Id="405594C3-042A-4155-B9A6-E25DAB8B1924" Version="@CLANG_TIDY_VS_VERSION@" Language="en-US" Publisher="LLVM" />
+    <DisplayName>ClangTidy</DisplayName>
     <Description xml:space="preserve">A static analysis tool for C/C++ code.</Description>
-    <Locale>1033</Locale>
-    <MoreInfoUrl>http://clang.llvm.org/extra/clang-tidy/</MoreInfoUrl>
+    <MoreInfo>http://clang.llvm.org/extra/clang-tidy/</MoreInfo>
     <License>license.txt</License>
-    <InstalledByMsi>false</InstalledByMsi>
-    <SupportedProducts>
-      <VisualStudio Version="10.0">
-        <Edition>Pro</Edition>
-      </VisualStudio>
-      <VisualStudio Version="11.0">
-        <Edition>Pro</Edition>
-      </VisualStudio>
-      <VisualStudio Version="12.0">
-        <Edition>Pro</Edition>
-      </VisualStudio>
-      <VisualStudio Version="14.0">
-        <Edition>Pro</Edition>
-      </VisualStudio>
-    </SupportedProducts>
-    <SupportedFrameworkRuntimeEdition MinVersion="4.0" MaxVersion="4.0" />
-  </Identifier>
-  <References>
-        <Reference Id="Microsoft.VisualStudio.MPF" MinVersion="10.0">
-            <Name>Visual Studio MPF</Name>
-        </Reference>
-  </References>
-  <Content>
-    <VsPackage>|%CurrentProject%;PkgdefProjectOutputGroup|</VsPackage>
-  </Content>
-</Vsix>
+  </Metadata>
+  <Installation>
+    <InstallationTarget Id="Microsoft.VisualStudio.Pro" Version="[14.0,)" />
+    <InstallationTarget Id="Microsoft.VisualStudio.Community" Version="[14.0,)" /> 
+  </Installation>
+  <Dependencies>
+    <Dependency Id="Microsoft.Framework.NDP" DisplayName="Microsoft .NET Framework" d:Source="Manual" Version="[4.5,)" />
+  </Dependencies>
+  <Assets>
+    <Asset Type="Microsoft.VisualStudio.MefComponent" d:Source="Project" d:ProjectName="%CurrentProject%" Path="|%CurrentProject%|" />
+    <Asset Type="Microsoft.VisualStudio.VsPackage" d:Source="Project" d:ProjectName="%CurrentProject%" Path="|%CurrentProject%;PkgdefProjectOutputGroup|" />
+  </Assets>
+</PackageManifest>