Introduce NotNoneAttribute alias (#1420)

* Add global using NotNoneAttribute

* Remove file-scope using Scripting.Runtime.NotNullAttribute

* Rename CodeAnalysis.NotNullAttribute to NotNullOnReturnAttribute

* Use NotNone in place of Microsoft.Scripting.Runtime.NotNull

* Replace NotDynamicNull with NotNone

* Replace NotNullOnReturn with NotNull

* IronPythonAnalyzer: Compare symbols correctly

* Update IronPythonAnalyzer messages

* Enforce [NotNone] usage in IronPythonAnalyzer

* Remove superfluous using Microsoft.Scripting.Runtime

Author: BCSharp

Directory.Build.props

@@ -116,6 +116,10 @@
     <EnableNETAnalyzers>true</EnableNETAnalyzers>
   </PropertyGroup>
 
+  <ItemGroup>
+    <Using Include="Microsoft.Scripting.Runtime.NotNullAttribute" Alias="NotNoneAttribute" />
+  </ItemGroup>
+
   <!-- Release -->
   <PropertyGroup Condition="'$(Configuration)' == 'Release'">
     <DebugSymbols>false</DebugSymbols>

IronPythonAnalyzer/IronPythonAnalyzer/IronPythonAnalyzerAnalyzer.cs

@@ -19,13 +19,14 @@ public class IronPythonAnalyzerAnalyzer : DiagnosticAnalyzer {
         public const string DiagnosticId = "IronPythonAnalyzer";
 
 #pragma warning disable RS2008 // Enable analyzer release tracking
-        private static readonly DiagnosticDescriptor Rule1 = new DiagnosticDescriptor("IPY01", title: "Parameter which is marked not nullable does not have the NotNullAttribute", messageFormat: "Parameter '{0}' does not have the NotNullAttribute", category: "Usage", DiagnosticSeverity.Warning, isEnabledByDefault: true, description: "Non-nullable reference type parameters should have the NotNullAttribute.");
-        private static readonly DiagnosticDescriptor Rule2 = new DiagnosticDescriptor("IPY02", title: "Parameter which is marked nullable has the NotNullAttribute", messageFormat: "Parameter '{0}' should not have the NotNullAttribute", category: "Usage", DiagnosticSeverity.Warning, isEnabledByDefault: true, description: "Nullable reference type parameters should not have the NotNullAttribute.");
+        private static readonly DiagnosticDescriptor Rule1 = new DiagnosticDescriptor("IPY01", title: "Parameter which is marked not nullable does not have the NotNoneAttribute", messageFormat: "Parameter '{0}' does not have the NotNoneAttribute", category: "Usage", DiagnosticSeverity.Warning, isEnabledByDefault: true, description: "Non-nullable reference type parameters should have the NotNoneAttribute.");
+        private static readonly DiagnosticDescriptor Rule2 = new DiagnosticDescriptor("IPY02", title: "Parameter which is marked nullable has the NotNoneAttribute", messageFormat: "Parameter '{0}' should not have the NotNoneAttribute", category: "Usage", DiagnosticSeverity.Warning, isEnabledByDefault: true, description: "Nullable reference type parameters should not have the NotNoneAttribute.");
         private static readonly DiagnosticDescriptor Rule3 = new DiagnosticDescriptor("IPY03", title: "BytesLikeAttribute used on a not supported type", messageFormat: "Parameter '{0}' declared bytes-like on unsupported type '{1}'", category: "Usage", DiagnosticSeverity.Warning, isEnabledByDefault: true, description: "BytesLikeAttribute is only allowed on parameters of type IReadOnlyList<byte>, or IList<byte>.");
         private static readonly DiagnosticDescriptor Rule4 = new DiagnosticDescriptor("IPY04", title: "Call to PythonTypeOps.GetName", messageFormat: "Direct call to PythonTypeOps.GetName", category: "Usage", DiagnosticSeverity.Warning, isEnabledByDefault: true, description: "To obtain a name of a python type of a given object to display to a user, use PythonOps.GetPythonTypeName.");
+        private static readonly DiagnosticDescriptor Rule5 = new DiagnosticDescriptor("IPY05", title: "DLR NotNullAttribute accessed without an alias", messageFormat: "Microsoft.Scripting.Runtime.NotNullAttribute should be accessed though alias 'NotNone'", category: "Usage", DiagnosticSeverity.Warning, isEnabledByDefault: true, description: "NotNullAttribute is ambiguous between 'System.Diagnostics.CodeAnalysis.NotNullAttribute' and 'Microsoft.Scripting.Runtime.NotNullAttribute'. The latter should be accesses as 'NotNoneAttribute'.");
 #pragma warning restore RS2008 // Enable analyzer release tracking
 
-        public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get { return ImmutableArray.Create(Rule1, Rule2, Rule3, Rule4); } }
+        public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get { return ImmutableArray.Create(Rule1, Rule2, Rule3, Rule4, Rule5); } }
 
         public override void Initialize(AnalysisContext context) {
             context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
@@ -41,20 +42,18 @@ private static void AnalyzeSymbol(SymbolAnalysisContext context) {
             var pythonTypeAttributeSymbol = context.Compilation.GetTypeByMetadataName("IronPython.Runtime.PythonTypeAttribute");
             var pythonModuleAttributeSymbol = context.Compilation.GetTypeByMetadataName("IronPython.Runtime.PythonModuleAttribute");
 
-#pragma warning disable RS1024 // Compare symbols correctly
-
             if (methodSymbol.ContainingType.GetAttributes()
-                    .Any(x => x.AttributeClass.Equals(pythonTypeAttributeSymbol)) ||
+                    .Any(x => x.AttributeClass.Equals(pythonTypeAttributeSymbol, SymbolEqualityComparer.Default)) ||
                 methodSymbol.ContainingAssembly.GetAttributes()
-                    .Where(x => x.AttributeClass.Equals(pythonModuleAttributeSymbol))
+                    .Where(x => x.AttributeClass.Equals(pythonModuleAttributeSymbol, SymbolEqualityComparer.Default))
                     .Select(x => (INamedTypeSymbol)x.ConstructorArguments[1].Value)
-                    .Any(x => x.Equals(methodSymbol.ContainingType))) {
+                    .Any(x => x.Equals(methodSymbol.ContainingType, SymbolEqualityComparer.Default))) {
                 var pythonHiddenAttributeSymbol = context.Compilation.GetTypeByMetadataName("IronPython.Runtime.PythonHiddenAttribute");
-                if (methodSymbol.GetAttributes().Any(x => x.AttributeClass.Equals(pythonHiddenAttributeSymbol))) return;
+                if (methodSymbol.GetAttributes().Any(x => x.AttributeClass.Equals(pythonHiddenAttributeSymbol, SymbolEqualityComparer.Default))) return;
 
                 var codeContextSymbol = context.Compilation.GetTypeByMetadataName("IronPython.Runtime.CodeContext");
                 var siteLocalStorageSymbol = context.Compilation.GetTypeByMetadataName("IronPython.Runtime.SiteLocalStorage");
-                var notNullAttributeSymbol = context.Compilation.GetTypeByMetadataName("Microsoft.Scripting.Runtime.NotNullAttribute");
+                var notNoneAttributeSymbol = context.Compilation.GetTypeByMetadataName("Microsoft.Scripting.Runtime.NotNullAttribute");
                 var bytesLikeAttributeSymbol = context.Compilation.GetTypeByMetadataName("IronPython.Runtime.BytesLikeAttribute");
 
                 var byteType = context.Compilation.GetTypeByMetadataName("System.Byte");
@@ -64,24 +63,31 @@ private static void AnalyzeSymbol(SymbolAnalysisContext context) {
                 var ilistOfByteType = ilistType.Construct(byteType);
 
                 foreach (IParameterSymbol parameterSymbol in methodSymbol.Parameters) {
-                    if (parameterSymbol.GetAttributes().Any(x => x.AttributeClass.Equals(bytesLikeAttributeSymbol))
-                            && !parameterSymbol.Type.Equals(ireadOnlyListOfByteType)
-                            && !parameterSymbol.Type.Equals(ilistOfByteType)) {
+                    if (parameterSymbol.GetAttributes().Any(x => x.AttributeClass.Equals(bytesLikeAttributeSymbol, SymbolEqualityComparer.Default))
+                            && !parameterSymbol.Type.Equals(ireadOnlyListOfByteType, SymbolEqualityComparer.Default)
+                            && !parameterSymbol.Type.Equals(ilistOfByteType, SymbolEqualityComparer.Default)) {
                         var diagnostic = Diagnostic.Create(Rule3, parameterSymbol.Locations[0], parameterSymbol.Name, parameterSymbol.Type.MetadataName);
                         context.ReportDiagnostic(diagnostic);
                         continue;
                     }
+                    if (parameterSymbol.GetAttributes().FirstOrDefault(x => x.AttributeClass.Equals(notNoneAttributeSymbol, SymbolEqualityComparer.Default)) is AttributeData attr) {
+                        SyntaxNode node = attr.ApplicationSyntaxReference.GetSyntax(); // Async?
+                        if (node.GetLastToken().Text != "NotNone") {
+                            var diagnostic = Diagnostic.Create(Rule5, node.GetLocation());
+                            context.ReportDiagnostic(diagnostic);
+                        }
+                    }
                     if (parameterSymbol.Type.IsValueType) continue;
-                    if (parameterSymbol.Type.Equals(codeContextSymbol)) continue;
+                    if (parameterSymbol.Type.Equals(codeContextSymbol, SymbolEqualityComparer.Default)) continue;
                     if (SymbolEqualityComparer.Default.Equals(parameterSymbol.Type.BaseType, siteLocalStorageSymbol)) continue;
                     if (parameterSymbol.NullableAnnotation == NullableAnnotation.NotAnnotated) {
-                        if (!parameterSymbol.GetAttributes().Any(x => x.AttributeClass.Equals(notNullAttributeSymbol))
+                        if (!parameterSymbol.GetAttributes().Any(x => x.AttributeClass.Equals(notNoneAttributeSymbol, SymbolEqualityComparer.Default))
                             && !parameterSymbol.GetAttributes().Any(x => IsAllowNull(x.AttributeClass))) {
                             var diagnostic = Diagnostic.Create(Rule1, parameterSymbol.Locations[0], parameterSymbol.Name);
                             context.ReportDiagnostic(diagnostic);
                         }
                     } else if (parameterSymbol.NullableAnnotation == NullableAnnotation.Annotated) {
-                        if (parameterSymbol.GetAttributes().Any(x => x.AttributeClass.Equals(notNullAttributeSymbol))
+                        if (parameterSymbol.GetAttributes().Any(x => x.AttributeClass.Equals(notNoneAttributeSymbol, SymbolEqualityComparer.Default))
                             && !parameterSymbol.GetAttributes().Any(x => IsDisallowNull(x.AttributeClass))) {
                             var diagnostic = Diagnostic.Create(Rule2, parameterSymbol.Locations[0], parameterSymbol.Name);
                             context.ReportDiagnostic(diagnostic);
@@ -96,9 +102,6 @@ bool IsDisallowNull(INamedTypeSymbol symbol) {
                     return symbol.ToString() == "System.Diagnostics.CodeAnalysis.DisallowNullAttribute";
                 }
             }
-
-#pragma warning restore RS1024 // Compare symbols correctly
-
         }
 
         private static void AnalyzeInvocation(OperationAnalysisContext context) {

Src/IronPython.Modules/IterTools.cs

@@ -197,7 +197,7 @@ private IEnumerator<object> LazyYielder() {
         public class compress : IterBase {
             private compress() { }
 
-            public compress(CodeContext/*!*/ context, [NotNull]object data, [NotNull]object selectors) {
+            public compress(CodeContext/*!*/ context, [NotNone] object data, [NotNone] object selectors) {
                 EnsureIterator(context, data);
                 EnsureIterator(context, selectors);
                 InnerEnumerator = LazyYielder(data, selectors);

Src/IronPython.Modules/ModuleOps.cs

@@ -11,7 +11,6 @@
 using System.Runtime.InteropServices;
 
 using Microsoft.Scripting;
-using Microsoft.Scripting.Runtime;
 using Microsoft.Scripting.Utils;
 
 using IronPython.Runtime;