Add a clang-tidy Visual Studio extension

[zturner]

Summary

This gets a pretty solid UI in place for editing clang-tidy files. It displays all the checks, descriptions of most of them with more to come later (it's a bit tedious), and allows disabling / enabling individual checks or entire groups of checks using a familiar UI such as the one in the C++ project system that supports inheritance or explicit overrides.

It supports serialization to and from Yaml using the NuGet package YamlDotNet, and depends on an additional NuGetPackage called BrutalStrongNameSigner which is required in order to strong name sign YamlDotNet (otherwise our extension can't load it).

Unfortunately implementing an inheritance-based property system such as Visual Studio's is *highly* non-trivial, and so this patch turned out much larger than I originally anticipated.

If need be, I can try to submit a skeleton patch that does nothing but add a blank options page first, so that this patch is not muddled up with the actual content.

I'm not sure who the best C# reviewer is around here, so adding a few people.

[alexfh]

Awesome!

A few comments.

CMakeLists.txt

6

Should the plugin be placed inside clang-tidy directory?

clang-tidy-vs/ClangTidy/CategoryVerb.cs

30

Remove the empty line.

35

Should this be value is string?

clang-tidy-vs/ClangTidy/CheckTree.cs

131

Ideally, this should be configurable without re-compilation. Not necessary for now, but please add a FIXME.

clang-tidy-vs/ClangTidy/ClangTidyConfigurationPage.cs

11

Are all of these actually used?

27

^K^F or whatever poor C# folks do to format code without clang-format ;)

clang-tidy-vs/ClangTidy/ClangTidyPackage.cs

59

Remove commented-out code?

clang-tidy-vs/ClangTidy/ClangTidyProperties.cs

82

I hope, this file is generated?

A way to update this file should be documented.

clang-tidy-vs/ClangTidy/Properties/AssemblyInfo.cs

33

Ideally, the file should be generated by CMake to use proper version number. Please add a FIXME.

clang-tidy-vs/ClangTidy/PropertyFileParser.cs

81

s/ClangTidy/ConfigFile/

209

Is the copy needed to avoid aliasing? (i.e. will this break if you iterate over Props.FindChecksMatching(Check) instead?)

clang-tidy-vs/ClangTidy/Utility.cs

32

Question marks are not supported in check patterns, so .Replace(@"\?", ".") can be dropped.

[Eugene.Zelenko]

clang-tidy-vs/ClangTidy/CheckTree.cs

80

Unnecessary empty line.

94

Unnecessary empty line.

clang-tidy-vs/ClangTidy/ClangTidy.vsct

23

Unnecessary empty line, same below in many places here.

clang-tidy-vs/ClangTidy/ClangTidyPropertyGrid.cs

179

Unnecessary empty line.

clang-tidy-vs/ClangTidy/PropertyFileParser.cs

15

Unnecessary empty line.

24

Please add empty line.

[zturner]

I can fix the empty lines, but keep in mind that Visual Studio's C# editor is MUCH more aggressive about auto-formatting your code. So it seems like a fruitless endeavor to me, as we will constantly be fighting against their auto formatter, which does this automatically every time you add a new function.

[zturner]

CMakeLists.txt

6

I followed the same way that the clang format VS extension uses. I don't mind to move it, I just did it this way for consistency.

clang-tidy-vs/ClangTidy/ClangTidyProperties.cs

82

No, I actually typed this entire file :-/ I don't know of a good way to auto generate it. We would need a single file, perhaps Yaml or something, consisting of:

1. Category Name
2. Display Name
3. Description
4. clang-tidy built in default value of check.

At that point, we wouldn't even need to generate the file, we could read it at runtime and add the properties dynamically (through the ICustomTypeDescriptor interface).

For now though, the way to update the file is to copy / paste one property and change the values accordingly to add a new check.

clang-tidy-vs/ClangTidy/PropertyFileParser.cs

209

The copy is not needed to avoid aliasing. It's fine to iterate over Props.FindChecksMatching(Check). I wrote it this way because it helps for debugging, as I could just add a watch for Matches and view the array in the debugger.

[zturner]

Updated with suggestions. I haven't fixed the empty lines yet because there are a lot of them, and I will wait to see how strongly people feel about it first. Personally I don't think it's worth worry about since we will be fighting with Visual Studio over this endlessly and we don't have a clang-format for C# to alleviate this nuisance.

[alexfh]

In D23848#524608, @zturner wrote:

I can fix the empty lines, but keep in mind that Visual Studio's C# editor is MUCH more aggressive about auto-formatting your code. So it seems like a fruitless endeavor to me, as we will constantly be fighting against their auto formatter, which does this automatically every time you add a new function.

I would definitely not fight with visual editors that reset formatting every time you touch the file. However, if VS only adds empty lines when initially adding a function, that doesn't promise much resistance ;)

CMakeLists.txt

6

I don't feel strongly either way. Let's figure this out later.

clang-tidy-vs/ClangTidy/ClangTidy.vsct

23

If there's a way to visually edit this file, I wouldn't care about formatting.

clang-tidy-vs/ClangTidy/ClangTidyProperties.cs

82

Manually updating this file won't fly =[

I guess, we could try to use .rst files as the source of truth. They follow a strict naming scheme (<check-name>.rst) and we could require the first paragraph of the text to be a single-sentence description of the check suitable for this purpose as well.

I'd also make the display name the same as the full clang-tidy check name (DCL50-CPP is neither more useful nor convenient than the full check name).

The only thing we'd need to maintain manually in this case is category descriptions.

WDYT?

[zturner]

clang-tidy-vs/ClangTidy/ClangTidyProperties.cs

82

Are the .rst files in the repo somewhere already? I don't see them.

As for the display name, I agree this one is bad (I forgot to change it). But you can look at some of the ones below for better examples. For example, I find I.22 - Complex Global Initializers to be a better short descriptor than cppcoreguidelines-interfaces-global-init.

What about a hand-maintained Yaml file that adheres to a format similar to the following?

---
Checks:
  - Name:        cert-dcl54-cpp
    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 objects
    Category:    C++ Core Guidelines
...

Some file somewhere is going to have to be maintained by hand, and since a file such as this doesn't appear to exist in clang-tidy already, we might as well use a format that we already have good tools to parse at runtime, such as Yaml.

[zturner]

BTW, since I forgot to do so in the original review, here is a screenshot of what the UI for the property editor looks like in this extension:

clang-tidy-vs/ClangTidy/ClangTidy.vsct

23

This file is auto-generated by Visual Studio. You can manually add your own things to it (as we've done at the end of the file), but it doesn't seem worthwhile to go back and fix auto-generated code.

BTW, this is just an XML file, so it gets collapse functionality in the Visual Studio Editor. That is, you can collapse tags so that they are not displayed. Not sure if that makes a difference.

[alexfh]

clang-tidy-vs/ClangTidy/ClangTidyProperties.cs

82

The .rst files are there: https://reviews.llvm.org/diffusion/L/browse/clang-tools-extra/trunk/docs/clang-tidy/checks/

Docs + source code are already enough hassle to maintain, so adding yet another file with a similar information seems too much. We can start with a hand-written YAML file and later add a script to generate it from the docs. I'm not sure though, what Label could be mapped on. Do you need it for the property editor or can you get away with just the name?

[zturner]

clang-tidy-vs/ClangTidy/ClangTidyProperties.cs

82

Well you can look at the screenshot to see how I'm using it. Basically the left hand side of the grid are all the "label" values. It's what people are going to see when deciding whether they want to enable a check or not. So it should be mostly self-explanatory without having to click on it to get more detail. The name kinda is, but the point of the extension is to be friendlier than editing files by hand, so I think we should try to provide a friendlier name too. When you're using the command line tool you have no choice but to specify the check name, but if you're using a UI I think we can give the user a little bit more info about each check.

Generating YAML from docs seems like a decent idea. Perhaps to map label we could extend the rst format a little to add the label to it. Sort of like "summary" vs "description".

I'll do a hand-written Yaml file for now, and think about the best way to generate the Yaml from RST in a later patch.

[alexfh]

clang-tidy-vs/ClangTidy/ClangTidyProperties.cs

82

SG.

Re: label vs check name. I think, even if we show a friendlier label (which we'll need to require for all new checks and back-fill for the existing ones), the extension should also show the check name somewhere for transparency. It's supposed to be human-readable to some degree (not a proper explanation though, rather a hint to what the check is about). It's also shown in the diagnostic messages, so there's no point in hiding it elsewhere.

[amccarth]

I don't know enough C# to review for language usage. I was mostly reading for understandability. Overall, I think this looks really nice.

clang-tidy-vs/ClangTidy/CheckTree.cs

67

This seems overly complicated so I assume I'm missing some nuance. Why not:

if (Parent_ == null)
    return Name_;
string ParentPath = Parent_.Path;

Is there a case where Parent_.Path could return null besides the one that you created?

clang-tidy-vs/ClangTidy/InheritablePropertyComponent.cs

14

s/good makes/makes/

clang-tidy-vs/README.txt

8

2010? 2015? Will Community editions work?

[zturner]

Remove the hand-written mega class and generate all the properties dynamically.

It was a little tricky getting dynamically generated properties working, so the diff is bigger than I expected. But it should all work now, and the code is much cleaner as a result I think. I renamed all the Inheritable stuff to Dynamic to better clarify its nature.

[Eugene.Zelenko]

I think will be good idea to mention this plugin in docs/ReleaseNotes.rst.

[zturner]

In D23848#525485, @Eugene.Zelenko wrote:

I think will be good idea to mention this plugin in docs/ReleaseNotes.rst.

I was planning to wait until it's "finished". This patch will give you a user interface for editing .clang-tidy files, but it still won't provide any means of *running* clang-tidy on the currently active source file, project, or solution.

I had planned to add those features incrementally to make the reviews more manageable. What do you guys think?

[zturner]

clang-tidy-vs/ClangTidy/CheckTree.cs

67

If Parent_ == null, that is the root note, or default node. It doesn't represent any particualr check, it's just the node at the top of the tree containing all the branches. So we have to return null in that case. We could probably return Name_ as it would probably be equal to null, but it seems more clear to just return a constant.

Even if Parent_ is not null though, Parent_.Path could equal null. This would happen for any node immediately under the root, because the parent would be the root, and by the previous explanation, Parent_.Path would then return null. So, for top-level check nodes we just want to return the name, because there is nothing before it to prepend a - to.

For deeper nodes though, we want to get the path from the parent, then join it with a -.

[zturner]

Properly save and reload the settings when the user clicks various buttons in the dialog (Apply, Cancel, etc).

[amccarth]

clang-tidy-vs/ClangTidy/CheckTree.cs

69

OK, cool. I assumed that the root had a name. Thus a node with no parent (a root) could return its name and the rest of the children would each append '-' + Name_. But if roots are nameless, then your solution is fine.

[zturner]

Anyone else have any thoughts on this or is this good to go?

[zturner]

I am planning to submit this today if there are no further suggestions.

[alexfh]

A few late comments. Looks good overall.

clang-tidy-vs/ClangTidy/CategoryVerb.cs

53

Should this be value is CategoryVerb?

clang-tidy-vs/ClangTidy/ClangTidyConfigurationPage.cs

12

Is this addressed?

clang-tidy-vs/ClangTidy/ClangTidyPropertyGrid.cs

177

I guess, this handler is not needed, since it's empty.

clang-tidy-vs/ClangTidy/Guids.cs

13

Could you fix the No newline at end of file?

clang-tidy-vs/ClangTidy/PkgCmdID.cs

8

Could you fix the No newline at end of file?

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

1 ↗

(On Diff #69296)

Does YAML support comments? If yes, I'd add a not that this file should be updated when new checks are added and a TODO to add a generator from .rst.

[alexfh]

clang-tidy-vs/ClangTidy/ClangTidyPackage.cs

54

Add a FIXME to actually implement this.

CMakeLists.txt

 add_subdirectory(clang-apply-replacements)
 add_subdirectory(clang-rename)
 add_subdirectory(modularize)
 if(CLANG_ENABLE_STATIC_ANALYZER)
 add_subdirectory(clang-tidy)
+add_subdirectory(clang-tidy-vs)
 endif()
 
 add_subdirectory(clang-query)
 add_subdirectory(include-fixer)
 add_subdirectory(pp-trace)
 add_subdirectory(tool-template)
 
 # Add the common testsuite after all the tools.

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")
+
+  if (NOT CLANG_TIDY_VS_VERSION)
+    set(CLANG_TIDY_VS_VERSION "${LLVM_VERSION_MAJOR}.${LLVM_VERSION_MINOR}.${LLVM_VERSION_PATCH}")
+  endif()
+
+  configure_file("source.extension.vsixmanifest.in"
+      "${CMAKE_CURRENT_SOURCE_DIR}/ClangTidy/source.extension.vsixmanifest")
+
+  add_custom_target(clang_tidy_vsix ALL
+      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.sln

+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 14
+VisualStudioVersion = 14.0.25123.0
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ClangTidy", "ClangTidy\ClangTidy.csproj", "{BE261DA1-36C6-449A-95C5-4653A549170A}"
+EndProject
+Global
+  GlobalSection(SolutionConfigurationPlatforms) = preSolution
+    Debug|Any CPU = Debug|Any CPU
+    Release|Any CPU = Release|Any CPU
+  EndGlobalSection
+  GlobalSection(ProjectConfigurationPlatforms) = postSolution
+    {BE261DA1-36C6-449A-95C5-4653A549170A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+    {BE261DA1-36C6-449A-95C5-4653A549170A}.Debug|Any CPU.Build.0 = Debug|Any CPU
+    {BE261DA1-36C6-449A-95C5-4653A549170A}.Release|Any CPU.ActiveCfg = Release|Any CPU
+    {BE261DA1-36C6-449A-95C5-4653A549170A}.Release|Any CPU.Build.0 = Release|Any CPU
+  EndGlobalSection
+  GlobalSection(SolutionProperties) = preSolution
+    HideSolutionNode = FALSE
+  EndGlobalSection
+EndGlobal

clang-tidy-vs/ClangTidy/CategoryVerb.cs

+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace LLVM.ClangTidy
+{
+    /// <summary>
+    /// Allows entire categories of properties to be enabled, disabled, or inherited
+    /// in one fell swoop.  We add properties to each category with the value being
+    /// this enum, and when the value is selected, we use reflection to find all other
+    /// properties in the same category and perform the corresponding action.
+    /// </summary>
+    public enum CategoryVerb
+    {
+        None,
+        Disable,
+        Enable,
+        Inherit
+    }
+
+    public class CategoryVerbConverter : EnumConverter
+    {
+        public CategoryVerbConverter() : base(typeof(CategoryVerb))
+        {
+        }
+
+        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
+        {
+            if (value is string)
+            {
+                switch ((string)value)
+                {
+                    case "Disable Category":
+                        return CategoryVerb.Disable;
+                    case "Enable Category":
+                        return CategoryVerb.Enable;
+                    case "Inherit Category":
+                        return CategoryVerb.Inherit;
+                    case "":
+                        return CategoryVerb.None;
+                }
+            }
+            return base.ConvertFrom(context, culture, value);
+        }
+
+        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
+        {
+            if (value.GetType() == typeof(CategoryVerb) && destinationType == typeof(string))
+            {
+                switch ((CategoryVerb)value)
+                {
+                    case CategoryVerb.Disable:
+                        return "Disable Category";
+                    case CategoryVerb.Enable:
+                        return "Enable Category";
+                    case CategoryVerb.Inherit:
+                        return "Inherit Category";
+                    case CategoryVerb.None:
+                        return String.Empty;
+                }
+            }
+
+            return base.ConvertTo(context, culture, value, destinationType);
+        }
+    }
+}

clang-tidy-vs/ClangTidy/CheckTree.cs

+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace LLVM.ClangTidy
+{
+    /// <summary>
+    /// CheckTree is used to group checks into categories and subcategories.  For
+    /// example, given the following list of checks:
+    /// 
+    ///   llvm-include-order
+    ///   llvm-namespace-comment
+    ///   llvm-twine-local
+    ///   llvm-header-guard
+    ///   google-runtime-member-string-references
+    ///   google-runtime-int
+    ///   google-readability-namespace-comments
+    ///   
+    /// the corresponding CheckTree would look like this:
+    /// 
+    ///   llvm
+    ///     include-order
+    ///     namespace-comment
+    ///     twine-local
+    ///     header-guard
+    ///   google
+    ///     runtime
+    ///       member-string-references
+    ///       int
+    ///     readability
+    ///       namespace-comments
+    ///       redundant-smartptr-get
+    ///       
+    /// This is useful when serializing a set of options out to a .clang-tidy file,
+    /// because we need to decide the most efficient way to serialize the sequence
+    /// of check commands, when to use wildcards, etc.  For example, if everything
+    /// under google is inherited, we can simply leave that entry out entirely from
+    /// the .clang-tidy file.  On the other hand, if anything is inherited, we *must
+    /// not* add or remove google-* by wildcard because that, by definition, means
+    /// the property is no longer inherited.  When we can categorize the checks into
+    /// groups and subgroups like this, it is possible to efficiently serialize to
+    /// a minimal representative .clang-tidy file.
+    /// </summary>
+
+    public abstract class CheckTreeNode
+    {
+        private string Name_;
+        private CheckTreeNode Parent_;
+
+        protected CheckTreeNode(string Name, CheckTreeNode Parent)
+        {
+            Name_ = Name;
+            Parent_ = Parent;
+        }
+
+        public string Path
+        {
+            get
+            {
+                if (Parent_ == null)
+                    return null;
+                string ParentPath = Parent_.Path;
+                if (ParentPath == null)
+                    return Name_;
+                return ParentPath + "-" + Name_;
+            }
+        }
+
+        public string Name
+        {
+            get
+            {
+                return Name_;
+            }
+        }
+
+
+        public abstract int CountChecks { get; }
+        public abstract int CountExplicitlyDisabledChecks { get; }
+        public abstract int CountExplicitlyEnabledChecks { get; }
+        public abstract int CountInheritedChecks { get; }
+    }
+
+    public class CheckTree : CheckTreeNode
+    {
+        private Dictionary<string, CheckTreeNode> Children_ = new Dictionary<string, CheckTreeNode>();
+        public CheckTree()
+            : base(null, null)
+        {
+
+        }
+
+        private CheckTree(string Name, CheckTree Parent)
+            : base(Name, Parent)
+        {
+        }
+
+        private void AddLeaf(string Name, InheritableValuePropertyDescriptor<bool> Property)
+        {
+            Children_[Name] = new CheckLeaf(Name, this, Property);
+        }
+
+        private CheckTree AddOrCreateSubgroup(string Name)
+        {
+            CheckTreeNode Subgroup = null;
+            if (Children_.TryGetValue(Name, out Subgroup))
+            {
+                System.Diagnostics.Debug.Assert(Subgroup is CheckTree);
+                return (CheckTree)Subgroup;
+            }
+
+            CheckTree SG = new CheckTree(Name, this);
+            Children_[Name] = SG;
+            return SG;
+        }
+
+        public static CheckTree Build(ClangTidyProperties Config)
+        {
+            // Since some check names contain dashes in them, it doesn't make sense to
+            // simply split all check names by dash and construct a huge tree.  For
+            // example, in the check called google-runtime-member-string-references,
+            // we don't need each of those to be a different subgroup.  So instead we
+            // explicitly specify the common breaking points at which a user might want
+            // to use a -* and everything else falls as a leaf under one of these
+            // categories.
+            // FIXME: This should be configurable without recompilation
+            CheckTree Root = new CheckTree();
+            string[][] Groups = new string[][] {
+                new string[] {"boost"},
+                new string[] {"cert"},
+                new string[] {"clang", "diagnostic"},
+                new string[] {"cppcoreguidelines", "interfaces"},
+                new string[] {"cppcoreguidelines", "pro", "bounds"},
+                new string[] {"cppcoreguidelines", "pro", "type"},
+                new string[] {"google", "build"},
+                new string[] {"google", "readability"},
+                new string[] {"google", "runtime"},
+                new string[] {"llvm"},
+                new string[] {"misc"},
+            };
+
+            foreach (string[] Group in Groups)
+            {
+                CheckTree Subgroup = Root;
+                foreach (string Component in Group)
+                    Subgroup = Subgroup.AddOrCreateSubgroup(Component);
+            }
+
+            var Props = Config.GetProperties()
+                              .Cast<PropertyDescriptor>()
+                              .OfType<InheritableValuePropertyDescriptor<bool>>()
+                              .Where(x => x.Attributes.OfType<ClangTidyCheckAttribute>().Count() > 0)
+                              .Select(x => new KeyValuePair<InheritableValuePropertyDescriptor<bool>, string>(
+                                            x, x.Attributes.OfType<ClangTidyCheckAttribute>().First().CheckName));
+            var PropArray = Props.ToArray();
+            foreach (var CheckInfo in PropArray)
+            {
+                string LeafName = null;
+                CheckTree Tree = Root.LocateCheckLeafGroup(CheckInfo.Value, out LeafName);
+                Tree.AddLeaf(LeafName, CheckInfo.Key);
+            }
+            return Root;
+        }
+
+        private CheckTree LocateCheckLeafGroup(string Check, out string LeafName)
+        {
+            string[] Components = Check.Split('-');
+            string FirstComponent = Components.FirstOrDefault();
+            if (FirstComponent == null)
+            {
+                LeafName = Check;
+                return this;
+            }
+
+            CheckTreeNode Subgroup = null;
+            if (!Children_.TryGetValue(FirstComponent, out Subgroup))
+            {
+                LeafName = Check;
+                return this;
+            }
+            System.Diagnostics.Debug.Assert(Subgroup is CheckTree);
+            CheckTree Child = (CheckTree)Subgroup;
+            string ChildName = Check.Substring(FirstComponent.Length + 1);
+            return Child.LocateCheckLeafGroup(ChildName, out LeafName);
+        }
+
+        public override int CountChecks
+        {
+            get
+            {
+                return Children_.Aggregate(0, (X, V) => { return X + V.Value.CountChecks; });
+            }
+        }
+
+        public override int CountExplicitlyDisabledChecks
+        {
+            get
+            {
+                return Children_.Aggregate(0, (X, V) => { return X + V.Value.CountExplicitlyDisabledChecks; });
+            }
+        }
+
+        public override int CountExplicitlyEnabledChecks
+        {
+            get
+            {
+                return Children_.Aggregate(0, (X, V) => { return X + V.Value.CountExplicitlyEnabledChecks; });
+            }
+        }
+        public override int CountInheritedChecks
+        {
+            get
+            {
+                return Children_.Aggregate(0, (X, V) => { return X + V.Value.CountInheritedChecks; });
+            }
+        }
+
+        public IDictionary<string, CheckTreeNode> Children
+        {
+            get { return Children_; }
+        }
+    }
+
+    public class CheckLeaf : CheckTreeNode
+    {
+        private InheritableValuePropertyDescriptor<bool> Property_;
+
+        public CheckLeaf(string Name, CheckTree Parent, InheritableValuePropertyDescriptor<bool> Property)
+            : base(Name, Parent)
+        {
+            Property_ = Property;
+        }
+
+        public override int CountChecks
+        {
+            get
+            {
+                return 1;
+            }
+        }
+
+        public override int CountExplicitlyDisabledChecks
+        {
+            get
+            {
+                if (Property_.IsInheriting)
+                    return 0;
+                return Property_.Value ? 0 : 1;
+            }
+        }
+
+        public override int CountExplicitlyEnabledChecks
+        {
+            get
+            {
+                if (Property_.IsInheriting)
+                    return 0;
+                return Property_.Value ? 1 : 0;
+            }
+        }
+
+        public override int CountInheritedChecks
+        {
+            get
+            {
+                return (Property_.IsInheriting) ? 1 : 0;
+            }
+        }
+
+    }
+}

clang-tidy-vs/ClangTidy/ClangTidy.csproj

+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{BE261DA1-36C6-449A-95C5-4653A549170A}</ProjectGuid>
+    <ProjectTypeGuids>{82b43b9b-a64c-4715-b499-d71e9ca2bd60};{60dc8134-eba5-43b8-bcc9-bb4bc16c2548};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>LLVM.ClangTidy</RootNamespace>
+    <AssemblyName>ClangTidy</AssemblyName>
+    <SignAssembly>true</SignAssembly>
+    <AssemblyOriginatorKeyFile>Key.snk</AssemblyOriginatorKeyFile>
+    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <MinimumVisualStudioVersion>14.0</MinimumVisualStudioVersion>
+    <FileUpgradeFlags>
+    </FileUpgradeFlags>
+    <UpgradeBackupLocation>
+    </UpgradeBackupLocation>
+    <OldToolsVersion>4.0</OldToolsVersion>
+    <PublishUrl>publish\</PublishUrl>
+    <Install>true</Install>
+    <InstallFrom>Disk</InstallFrom>
+    <UpdateEnabled>false</UpdateEnabled>
+    <UpdateMode>Foreground</UpdateMode>
+    <UpdateInterval>7</UpdateInterval>
+    <UpdateIntervalUnits>Days</UpdateIntervalUnits>
+    <UpdatePeriodically>false</UpdatePeriodically>
+    <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="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.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.TextManager.Interop" />
+    <Reference Include="Microsoft.VisualStudio.Utilities, Version=14.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
+    <Reference Include="System" />
+    <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="CategoryVerb.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="ForwardingPropertyDescriptor.cs" />
+    <Compile Include="Guids.cs" />
+    <Compile Include="InheritableProperty.cs" />
+    <Compile Include="InheritablePropertyComponent.cs">
+      <SubType>Component</SubType>
+    </Compile>
+    <Compile Include="InheritablePropertyComponent.Designer.cs" />
+    <Compile Include="InheritablePropertyConverter.cs" />
+    <Compile Include="PropertyFileParser.cs" />
+    <Compile Include="Resources.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DesignTime>True</DesignTime>
+      <DependentUpon>Resources.resx</DependentUpon>
+    </Compile>
+    <Compile Include="GlobalSuppressions.cs" />
+    <Compile Include="ClangTidyPackage.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="PkgCmdID.cs" />
+    <Compile Include="ClangTidyPropertyGrid.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="ClangTidyPropertyGrid.Designer.cs">
+      <DependentUpon>ClangTidyPropertyGrid.cs</DependentUpon>
+    </Compile>
+    <Compile Include="Utility.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <EmbeddedResource Include="Resources.resx">
+      <Generator>ResXFileCodeGenerator</Generator>
+      <LastGenOutput>Resources.Designer.cs</LastGenOutput>
+      <SubType>Designer</SubType>
+    </EmbeddedResource>
+    <EmbeddedResource Include="ClangTidyPropertyGrid.resx">
+      <DependentUpon>ClangTidyPropertyGrid.cs</DependentUpon>
+    </EmbeddedResource>
+    <EmbeddedResource Include="VSPackage.resx">
+      <MergeWithCTO>true</MergeWithCTO>
+      <ManifestResourceName>VSPackage</ManifestResourceName>
+    </EmbeddedResource>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="Key.snk" />
+    <None Include="packages.config" />
+    <None Include="source.extension.vsixmanifest">
+      <SubType>Designer</SubType>
+    </None>
+  </ItemGroup>
+  <ItemGroup>
+    <VSCTCompile Include="ClangTidy.vsct">
+      <ResourceName>Menus.ctmenu</ResourceName>
+    </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>
+    <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>
+    <BootstrapperPackage Include="Microsoft.Net.Client.3.5">
+      <Visible>False</Visible>
+      <ProductName>.NET Framework 3.5 SP1 Client Profile</ProductName>
+      <Install>false</Install>
+    </BootstrapperPackage>
+    <BootstrapperPackage Include="Microsoft.Net.Framework.3.5.SP1">
+      <Visible>False</Visible>
+      <ProductName>.NET Framework 3.5 SP1</ProductName>
+      <Install>false</Install>
+    </BootstrapperPackage>
+    <BootstrapperPackage Include="Microsoft.Windows.Installer.4.5">
+      <Visible>False</Visible>
+      <ProductName>Windows Installer 4.5</ProductName>
+      <Install>true</Install>
+    </BootstrapperPackage>
+  </ItemGroup>
+  <PropertyGroup>
+    <UseCodebase>true</UseCodebase>
+  </PropertyGroup>
+  <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>
+  </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;" />
+  </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

+<?xml version="1.0" encoding="utf-8"?>
+<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 actual layout and type of the commands.
+        It is divided in different sections (e.g. command definition, command
+        placement, ...), with each defining a specific set of properties.
+        See the comment before each section for more details about how to
+        use it. -->
+
+  <!--  The VSCT compiler (the tool that translates this file into the binary 
+        format that VisualStudio will consume) has the ability to run a preprocessor 
+        on the vsct file; this preprocessor is (usually) the C++ preprocessor, so 
+        it is possible to define includes and macros with the same syntax used 
+        in C++ files. Using this ability of the compiler here, we include some files 
+        defining some of the constants that we will use inside the file. -->
+
+  <!--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. -->
+
+    
+    <!-- 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>
+      
+
+
+    </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" />
+        <Strings>
+          <ButtonText>ClangTidy</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"/>
+      
+    </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" />
+    </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>
+  </Symbols>
+
+</CommandTable>

clang-tidy-vs/ClangTidy/ClangTidyCheckAttribute.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace LLVM.ClangTidy
+{
+    public class ClangTidyCheckAttribute : Attribute
+    {
+        private string CheckName_;
+        public ClangTidyCheckAttribute(string CheckName)
+        {
+            this.CheckName_ = CheckName;
+        }
+
+        public string CheckName
+        {
+            get { return CheckName_; }
+        }
+    }
+}

clang-tidy-vs/ClangTidy/ClangTidyConfigurationPage.cs

+using EnvDTE;
+using EnvDTE100;
+using Microsoft.VisualStudio;
+using Microsoft.VisualStudio.Shell;
+using Microsoft.VisualStudio.Shell.Interop;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows.Forms;
+
+namespace LLVM.ClangTidy
+{
+    [ClassInterface(ClassInterfaceType.AutoDual)]
+    [CLSCompliant(false), ComVisible(true)]
+    public class ClangTidyConfigurationPage : DialogPage
+    {
+        ClangTidyPropertyGrid Grid = null;
+        protected override IWin32Window Window
+        {
+            get
+            {
+                if (Grid == null)
+                    Grid = new ClangTidyPropertyGrid();
+                return Grid;
+            }
+        }
+    }
+}

clang-tidy-vs/ClangTidy/ClangTidyPackage.cs

+//===-- ClangTidyPackages.cs - VSPackage for clang-tidy ----------*- C# -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This class contains a VS extension package that runs clang-tidy over a
+// file in a VS text editor.
+//
+//===----------------------------------------------------------------------===//
+
+using Microsoft.VisualStudio.Editor;
+using Microsoft.VisualStudio.Shell;
+using Microsoft.VisualStudio.Shell.Interop;
+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
+    {
+        #region Package Members
+        protected override void Initialize()
+        {
+            base.Initialize();
+
+            var commandService = GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
+            if (commandService != null)
+            {
+                var menuCommandID = new CommandID(GuidList.guidClangTidyCmdSet, (int)PkgCmdIDList.cmdidClangTidy);
+                var menuItem = new MenuCommand(MenuItemCallback, menuCommandID);
+                commandService.AddCommand(menuItem);
+            }
+        }
+        #endregion
+
+        private void MenuItemCallback(object sender, EventArgs args)
+        {
+        }
+    }
+}

clang-tidy-vs/ClangTidy/ClangTidyProperties.cs

+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Globalization;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace LLVM.ClangTidy
+{
+
+    public class ClangTidyProperties : InheritablePropertyComponent
+    {
+        private static ClangTidyProperties RootProperties_ = null;
+        private CheckTree CheckTree_;
+        private bool HasUnsavedChanges_ = false;
+
+        public struct CheckMapping
+        {
+            public string CheckName;
+            public string Property;
+        }
+
+        public ClangTidyProperties()
+            : base(null)
+        {
+            CheckTree_ = CheckTree.Build(this);
+        }
+
+        public ClangTidyProperties(InheritablePropertyComponent Parent)
+            : base(Parent)
+        {
+            CheckTree_ = CheckTree.Build(this);
+        }
+
+        static ClangTidyProperties()
+        {
+            RootProperties_ = new ClangTidyProperties(null);
+            PropertyDescriptor D;
+        }
+
+        public static ClangTidyProperties RootProperties
+        {
+            get { return RootProperties_; }
+        }
+
+        public CheckTree GetCheckTree() { return CheckTree_; }
+        public bool GetHasUnsavedChanges() { return HasUnsavedChanges_; }
+        public void SetHasUnsavedChanges(bool Value) { HasUnsavedChanges_ = Value; }
+
+        public IEnumerable<CheckMapping> FindChecksMatching(string Pattern)
+        {
+            foreach (var V in InheritedDescriptors_)
+            {
+                ClangTidyCheckAttribute CheckAttr = V.Value.Attributes.OfType<ClangTidyCheckAttribute>().FirstOrDefault();
+                if (CheckAttr == null)
+                    continue;
+
+                if (!Utility.MatchWildcardString(CheckAttr.CheckName, Pattern))
+                    continue;
+
+                var Result = new CheckMapping { CheckName = CheckAttr.CheckName, Property = V.Value.Name };
+                yield return Result;
+            }
+        }
+
+        [Category("CERT Secure Coding Standards")]
+        [DisplayName("(Quick Actions)")]
+        [Description("")]
+        [TypeConverter(typeof(CategoryVerbConverter))]
+        [DefaultValue(CategoryVerb.None)]
+        public CategoryVerb CERTQuickActions { get; set; }
+
+        [Category("CERT Secure Coding Standards")]
+        [DisplayName("DCL50-CPP")]
+        [Description("Checks for violations of CERT DCL50-CPP - Do not define a C-style variadic function")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("cert-dcl50-cpp")]
+        public bool CERTDCL50
+        {
+            get { return GetInheritableProperty<bool>("CERTDCL50").Value;  }
+            set { GetInheritableProperty<bool>("CERTDCL50").Value = value; }
+        }
+
+        [Category("CERT Secure Coding Standards")]
+        [DisplayName("DCL54-CPP")]
+        [Description("Checks for violations of CERT DCL54-CPP - Overload allocation and deallocation functions as a pair in the same scope")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("cert-dcl54-cpp")]
+        public bool CERTDCL54
+        {
+            get { return GetInheritableProperty<bool>("CERTDCL54").Value; }
+            set { GetInheritableProperty<bool>("CERTDCL54").Value = value; }
+        }
+
+
+        [Category("C++ Core Guidelines")]
+        [DisplayName("(Quick Actions)")]
+        [Description("")]
+        [TypeConverter(typeof(CategoryVerbConverter))]
+        [DefaultValue(CategoryVerb.None)]
+        public CategoryVerb CPPCoreQuickActions { get; set; }
+
+        [Category("C++ Core Guidelines")]
+        [DisplayName("I.22 - Complex Global Initializers")]
+        [Description("Checks for violations of Core Guideline I.22 - Avoid complex initializers of global objects")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("cppcoreguidelines-interfaces-global-init")]
+        public bool CPPCoreI22
+        {
+            get { return GetInheritableProperty<bool>("CPPCoreI22").Value; }
+            set { GetInheritableProperty<bool>("CPPCoreI22").Value = value; }
+        }
+
+        [Category("C++ Core Guidelines")]
+        [DisplayName("Bounds.1 - No pointer arithmetic")]
+        [Description("Checks for violations of Core Guideline Bounds.3 - Don't use pointer arithmetic.  Use span<> instead.")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("cppcoreguidelines-pro-bounds-pointer-arithmetic")]
+        public bool CPPCoreBounds1
+        {
+            get { return GetInheritableProperty<bool>("CPPCoreBounds1").Value; }
+            set { GetInheritableProperty<bool>("CPPCoreBounds1").Value = value; }
+        }
+
+        [Category("C++ Core Guidelines")]
+        [DisplayName("Bounds.2 - Constant array indices")]
+        [Description("Checks for violations of Core Bounds.2 - Only index into arrays using constant expressions.")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("cppcoreguidelines-pro-bounds-constant-array-index")]
+        public bool CPPCoreBounds2
+        {
+            get { return GetInheritableProperty<bool>("CPPCoreBounds2").Value; }
+            set { GetInheritableProperty<bool>("CPPCoreBounds2").Value = value; }
+        }
+
+        [Category("C++ Core Guidelines")]
+        [DisplayName("Bounds.3 - Array to Pointer Decay")]
+        [Description("Checks for violations of Core Guideline Bounds.3 - No array-to-pointer decay")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("cppcoreguidelines-pro-bounds-array-to-pointer-decay")]
+        public bool CPPCoreBounds3
+        {
+            get { return GetInheritableProperty<bool>("CPPCoreBounds3").Value; }
+            set { GetInheritableProperty<bool>("CPPCoreBounds3").Value = value; }
+        }
+
+        [Category("C++ Core Guidelines")]
+        [DisplayName("const_cast (Type.3)")]
+        [Description("Checks for violations of Core Guideline Type.3 - Don't use const_cast to cast away const")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("cppcoreguidelines-pro-type-const-cast")]
+        public bool CPPCoreConstCast
+        {
+            get { return GetInheritableProperty<bool>("CPPCoreConstCast").Value; }
+            set { GetInheritableProperty<bool>("CPPCoreConstCast").Value = value; }
+        }
+
+        [Category("C++ Core Guidelines")]
+        [DisplayName("C style casts (Type.4)")]
+        [Description("Checks for violations of Core Guideline Type.3 - Don't use C-style (T)expression casts that would perform a static downcast, const_cast, or reinterpret_cast")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("cppcoreguidelines-pro-type-cstyle-cast")]
+        public bool CPPCoreCStyleCast
+        {
+            get { return GetInheritableProperty<bool>("CPPCoreCStyleCast").Value; }
+            set { GetInheritableProperty<bool>("CPPCoreCStyleCast").Value = value; }
+        }
+
+        [Category("C++ Core Guidelines")]
+        [DisplayName("reinterpret_cast (Type.1)")]
+        [Description("Checks for violations of Core Guideline Type.1 - Don't use reinterpret_cast.")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("cppcoreguidelines-pro-type-reinterpret-cast")]
+        public bool CPPCoreReinterpretCast
+        {
+            get { return GetInheritableProperty<bool>("CPPCoreReinterpretCast").Value; }
+            set { GetInheritableProperty<bool>("CPPCoreReinterpretCast").Value = value; }
+        }
+
+        [Category("C++ Core Guidelines")]
+        [DisplayName("Prefer dynamic_cast (Type.2)")]
+        [Description("Checks for violations of Core Guideline Type.2 - Don't use static_cast downcasts.  Use dynamic_cast instead.")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("cppcoreguidelines-pro-type-static-cast-downcast")]
+        public bool CPPCoreDynamicCast
+        {
+            get { return GetInheritableProperty<bool>("CPPCoreDynamicCast").Value; }
+            set { GetInheritableProperty<bool>("CPPCoreDynamicCast").Value = value; }
+        }
+
+        [Category("C++ Core Guidelines")]
+        [DisplayName("Member variable initialization (Type.6)")]
+        [Description("Checks for violations of Core Guideline Type.6 - Always initialize a member variable.")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("cppcoreguidelines-pro-type-member-init")]
+        public bool CPPCoreMemberVariableInit
+        {
+            get { return GetInheritableProperty<bool>("CPPCoreMemberVariableInit").Value; }
+            set { GetInheritableProperty<bool>("CPPCoreMemberVariableInit").Value = value; }
+        }
+
+        [Category("C++ Core Guidelines")]
+        [DisplayName("Avoid unions (Type.7)")]
+        [Description("Checks for violations of Core Guideline Type.7 - Avoid accessing members of raw unions.  Use variant instead.")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("cppcoreguidelines-pro-type-union-access")]
+        public bool CPPCoreUnionMemberAccess
+        {
+            get { return GetInheritableProperty<bool>("CPPCoreUnionMemberAccess").Value; }
+            set { GetInheritableProperty<bool>("CPPCoreUnionMemberAccess").Value = value; }
+        }
+
+        [Category("C++ Core Guidelines")]
+        [DisplayName("Don't use varargs (Type.8)")]
+        [Description("Checks for violations of Core Guideline Type.8 - Avoid reading varargs or passing vararg arguments.  Prefer variadic templates instead.")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("cppcoreguidelines-pro-type-vararg")]
+        public bool CPPCoreVarArgs
+        {
+            get { return GetInheritableProperty<bool>("CPPCoreVarArgs").Value; }
+            set { GetInheritableProperty<bool>("CPPCoreVarArgs").Value = value; }
+        }
+
+        [Category("C++ Core Guidelines")]
+        [DisplayName("Don't slice (ES.63 & C.145)")]
+        [Description("Checks for violations of Core Guidelines ES.63 (Don't slice) and C.145 (Access polymorphic objects through pointers and references)")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("cppcoreguidelines-slicing")]
+        public bool CPPCoreDontSlice
+        {
+            get { return GetInheritableProperty<bool>("CPPCoreDontSlice").Value; }
+            set { GetInheritableProperty<bool>("CPPCoreDontSlice").Value = value; }
+        }
+
+        [Category("C++ Core Guidelines")]
+        [DisplayName("Detect unsafe special functions (C.21)")]
+        [Description("Checks for violations of Core Guidelines C.21 - If you define or =delete any default operation, define or =delete them all.")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("cppcoreguidelines-special-member-functions")]
+        public bool CPPCoreUnsafeSpecialFunctions
+        {
+            get { return GetInheritableProperty<bool>("CPPCoreUnsafeSpecialFunctions").Value; }
+            set { GetInheritableProperty<bool>("CPPCoreUnsafeSpecialFunctions").Value = value; }
+        }
+
+
+        [Category("Google Style Guide")]
+        [DisplayName("(Quick Actions)")]
+        [Description("")]
+        [TypeConverter(typeof(CategoryVerbConverter))]
+        [DefaultValue(CategoryVerb.None)]
+        public CategoryVerb GoogleQuickActions { get; set; }
+
+        [Category("Google Style Guide")]
+        [DisplayName("Forbid explicitly parameterized make_pair")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("google-build-explicit-make-pair")]
+        public bool GoogleExplicitMakePair
+        {
+            get { return GetInheritableProperty<bool>("GoogleExplicitMakePair").Value; }
+            set { GetInheritableProperty<bool>("GoogleExplicitMakePair").Value = value; }
+        }
+
+        [Category("Google Style Guide")]
+        [DisplayName("Anonymous namespace in headers")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("google-build-namespaces")]
+        public bool GoogleBuildNamespaces
+        {
+            get { return GetInheritableProperty<bool>("GoogleBuildNamespaces").Value; }
+            set { GetInheritableProperty<bool>("GoogleBuildNamespaces").Value = value; }
+        }
+
+        [Category("Google Style Guide")]
+        [DisplayName("Find using namespace directives")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("google-build-using-namespace")]
+        public bool GoogleBuildUsingNamespace
+        {
+            get { return GetInheritableProperty<bool>("GoogleBuildUsingNamespace").Value; }
+            set { GetInheritableProperty<bool>("GoogleBuildUsingNamespace").Value = value; }
+        }
+
+        [Category("Google Style Guide")]
+        [DisplayName("Default arguments in virtual methods")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("google-default-arguments")]
+        public bool GoogleDefaultArgs
+        {
+            get { return GetInheritableProperty<bool>("GoogleDefaultArgs").Value; }
+            set { GetInheritableProperty<bool>("GoogleDefaultArgs").Value = value; }
+        }
+
+        [Category("Google Style Guide")]
+        [DisplayName("explicit constructors")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("google-explicit-constructor")]
+        public bool GoogleExplicitConstructor
+        {
+            get { return GetInheritableProperty<bool>("GoogleExplicitConstructor").Value; }
+            set { GetInheritableProperty<bool>("GoogleExplicitConstructor").Value = value; }
+        }
+
+        [Category("Google Style Guide")]
+        [DisplayName("Global namespace pollution in headers")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("google-global-names-in-headers")]
+        public bool GoogleGlobalNamesInHeaders
+        {
+            get { return GetInheritableProperty<bool>("GoogleGlobalNamesInHeaders").Value; }
+            set { GetInheritableProperty<bool>("GoogleGlobalNamesInHeaders").Value = value; }
+        }
+
+        [Category("Google Style Guide")]
+        [DisplayName("Braces around statements")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("google-readability-braces-around-statements")]
+        public bool GoogleReadabilityBracesAroundStatements
+        {
+            get { return GetInheritableProperty<bool>("GoogleReadabilityBracesAroundStatements").Value; }
+            set { GetInheritableProperty<bool>("GoogleReadabilityBracesAroundStatements").Value = value; }
+        }
+
+        [Category("Google Style Guide")]
+        [DisplayName("No C-style casts")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("google-readability-casting")]
+        public bool GoogleReadabilityCasting
+        {
+            get { return GetInheritableProperty<bool>("GoogleReadabilityCasting").Value; }
+            set { GetInheritableProperty<bool>("GoogleReadabilityCasting").Value = value; }
+        }
+
+        [Category("Google Style Guide")]
+        [DisplayName("Find large functions")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("google-readability-function-size")]
+        public bool GoogleReadabilityFunctionSize
+        {
+            get { return GetInheritableProperty<bool>("GoogleReadabilityFunctionSize").Value; }
+            set { GetInheritableProperty<bool>("GoogleReadabilityFunctionSize").Value = value; }
+        }
+
+        [Category("Google Style Guide")]
+        [DisplayName("Namespace closing comments")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("google-readability-namespace-comments")]
+        public bool GoogleReadabilityNamespaceComments
+        {
+            get { return GetInheritableProperty<bool>("GoogleReadabilityNamespaceComments").Value; }
+            set { GetInheritableProperty<bool>("GoogleReadabilityNamespaceComments").Value = value; }
+        }
+
+        [Category("Google Style Guide")]
+        [DisplayName("Find unnecessary calls to .get()")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("google-readability-redundant-smartptr-get")]
+        public bool GoogleReadabilityRedundantSmartPtrGet
+        {
+            get { return GetInheritableProperty<bool>("GoogleReadabilityRedundantSmartPtrGet").Value; }
+            set { GetInheritableProperty<bool>("GoogleReadabilityRedundantSmartPtrGet").Value = value; }
+        }
+
+        [Category("Google Style Guide")]
+        [DisplayName("")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("google-readability-todo")]
+        public bool GoogleReadabilityTodo
+        {
+            get { return GetInheritableProperty<bool>("GoogleReadabilityTodo").Value; }
+            set { GetInheritableProperty<bool>("GoogleReadabilityTodo").Value = value; }
+        }
+
+        [Category("Google Style Guide")]
+        [DisplayName("Find non-conformant TODO comments")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("google-runtime-int")]
+        public bool GoogleRuntimeInt
+        {
+            get { return GetInheritableProperty<bool>("GoogleRuntimeInt").Value; }
+            set { GetInheritableProperty<bool>("GoogleRuntimeInt").Value = value; }
+        }
+
+        [Category("Google Style Guide")]
+        [DisplayName("Find const string references")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("google-runtime-member-string-references")]
+        public bool GoogleRuntimeMemberStringReferences
+        {
+            get { return GetInheritableProperty<bool>("GoogleRuntimeMemberStringReferences").Value; }
+            set { GetInheritableProperty<bool>("GoogleRuntimeMemberStringReferences").Value = value; }
+        }
+
+        [Category("Google Style Guide")]
+        [DisplayName("Find zero-length memsets")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("google-runtime-memset")]
+        public bool GoogleRuntimeMemset
+        {
+            get { return GetInheritableProperty<bool>("GoogleRuntimeMemset").Value; }
+            set { GetInheritableProperty<bool>("GoogleRuntimeMemset").Value = value; }
+        }
+
+        [Category("Google Style Guide")]
+        [DisplayName("Find overloads of operator&")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("google-runtime-operator")]
+        public bool GoogleRuntimeOperator
+        {
+            get { return GetInheritableProperty<bool>("GoogleRuntimeOperator").Value; }
+            set { GetInheritableProperty<bool>("GoogleRuntimeOperator").Value = value; }
+        }
+
+        [Category("Google Style Guide")]
+        [DisplayName("Check usage of non-const references")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("google-runtime-references")]
+        public bool GoogleRuntimeReferences
+        {
+            get { return GetInheritableProperty<bool>("GoogleRuntimeReferences").Value; }
+            set { GetInheritableProperty<bool>("GoogleRuntimeReferences").Value = value; }
+        }
+
+
+        [Category("LLVM Style Guide")]
+        [DisplayName("(Quick Actions)")]
+        [Description("")]
+        [TypeConverter(typeof(CategoryVerbConverter))]
+        [DefaultValue(CategoryVerb.None)]
+        public CategoryVerb LLVMQuickActions { get; set; }
+
+        [Category("LLVM Style Guide")]
+        [DisplayName("LLVM header guards")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("llvm-header-guard")]
+        public bool LLVMHeaderGuard
+        {
+            get { return GetInheritableProperty<bool>("LLVMHeaderGuard").Value; }
+            set { GetInheritableProperty<bool>("LLVMHeaderGuard").Value = value; }
+        }
+
+        [Category("LLVM Style Guide")]
+        [DisplayName("LLVM include order")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("llvm-include-order")]
+        public bool LLVMIncludeOrder
+        {
+            get { return GetInheritableProperty<bool>("LLVMIncludeOrder").Value; }
+            set { GetInheritableProperty<bool>("LLVMIncludeOrder").Value = value; }
+        }
+
+        [Category("LLVM Style Guide")]
+        [DisplayName("LLVM namespace comments")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("llvm-namespace-comment")]
+        public bool LLVMNamespaceComment
+        {
+            get { return GetInheritableProperty<bool>("LLVMNamespaceComment").Value; }
+            set { GetInheritableProperty<bool>("LLVMNamespaceComment").Value = value; }
+        }
+
+        [Category("LLVM Style Guide")]
+        [DisplayName("Find local twines")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("llvm-twine-local")]
+        public bool LLVMTwineLocal
+        {
+            get { return GetInheritableProperty<bool>("LLVMTwineLocal").Value; }
+            set { GetInheritableProperty<bool>("LLVMTwineLocal").Value = value; }
+        }
+
+
+        [Category("Clang Diagnostics")]
+        [DisplayName("(Quick Actions)")]
+        [Description("")]
+        [TypeConverter(typeof(CategoryVerbConverter))]
+        [DefaultValue(CategoryVerb.None)]
+        public CategoryVerb ClangDiagQuickActions { get; set; }
+
+        [Category("Clang Diagnostics")]
+        [DisplayName("Warnings")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("clang-diagnostic-warning")]
+        public bool ClangDiagWarning
+        {
+            get { return GetInheritableProperty<bool>("ClangDiagWarning").Value; }
+            set { GetInheritableProperty<bool>("ClangDiagWarning").Value = value; }
+        }
+
+        [Category("Clang Diagnostics")]
+        [DisplayName("Errors")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("clang-diagnostic-error")]
+        public bool ClangDiagError
+        {
+            get { return GetInheritableProperty<bool>("ClangDiagError").Value; }
+            set { GetInheritableProperty<bool>("ClangDiagError").Value = value; }
+        }
+
+        [Category("Clang Diagnostics")]
+        [DisplayName("Unknown")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("clang-diagnostic-unknown")]
+        public bool ClangDiagUnknown
+        {
+            get { return GetInheritableProperty<bool>("ClangDiagUnknown").Value; }
+            set { GetInheritableProperty<bool>("ClangDiagUnknown").Value = value; }
+        }
+
+
+        [Category("Miscellaneous")]
+        [DisplayName("(Quick Actions)")]
+        [Description("")]
+        [TypeConverter(typeof(CategoryVerbConverter))]
+        [DefaultValue(CategoryVerb.None)]
+        public CategoryVerb MiscQuickActions { get; set; }
+
+        [Category("Miscellaneous")]
+        [DisplayName("Validate argument comments")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("misc-argument-comment")]
+        public bool MiscArgumentComment
+        {
+            get { return GetInheritableProperty<bool>("MiscArgumentComment").Value; }
+            set { GetInheritableProperty<bool>("MiscArgumentComment").Value = value; }
+        }
+
+        [Category("Miscellaneous")]
+        [DisplayName("Side effects in assert()")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("misc-assert-side-effect")]
+        public bool MiscAssertSideEffect
+        {
+            get { return GetInheritableProperty<bool>("MiscAssertSideEffect").Value; }
+            set { GetInheritableProperty<bool>("MiscAssertSideEffect").Value = value; }
+        }
+
+        [Category("Miscellaneous")]
+        [DisplayName("bool / pointer implicit conversions")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("misc-bool-pointer-implicit-conversion")]
+        public bool MiscBoolPointerImplicitConversion
+        {
+            get { return GetInheritableProperty<bool>("MiscBoolPointerImplicitConversion").Value; }
+            set { GetInheritableProperty<bool>("MiscBoolPointerImplicitConversion").Value = value; }
+        }
+
+        [Category("Miscellaneous")]
+        [DisplayName("Dangling handles")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("misc-dangling-handle")]
+        public bool MiscDanglingHandle
+        {
+            get { return GetInheritableProperty<bool>("MiscDanglingHandle").Value; }
+            set { GetInheritableProperty<bool>("MiscDanglingHandle").Value = value; }
+        }
+
+        [Category("Miscellaneous")]
+        [DisplayName("Definitions in headers")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("misc-definitions-in-headers")]
+        public bool MiscDefinitionsInHeaders
+        {
+            get { return GetInheritableProperty<bool>("MiscDefinitionsInHeaders").Value; }
+            set { GetInheritableProperty<bool>("MiscDefinitionsInHeaders").Value = value; }
+        }
+
+        [Category("Miscellaneous")]
+        [DisplayName("Type mismatch in fold operations")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("misc-fold-init-type")]
+        public bool MiscFoldInitType
+        {
+            get { return GetInheritableProperty<bool>("MiscFoldInitType").Value; }
+            set { GetInheritableProperty<bool>("MiscFoldInitType").Value = value; }
+        }
+
+        [Category("Miscellaneous")]
+        [DisplayName("Forward declaration namespace")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("misc-forward-declaration-namespace")]
+        public bool MiscForwardDeclarationNamespace
+        {
+            get { return GetInheritableProperty<bool>("MiscForwardDeclarationNamespace").Value; }
+            set { GetInheritableProperty<bool>("MiscForwardDeclarationNamespace").Value = value; }
+        }
+
+        [Category("Miscellaneous")]
+        [DisplayName("Inaccurate erase")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("misc-inaccurate-erase")]
+        public bool MiscInaccurateErase
+        {
+            get { return GetInheritableProperty<bool>("MiscInaccurateErase").Value; }
+            set { GetInheritableProperty<bool>("MiscInaccurateErase").Value = value; }
+        }
+
+        [Category("Miscellaneous")]
+        [DisplayName("Incorrect rounding")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("misc-incorrect-roundings")]
+        public bool MiscIncorrectRoundings
+        {
+            get { return GetInheritableProperty<bool>("MiscIncorrectRoundings").Value; }
+            set { GetInheritableProperty<bool>("MiscIncorrectRoundings").Value = value; }
+        }
+
+        [Category("Miscellaneous")]
+        [DisplayName("Inefficient STL algorithms")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("misc-inefficient-algorithm")]
+        public bool MiscInefficientAlgorithm
+        {
+            get { return GetInheritableProperty<bool>("MiscInefficientAlgorithm").Value; }
+            set { GetInheritableProperty<bool>("MiscInefficientAlgorithm").Value = value; }
+        }
+
+        [Category("Miscellaneous")]
+        [DisplayName("Macro parentheses")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("misc-macro-parentheses")]
+        public bool MiscMacroParens
+        {
+            get { return GetInheritableProperty<bool>("MiscMacroParens").Value; }
+            set { GetInheritableProperty<bool>("MiscMacroParens").Value = value; }
+        }
+
+        [Category("Miscellaneous")]
+        [DisplayName("Macro repeated side effects")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("misc-macro-repeated-side-effects")]
+        public bool MiscMacroRepeatedSideEffects
+        {
+            get { return GetInheritableProperty<bool>("MiscMacroRepeatedSideEffects").Value; }
+            set { GetInheritableProperty<bool>("MiscMacroRepeatedSideEffects").Value = value; }
+        }
+
+        [Category("Miscellaneous")]
+        [DisplayName("Misplaced const")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("misc-misplaced-const")]
+        public bool MiscMisplacedConst
+        {
+            get { return GetInheritableProperty<bool>("MiscMisplacedConst").Value; }
+            set { GetInheritableProperty<bool>("MiscMisplacedConst").Value = value; }
+        }
+
+        [Category("Miscellaneous")]
+        [DisplayName("Misplaced widening casts")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("misc-misplaced-widening-cast")]
+        public bool MiscMisplacedWideningCast
+        {
+            get { return GetInheritableProperty<bool>("MiscMisplacedWideningCast").Value; }
+            set { GetInheritableProperty<bool>("MiscMisplacedWideningCast").Value = value; }
+        }
+
+        [Category("Miscellaneous")]
+        [DisplayName("Move constructor const arguments")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("misc-move-const-arg")]
+        public bool MiscMoveConstArg
+        {
+            get { return GetInheritableProperty<bool>("MiscMoveConstArg").Value; }
+            set { GetInheritableProperty<bool>("MiscMoveConstArg").Value = value; }
+        }
+
+        [Category("Miscellaneous")]
+        [DisplayName("Move constructor initialization")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("misc-move-constructor-init")]
+        public bool MiscMoveConstructorInit
+        {
+            get { return GetInheritableProperty<bool>("MiscMoveConstructorInit").Value; }
+            set { GetInheritableProperty<bool>("MiscMoveConstructorInit").Value = value; }
+        }
+
+        [Category("Miscellaneous")]
+        [DisplayName("Multi-statement macros")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("misc-multiple-statement-macro")]
+        public bool MiscMultipleStatementMacro
+        {
+            get { return GetInheritableProperty<bool>("MiscMultipleStatementMacro").Value; }
+            set { GetInheritableProperty<bool>("MiscMultipleStatementMacro").Value = value; }
+        }
+
+        [Category("Miscellaneous")]
+        [DisplayName("Verify new / delete overloads")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("misc-new-delete-overloads")]
+        public bool MiscNewDeleteOverloads
+        {
+            get { return GetInheritableProperty<bool>("MiscNewDeleteOverloads").Value; }
+            set { GetInheritableProperty<bool>("MiscNewDeleteOverloads").Value = value; }
+        }
+
+        [Category("Miscellaneous")]
+        [DisplayName("Ensure move constructors are noexcept")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("misc-noexcept-move-constructor")]
+        public bool MiscNoexceptMoveConstructor
+        {
+            get { return GetInheritableProperty<bool>("MiscNoexceptMoveConstructor").Value; }
+            set { GetInheritableProperty<bool>("MiscNoexceptMoveConstructor").Value = value; }
+        }
+
+        [Category("Miscellaneous")]
+        [DisplayName("Copying of non-copyable objects")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("misc-non-copyable-objects")]
+        public bool MiscNoncopyableObjects
+        {
+            get { return GetInheritableProperty<bool>("MiscNoncopyableObjects").Value; }
+            set { GetInheritableProperty<bool>("MiscNoncopyableObjects").Value = value; }
+        }
+
+        [Category("Miscellaneous")]
+        [DisplayName("Suspicious pointer / integer operations")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("misc-pointer-and-integral-operation")]
+        public bool MiscPointerAndIntegralOperation
+        {
+            get { return GetInheritableProperty<bool>("MiscPointerAndIntegralOperation").Value; }
+            set { GetInheritableProperty<bool>("MiscPointerAndIntegralOperation").Value = value; }
+        }
+
+        [Category("Miscellaneous")]
+        [DisplayName("Find redundant expressions")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("misc-redundant-expression")]
+        public bool MiscRedundantExpression
+        {
+            get { return GetInheritableProperty<bool>("MiscRedundantExpression").Value; }
+            set { GetInheritableProperty<bool>("MiscRedundantExpression").Value = value; }
+        }
+
+        [Category("Miscellaneous")]
+        [DisplayName("sizeof() on stl containers")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("misc-sizeof-container")]
+        public bool MiscSizeofContainer
+        {
+            get { return GetInheritableProperty<bool>("MiscSizeofContainer").Value; }
+            set { GetInheritableProperty<bool>("MiscSizeofContainer").Value = value; }
+        }
+
+        [Category("Miscellaneous")]
+        [DisplayName("Suspicious sizeof() usage")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("misc-sizeof-expression")]
+        public bool MiscSizeofExpression
+        {
+            get { return GetInheritableProperty<bool>("MiscSizeofExpression").Value; }
+            set { GetInheritableProperty<bool>("MiscSizeofExpression").Value = value; }
+        }
+
+        [Category("Miscellaneous")]
+        [DisplayName("Replace assert with static_assert")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("misc-static-assert")]
+        public bool MiscStaticAssert
+        {
+            get { return GetInheritableProperty<bool>("MiscStaticAssert").Value; }
+            set { GetInheritableProperty<bool>("MiscStaticAssert").Value = value; }
+        }
+
+        [Category("Miscellaneous")]
+        [DisplayName("Suspicious string constructor")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("misc-string-constructor")]
+        public bool MiscStringConstructor
+        {
+            get { return GetInheritableProperty<bool>("MiscStringConstructor").Value; }
+            set { GetInheritableProperty<bool>("MiscStringConstructor").Value = value; }
+        }
+
+        [Category("Miscellaneous")]
+        [DisplayName("String integer assignment")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("misc-string-integer-assignment")]
+        public bool MiscStringIntegerAssignment
+        {
+            get { return GetInheritableProperty<bool>("MiscStringIntegerAssignment").Value; }
+            set { GetInheritableProperty<bool>("MiscStringIntegerAssignment").Value = value; }
+        }
+
+        [Category("Miscellaneous")]
+        [DisplayName("String literal with embedded null")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("misc-string-literal-with-embedded-nul")]
+        public bool MiscStringLiteralWithEmbeddedNull
+        {
+            get { return GetInheritableProperty<bool>("MiscStringLiteralWithEmbeddedNull").Value; }
+            set { GetInheritableProperty<bool>("MiscStringLiteralWithEmbeddedNull").Value = value; }
+        }
+
+        [Category("Miscellaneous")]
+        [DisplayName("Suspicious missing comma")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("misc-suspicious-missing-comma")]
+        public bool MiscSuspiciousMissingComma
+        {
+            get { return GetInheritableProperty<bool>("MiscSuspiciousMissingComma").Value; }
+            set { GetInheritableProperty<bool>("MiscSuspiciousMissingComma").Value = value; }
+        }
+
+        [Category("Miscellaneous")]
+        [DisplayName("Suspicious semicolon")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("misc-suspicious-semicolon")]
+        public bool MiscSuspiciousSemicolon
+        {
+            get { return GetInheritableProperty<bool>("MiscSuspiciousSemicolon").Value; }
+            set { GetInheritableProperty<bool>("MiscSuspiciousSemicolon").Value = value; }
+        }
+
+        [Category("Miscellaneous")]
+        [DisplayName("Suspicious string compare")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("misc-suspicious-string-compare")]
+        public bool MiscSuspiciousStringCompare
+        {
+            get { return GetInheritableProperty<bool>("MiscSuspiciousStringCompare").Value; }
+            set { GetInheritableProperty<bool>("MiscSuspiciousStringCompare").Value = value; }
+        }
+
+        [Category("Miscellaneous")]
+        [DisplayName("Swapped arguments")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("misc-swapped-arguments")]
+        public bool MiscSwappedArguments
+        {
+            get { return GetInheritableProperty<bool>("MiscSwappedArguments").Value; }
+            set { GetInheritableProperty<bool>("MiscSwappedArguments").Value = value; }
+        }
+
+        [Category("Miscellaneous")]
+        [DisplayName("Throw by value / catch by reference")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("misc-throw-by-value-catch-by-reference")]
+        public bool MiscThrowCatch
+        {
+            get { return GetInheritableProperty<bool>("MiscThrowCatch").Value; }
+            set { GetInheritableProperty<bool>("MiscThrowCatch").Value = value; }
+        }
+
+        [Category("Miscellaneous")]
+        [DisplayName("Unconventional operator=()")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("misc-unconventional-assign-operator")]
+        public bool MiscUnconventionalAssignOperator
+        {
+            get { return GetInheritableProperty<bool>("MiscUnconventionalAssignOperator").Value; }
+            set { GetInheritableProperty<bool>("MiscUnconventionalAssignOperator").Value = value; }
+        }
+
+        [Category("Miscellaneous")]
+        [DisplayName("Undelegated constructor")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("misc-undelegated-constructor")]
+        public bool MiscUndelegatedConstructor
+        {
+            get { return GetInheritableProperty<bool>("MiscUndelegatedConstructor").Value; }
+            set { GetInheritableProperty<bool>("MiscUndelegatedConstructor").Value = value; }
+        }
+
+        [Category("Miscellaneous")]
+        [DisplayName("unique_ptr<> reset / release")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("misc-uniqueptr-reset-release")]
+        public bool MiscUniqueptrResetRelease
+        {
+            get { return GetInheritableProperty<bool>("MiscUniqueptrResetRelease").Value; }
+            set { GetInheritableProperty<bool>("MiscUniqueptrResetRelease").Value = value; }
+        }
+
+        [Category("Miscellaneous")]
+        [DisplayName("Unused Alias Decls")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("misc-unused-alias-decls")]
+        public bool MiscUnusedAliasDecls
+        {
+            get { return GetInheritableProperty<bool>("MiscUnusedAliasDecls").Value; }
+            set { GetInheritableProperty<bool>("MiscUnusedAliasDecls").Value = value; }
+        }
+
+        [Category("Miscellaneous")]
+        [DisplayName("Unused Params")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("misc-unused-parameters")]
+        public bool MiscUnusedParams
+        {
+            get { return GetInheritableProperty<bool>("MiscUnusedParams").Value; }
+            set { GetInheritableProperty<bool>("MiscUnusedParams").Value = value; }
+        }
+
+        [Category("Miscellaneous")]
+        [DisplayName("Unused Raii")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("misc-unused-raii")]
+        public bool MiscUnusedRaii
+        {
+            get { return GetInheritableProperty<bool>("MiscUnusedRaii").Value; }
+            set { GetInheritableProperty<bool>("MiscUnusedRaii").Value = value; }
+        }
+
+        [Category("Miscellaneous")]
+        [DisplayName("Unused Using Decls")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("misc-unused-using-decls")]
+        public bool MiscUnusedUsingDecls
+        {
+            get { return GetInheritableProperty<bool>("MiscUnusedUsingDecls").Value; }
+            set { GetInheritableProperty<bool>("MiscUnusedUsingDecls").Value = value; }
+        }
+
+        [Category("Miscellaneous")]
+        [DisplayName("Virtual Near Miss")]
+        [Description("")]
+        [DefaultValue(true)]
+        [ClangTidyCheck("misc-virtual-near-miss")]
+        public bool MiscVirtualNearMiss
+        {
+            get { return GetInheritableProperty<bool>("MiscVirtualNearMiss").Value; }
+            set { GetInheritableProperty<bool>("MiscVirtualNearMiss").Value = value; }
+        }
+    }
+}

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

+namespace LLVM.ClangTidy
+{
+    partial class ClangTidyPropertyGrid
+    {
+        /// <summary> 
+        /// Required designer variable.
+        /// </summary>
+        private System.ComponentModel.IContainer components = null;
+
+        /// <summary> 
+        /// Clean up any resources being used.
+        /// </summary>
+        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing && (components != null))
+            {
+                components.Dispose();
+            }
+            base.Dispose(disposing);
+        }
+
+        #region Component Designer generated code
+
+        /// <summary> 
+        /// Required method for Designer support - do not modify 
+        /// the contents of this method with the code editor.
+        /// </summary>
+        private void InitializeComponent()
+        {
+            this.label1 = new System.Windows.Forms.Label();
+            this.textBox1 = new System.Windows.Forms.TextBox();
+            this.button1 = new System.Windows.Forms.Button();
+            this.propertyGrid1 = new System.Windows.Forms.PropertyGrid();
+            this.clangTidyProperties1 = new LLVM.ClangTidy.ClangTidyProperties();
+            this.clangTidyConfigurationPage1 = new LLVM.ClangTidy.ClangTidyConfigurationPage();
+            this.linkLabelPath = new System.Windows.Forms.LinkLabel();
+            this.SuspendLayout();
+            // 
+            // label1
+            // 
+            this.label1.AutoSize = true;
+            this.label1.Location = new System.Drawing.Point(14, 17);
+            this.label1.Name = "label1";
+            this.label1.Size = new System.Drawing.Size(88, 13);
+            this.label1.TabIndex = 0;
+            this.label1.Text = "Configuration File";
+            // 
+            // textBox1
+            // 
+            this.textBox1.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
+            | System.Windows.Forms.AnchorStyles.Right)));
+            this.textBox1.Location = new System.Drawing.Point(108, 14);
+            this.textBox1.Name = "textBox1";
+            this.textBox1.Size = new System.Drawing.Size(222, 20);
+            this.textBox1.TabIndex = 1;
+            // 
+            // button1
+            // 
+            this.button1.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
+            this.button1.Location = new System.Drawing.Point(336, 14);
+            this.button1.Name = "button1";
+            this.button1.Size = new System.Drawing.Size(78, 20);
+            this.button1.TabIndex = 2;
+            this.button1.Text = "Browse";
+            this.button1.UseVisualStyleBackColor = true;
+            this.button1.Click += new System.EventHandler(this.button1_Click);
+            // 
+            // propertyGrid1
+            // 
+            this.propertyGrid1.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
+            | System.Windows.Forms.AnchorStyles.Left) 
+            | System.Windows.Forms.AnchorStyles.Right)));
+            this.propertyGrid1.Location = new System.Drawing.Point(20, 73);
+            this.propertyGrid1.Name = "propertyGrid1";
+            this.propertyGrid1.SelectedObject = this.clangTidyProperties1;
+            this.propertyGrid1.Size = new System.Drawing.Size(391, 384);
+            this.propertyGrid1.TabIndex = 6;
+            this.propertyGrid1.ViewBorderColor = System.Drawing.SystemColors.ControlDarkDark;
+            this.propertyGrid1.PropertyValueChanged += new System.Windows.Forms.PropertyValueChangedEventHandler(this.propertyGrid1_PropertyValueChanged);
+            // 
+            // linkLabelPath
+            // 
+            this.linkLabelPath.AutoSize = true;
+            this.linkLabelPath.Location = new System.Drawing.Point(29, 50);
+            this.linkLabelPath.Name = "linkLabelPath";
+            this.linkLabelPath.Size = new System.Drawing.Size(55, 13);
+            this.linkLabelPath.TabIndex = 7;
+            this.linkLabelPath.TabStop = true;
+            this.linkLabelPath.Text = "linkLabel1";
+            this.linkLabelPath.LinkClicked += new System.Windows.Forms.LinkLabelLinkClickedEventHandler(this.linkLabelPath_LinkClicked);
+            // 
+            // ClangTidyPropertyGrid
+            // 
+            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+            this.Controls.Add(this.linkLabelPath);
+            this.Controls.Add(this.propertyGrid1);
+            this.Controls.Add(this.button1);
+            this.Controls.Add(this.textBox1);
+            this.Controls.Add(this.label1);
+            this.Name = "ClangTidyPropertyGrid";
+            this.Size = new System.Drawing.Size(444, 469);
+            this.Load += new System.EventHandler(this.ClangTidyPropertyGrid_Load);
+            this.ResumeLayout(false);
+            this.PerformLayout();
+
+        }
+
+        #endregion
+
+        private System.Windows.Forms.Label label1;
+        private System.Windows.Forms.TextBox textBox1;
+        private System.Windows.Forms.Button button1;
+        private System.Windows.Forms.PropertyGrid propertyGrid1;
+        private ClangTidyProperties clangTidyProperties1;
+        private ClangTidyConfigurationPage clangTidyConfigurationPage1;
+        private System.Windows.Forms.LinkLabel linkLabelPath;
+    }
+}

