Merge pull request #28 from episerver/user/shsh/Analyze-HtpContextBase

Added analyzer and code fixer for IHttpContextAccessor

Author: shahramshahram

src/EpiSourceUpdater/EpiHttpContextBaseAccessorAnalyzer.cs

@@ -0,0 +1,70 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+using System;
+using System.Collections.Immutable;
+using System.Linq;
+
+namespace Epi.Source.Updater
+{
+    /// <summary>
+    /// Analyzer for identifying and removing obsolet types or methods.
+    /// </summary>
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public sealed class EpiHttpContextBaseAccessorAnalyzer : DiagnosticAnalyzer
+    {
+        /// <summary>
+        /// The diagnostic ID for diagnostics produced by this analyzer.
+        /// </summary>
+        public const string DiagnosticId = "EP0010";
+
+        /// <summary>
+        /// The diagnsotic category for diagnostics produced by this analyzer.
+        /// </summary>
+        private const string Category = "Upgrade";
+
+
+        internal static readonly string HttpContextBaseParameterType = "ServiceAccessor<HttpContextBase>";
+
+        private static readonly LocalizableString Title = new LocalizableResourceString(nameof(Resources.EpiHttpContextBaseTitle), Resources.ResourceManager, typeof(Resources));
+        private static readonly LocalizableString MessageFormat = new LocalizableResourceString(nameof(Resources.EpiHttpContextBaseFormat), Resources.ResourceManager, typeof(Resources));
+        private static readonly LocalizableString Description = new LocalizableResourceString(nameof(Resources.EpiHttpContextBaseDescription), Resources.ResourceManager, typeof(Resources));
+
+        private static readonly DiagnosticDescriptor Rule = new(DiagnosticId, Title, MessageFormat, Category, DiagnosticSeverity.Warning, isEnabledByDefault: true, description: Description);
+
+        public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Rule);
+
+        public override void Initialize(AnalysisContext context)
+        {
+            if (context is null)
+            {
+                throw new ArgumentNullException(nameof(context));
+            }
+
+            context.EnableConcurrentExecution();
+            context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.Analyze | GeneratedCodeAnalysisFlags.ReportDiagnostics);
+
+            context.RegisterSyntaxNodeAction(AnalyzeConstructor, SyntaxKind.ClassDeclaration);
+        }
+
+        private void AnalyzeConstructor(SyntaxNodeAnalysisContext context)
+        {
+            //var constructorDirective = (ConstructorDeclarationSyntax)context.Node;
+            var classDirective = (ClassDeclarationSyntax)context.Node;
+
+            foreach(var constructorSyntax in classDirective.Members.Where(m => m is ConstructorDeclarationSyntax))
+            {
+                var parameters = (constructorSyntax as ConstructorDeclarationSyntax).ParameterList.Parameters;
+                if (parameters.Any(p => p.Type != null && p.Type.ToString().Equals(HttpContextBaseParameterType, StringComparison.OrdinalIgnoreCase)))
+                {
+                    var diagnostic = Diagnostic.Create(Rule, classDirective.GetLocation(), constructorSyntax.ToFullString());
+                    context.ReportDiagnostic(diagnostic);
+                }
+            }
+        }
+    }
+}

src/EpiSourceUpdater/EpiHttpContextBaseAccessorCodeFixProvider.cs

