Moving CA1036 to System.Runtime.Analyzers. Also:

- Make all analyzers cache the wellknown type by implementing compilationstart action.
- Cleaning up the resx file in FxCopAnalyzers.

src/Diagnostics/FxCop/Core/FxCopFixersResources.Designer.cs

 //------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by a tool.
-//     Runtime Version:4.0.30319.34014
+//     Runtime Version:4.0.30319.0
 //
 //     Changes to this file may cause incorrect behavior and will be lost if
 //     the code is regenerated.
@@ -159,15 +159,6 @@ internal class FxCopFixersResources {
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Implement IDisposable Interface.
-        /// </summary>
-        internal static string ImplementIDisposableInterface {
-            get {
-                return ResourceManager.GetString("ImplementIDisposableInterface", resourceCulture);
-            }
-        }
-        
         /// <summary>
         ///   Looks up a localized string similar to Implement Serialization constructor.
         /// </summary>

src/Diagnostics/FxCop/Core/FxCopFixersResources.resx

@@ -117,9 +117,6 @@
   <resheader name="writer">
     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </resheader>
-  <data name="ImplementIDisposableInterface" xml:space="preserve">
-    <value>Implement IDisposable Interface</value>
-  </data>
   <data name="OverloadOperatorEqualsOnOverridingValueTypeEquals" xml:space="preserve">
     <value>Overload operator equals on overriding ValueType.Equals</value>
   </data>

src/Diagnostics/FxCop/Core/FxCopRulesDiagnosticAnalyzers.csproj

@@ -152,7 +152,6 @@
     <Compile Include="Shared\WellKnownTypes.cs" />
     <Compile Include="Shared\WordParser.cs" />
     <Compile Include="Shared\WordParserOptions.cs" />
-    <Compile Include="Design\CA1036DiagnosticAnalyzer.cs" />
     <Compile Include="SolutionChangeAction.cs" />
     <Compile Include="Usage\CA2200DiagnosticAnalyzer.cs" />
     <Compile Include="Usage\CA2213DiagnosticAnalyzer.cs" />

src/Diagnostics/FxCop/Core/FxCopRulesResources.Designer.cs

@@ -195,15 +195,6 @@ internal class FxCopRulesResources {
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Custom attributes should have AttributeUsage attribute defined..
-        /// </summary>
-        internal static string CustomAttrShouldHaveAttributeUsage {
-            get {
-                return ResourceManager.GetString("CustomAttrShouldHaveAttributeUsage", resourceCulture);
-            }
-        }
-        
         /// <summary>
         ///   Looks up a localized string similar to Disposable fields should be disposed.
         /// </summary>
@@ -438,15 +429,6 @@ internal class FxCopRulesResources {
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Specify AttributeUsage attribute on &apos;{0}&apos; attribute class..
-        /// </summary>
-        internal static string MarkAttributesWithAttributeUsage {
-            get {
-                return ResourceManager.GetString("MarkAttributesWithAttributeUsage", resourceCulture);
-            }
-        }
-        
         /// <summary>
         ///   Looks up a localized string similar to Mark Enum with FlagsAttribute.
         /// </summary>
@@ -501,24 +483,6 @@ internal class FxCopRulesResources {
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Overload operator Equals and comparison operators when implementing System.IComparable.
-        /// </summary>
-        internal static string OverloadOperatorEqualsOnIComparableInterface {
-            get {
-                return ResourceManager.GetString("OverloadOperatorEqualsOnIComparableInterface", resourceCulture);
-            }
-        }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Types that implement IComparable should redefine Equals and comparison operators to keep the meanings of less than, greater than, and equals consistent throughout the type..
-        /// </summary>
-        internal static string OverloadOperatorEqualsOnIComparableInterfaceDescription {
-            get {
-                return ResourceManager.GetString("OverloadOperatorEqualsOnIComparableInterfaceDescription", resourceCulture);
-            }
-        }
-        
         /// <summary>
         ///   Looks up a localized string similar to Overload operator equals on overriding ValueType.Equals.
         /// </summary>

src/Diagnostics/FxCop/Core/FxCopRulesResources.resx

@@ -201,12 +201,6 @@
   <data name="ImplementSerializationConstructor" xml:space="preserve">
     <value>Implement Serialization constructor</value>
   </data>
-  <data name="MarkAttributesWithAttributeUsage" xml:space="preserve">
-    <value>Specify AttributeUsage attribute on '{0}' attribute class.</value>
-  </data>
-  <data name="OverloadOperatorEqualsOnIComparableInterface" xml:space="preserve">
-    <value>Overload operator Equals and comparison operators when implementing System.IComparable</value>
-  </data>
   <data name="IdentifierNamesShouldDifferMoreThanCase" xml:space="preserve">
     <value>{0} '{1}' have identical names in a case-insensitive manner.</value>
   </data>
@@ -216,9 +210,6 @@
   <data name="AvoidUnsealedAttributes" xml:space="preserve">
     <value>Avoid unsealed attributes.</value>
   </data>
-  <data name="CustomAttrShouldHaveAttributeUsage" xml:space="preserve">
-    <value>Custom attributes should have AttributeUsage attribute defined.</value>
-  </data>
   <data name="DoNotLockOnObjectsWithWeakIdentity" xml:space="preserve">
     <value>Do not lock on objects with weak identity.</value>
   </data>
@@ -315,9 +306,6 @@
   <data name="MarkISerializableTypesWithAttributeDescription" xml:space="preserve">
     <value>The System.Runtime.Serialization.ISerializable interface allows the type to customize its serialization, while the Serializable attribute enables the runtime to recognize the type as being serializable.</value>
   </data>
-  <data name="OverloadOperatorEqualsOnIComparableInterfaceDescription" xml:space="preserve">
-    <value>Types that implement IComparable should redefine Equals and comparison operators to keep the meanings of less than, greater than, and equals consistent throughout the type.</value>
-  </data>
   <data name="OverloadOperatorEqualsOnOverridingValueTypeEqualsDescription" xml:space="preserve">
     <value>Value types that redefine System.ValueType.Equals should redefine the equality operator as well to ensure that these members return the same results. This helps ensure that types that rely on Equals (such as ArrayList and Hashtable) behave in a manner that is expected and consistent with the equality operator.</value>
   </data>

src/Diagnostics/FxCop/System.Runtime.Analyzers/Core/Design/DefineAccessorsForAttributeArguments.cs

@@ -43,14 +43,23 @@ public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics
 
         public override void Initialize(AnalysisContext analysisContext)
         {
-            analysisContext.RegisterSymbolAction(context =>
+            analysisContext.RegisterCompilationStartAction(compilationContext =>
             {
-                AnalyzeSymbol((INamedTypeSymbol)context.Symbol, context.Compilation, context.ReportDiagnostic, context.Options, context.CancellationToken);
-            },
-            SymbolKind.NamedType);
+                var attributeType = WellKnownTypes.IDisposable(compilationContext.Compilation);
+                if (attributeType == null)
+                {
+                    return;
+                }
+
+                compilationContext.RegisterSymbolAction(context =>
+                {
+                    AnalyzeSymbol((INamedTypeSymbol)context.Symbol, attributeType, context.Compilation, context.ReportDiagnostic);
+                },
+                SymbolKind.NamedType);
+            });
         }
 
-        private void AnalyzeSymbol(INamedTypeSymbol symbol, Compilation compilation, Action<Diagnostic> addDiagnostic, AnalyzerOptions options, CancellationToken cancellationToken)
+        private void AnalyzeSymbol(INamedTypeSymbol symbol, INamedTypeSymbol attributeType, Compilation compilation, Action<Diagnostic> addDiagnostic)
         {
             if (symbol != null && symbol.GetBaseTypesAndThis().Contains(WellKnownTypes.Attribute(compilation)) && symbol.DeclaredAccessibility != Accessibility.Private)
             {

src/Diagnostics/FxCop/System.Runtime.Analyzers/Core/Design/MarkAttributesWithAttributeUsage.cs

@@ -28,42 +28,35 @@ public sealed class MarkAttributesWithAttributeUsageAnalyzer : DiagnosticAnalyze
                                                                     helpLinkUri: "http://msdn.microsoft.com/library/ms182158.aspx",
                                                                     customTags: WellKnownDiagnosticTags.Telemetry);
 
-        public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics
-        {
-            get
-            {
-                return ImmutableArray.Create(Rule);
-            }
-        }
+        public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Rule);
 
         public override void Initialize(AnalysisContext analysisContext)
         {
-            analysisContext.RegisterSymbolAction(context =>
+            analysisContext.RegisterCompilationStartAction(compilationContext =>
             {
-                AnalyzeSymbol((INamedTypeSymbol)context.Symbol, context.Compilation, context.ReportDiagnostic, context.Options, context.CancellationToken);
-            },
-            SymbolKind.NamedType);
+                var attributeType = WellKnownTypes.Attribute(compilationContext.Compilation);
+                var attributeUsageAttributeType = WellKnownTypes.AttributeUsageAttribute(compilationContext.Compilation);
+                if (attributeType == null || attributeUsageAttributeType == null)
+                {
+                    return;
+                }
+
+                compilationContext.RegisterSymbolAction(context =>
+                {
+                    AnalyzeSymbol((INamedTypeSymbol)context.Symbol, attributeType, attributeUsageAttributeType, context.ReportDiagnostic);
+                },
+                SymbolKind.NamedType);
+            });
         }
 
-        private static void AnalyzeSymbol(INamedTypeSymbol symbol, Compilation compilation, Action<Diagnostic> addDiagnostic, AnalyzerOptions options, CancellationToken cancellationToken)
+        private static void AnalyzeSymbol(INamedTypeSymbol symbol, INamedTypeSymbol attributeType, INamedTypeSymbol attributeUsageAttributeType, Action<Diagnostic> addDiagnostic)
         {
-            var attributeUsageAttribute = WellKnownTypes.AttributeUsageAttribute(compilation);
-            if (attributeUsageAttribute == null)
-            {
-                return;
-            }
-
-            if (symbol.IsAbstract || !symbol.GetBaseTypesAndThis().Contains(WellKnownTypes.Attribute(compilation)))
-            {
-                return;
-            }
-
-            if (attributeUsageAttribute == null)
+            if (symbol.IsAbstract || !symbol.GetBaseTypesAndThis().Contains(attributeType))
             {
                 return;
             }
 
-            var hasAttributeUsageAttribute = symbol.GetAttributes().Any(attribute => attribute.AttributeClass == attributeUsageAttribute);
+            var hasAttributeUsageAttribute = symbol.GetAttributes().Any(attribute => attribute.AttributeClass == attributeUsageAttributeType);
             if (!hasAttributeUsageAttribute)
             {
                 addDiagnostic(symbol.CreateDiagnostic(Rule, symbol.Name));

src/Diagnostics/FxCop/Core/Design/CA1036DiagnosticAnalyzer.cs → src/Diagnostics/FxCop/System.Runtime.Analyzers/Core/Design/OverrideMethodsOnComparableTypes.cs

 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
-using System;
 using System.Collections.Immutable;
 using System.Linq;
 using System.Threading;
+using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Diagnostics;
-using Microsoft.CodeAnalysis.FxCopAnalyzers.Utilities;
 
-namespace Microsoft.CodeAnalysis.FxCopAnalyzers.Design
+namespace System.Runtime.Analyzers
 {
     [DiagnosticAnalyzer(LanguageNames.CSharp, LanguageNames.VisualBasic)]
-    public sealed class CA1036DiagnosticAnalyzer : AbstractNamedTypeAnalyzer
+    public sealed class OverrideMethodsOnComparableTypesAnalyzer : DiagnosticAnalyzer
     {
         internal const string RuleId = "CA1036";
-        private static LocalizableString s_localizableTitle = new LocalizableResourceString(nameof(FxCopRulesResources.OverloadOperatorEqualsOnIComparableInterface), FxCopRulesResources.ResourceManager, typeof(FxCopRulesResources));
-        private static LocalizableString s_localizableMessage = new LocalizableResourceString(nameof(FxCopRulesResources.OverloadOperatorEqualsOnIComparableInterface), FxCopRulesResources.ResourceManager, typeof(FxCopRulesResources));
-        private static LocalizableString s_localizableDescription = new LocalizableResourceString(nameof(FxCopRulesResources.OverloadOperatorEqualsOnIComparableInterfaceDescription), FxCopRulesResources.ResourceManager, typeof(FxCopRulesResources));
+        private static LocalizableString s_localizableTitle = new LocalizableResourceString(nameof(SystemRuntimeAnalyzersResources.OverloadOperatorEqualsOnIComparableInterface), SystemRuntimeAnalyzersResources.ResourceManager, typeof(SystemRuntimeAnalyzersResources));
+        private static LocalizableString s_localizableMessage = new LocalizableResourceString(nameof(SystemRuntimeAnalyzersResources.OverloadOperatorEqualsOnIComparableInterface), SystemRuntimeAnalyzersResources.ResourceManager, typeof(SystemRuntimeAnalyzersResources));
+        private static LocalizableString s_localizableDescription = new LocalizableResourceString(nameof(SystemRuntimeAnalyzersResources.OverloadOperatorEqualsOnIComparableInterfaceDescription), SystemRuntimeAnalyzersResources.ResourceManager, typeof(SystemRuntimeAnalyzersResources));
 
         internal static readonly DiagnosticDescriptor Rule = new DiagnosticDescriptor(RuleId,
                                                                                   s_localizableTitle,
                                                                                   s_localizableMessage,
-                                                                                  FxCopDiagnosticCategory.Design,
+                                                                                  DiagnosticCategory.Design,
                                                                                   DiagnosticSeverity.Warning,
                                                                                   isEnabledByDefault: true,
                                                                                   description: s_localizableDescription,
                                                                                   helpLinkUri: "http://msdn.microsoft.com/library/ms182163.aspx",
-                                                                                  customTags: DiagnosticCustomTags.Microsoft);
+                                                                                  customTags: WellKnownDiagnosticTags.Telemetry);
 
-        public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics
+        public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Rule);
+
+        public override void Initialize(AnalysisContext analysisContext)
         {
-            get
+            analysisContext.RegisterCompilationStartAction(compilationContext =>
             {
-                return ImmutableArray.Create(Rule);
-            }
-        }
+                var comparableType = WellKnownTypes.IComparable(compilationContext.Compilation);
+                var genericComparableType = WellKnownTypes.GenericIComparable(compilationContext.Compilation);
 
-        protected override void AnalyzeSymbol(INamedTypeSymbol namedTypeSymbol, Compilation compilation, Action<Diagnostic> addDiagnostic, AnalyzerOptions options, CancellationToken cancellationToken)
-        {
-            var comparableType = WellKnownTypes.IComparable(compilation);
+                // Even if one of them is available, we should continue analysis.
+                if (comparableType == null && genericComparableType == null)
+                {
+                    return;
+                }
 
-            if (comparableType == null)
-            {
-                return;
-            }
+                compilationContext.RegisterSymbolAction(context =>
+                {
+                    AnalyzeSymbol((INamedTypeSymbol)context.Symbol, comparableType, genericComparableType, context.ReportDiagnostic);
+                }, 
+                SymbolKind.NamedType);
+            });
+        }
 
-            if (namedTypeSymbol.DeclaredAccessibility == Accessibility.Private)
+        private static void AnalyzeSymbol(INamedTypeSymbol namedTypeSymbol, INamedTypeSymbol comparableType, INamedTypeSymbol genericComparableType, Action<Diagnostic> addDiagnostic)
+        {
+            if (namedTypeSymbol.DeclaredAccessibility == Accessibility.Private || namedTypeSymbol.TypeKind == TypeKind.Interface)
             {
                 return;
             }
 
-            if (namedTypeSymbol.Interfaces.Contains(comparableType))
+            if (namedTypeSymbol.AllInterfaces.Any(t => t.Equals(comparableType) || 
+                                                      (t.ConstructedFrom?.Equals(genericComparableType) ?? false)))
             {
                 if (!(DoesOverrideEquals(namedTypeSymbol) && IsEqualityOperatorImplemented(namedTypeSymbol)))
                 {

src/Diagnostics/FxCop/System.Runtime.Analyzers/Core/Design/TypesThatOwnDisposableFieldsShouldBeDisposable.cs

@@ -17,7 +17,6 @@ public sealed class TypesThatOwnDisposableFieldsShouldBeDisposableAnalyzer : Dia
     {
         internal const string RuleId = "CA1001";
         internal const string Dispose = "Dispose";
-        internal const string IDisposable = "System.IDisposable";
 
         internal static DiagnosticDescriptor Rule = new DiagnosticDescriptor(RuleId,
                                                                          new LocalizableResourceString(nameof(SystemRuntimeAnalyzersResources.TypesThatOwnDisposableFieldsShouldBeDisposable), SystemRuntimeAnalyzersResources.ResourceManager, typeof(SystemRuntimeAnalyzersResources)),
@@ -28,27 +27,29 @@ public sealed class TypesThatOwnDisposableFieldsShouldBeDisposableAnalyzer : Dia
                                                                          helpLinkUri: "http://msdn.microsoft.com/library/ms182172.aspx",
                                                                          customTags: WellKnownDiagnosticTags.Telemetry);
 
-        public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics
-        {
-            get
-            {
-                return ImmutableArray.Create(Rule);
-            }
-        }
+        public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Rule);
 
         public override void Initialize(AnalysisContext analysisContext)
         {
-            analysisContext.RegisterSymbolAction(context =>
+            analysisContext.RegisterCompilationStartAction(compilationContext =>
             {
-                AnalyzeSymbol((INamedTypeSymbol)context.Symbol, context.Compilation, context.ReportDiagnostic, context.Options, context.CancellationToken);
-            },
-            SymbolKind.NamedType);
+                var disposableType = WellKnownTypes.IDisposable(compilationContext.Compilation);
+                if (disposableType == null)
+                {
+                    return;
+                }
+
+                compilationContext.RegisterSymbolAction(context =>
+                {
+                    AnalyzeSymbol((INamedTypeSymbol)context.Symbol, disposableType, context.ReportDiagnostic);
+                },
+                SymbolKind.NamedType);
+            });
         }
 
-        private static void AnalyzeSymbol(INamedTypeSymbol symbol, Compilation compilation, Action<Diagnostic> addDiagnostic, AnalyzerOptions options, CancellationToken cancellationToken)
+        private static void AnalyzeSymbol(INamedTypeSymbol symbol, INamedTypeSymbol disposableType, Action<Diagnostic> addDiagnostic)
         {
-            var disposableType = WellKnownTypes.IDisposable(compilation);
-            if (disposableType != null && !symbol.AllInterfaces.Contains(disposableType))
+            if (!symbol.AllInterfaces.Contains(disposableType))
             {
                 var disposableFields = from member in symbol.GetMembers()
                                        where member.Kind == SymbolKind.Field && !member.IsStatic

src/Diagnostics/FxCop/System.Runtime.Analyzers/Core/SystemRuntimeAnalyzers.csproj

@@ -53,6 +53,7 @@
     <None Include="packages.config" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Design\OverrideMethodsOnComparableTypes.cs" />
     <Compile Include="Design\DefineAccessorsForAttributeArguments.cs" />
     <Compile Include="Design\DefineAccessorsForAttributeArguments.Fixer.cs" />
     <Compile Include="Design\MarkAttributesWithAttributeUsage.cs" />

src/Diagnostics/FxCop/System.Runtime.Analyzers/Core/SystemRuntimeAnalyzersResources.Designer.cs

@@ -187,6 +187,24 @@ internal class SystemRuntimeAnalyzersResources {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Overload operator Equals and comparison operators when implementing System.IComparable.
+        /// </summary>
+        internal static string OverloadOperatorEqualsOnIComparableInterface {
+            get {
+                return ResourceManager.GetString("OverloadOperatorEqualsOnIComparableInterface", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Types that implement IComparable should redefine Equals and comparison operators to keep the meanings of less than, greater than, and equals consistent throughout the type..
+        /// </summary>
+        internal static string OverloadOperatorEqualsOnIComparableInterfaceDescription {
+            get {
+                return ResourceManager.GetString("OverloadOperatorEqualsOnIComparableInterfaceDescription", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Type &apos;{0}&apos; owns disposable fields but is not disposable.
         /// </summary>

src/Diagnostics/FxCop/System.Runtime.Analyzers/Core/SystemRuntimeAnalyzersResources.resx

@@ -165,4 +165,10 @@
   <data name="DefineAccessorsForAttributeArgumentsRemoveSetter" xml:space="preserve">
     <value>Remove the property setter from '{0}' or reduce its accessibility because it corresponds to positional argument '{1}'.</value>
   </data>
+  <data name="OverloadOperatorEqualsOnIComparableInterface" xml:space="preserve">
+    <value>Overload operator Equals and comparison operators when implementing System.IComparable</value>
+  </data>
+  <data name="OverloadOperatorEqualsOnIComparableInterfaceDescription" xml:space="preserve">
+    <value>Types that implement IComparable should redefine Equals and comparison operators to keep the meanings of less than, greater than, and equals consistent throughout the type.</value>
+  </data>
 </root>
\ No newline at end of file

src/Diagnostics/FxCop/System.Runtime.Analyzers/Core/WellKnownTypes.cs

@@ -141,6 +141,11 @@ public static INamedTypeSymbol IComparable(Compilation compilation)
             return compilation.GetTypeByMetadataName("System.IComparable");
         }
 
+        public static INamedTypeSymbol GenericIComparable(Compilation compilation)
+        {
+            return compilation.GetTypeByMetadataName("System.IComparable`1");
+        }
+
         public static INamedTypeSymbol ComSourceInterfaceAttribute(Compilation compilation)
         {
             return compilation.GetTypeByMetadataName("System.Runtime.InteropServices.ComSourceInterfacesAttribute");

src/Diagnostics/FxCop/Test/Design/CA1036Tests.cs → src/Diagnostics/FxCop/System.Runtime.Analyzers/Test/Design/OverrideMethodsOnComparableTypesTests.cs

 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 using Microsoft.CodeAnalysis.Diagnostics;
-using Microsoft.CodeAnalysis.FxCopAnalyzers.Design;
 using Microsoft.CodeAnalysis.Test.Utilities;
+using Microsoft.CodeAnalysis.UnitTests;
 using Roslyn.Test.Utilities;
 using Xunit;
 
-namespace Microsoft.CodeAnalysis.UnitTests
+namespace System.Runtime.Analyzers.UnitTests
 {
     [WorkItem(858659, "DevDiv")]
-    public partial class CA1030Tests : DiagnosticAnalyzerTestBase
+    public partial class OverrideMethodsOnComparableTypesTests : DiagnosticAnalyzerTestBase
     {
         protected override DiagnosticAnalyzer GetBasicDiagnosticAnalyzer()
         {
-            return new CA1036DiagnosticAnalyzer();
+            return new OverrideMethodsOnComparableTypesAnalyzer();
         }
 
         protected override DiagnosticAnalyzer GetCSharpDiagnosticAnalyzer()
         {
-            return new CA1036DiagnosticAnalyzer();
+            return new OverrideMethodsOnComparableTypesAnalyzer();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.Diagnostics)]
@@ -397,6 +397,82 @@ public override bool Equals(object obj)
             GetCA1036CSharpResultAt(4, 19));
         }
 
+        [Fact, Trait(Traits.Feature, Traits.Features.Diagnostics)]
+        public void CA1036ClassWithGenericIComparableCSharp()
+        {
+            VerifyCSharp(@"
+    using System;
+
+    public class A : IComparable<int>
+    {    
+        public override int GetHashCode()
+        {
+            return 1234;
+        }
+
+        public int CompareTo(int obj)
+        {
+            return 1;
+        }
+
+        public override bool Equals(object obj)
+        {
+            return true;
+        }
+
+        public static bool operator <(A objLeft, A objRight)
+        {
+            return true;
+        }
+
+        public static bool operator >(A objLeft, A objRight)
+        {
+            return true;
+        }
+    }
+",
+            GetCA1036CSharpResultAt(4, 18));
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Diagnostics)]
+        public void CA1036ClassWithDerivedIComparableCSharp()
+        {
+            VerifyCSharp(@"
+    using System;
+
+    interface  IDerived : IComparable<int> { }
+
+    public class A : IDerived
+    {    
+        public override int GetHashCode()
+        {
+            return 1234;
+        }
+
+        public int CompareTo(int obj)
+        {
+            return 1;
+        }
+
+        public override bool Equals(object obj)
+        {
+            return true;
+        }
+
+        public static bool operator <(A objLeft, A objRight)
+        {
+            return true;
+        }
+
+        public static bool operator >(A objLeft, A objRight)
+        {
+            return true;
+        }
+    }
+",
+            GetCA1036CSharpResultAt(6, 18));
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.Diagnostics)]
         public void CA1036ClassNoWarningBasic()
         {
@@ -723,6 +799,76 @@ End Class
             GetCA1036BasicResultAt(4, 18));
         }
 
+        [Fact, Trait(Traits.Feature, Traits.Features.Diagnostics)]
+        public void CA1036ClassWithGenericIComparableBasic()
+        {
+            VerifyBasic(@"
+Imports System
+
+Public Structure A : Implements IComparable(Of Integer)
+
+    Public Function Overrides GetHashCode() As Integer
+        Return 1234
+    End Function
+
+    Public Function CompareTo(obj As Integer) As Integer
+        Return 1
+    End Function
+
+    Public Overloads Overrides Function Equals(obj As Object) As Boolean
+        Return True
+    End Function
+
+    Public Shared Operator =(objLeft As A, objRight As A) As Boolean
+        Return True
+    End Operator
+
+    Public Shared Operator <>(objLeft As A, objRight As A) As Boolean
+        Return True
+    End Operator
+
+End Class
+",
+            GetCA1036BasicResultAt(4, 18));
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Diagnostics)]
+        public void CA1036ClassWithDerivedIComparableBasic()
+        {
+            VerifyBasic(@"
+Imports System
+
+Public Interface IDerived 
+    Inherits IComparable(Of Integer)
+End Interface
+
+Public Structure A : Implements IDerived
+
+    Public Function Overrides GetHashCode() As Integer
+        Return 1234
+    End Function
+
+    Public Function CompareTo(obj As Object) As Integer
+        Return 1
+    End Function
+
+    Public Overloads Overrides Function Equals(obj As Object) As Boolean
+        Return True
+    End Function
+
+    Public Shared Operator =(objLeft As A, objRight As A) As Boolean
+        Return True
+    End Operator
+
+    Public Shared Operator <>(objLeft As A, objRight As A) As Boolean
+        Return True
+    End Operator
+
+End Class
+",
+            GetCA1036BasicResultAt(8, 18));
+        }
+
         internal static string CA1036Name = "CA1036";
         internal static string CA1036Message = "Overload operator Equals and comparison operators when implementing System.IComparable";
 

src/Diagnostics/FxCop/System.Runtime.Analyzers/Test/Design/TypesThatOwnDisposableFieldsShouldBeDisposableTests.Fixer.cs

@@ -8,7 +8,7 @@
 
 namespace System.Runtime.Analyzers.UnitTests
 {
-    public partial class CA1001FixerTests : CodeFixTestBase
+    public partial class TypesThatOwnDisposableFieldsShouldBeDisposableFixerTests : CodeFixTestBase
     {
         protected override DiagnosticAnalyzer GetBasicDiagnosticAnalyzer()
         {

src/Diagnostics/FxCop/System.Runtime.Analyzers/Test/Design/TypesThatOwnDisposableFieldsShouldBeDisposableTests.cs

@@ -7,7 +7,7 @@
 
 namespace System.Runtime.Analyzers.UnitTests
 {
-    public partial class CA1001Tests : DiagnosticAnalyzerTestBase
+    public partial class TypesThatOwnDisposableFieldsShouldBeDisposableAnalyzerTests : DiagnosticAnalyzerTestBase
     {
         protected override DiagnosticAnalyzer GetBasicDiagnosticAnalyzer()
         {

src/Diagnostics/FxCop/System.Runtime.Analyzers/Test/SystemRuntimeAnalyzersTest.csproj

@@ -97,6 +97,7 @@
     <None Include="packages.config" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Design\OverrideMethodsOnComparableTypesTests.cs" />
     <Compile Include="Design\DefineAccessorsForAttributeArgumentsTests.Fixer.cs" />
     <Compile Include="Design\DefineAccessorsForAttributeArgumentsTests.cs" />
     <Compile Include="Design\MarkAttributesWithAttributeUsageTests.cs" />

src/Diagnostics/FxCop/Test/FxCopRulesDiagnosticAnalyzersTest.csproj

@@ -106,7 +106,6 @@
     <Compile Include="Performance\CodeFixes\CA1813FixerTests.cs" />
     <Compile Include="Performance\CodeFixes\CA1821FixerTests.cs" />
     <Compile Include="Reliability\CA2002Tests.cs" />
-    <Compile Include="Design\CA1036Tests.cs" />
     <Compile Include="Usage\CA2200Tests.cs" />
     <Compile Include="Usage\CA2213Tests.cs" />
     <Compile Include="Usage\CA2214Tests.cs" />