clang-tidy-vs/ClangTidy/ClangTidyPropertyGrid.cs

+//===-- ClangTidyPropertyGrid.cs - UI for configuring clang-tidy -*- C# -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This class contains a UserControl consisting of a .NET PropertyGrid control
+// allowing configuration of checks and check options for ClangTidy.
+//
+//===----------------------------------------------------------------------===//
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Drawing;
+using System.Data;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows.Forms;
+using System.IO;
+
+namespace LLVM.ClangTidy
+{
+    /// <summary>
+    ///  A UserControl displaying a PropertyGrid allowing configuration of clang-tidy
+    ///  checks and check options, as well as serialization and deserialization of
+    ///  clang-tidy configuration files.  When a configuration file is loaded, the
+    ///  entire chain of configuration files is analyzed based on the file path,
+    ///  and quick access is provided to edit or view any of the files in the
+    ///  configuration chain, allowing easy visualization of where values come from
+    ///  (similar in spirit to the -explain-config option of clang-tidy).
+    /// </summary>
+    public partial class ClangTidyPropertyGrid : UserControl
+    {
+        /// <summary>
+        /// The sequence of .clang-tidy configuration files, starting from the root
+        /// of the filesystem, down to the selected file.
+        /// </summary>
+        List<KeyValuePair<string, ClangTidyProperties>> PropertyChain_;
+
+        /// <summary>
+        /// A tree representing all the checks that the extension knows about, used
+        /// when serializing a file to intelligently determine when to use wildcard
+        /// include / exclude rules.
+        /// </summary>
+        CheckTree Checks_;
+
+        public ClangTidyPropertyGrid()
+        {
+            InitializeComponent();
+
+            PropertyChain_ = new List<KeyValuePair<string, ClangTidyProperties>>();
+            PropertyChain_.Add(new KeyValuePair<string, ClangTidyProperties>(null, ClangTidyProperties.RootProperties));
+            reloadPropertyChain();
+        }
+
+        private void button1_Click(object sender, EventArgs e)
+        {
+            var UnsavedResults = PropertyChain_.Where(x => x.Key != null && x.Value.GetHasUnsavedChanges());
+            if (UnsavedResults.Count() > 0)
+            {
+                var Response = MessageBox.Show(
+                    "You have unsaved changes!  Do you want to save before loading a new file?",
+                    "clang-tidy",
+                    MessageBoxButtons.YesNoCancel);
+                if (Response == DialogResult.Cancel)
+                    return;
+                if (Response == DialogResult.Yes)
+                {
+                    foreach (var Result in UnsavedResults)
+                    {
+                        PropertyFileParser.SerializeClangTidyFile(Result.Value, Result.Key);
+                        Result.Value.SetHasUnsavedChanges(false);
+                    }
+                }
+            }
+
+            using (OpenFileDialog D = new OpenFileDialog())
+            {
+                D.Filter = "Clang Tidy files|.clang-tidy";
+                D.CheckPathExists = true;
+                D.CheckFileExists = true;
+
+                if (D.ShowDialog() == DialogResult.OK)
+                {
+                    PropertyChain_.Clear();
+                    PropertyChain_ = PropertyFileParser.ParseConfigurationChain(D.FileName);
+                    textBox1.Text = D.FileName;
+                    reloadPropertyChain();
+                }
+            }
+        }
+
+        private static readonly string DefaultText = "(Default)";
+        private static readonly string BrowseText = "Browse for a file to edit its properties";
+
+        /// <summary>
+        /// After a new configuration file is chosen, analyzes the directory hierarchy
+        /// and finds all .clang-tidy files in the path, parses them and updates the
+        /// PropertyGrid and quick-access LinkLabel control to reflect the new property
+        /// chain.
+        /// </summary>
+        private void reloadPropertyChain()
+        {
+            StringBuilder LinkBuilder = new StringBuilder();
+            LinkBuilder.Append(DefaultText);
+            LinkBuilder.Append(" > ");
+            int PrefixLength = LinkBuilder.Length;
+
+            if (PropertyChain_.Count == 1)
+                LinkBuilder.Append(BrowseText);
+            else
+                LinkBuilder.Append(PropertyChain_[PropertyChain_.Count - 1].Key);
+
+            linkLabelPath.Text = LinkBuilder.ToString();
+
+            // Given a path like D:\Foo\Bar\Baz, construct a LinkLabel where individual
+            // components of the path are clickable iff they contain a .clang-tidy file.
+            // Clicking one of the links then updates the PropertyGrid to display the
+            // selected .clang-tidy file.
+            ClangTidyProperties LastProps = ClangTidyProperties.RootProperties;
+            linkLabelPath.Links.Clear();
+            linkLabelPath.Links.Add(0, DefaultText.Length, LastProps);
+            foreach (var Prop in PropertyChain_.Skip(1))
+            {
+                LastProps = Prop.Value;
+                string ClangTidyFolder = Path.GetFileName(Prop.Key);
+                int ClangTidyFolderOffset = Prop.Key.Length - ClangTidyFolder.Length;
+                linkLabelPath.Links.Add(PrefixLength + ClangTidyFolderOffset, ClangTidyFolder.Length, LastProps);
+            }
+            propertyGrid1.SelectedObject = LastProps;
+        }
+
+        private void propertyGrid1_PropertyValueChanged(object s, PropertyValueChangedEventArgs e)
+        {
+            ClangTidyProperties Props = (ClangTidyProperties)propertyGrid1.SelectedObject;
+            Props.SetHasUnsavedChanges(true);
+
+            // When a CategoryVerb is selected, perform the corresponding action.
+            PropertyDescriptor Property = e.ChangedItem.PropertyDescriptor;
+            if (!(e.ChangedItem.Value is CategoryVerb))
+                return;
+
+            CategoryVerb Action = (CategoryVerb)e.ChangedItem.Value;
+            if (Action == CategoryVerb.None)
+                return;
+
+            var Category = Property.Attributes.OfType<CategoryAttribute>().FirstOrDefault();
+            if (Category == null)
+                return;
+            var SameCategoryProps = Props.GetProperties(new Attribute[] { Category });
+            foreach (PropertyDescriptor P in SameCategoryProps)
+            {
+                if (P == Property)
+                    continue;
+                switch (Action)
+                {
+                    case CategoryVerb.Disable:
+                        P.SetValue(propertyGrid1.SelectedObject, false);
+                        break;
+                    case CategoryVerb.Enable:
+                        P.SetValue(propertyGrid1.SelectedObject, true);
+                        break;
+                    case CategoryVerb.Inherit:
+                        P.ResetValue(propertyGrid1.SelectedObject);
+                        break;
+                }
+            }
+            Property.ResetValue(propertyGrid1.SelectedObject);
+            propertyGrid1.Invalidate();
+        }
+
+        private void ClangTidyPropertyGrid_Load(object sender, EventArgs e)
+        {
+
+        }
+
+        private void linkLabelPath_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
+        {
+            ClangTidyProperties Props = (ClangTidyProperties)e.Link.LinkData;
+            propertyGrid1.SelectedObject = Props;
+        }
+    }
+}