@@ -0,0 +1,127 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Editing;
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Epi.Source.Updater
+{
+    /// <summary>
+    /// As with the analzyers, code fix providers that are registered into Upgrade Assistant's
+    /// dependency injection container (by IExtensionServiceProvider) will be used during
+    /// the source update step.
+    /// </summary>
+    [ExportCodeFixProvider(LanguageNames.CSharp, Name = "EP00010 CodeFix Provider")]
+    public class EpiHttpContextBaseAccessorCodeFixProvider : CodeFixProvider
+    {
+
+        // The Upgrade Assistant will only use analyzers that have an associated code fix provider registered including
+        // the analyzer's ID in the code fix provider's FixableDiagnosticIds array.
+        public sealed override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create(EpiHttpContextBaseAccessorAnalyzer.DiagnosticId);
+        private const string MicrosoftAspNetCoreHttpNamespace = "Microsoft.AspNetCore.Http";
+
+        public sealed override FixAllProvider GetFixAllProvider() =>
+            // See https://github.com/dotnet/roslyn/blob/master/docs/analyzers/FixAllProvider.md for more information on Fix All Providers
+            WellKnownFixAllProviders.BatchFixer;
+
+        public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
+        {
+            var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
+
+            if (root is null)
+            {
+                return;
+            }
+
+            var diagnostic = context.Diagnostics.First();
+            var diagnosticSpan = diagnostic.Location.SourceSpan;
+            var classDeclarationSyntax = root.FindNode(diagnosticSpan) as ClassDeclarationSyntax;
+            if (classDeclarationSyntax is null)
+            {
+                return;
+            }
+
+            context.RegisterCodeFix(
+                     CodeAction.Create(
+                         Resources.EpiHttpContextBaseTitle,
+                         c => ReplaceParameterTypeAsync(context.Document, classDeclarationSyntax, c),
+                         nameof(Resources.EpiHttpContextBaseTitle)),
+                     diagnostic);
+        }
+
+        private static async Task<Document> ReplaceParameterTypeAsync(Document document, ClassDeclarationSyntax classDeclarationSyntax, CancellationToken cancellationToken)
+        {
+            var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+            var updatedClassDeclaration = UpdateMemberField(classDeclarationSyntax);
+            var updatedClassDeclarationByCostr = UpdateConstructor(updatedClassDeclaration);
+            var newRoot = root!.ReplaceNode(classDeclarationSyntax, updatedClassDeclarationByCostr);
+
+            // Return document with transformed tree.
+            var updatedDocument = document.WithSyntaxRoot(newRoot);
+            return await updatedDocument.AddUsingIfMissingAsync(cancellationToken, MicrosoftAspNetCoreHttpNamespace);
+        }
+
+        private static ClassDeclarationSyntax UpdateMemberField(ClassDeclarationSyntax classDecSyntax)
+        {
+            var updatedMembers = new List<MemberDeclarationSyntax>();
+            foreach (var m in classDecSyntax.Members)
+            {
+                if (m is FieldDeclarationSyntax field && field.Declaration.Type.ToString().Equals(EpiHttpContextBaseAccessorAnalyzer.HttpContextBaseParameterType, StringComparison.OrdinalIgnoreCase))
+                {
+                    var svcAccessorHttpContextBaseMember = m as FieldDeclarationSyntax;
+                    var variableDeclaration = svcAccessorHttpContextBaseMember.Declaration.WithType(SyntaxFactory.ParseTypeName("IHttpContextAccessor").WithTrailingTrivia(SyntaxFactory.Whitespace(" "))).WithVariables(svcAccessorHttpContextBaseMember.Declaration.Variables);
+                    var iHttpContextBaseMember = SyntaxFactory.FieldDeclaration(svcAccessorHttpContextBaseMember.AttributeLists, (m as FieldDeclarationSyntax).Modifiers, variableDeclaration);
+                    updatedMembers.Add(iHttpContextBaseMember);
+                }
+                else
+                {
+                    updatedMembers.Add(m);
+                }
+            }
+            return classDecSyntax.WithMembers(SyntaxFactory.List<MemberDeclarationSyntax>().AddRange(updatedMembers));
+        }
+
+        private static ClassDeclarationSyntax UpdateConstructor(ClassDeclarationSyntax classDeclarationSyntax)
+        {
+            ClassDeclarationSyntax updatedClassDeclaration = classDeclarationSyntax;
+            foreach (var constructorSyntax in classDeclarationSyntax.Members.Where(m => m is ConstructorDeclarationSyntax))
+            {
+                var parameters = new List<ParameterSyntax>();
+
+                foreach (var parameter in (constructorSyntax as ConstructorDeclarationSyntax).ParameterList.Parameters)
+                {
+                    if (parameter.Type != null && parameter.Type.ToString().Equals(EpiHttpContextBaseAccessorAnalyzer.HttpContextBaseParameterType, StringComparison.OrdinalIgnoreCase))
+                    {
+                        var updatedParameter = parameter.WithType(SyntaxFactory.ParseTypeName("IHttpContextAccessor")).WithTrailingTrivia();
+                        parameters.Add(updatedParameter);
+                    }
+                    else
+                    {
+                        parameters.Add(parameter);
+                    }
+                }
+
+                var updateConstructor =  (constructorSyntax as ConstructorDeclarationSyntax).WithParameterList(SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList(parameters)));
+                updatedClassDeclaration = updatedClassDeclaration.ReplaceNode(constructorSyntax, updateConstructor);
+            }
+            return updatedClassDeclaration;
+        }
+
+        private static CompilationUnitSyntax AddUsing(CompilationUnitSyntax compilationRoot, string namespaceToAdd)
+        {
+            var usingDirective = SyntaxFactory.UsingDirective(SyntaxFactory.ParseName(namespaceToAdd).WithLeadingTrivia(SyntaxFactory.Whitespace(" ")))
+                .WithTrailingTrivia(SyntaxFactory.CarriageReturnLineFeed);
+            return compilationRoot.AddUsings(usingDirective);
+        }
+    }
+}

