Add an analyzer to prevent use of some internal shared source types

src/dotnet/Azure.ClientSdk.Analyzers/Azure.ClientSdk.Analyzers.Tests/AZC0020Tests.cs

@@ -0,0 +1,138 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Xunit;
+using Verifier = Azure.ClientSdk.Analyzers.Tests.AzureAnalyzerVerifier<Azure.ClientSdk.Analyzers.BannedTypesAnalyzer>;
+
+namespace Azure.ClientSdk.Analyzers.Tests
+{
+    public class AZC0020Tests
+    {
+        private List<(string fileName, string source)> _sharedSourceFiles;
+
+        public AZC0020Tests()
+        {
+            _sharedSourceFiles = new List<(string fileName, string source)>() {
+
+            ("MutableJsonDocument.cs", @"
+                namespace Azure.Core.Json
+                {
+                    internal sealed partial class MutableJsonDocument
+                    {
+                    }
+                }
+                "),
+
+            ("MutableJsonElement.cs", @"
+                namespace Azure.Core.Json
+                {
+                    internal sealed partial class MutableJsonElement
+                    {
+                    }
+                }
+                ")
+            };
+        }
+
+        [Fact]
+        public async Task AZC0020ProducedForMutableJsonDocumentUsage()
+        {
+            string code = @"
+using System;
+using Azure.Core.Json;
+
+namespace LibraryNamespace
+{
+    public class Model
+    {
+        private MutableJsonDocument {|AZC0020:_document|};
+        internal MutableJsonDocument {|AZC0020:Document|} => {|AZC0020:_document|};
+        internal event EventHandler<MutableJsonDocument> {|AZC0020:_docEvent|};
+
+        internal MutableJsonDocument {|AZC0020:GetDocument|}(MutableJsonDocument {|AZC0020:value|})
+        {
+            MutableJsonDocument mdoc = new MutableJsonDocument();
+            return mdoc;
+        }
+    }
+}";
+            await Verifier.VerifyAnalyzerAsync(code, _sharedSourceFiles);
+        }
+
+        [Fact]
+        public async Task AZC0020ProducedForMutableJsonDocumentUsage2()
+        {
+            string code = @"
+using System;
+using Azure.Core.Json;
+
+namespace LibraryNamespace
+{
+    public class Model
+    {
+        private MutableJsonDocument {|AZC0020:_document|};
+        internal MutableJsonDocument {|AZC0020:Document|} => {| AZC0020:_document |};
+        internal event EventHandler<MutableJsonDocument> {|AZC0020:_docEvent|};
+
+        internal MutableJsonDocument {|AZC0020:GetDocument|}(MutableJsonDocument {|AZC0020:value|})
+        {
+            MutableJsonDocument {|AZC0020:mdoc|} = new MutableJsonDocument();
+            return mdoc;
+        }
+    }
+}";
+            await Verifier.VerifyAnalyzerAsync(code, _sharedSourceFiles);
+        }
+
+        [Fact]
+        public async Task AZC0020ProducedForMutableJsonElementUsage()
+        {
+            string code = @"
+using Azure.Core.Json;
+
+namespace LibraryNamespace
+{
+    public class Model
+    {
+        MutableJsonElement {|AZC0020:_element|};
+    }
+}";
+            await Verifier.VerifyAnalyzerAsync(code, _sharedSourceFiles);
+        }
+
+        [Fact]
+        public async Task AZC0020NotProducedForAllowedTypeUsage()
+        {
+            string code = @"
+using System.Text.Json;
+
+namespace LibraryNamespace
+{
+    public class Model
+    {
+        JsonElement _element;
+    }
+}";
+            await Verifier.VerifyAnalyzerAsync(code, _sharedSourceFiles);
+        }
+
+        [Fact]
+        public async Task AZC0020NotProducedForTypeWithBannedNameButAllowedNamespace()
+        {
+            string code = @"
+namespace LibraryNamespace
+{
+    public class MutableJsonDocument
+    {
+    }
+    public class Model
+    {
+        MutableJsonDocument _document;
+    }
+}";
+            await Verifier.VerifyAnalyzerAsync(code, _sharedSourceFiles);
+        }
+    }
+}

src/dotnet/Azure.ClientSdk.Analyzers/Azure.ClientSdk.Analyzers.Tests/AzureAnalyzerVerifier.cs

@@ -1,6 +1,7 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
+// Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
+using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Threading;
 using System.Threading.Tasks;
@@ -11,16 +12,16 @@
 using Microsoft.CodeAnalysis.Testing;
 using Microsoft.CodeAnalysis.Testing.Verifiers;
 
-namespace Azure.ClientSdk.Analyzers.Tests 
+namespace Azure.ClientSdk.Analyzers.Tests
 {
     public static class AzureAnalyzerVerifier<TAnalyzer> where TAnalyzer : DiagnosticAnalyzer, new()
     {
         private static readonly ReferenceAssemblies DefaultReferenceAssemblies =
             ReferenceAssemblies.Default.AddPackages(ImmutableArray.Create(
                 new PackageIdentity("Azure.Core", "1.26.0"),
                 new PackageIdentity("Microsoft.Bcl.AsyncInterfaces", "1.1.0"),
-                new PackageIdentity("System.Text.Json", "4.6.0"),
                 new PackageIdentity("Newtonsoft.Json", "12.0.3"),
+                new PackageIdentity("System.Text.Json", "4.6.0"),
                 new PackageIdentity("System.Threading.Tasks.Extensions", "4.5.3")));
 
         public static CSharpAnalyzerTest<TAnalyzer, XUnitVerifier> CreateAnalyzer(string source, LanguageVersion languageVersion = LanguageVersion.Latest)
@@ -37,7 +38,7 @@ public static CSharpAnalyzerTest<TAnalyzer, XUnitVerifier> CreateAnalyzer(string
                 TestBehaviors = TestBehaviors.SkipGeneratedCodeCheck
             };
 
-        public static Task VerifyAnalyzerAsync(string source, LanguageVersion languageVersion = LanguageVersion.Latest) 
+        public static Task VerifyAnalyzerAsync(string source, LanguageVersion languageVersion = LanguageVersion.Latest)
             => CreateAnalyzer(source, languageVersion).RunAsync(CancellationToken.None);
 
         public static Task VerifyAnalyzerAsync(string source, params DiagnosticResult[] diagnostics)
@@ -47,6 +48,16 @@ public static Task VerifyAnalyzerAsync(string source, params DiagnosticResult[]
             return test.RunAsync(CancellationToken.None);
         }
 
+        public static Task VerifyAnalyzerAsync(string source, List<(string fileName, string source)> files)
+        {
+            var test = CreateAnalyzer(source);
+            foreach (var file in files)
+            {
+                test.TestState.Sources.Add(file);
+            }
+            return test.RunAsync(CancellationToken.None);
+        }
+
         public static DiagnosticResult Diagnostic(string expectedDescriptor) => AnalyzerVerifier<TAnalyzer>.Diagnostic(expectedDescriptor);
     }
 }

src/dotnet/Azure.ClientSdk.Analyzers/Azure.ClientSdk.Analyzers/BannedTypesAnalyzer.cs

@@ -0,0 +1,106 @@
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Diagnostics;
+using System.Linq;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace Azure.ClientSdk.Analyzers
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public sealed class BannedTypesAnalyzer : SymbolAnalyzerBase
+    {
+        private static HashSet<string> BannedTypes = new HashSet<string>()
+        {
+            "Azure.Core.Json.MutableJsonDocument",
+            "Azure.Core.Json.MutableJsonElement",
+            "Azure.Core.Json.MutableJsonChange",
+            "Azure.Core.Json.MutableJsonChangeKind",
+        };
+
+        private static readonly string BannedTypesMessageArgs = string.Join(", ", BannedTypes);
+
+        public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(Descriptors.AZC0020);
+
+        public override SymbolKind[] SymbolKinds { get; } = new[]
+        {
+            SymbolKind.Method,
+            SymbolKind.Field,
+            SymbolKind.Property,
+            SymbolKind.Parameter,
+            SymbolKind.Event,
+            SymbolKind.NamedType,
+            SymbolKind.Local,
+        };
+
+        public override void Analyze(ISymbolAnalysisContext context)
+        {
+            Debug.WriteLine($"{context.Symbol}");
+
+            if (IsAzureCore(context.Symbol.ContainingAssembly))
+            {
+                return;
+            }
+
+            switch (context.Symbol)
+            {
+                case IParameterSymbol parameterSymbol:
+                    CheckType(context, parameterSymbol.Type, parameterSymbol);
+                    break;
+                case IMethodSymbol methodSymbol:
+                    CheckType(context, methodSymbol.ReturnType, methodSymbol);
+                    break;
+                case IEventSymbol eventSymbol:
+                    CheckType(context, eventSymbol.Type, eventSymbol);
+                    break;
+                case IPropertySymbol propertySymbol:
+                    CheckType(context, propertySymbol.Type, propertySymbol);
+                    break;
+                case IFieldSymbol fieldSymbol:
+                    CheckType(context, fieldSymbol.Type, fieldSymbol);
+                    break;
+                case ILocalSymbol localSymbol:
+                    CheckType(context, localSymbol.Type, localSymbol);
+                    break;
+                case INamedTypeSymbol namedTypeSymbol:
+                    CheckType(context, namedTypeSymbol.BaseType, namedTypeSymbol);
+                    foreach (var iface in namedTypeSymbol.Interfaces)
+                    {
+                        CheckType(context, iface, namedTypeSymbol);
+                    }
+                    break;
+            }
+
+            Debug.WriteLine($"done");
+        }
+
+        private static void CheckType(ISymbolAnalysisContext context, ITypeSymbol type, ISymbol symbol)
+        {
+            if (type is INamedTypeSymbol namedTypeSymbol)
+            {
+                if (IsBannedType(namedTypeSymbol))
+                {
+                    context.ReportDiagnostic(Diagnostic.Create(Descriptors.AZC0020, symbol.Locations.First(), BannedTypesMessageArgs), symbol);
+                }
+
+                if (namedTypeSymbol.IsGenericType)
+                {
+                    foreach (var typeArgument in namedTypeSymbol.TypeArguments)
+                    {
+                        CheckType(context, typeArgument, symbol);
+                    }
+                }
+            }
+        }
+
+        private static bool IsBannedType(INamedTypeSymbol namedTypeSymbol)
+        {
+            return BannedTypes.Contains($"{namedTypeSymbol.ContainingNamespace}.{namedTypeSymbol.Name}");
+        }
+
+        private static bool IsAzureCore(IAssemblySymbol assembly)
+        {
+            return assembly.Name.Equals("Azure.Core");
+        }
+    }
+}

src/dotnet/Azure.ClientSdk.Analyzers/Azure.ClientSdk.Analyzers/Descriptors.cs

@@ -110,9 +110,16 @@ internal class Descriptors
             "Invalid ServiceVersion member name.",
             "All parts of ServiceVersion members' names must begin with a number or uppercase letter and cannot have consecutive underscores.",
             "Usage",
+            DiagnosticSeverity.Warning, true);
+
+        public static DiagnosticDescriptor AZC0020 = new DiagnosticDescriptor(
+            nameof(AZC0020),
+            "Avoid using banned types in public APIs",
+            "The Azure.Core internal shared source types {0} should not be used outside of the Azure.Core library.",
+            "Usage",
             DiagnosticSeverity.Warning, true);
         #endregion
-
+
         #region General
         public static DiagnosticDescriptor AZC0100 = new DiagnosticDescriptor(
             nameof(AZC0100),