clang-tidy-vs/ClangTidy/ClangTidyPropertyGrid.resx

+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </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>
+  <metadata name="clangTidyConfigurationPage1.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
+    <value>183, 17</value>
+  </metadata>
+</root>
 No newline at end of file

clang-tidy-vs/ClangTidy/ForwardingPropertyDescriptor.cs

+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace LLVM.ClangTidy
+{
+    /// <summary>
+    /// A decorator of sorts.  Accepts a PropertyDescriptor to its constructor
+    /// and forwards all calls to the underlying PropertyDescriptor.  In this way
+    /// we can inherit from ForwardingPropertyDescriptor and override only the
+    /// few methods we need to customize the behavior of, while allowing the
+    /// underlying PropertyDescriptor to do the real work.
+    /// </summary>
+    public abstract class ForwardingPropertyDescriptor : PropertyDescriptor
+    {
+        private readonly PropertyDescriptor root;
+        protected PropertyDescriptor Root { get { return root; } }
+        protected ForwardingPropertyDescriptor(PropertyDescriptor root)
+            : base(root)
+        {
+            this.root = root;
+        }
+
+        public override void AddValueChanged(object component, EventHandler handler)
+        {
+            root.AddValueChanged(component, handler);
+        }
+
+        public override AttributeCollection Attributes
+        {
+            get
+            {
+                return root.Attributes;
+            }
+        }
+
+        public override bool CanResetValue(object component)
+        {
+            return root.CanResetValue(component);
+        }
+
+        public override string Category
+        {
+            get
+            {
+                return root.Category;
+            }
+        }
+
+        public override Type ComponentType
+        {
+            get
+            {
+                return root.ComponentType;
+            }
+        }
+
+        public override TypeConverter Converter
+        {
+            get
+            {
+                return root.Converter;
+            }
+        }
+
+        public override string Description
+        {
+            get
+            {
+                return root.Description;
+            }
+        }
+
+        public override bool DesignTimeOnly
+        {
+            get
+            {
+                return root.DesignTimeOnly;
+            }
+        }
+
+        public override string DisplayName
+        {
+            get
+            {
+                return root.DisplayName;
+            }
+        }
+
+        public override bool Equals(object obj)
+        {
+            return root.Equals(obj);
+        }
+
+        public override PropertyDescriptorCollection GetChildProperties(object instance, Attribute[] filter)
+        {
+            return root.GetChildProperties(instance, filter);
+        }
+
+        public override object GetEditor(Type editorBaseType)
+        {
+            return root.GetEditor(editorBaseType);
+        }
+
+        public override int GetHashCode()
+        {
+            return root.GetHashCode();
+        }
+
+        public override object GetValue(object component)
+        {
+            return root.GetValue(component);
+        }
+
+        public override bool IsBrowsable
+        {
+            get
+            {
+                return root.IsBrowsable;
+            }
+        }
+
+        public override bool IsLocalizable
+        {
+            get
+            {
+                return root.IsLocalizable;
+            }
+        }
+
+        public override bool IsReadOnly
+        {
+            get
+            {
+                return root.IsReadOnly;
+            }
+        }
+
+        public override string Name
+        {
+            get
+            {
+                return root.Name;
+            }
+        }
+
+        public override Type PropertyType
+        {
+            get
+            {
+                return root.PropertyType;
+            }
+        }
+
+        public override void RemoveValueChanged(object component, EventHandler handler)
+        {
+            root.RemoveValueChanged(component, handler);
+        }
+
+        public override void ResetValue(object component)
+        {
+            root.ResetValue(component);
+        }
+
+        public override void SetValue(object component, object value)
+        {
+            root.SetValue(component, value);
+        }
+
+        public override bool ShouldSerializeValue(object component)
+        {
+            return root.ShouldSerializeValue(component);
+        }
+
+        public override bool SupportsChangeEvents
+        {
+            get
+            {
+                return root.SupportsChangeEvents;
+            }
+        }
+
+        public override string ToString()
+        {
+            return root.ToString();
+        }
+    }
+}