src/EpiSourceUpdater/EpiSourceUpdaterServiceProvider.cs

@@ -59,6 +59,7 @@ public void AddServices(IExtensionServiceCollection services)
             services.Services.AddTransient<DiagnosticAnalyzer, EpiDisplayChannelAnalyzer>();         // EP0007
             services.Services.AddTransient<DiagnosticAnalyzer, EpiMetadataAwareAnalyzer>();         // EP0008
             services.Services.AddTransient<DiagnosticAnalyzer, EpiPartialRouterAnalyzer>();         // EP0009
+            services.Services.AddTransient<DiagnosticAnalyzer, EpiHttpContextBaseAccessorAnalyzer>();         // EP0010
 
             // Upgrade Step.
             services.Services.AddUpgradeStep<FindReplaceUpgradeStep>();
@@ -74,6 +75,7 @@ public void AddServices(IExtensionServiceCollection services)
             services.Services.AddTransient<CodeFixProvider, EpiDisplayChannelCodeFixProvider>();     // EP0007
             services.Services.AddTransient<CodeFixProvider, EpiMetadataAwareCodeFixProvider>();     // EP0008
             services.Services.AddTransient<CodeFixProvider, EpiPartialRouterCodeFixProvider>();     // EP0009
+            services.Services.AddTransient<CodeFixProvider, EpiHttpContextBaseAccessorCodeFixProvider>();     // EP0010
         }
     }
 }

src/EpiSourceUpdater/Resources.Designer.cs

@@ -153,6 +153,15 @@
   <data name="EpiDisplayChannelTitle" xml:space="preserve">
     <value>CMS display channels will be updated</value>
   </data>
+  <data name="EpiHttpContextBaseDescription" xml:space="preserve">
+    <value>ServiceAccessor&lt;HttpContextBase&gt; in constructor will changed to HttpContextAccessor.</value>
+  </data>
+  <data name="EpiHttpContextBaseFormat" xml:space="preserve">
+    <value>ServiceAccessor&lt;HttpContextBase&gt; in constructor will changed to HttpContextAccessor</value>
+  </data>
+  <data name="EpiHttpContextBaseTitle" xml:space="preserve">
+    <value>ServiceAccessor&lt;HttpContextBase&gt; in constructor will changed to HttpContextAccessor</value>
+  </data>
   <data name="EpiMemberReplacementDescription" xml:space="preserve">
     <value>The Interface IFindUIConfiguration is no longer supported and will be replaced</value>
   </data>