clang-tidy-vs/ClangTidy/GlobalSuppressions.cs

+// This file is used by Code Analysis to maintain SuppressMessage
+// attributes that are applied to this project. Project-level
+// suppressions either have no target or are given a specific target
+// and scoped to a namespace, type, member, etc.
+//
+// To add a suppression to this file, right-click the message in the
+// Error List, point to "Suppress Message(s)", and click "In Project
+// Suppression File". You do not need to add suppressions to this
+// file manually.
+
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1017:MarkAssembliesWithComVisible")]

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 static readonly Guid guidClangTidyCmdSet = new Guid(guidClangTidyCmdSetString);
+    };
+}
 No newline at end of file

clang-tidy-vs/ClangTidy/InheritableProperty.cs

+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace LLVM.ClangTidy
+{
+    /// <summary>
+    /// The PropertyDescriptor itself.  This is where the actual magic of inheritance happens.
+    /// This class determines what constitutes a "default" value and whether the user has
+    /// overridden the value of this property or if it is inherited.
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public class InheritableValuePropertyDescriptor<T> : ForwardingPropertyDescriptor
+    {
+        T Value_;
+        InheritableValuePropertyDescriptor<T> Parent_;
+        bool IsInheriting_;
+
+        /// <summary>
+        /// Create a new PropertyDescriptor
+        /// </summary>
+        /// <param name="Parent">The parent from which inherited values will be taken.  If null,
+        /// this PropertyDescriptor represents the global set of defaults which cannot be modified.
+        /// </param>
+        /// <param name="Root">A PropertyDescriptor representing the original unmodified property.
+        /// We will forward most calls to the underlying PropertyDescriptor, and only override the
+        /// behavior where it is necessary to implement property inheritance.
+        /// </param>
+        public InheritableValuePropertyDescriptor(InheritableValuePropertyDescriptor<T> Parent, PropertyDescriptor Root)
+            : base(Root)
+        {
+            foreach (DefaultValueAttribute Attr in Attributes.OfType<DefaultValueAttribute>())
+            {
+                Value_ = (T)Attr.Value;
+            }
+            Parent_ = Parent;
+            IsInheriting_ = true;
+        }
+
+        public bool IsInheriting { get { return IsInheriting_; } set { IsInheriting_ = value; } }
+        public InheritableValuePropertyDescriptor<T> Parent { get { return Parent_; } }
+        public T Value
+        {
+            get
+            {
+                // Return either this property's value or the parents value, depending on
+                // whether or not this property is inheriting.
+                if (IsInheriting_ && Parent != null)
+                    return Parent.Value;
+                return Value_;
+            }
+            set
+            {
+                // By explicitly setting the value, this property is no longer inheriting,
+                // even if the value the property is being set to is the same as that of
+                // the parent.
+                IsInheriting_ = false;
+                Value_ = value;
+            }
+        }
+
+        /// <summary>
+        /// Determines whether this property's value should be considered "default" (e.g.
+        /// displayed in bold in the property grid).  Root properties are unmodifiable and
+        /// always default.  Non-root properties are default iff they are inheriting.
+        /// That is to say, if a property is explicitly set to False, the property should
+        /// be serialized even if the parent is also False.  It would only not be serialized
+        /// if the user had explicitly chosen to inherit it.
+        /// </summary>
+        /// <param name="component"></param>
+        /// <returns></returns>
+        public override bool ShouldSerializeValue(object component)
+        {
+            if (Parent_ == null)
+                return false;
+            return !IsInheriting;
+        }
+
+        /// <summary>
+        /// Set the value back to the default.  For root properties, this essentially does
+        /// nothing as they are read-only anyway.  For non-root properties, this only means
+        /// that the property is now inheriting.
+        /// </summary>
+        /// <param name="component"></param>
+        public override void ResetValue(object component)
+        {
+            if (Parent_ == null)
+                Root.ResetValue(component);
+            IsInheriting_ = true;
+        }
+
+        public override void SetValue(object component, object value)
+        {
+            // This is a bit of a trick.  If the user chose the inheritance option from the
+            // dropdown, we will try to set the value to that string.  So look for that and
+            // then just reset the value.
+            if (value.Equals(MagicInheritance.Text))
+                ResetValue(component);
+            else
+            {
+                Value = (T)value;
+                Root.SetValue(component, value);
+            }
+        }
+
+        public override TypeConverter Converter
+        {
+            get
+            {
+                return new InheritablePropertyConverter<T>(this, Root.Converter);
+            }
+        }
+
+        public override bool IsReadOnly
+        {
+            get
+            {
+                if (Parent_ == null)
+                    return true;
+                return base.IsReadOnly;
+            }
+        }
+    }
+}

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

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace LLVM.ClangTidy
+{
+    partial class InheritablePropertyComponent
+    {
+        /// <summary>
+        /// Required designer variable.
+        /// </summary>
+        private System.ComponentModel.IContainer components = null;
+
+        /// <summary> 
+        /// Clean up any resources being used.
+        /// </summary>
+        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing && (components != null))
+            {
+                components.Dispose();
+            }
+            base.Dispose(disposing);
+        }
+
+        #region Component Designer generated code
+
+        /// <summary>
+        /// Required method for Designer support - do not modify
+        /// the contents of this method with the code editor.
+        /// </summary>
+        private void InitializeComponent()
+        {
+            components = new System.ComponentModel.Container();
+        }
+
+        #endregion
+    }
+}

clang-tidy-vs/ClangTidy/InheritablePropertyComponent.cs

+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace LLVM.ClangTidy
+{
+    /// <summary>
+    /// The goal of this class is to enable displaying of a PropertyGrid in much the
+    /// same way that Visual Studio's C++ project system does.  A project or file can
+    /// have properties which might inherit from their parent, or be overridden.
+    /// It turns out this is somewhat non-trivial.  The .NET PropertyGrid is good makes
+    /// displaying simple properties with a static notion of what constitutes a
+    /// "default" value very easy.  You simply apply an Attribute to the class that says
+    /// what the default value is and you're done.  But when you try to introduce the idea
+    /// that a property's default value depends on some other factor, things get much more
+    /// complicated due to the static nature of Attributes.
+    /// 
+    /// The solution to this is to inherit from ICustomTypeDescriptor.  This is the mechanism
+    /// by which you can inject or modify attributes or properties at runtime.  The .NET
+    /// PropertyGrid is designed in such a way that instead of using simple .NET Reflection to
+    /// look for the properties and attributes on a class, it will invoke the methods of
+    /// ICustomTypeDescriptor (if your type inherits from it), and ask those methods.  Our
+    /// implementation of ICustomTypeDescriptor works by waiting until the PropertyGrid requests
+    /// PropertyDescriptors for each of the properties, and then "decorating" them with our
+    /// own custom PropertyDescriptor implementation which understands the proeprty inheritance
+    /// model we wish to implement.
+    /// </summary>
+    public partial class InheritablePropertyComponent : Component, ICustomTypeDescriptor
+    {
+        private PropertyDescriptorCollection HackedProperties_ = null;
+        protected Dictionary<string, PropertyDescriptor> InheritedDescriptors_ = new Dictionary<string, PropertyDescriptor>();
+        private InheritablePropertyComponent Parent_;
+
+        public InheritablePropertyComponent(InheritablePropertyComponent Parent)
+        {
+            Parent_ = Parent;
+
+            InitializeHackedProperties();
+        }
+
+        public InheritablePropertyComponent(InheritablePropertyComponent Parent, IContainer container)
+        {
+            Parent_ = Parent;
+
+            container.Add(this);
+            InitializeComponent();
+
+            InitializeHackedProperties();
+        }
+
+        private void InitializeHackedProperties()
+        {
+            PropertyDescriptorCollection ParentProperties = null;
+            if (Parent_ != null)
+                ParentProperties = Parent_.GetProperties();
+
+            PropertyDescriptorCollection Props = TypeDescriptor.GetProperties(GetType());
+            HackedProperties_ = HackProperties(ParentProperties, Props);
+        }
+
+        public AttributeCollection GetAttributes()
+        {
+            return TypeDescriptor.GetAttributes(GetType());
+        }
+
+        public string GetClassName()
+        {
+            return TypeDescriptor.GetClassName(GetType());
+        }
+
+        public string GetComponentName()
+        {
+            return TypeDescriptor.GetComponentName(GetType());
+        }
+
+        public TypeConverter GetConverter()
+        {
+            return TypeDescriptor.GetConverter(GetType());
+        }
+
+        public EventDescriptor GetDefaultEvent()
+        {
+            return TypeDescriptor.GetDefaultEvent(GetType());
+        }
+
+        public PropertyDescriptor GetDefaultProperty()
+        {
+            return TypeDescriptor.GetDefaultProperty(GetType());
+        }
+
+        public object GetEditor(Type editorBaseType)
+        {
+            return TypeDescriptor.GetEditor(GetType(), editorBaseType);
+        }
+
+        public EventDescriptorCollection GetEvents()
+        {
+            return TypeDescriptor.GetEvents(GetType());
+        }
+
+        public EventDescriptorCollection GetEvents(Attribute[] attributes)
+        {
+            return TypeDescriptor.GetEvents(GetType(), attributes);
+        }
+
+        public PropertyDescriptorCollection GetProperties()
+        {
+            return HackedProperties_;
+        }
+
+        public PropertyDescriptorCollection GetProperties(Attribute[] attributes)
+        {
+            List<PropertyDescriptor> Props = new List<PropertyDescriptor>();
+            PropertyDescriptorCollection UnhackedResult = TypeDescriptor.GetProperties(GetType(), attributes);
+
+            foreach (PropertyDescriptor Prop in UnhackedResult)
+                Props.Add(HackedProperties_[Prop.Name]);
+            return new PropertyDescriptorCollection(Props.ToArray(), true);
+        }
+
+        public object GetPropertyOwner(PropertyDescriptor pd)
+        {
+            return this;
+        }
+
+        protected InheritableValuePropertyDescriptor<T> GetInheritableProperty<T>(string Name)
+        {
+            return (InheritableValuePropertyDescriptor<T>)(GetInheritableProperty(Name));
+        }
+
+        protected PropertyDescriptor GetInheritableProperty(string Name)
+        {
+            PropertyDescriptor Result = null;
+            if (!InheritedDescriptors_.TryGetValue(Name, out Result))
+            {
+                GetProperties();
+                if (!InheritedDescriptors_.TryGetValue(Name, out Result))
+                    return null;
+            }
+            return Result;
+        }
+
+
+        public void SetPropertyValue<T>(string Property, T Value)
+        {
+            GetInheritableProperty<T>(Property).Value = Value;
+        }
+
+
+        private PropertyDescriptorCollection HackProperties(PropertyDescriptorCollection ParentProperties, PropertyDescriptorCollection Properties)
+        {
+            List<PropertyDescriptor> Props = new List<PropertyDescriptor>();
+            foreach (PropertyDescriptor Prop in Properties)
+            {
+                PropertyDescriptor Result = null;
+                if (!InheritedDescriptors_.TryGetValue(Prop.Name, out Result))
+                {
+                    // The goal here is to invoke
+                    // InheritableValuePropertyDescriptor<T>(ParentDescriptor, Prop)
+                    // to create the inherited descriptor.
+
+
+                    // If we have a parent, find the corresponding PropertyDescriptor with the same
+                    // name from the parent.
+                    PropertyDescriptor ParentDescriptor = null;
+                    if (ParentProperties != null)
+                        ParentDescriptor = ParentProperties.Find(Prop.Name, false);
+
+                    // Create a Type representing InheritableValuePropertyDescriptor<T>
+                    Type DescriptorType = typeof(InheritableValuePropertyDescriptor<>);
+                    Type[] TypeArgs = { Prop.PropertyType };
+                    Type ParameterizedDescriptorType = DescriptorType.MakeGenericType(TypeArgs);
+
+                    // Call the constructor with ParentDescriptor, Prop as the args.
+                    object[] ConstructorParams = { ParentDescriptor, Prop };
+                    Result = (PropertyDescriptor)Activator.CreateInstance(ParameterizedDescriptorType, ConstructorParams);
+                    InheritedDescriptors_.Add(Prop.Name, Result);
+                }
+                Props.Add(Result);
+            }
+            return new PropertyDescriptorCollection(Props.ToArray(), true);
+        }
+
+    }
+}

clang-tidy-vs/ClangTidy/InheritablePropertyConverter.cs

+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace LLVM.ClangTidy
+{
+    class MagicInheritance {
+        public static readonly string Value = "{3A27184D-1774-489B-9BB7-7191B8E8E622}";
+        public static readonly string Text = "<Inherit from project or parent>";
+    }
+
+    /// <summary>
+    /// This will be used by the PropertyGrid to convert values (usually booleans) to
+    /// strings and back in order to display them in the PropertyGrid.  Inheritable
+    /// properties have an additional quirk though, in that the drop down list should
+    /// display an option to inherit the value from the parent.  This means we have to
+    /// inject a value into the drop down that doesn't correspond to a unique value
+    /// of the property.
+    /// </summary>
+    /// <typeparam name="T">The underlying type of the property being converted</typeparam>
+    class InheritablePropertyConverter<T> : TypeConverter
+    {
+        private InheritableValuePropertyDescriptor<T> Descriptor_;
+        private TypeConverter Root_;
+
+        public InheritablePropertyConverter(InheritableValuePropertyDescriptor<T> Descriptor, TypeConverter Root)
+        {
+            Descriptor_ = Descriptor;
+            Root_ = Root;
+        }
+
+        /// <summary>
+        /// Returns true if there are specific values that can be chosen from a dropdown
+        /// for this property.  Regardless of whether standard values are supported for
+        /// the underlying type, we always support standard values because we need to
+        /// display the inheritance option.
+        /// </summary>
+        /// <returns>true</returns>
+        public override bool GetStandardValuesSupported(ITypeDescriptorContext context)
+        {
+            return true;
+        }
+
+        /// <summary>
+        /// Get the set of all standard values that can be chosen from a dropdown for this
+        /// property.  If the underlying type supports standard values, we want to include
+        /// all those.  Additionally, we want to display the option to inherit the value,
+        /// but only if the value is not already inheriting.
+        /// </summary>
+        public override StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
+        {
+            List<object> Values = new List<object>();
+            if (Root_.GetStandardValuesSupported(context))
+            {
+                StandardValuesCollection RootValues = Root_.GetStandardValues(context);
+                Values.AddRange(RootValues.Cast<object>());
+            }
+            if (!Descriptor_.IsInheriting)
+                Values.Add(MagicInheritance.Value);
+            StandardValuesCollection Result = new StandardValuesCollection(Values);
+            return Result;
+        }
+
+        /// <summary>
+        /// Determines whether this property can accept values other than those specified
+        /// in the dropdown (for example by manually typing into the field).
+        /// </summary>
+        public override bool GetStandardValuesExclusive(ITypeDescriptorContext context)
+        {
+            // Although we add items to the dropdown list, we do not change whether or not
+            // the set of values are exclusive.  If the user could type into the field before
+            // they still can.  And if they couldn't before, they still can't.
+            return Root_.GetStandardValuesExclusive(context);
+        }
+
+        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
+        {
+            return Root_.CanConvertFrom(context, sourceType);
+        }
+
+        public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
+        {
+            return Root_.CanConvertTo(context, destinationType);
+        }
+
+        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
+        {
+            if (value.Equals(MagicInheritance.Value))
+                return MagicInheritance.Text;
+            return Root_.ConvertFrom(context, culture, value);
+        }
+
+        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
+        {
+            if (value.GetType() == destinationType)
+                return value;
+
+            return Root_.ConvertTo(context, culture, value, destinationType);
+        }
+
+        public override object CreateInstance(ITypeDescriptorContext context, IDictionary propertyValues)
+        {
+            return Root_.CreateInstance(context, propertyValues);
+        }
+
+        public override bool Equals(object obj)
+        {
+            return Root_.Equals(obj);
+        }
+
+        public override bool GetCreateInstanceSupported(ITypeDescriptorContext context)
+        {
+            return Root_.GetCreateInstanceSupported(context);
+        }
+
+        public override int GetHashCode()
+        {
+            return Root_.GetHashCode();
+        }
+
+        public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes)
+        {
+            return Root_.GetProperties(context, value, attributes);
+        }
+
+        public override bool GetPropertiesSupported(ITypeDescriptorContext context)
+        {
+            return Root_.GetPropertiesSupported(context);
+        }
+
+        public override bool IsValid(ITypeDescriptorContext context, object value)
+        {
+            return Root_.IsValid(context, value);
+        }
+
+        public override string ToString()
+        {
+            return Root_.ToString();
+        }
+    }
+}

clang-tidy-vs/ClangTidy/PkgCmdID.cs

+namespace LLVM.ClangTidy
+{
+    static class PkgCmdIDList
+    {
+        public const uint cmdidClangTidy = 0x100;
+    };
+}
 No newline at end of file

clang-tidy-vs/ClangTidy/Properties/AssemblyInfo.cs

+using System;
+using System.Reflection;
+using System.Resources;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("ClangFormat")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("LLVM")]
+[assembly: AssemblyProduct("ClangFormat")]
+[assembly: AssemblyCopyright("")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+[assembly: ComVisible(false)]
+[assembly: CLSCompliant(false)]
+[assembly: NeutralResourcesLanguage("en-US")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Revision and Build Numbers 
+// by using the '*' as shown below:
+// FIXME: Add a way to have this generated automatically by CMake
+[assembly: AssemblyVersion("1.1.0.0")]
+[assembly: AssemblyFileVersion("1.1.0.0")]

clang-tidy-vs/ClangTidy/PropertyFileParser.cs

+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using YamlDotNet.Serialization;
+using YamlDotNet.Serialization.NamingConventions;
+
+namespace LLVM.ClangTidy
+{
+    static class PropertyFileParser
+    {
+        public class CheckOption
+        {
+            [YamlAlias("key")]
+            public string Key { get; set; }
+
+            [YamlAlias("value")]
+            public string Value { get; set; }
+        }
+        public class ClangTidyYaml
+        {
+            [YamlAlias("Checks")]
+            public string Checks { get; set; }
+
+            [YamlAlias("CheckOptions")]
+            public List<CheckOption> CheckOptions { get; set; }
+        }
+
+        public static List<KeyValuePair<string, ClangTidyProperties>> ParseConfigurationChain(string ClangTidyFile)
+        {
+            List<KeyValuePair<string, ClangTidyProperties>> Result = new List<KeyValuePair<string, ClangTidyProperties>>();
+            Result.Add(new KeyValuePair<string, ClangTidyProperties>(null, ClangTidyProperties.RootProperties));
+
+            foreach (string P in Utility.SplitPath(ClangTidyFile).Reverse())
+            {
+                if (!Utility.HasClangTidyFile(P))
+                    continue;
+
+                string ConfigFile = Path.Combine(P, ".clang-tidy");
+
+                using (StreamReader Reader = new StreamReader(ConfigFile))
+                {
+                    Deserializer D = new Deserializer(namingConvention: new PascalCaseNamingConvention());
+                    ClangTidyYaml Y = D.Deserialize<ClangTidyYaml>(Reader);
+                    ClangTidyProperties Parent = Result[Result.Count - 1].Value;
+                    ClangTidyProperties NewProps = new ClangTidyProperties(Parent);
+                    SetPropertiesFromYaml(Y, NewProps);
+                    Result.Add(new KeyValuePair<string, ClangTidyProperties>(P, NewProps));
+                }
+            }
+            return Result;
+        }
+
+        enum TreeLevelOp
+        {
+            Enable,
+            Disable,
+            Inherit
+        }
+
+        public static void SerializeClangTidyFile(ClangTidyProperties Props, string ClangTidyFilePath)
+        {
+            List<string> CommandList = new List<string>();
+            SerializeCheckTree(CommandList, Props.GetCheckTree(), TreeLevelOp.Inherit);
+
+            CommandList.Sort((x, y) =>
+            {
+                bool LeftSub = x.StartsWith("-");
+                bool RightSub = y.StartsWith("-");
+                if (LeftSub && !RightSub)
+                    return -1;
+                if (RightSub && !LeftSub)
+                    return 1;
+                return StringComparer.CurrentCulture.Compare(x, y);
+            });
+
+            string ConfigFile = Path.Combine(ClangTidyFilePath, ".clang-tidy");
+            using (StreamWriter Writer = new StreamWriter(ConfigFile))
+            {
+                Serializer S = new Serializer(namingConvention: new PascalCaseNamingConvention());
+                ClangTidyYaml Yaml = new ClangTidyYaml();
+                Yaml.Checks = String.Join(",", CommandList.ToArray());
+                S.Serialize(Writer, Yaml);
+            }
+        }
+
+        /// <summary>
+        /// Convert the given check tree into serialized list of commands that can be written to
+        /// the Yaml.  The goal here is to determine the minimal sequence of check commands that
+        /// will produce the exact configuration displayed in the UI.  This is complicated by the
+        /// fact that an inherited True is not the same as an explicitly specified True.  If the
+        /// user has chosen to inherit a setting in a .clang-tidy file, then changing it in the
+        /// parent should show the reflected changes in the current file as well.  So we cannot
+        /// simply -* everything and then add in the checks we need, because -* immediately marks
+        /// every single check as explicitly false, thus disabling inheritance.
+        /// </summary>
+        /// <param name="CommandList">State passed through this recursive algorithm representing
+        /// the sequence of commands we have determined so far.
+        /// </param>
+        /// <param name="Tree">The check tree to serialize.  This is the parameter that will be
+        /// recursed on as successive subtrees get serialized to `CommandList`.
+        /// </param>
+        /// <param name="CurrentOp">The current state of the subtree.  For example, if the
+        /// algorithm decides to -* an entire subtree and then add back one single check,
+        /// after adding a -subtree-* command to CommandList, it would pass in a value of
+        /// CurrentOp=TreeLevelOp.Disable when it recurses down.  This allows deeper iterations
+        /// of the algorithm to know what kind of command (if any) needs to be added to CommandList
+        /// in order to put a particular check into a particular state.
+        /// </param>
+        private static void SerializeCheckTree(List<string> CommandList, CheckTree Tree, TreeLevelOp CurrentOp)
+        {
+            int NumChecks = Tree.CountChecks;
+            int NumDisabled = Tree.CountExplicitlyDisabledChecks;
+            int NumEnabled = Tree.CountExplicitlyEnabledChecks;
+            int NumInherited = Tree.CountInheritedChecks;
+
+            if (NumChecks == 0)
+                return;
+
+            if (NumInherited > 0)
+                System.Diagnostics.Debug.Assert(CurrentOp == TreeLevelOp.Inherit);
+
+            // If this entire tree is inherited, just exit, nothing about this needs to
+            // go in the clang-tidy file.
+            if (NumInherited == NumChecks)
+                return;
+
+            TreeLevelOp NewOp = CurrentOp;
+            // If there are no inherited properties in this subtree, decide whether to
+            // explicitly enable or disable this subtree.  Decide by looking at whether
+            // there is a larger proportion of disabled or enabled descendants.  If
+            // there are more disabled items in this subtree for example, disabling the
+            // subtree will lead to a smaller configuration file.
+            if (NumInherited == 0)
+            {
+                if (NumDisabled >= NumEnabled)
+                    NewOp = TreeLevelOp.Disable;
+                else
+                    NewOp = TreeLevelOp.Enable;
+            }
+
+            if (NewOp == TreeLevelOp.Disable)
+            {
+                // Only add an explicit disable command if the tree was not already disabled
+                // to begin with.
+                if (CurrentOp != TreeLevelOp.Disable)
+                {
+                    string WildcardPath = "*";
+                    if (Tree.Path != null)
+                        WildcardPath = Tree.Path + "-" + WildcardPath;
+                    CommandList.Add("-" + WildcardPath);
+                }
+                // If the entire subtree was disabled, there's no point descending.
+                if (NumDisabled == NumChecks)
+                    return;
+            }
+            else if (NewOp == TreeLevelOp.Enable)
+            {
+                // Only add an explicit enable command if the tree was not already enabled
+                // to begin with.  Note that if we're at the root, all checks are already
+                // enabled by default, so there's no need to explicitly include *
+                if (CurrentOp != TreeLevelOp.Enable && Tree.Path != null)
+                {
+                    string WildcardPath = Tree.Path + "-*";
+                    CommandList.Add(WildcardPath);
+                }
+                // If the entire subtree was enabled, there's no point descending.
+                if (NumEnabled == NumChecks)
+                    return;
+            }
+
+            foreach (var Child in Tree.Children)
+            {
+                if (Child.Value is CheckLeaf)
+                {
+                    CheckLeaf Leaf = (CheckLeaf)Child.Value;
+                    if (Leaf.CountExplicitlyEnabledChecks == 1 && NewOp != TreeLevelOp.Enable)
+                        CommandList.Add(Leaf.Path);
+                    else if (Leaf.CountExplicitlyDisabledChecks == 1 && NewOp != TreeLevelOp.Disable)
+                        CommandList.Add("-" + Leaf.Path);
+                    continue;
+                }
+
+                System.Diagnostics.Debug.Assert(Child.Value is CheckTree);
+                CheckTree ChildTree = (CheckTree)Child.Value;
+                SerializeCheckTree(CommandList, ChildTree, NewOp);
+            }
+        }
+
+        private static void SetPropertiesFromYaml(ClangTidyYaml Yaml, ClangTidyProperties Props)
+        {
+            string[] CheckCommands = Yaml.Checks.Split(',');
+            foreach (string Command in CheckCommands)
+            {
+                if (Command == null || Command.Length == 0)
+                    continue;
+                bool Add = true;
+                string Check = Command;
+                if (Check[0] == '-')
+                {
+                    Check = Check.Substring(1);
+                    Add = false;
+                }
+
+                ClangTidyProperties.CheckMapping[] Matches = Props.FindChecksMatching(Check).ToArray();
+                foreach (var Match in Matches)
+                {
+                    Props.SetPropertyValue(Match.Property, Add);
+                }
+            }
+        }
+    }
+}

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

+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//     Runtime Version:4.0.30319.42000
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace LLVM.ClangTidy {
+    using System;
+    
+    
+    /// <summary>
+    ///   A strongly-typed resource class, for looking up localized strings, etc.
+    /// </summary>
+    // This class was auto-generated by the StronglyTypedResourceBuilder
+    // class via a tool like ResGen or Visual Studio.
+    // To add or remove a member, edit your .ResX file then rerun ResGen
+    // with the /str option, or rebuild your VS project.
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    internal class Resources {
+        
+        private static global::System.Resources.ResourceManager resourceMan;
+        
+        private static global::System.Globalization.CultureInfo resourceCulture;
+        
+        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+        internal Resources() {
+        }
+        
+        /// <summary>
+        ///   Returns the cached ResourceManager instance used by this class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Resources.ResourceManager ResourceManager {
+            get {
+                if (object.ReferenceEquals(resourceMan, null)) {
+                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("LLVM.ClangTidy.Resources", typeof(Resources).Assembly);
+                    resourceMan = temp;
+                }
+                return resourceMan;
+            }
+        }
+        
+        /// <summary>
+        ///   Overrides the current thread's CurrentUICulture property for all
+        ///   resource lookups using this strongly typed resource class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Globalization.CultureInfo Culture {
+            get {
+                return resourceCulture;
+            }
+            set {
+                resourceCulture = value;
+            }
+        }
+    }
+}

clang-tidy-vs/ClangTidy/Resources.resx

+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    VS SDK Notes: This resx file contains the resources that will be consumed directly by your package.
+    For example, if you chose to create a tool window, there is a resource with ID 'CanNotCreateWindow'. This
+    is used in VsPkg.cs to determine the string to show the user if there is an error when attempting to create
+    the tool window.
+
+    Resources that are accessed directly from your package *by Visual Studio* are stored in the VSPackage.resx 
+    file.
+-->
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </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>
+</root>
 No newline at end of file

clang-tidy-vs/ClangTidy/Utility.cs

+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+
+namespace LLVM.ClangTidy
+{
+    static class Utility
+    {
+        public static IEnumerable<string> SplitPath(string FileOrDir)
+        {
+            string P = Path.GetDirectoryName(FileOrDir);
+            do
+            {
+                yield return P;
+                P = Path.GetDirectoryName(P);
+            } while (P != null);
+        }
+
+        public static bool HasClangTidyFile(string Folder)
+        {
+            string ClangTidy = Path.Combine(Folder, ".clang-tidy");
+            return File.Exists(ClangTidy);
+        }
+
+        public static bool MatchWildcardString(string Value, string Pattern)
+        {
+            string RE = Regex.Escape(Pattern).Replace(@"\*", ".*");
+            return Regex.IsMatch(Value, RE);
+        }
+    }
+}

clang-tidy-vs/ClangTidy/VSPackage.resx

+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    VS SDK Notes: This resx file contains the resources that will be consumed from your package by Visual Studio.
+    For example, Visual Studio will attempt to load resource '400' from this resource stream when it needs to
+    load your package's icon. Because Visual Studio will always look in the VSPackage.resources stream first for
+    resources it needs, you should put additional resources that Visual Studio will load directly into this resx 
+    file. 
+
+    Resources that you would like to access directly from your package in a strong-typed fashion should be stored 
+    in Resources.resx or another resx file.
+-->
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </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="110" xml:space="preserve">
+    <value>ClangTidy</value>
+  </data>
+  <data name="112" xml:space="preserve">
+    <value>Analyzes code by calling the clang-tidy executable.</value>
+  </data>
+  <data name="400" 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>
+</root>
 No newline at end of file

clang-tidy-vs/ClangTidy/license.txt

+==============================================================================
+LLVM Release License
+==============================================================================
+University of Illinois/NCSA
+Open Source License
+
+Copyright (c) 2007-2016 University of Illinois at Urbana-Champaign.
+All rights reserved.
+
+Developed by:
+
+    LLVM Team
+
+    University of Illinois at Urbana-Champaign
+
+    http://llvm.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal with
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimers.
+
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimers in the
+      documentation and/or other materials provided with the distribution.
+
+    * Neither the names of the LLVM Team, University of Illinois at
+      Urbana-Champaign, nor the names of its contributors may be used to
+      endorse or promote products derived from this Software without specific
+      prior written permission.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
+SOFTWARE.
+
+==============================================================================
+The LLVM software contains code written by third parties.  Such software will
+have its own individual LICENSE.TXT file in the directory in which it appears.
+This file will describe the copyrights, license, and restrictions which apply
+to that code.
+
+The disclaimer of warranty in the University of Illinois Open Source License
+applies to all code in the LLVM Distribution, and nothing in any of the
+other licenses gives permission to use the names of the LLVM Team or the
+University of Illinois to endorse or promote products derived from this
+Software.
+
+The following pieces of software have additional or alternate copyrights,
+licenses, and/or restrictions:
+
+Program             Directory
+-------             ---------
+<none yet>
+

clang-tidy-vs/ClangTidy/packages.config

+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="Brutal.Dev.StrongNameSigner" version="1.8.0" targetFramework="net45" />
+  <package id="YamlDotNet" version="3.3.0" targetFramework="net45" />
+  <package id="YamlDotNet.Dynamic" version="3.2.3" targetFramework="net45" />
+</packages>
 No newline at end of file

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 (?)
+
+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.

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>ClangFormat</Name>
+    <Author>LLVM</Author>
+    <Version>@CLANG_TIDY_VS_VERSION@</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>