Add anonymous object desctructuring analyzer

Author: olsh

README.md

@@ -58,3 +58,19 @@ Compliant Solution:
 ```csharp
 Log.Error("Disk quota {Quota} MB exceeded by {User}", quota, user);
 ```
+
+### Anonymous objects must be destructured
+
+Noncompliant Code Examples:
+```csharp
+Log.Error("Processed {Position}", new { x = 4, y = 2});
+```
+
+Compliant Solution:
+```csharp
+Log.Error("Processed {@Position}", new { x = 4, y = 2});
+```
+
+## Credits
+
+Inpired by [SerilogAnalyzer](https://github.com/Suchiman/SerilogAnalyzer)

src/ReSharper.Structured.Logging/Analyzer/AnonymousTypeDestructureAnalyzer.cs

@@ -0,0 +1,72 @@
+using System.Linq;
+
+using JetBrains.ReSharper.Feature.Services.Daemon;
+using JetBrains.ReSharper.Psi;
+using JetBrains.ReSharper.Psi.CSharp.Tree;
+using JetBrains.ReSharper.Psi.Util;
+
+using ReSharper.Structured.Logging.Extensions;
+using ReSharper.Structured.Logging.Highlighting;
+using ReSharper.Structured.Logging.Serilog.Parsing;
+
+namespace ReSharper.Structured.Logging.Analyzer
+{
+    [ElementProblemAnalyzer(typeof(IInvocationExpression))]
+    public class AnonymousTypeDestructureAnalyzer : ElementProblemAnalyzer<IInvocationExpression>
+    {
+        private readonly MessageTemplateParser _messageTemplateParser;
+
+        public AnonymousTypeDestructureAnalyzer(MessageTemplateParser messageTemplateParser)
+        {
+            _messageTemplateParser = messageTemplateParser;
+        }
+
+        protected override void Run(
+            IInvocationExpression element,
+            ElementProblemAnalyzerData data,
+            IHighlightingConsumer consumer)
+        {
+            var templateArgument = element.GetTemplateArgument();
+            if (templateArgument == null)
+            {
+                return;
+            }
+
+            var anonymousObjectsArguments = element.ArgumentList.Arguments
+                .Where(a => a.Value is IAnonymousObjectCreationExpression)
+                .ToArray();
+            if (anonymousObjectsArguments.Length == 0)
+            {
+                return;
+            }
+
+            var stringLiteral = StringLiteralAltererUtil.TryCreateStringLiteralByExpression(templateArgument.Value);
+            if (stringLiteral == null)
+            {
+                return;
+            }
+
+            var messageTemplate = _messageTemplateParser.Parse(stringLiteral.Expression.GetUnquotedText());
+            if (messageTemplate.NamedProperties == null)
+            {
+                return;
+            }
+
+            var templateArgumentIndex = templateArgument.IndexOf();
+            foreach (var argument in anonymousObjectsArguments)
+            {
+                var index = argument.IndexOf() - templateArgumentIndex - 1;
+                if (index < messageTemplate.NamedProperties.Length)
+                {
+                    var namedProperty = messageTemplate.NamedProperties[index];
+                    if (namedProperty.Destructuring != Destructuring.Default)
+                    {
+                        continue;
+                    }
+
+                    consumer.AddHighlighting(new AnonymousObjectDestructuringWarning(stringLiteral.GetTokenDocumentRange(namedProperty)));
+                }
+            }
+        }
+    }
+}

src/ReSharper.Structured.Logging/Highlighting/AnonymousObjectWithoutDestructuringWarning.cs

@@ -0,0 +1,46 @@
+using JetBrains.DocumentModel;
+using JetBrains.ReSharper.Feature.Services.Daemon;
+using JetBrains.ReSharper.Psi.CSharp;
+
+using ReSharper.Structured.Logging.Highlighting;
+
+[assembly:
+    RegisterConfigurableSeverity(AnonymousObjectDestructuringWarning.SeverityId, null, HighlightingGroupIds.CompilerWarnings,
+        AnonymousObjectDestructuringWarning.Message, AnonymousObjectDestructuringWarning.Message,
+        Severity.WARNING)]
+
+namespace ReSharper.Structured.Logging.Highlighting
+{
+    [ConfigurableSeverityHighlighting(
+        SeverityId,
+        CSharpLanguage.Name,
+        OverlapResolve = OverlapResolveKind.WARNING,
+        ToolTipFormatString = Message)]
+    public class AnonymousObjectDestructuringWarning : IHighlighting
+    {
+        public const string Message = "Anonymous objects must be destructured";
+
+        public const string SeverityId = "AnonymousObjectDestructuringProblem";
+
+        private readonly DocumentRange _documentRange;
+
+        public AnonymousObjectDestructuringWarning(DocumentRange documentRange)
+        {
+            _documentRange = documentRange;
+        }
+
+        public string ErrorStripeToolTip => ToolTip;
+
+        public string ToolTip => Message;
+
+        public DocumentRange CalculateRange()
+        {
+            return _documentRange;
+        }
+
+        public bool IsValid()
+        {
+            return _documentRange.IsValid();
+        }
+    }
+}

src/ReSharper.Structured.Logging/Highlighting/TemplateFormatItemAndMatchingArgumentHighlighter.cs

@@ -142,9 +142,6 @@ private static void HighlightByArgument(
                 consumer.ConsumeHighlighting(
                     HighlightingAttributeIds.USAGE_OF_ELEMENT_UNDER_CURSOR,
                     templateArgument.GetTokenDocumentRange(property));
-                consumer.ConsumeHighlighting(
-                    HighlightingAttributeIds.USAGE_OF_ELEMENT_UNDER_CURSOR,
-                    selectedArgument.GetDocumentRange());
             }
             else if (positionalProperties != null)
             {
@@ -164,11 +161,11 @@ private static void HighlightByArgument(
                         HighlightingAttributeIds.USAGE_OF_ELEMENT_UNDER_CURSOR,
                         templateArgument.GetTokenDocumentRange(property));
                 }
-
-                consumer.ConsumeHighlighting(
-                    HighlightingAttributeIds.USAGE_OF_ELEMENT_UNDER_CURSOR,
-                    selectedArgument.GetDocumentRange());
             }
+
+            consumer.ConsumeHighlighting(
+                HighlightingAttributeIds.USAGE_OF_ELEMENT_UNDER_CURSOR,
+                selectedArgument.GetDocumentRange());
         }
 
         private static void HighlightByNamedPlaceholder(

src/ReSharper.Structured.Logging/ReSharper.Structured.Logging.csproj

@@ -324,11 +324,13 @@
     </Reference>
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Analyzer\AnonymousTypeDestructureAnalyzer.cs" />
     <Compile Include="Analyzer\CompileTimeConstantTemplateAnalyzer.cs" />
     <Compile Include="Analyzer\CorrectExceptionPassingAnalyzer.cs" />
     <Compile Include="Analyzer\DuplicatePropertiesTemplateAnalyzer.cs" />
     <Compile Include="Analyzer\TemplateFormatAnalyzer.cs" />
     <Compile Include="Extensions\PsiExtensions.cs" />
+    <Compile Include="Highlighting\AnonymousObjectWithoutDestructuringWarning.cs" />
     <Compile Include="Highlighting\DuplicateTemplatePropertyWarning.cs" />
     <Compile Include="Highlighting\ExceptionPassedAsTemplateArgumentWarning.cs" />
     <Compile Include="Highlighting\TemplateFormatStringArgumentIsNotUsedWarning.cs" />

test/data/Analyzers/SerilogAnonymousTypeWithoutDestructure.cs

@@ -0,0 +1,12 @@
+using Serilog;
+
+namespace ConsoleApp
+{
+    public static class Program
+    {
+        public static void Main()
+        {
+            Log.Logger.Information("{MyProperty}", new { Test = 1 });
+        }
+    }
+}

test/data/Analyzers/SerilogAnonymousTypeWithoutDestructure.cs.gold

@@ -0,0 +1,16 @@
+using Serilog;
+
+namespace ConsoleApp
+{
+    public static class Program
+    {
+        public static void Main()
+        {
+            Log.Logger.Information("||{MyProperty}|(0)|(1)", new { Test = 1 });
+        }
+    }
+}
+
+---------------------------------------------------------
+(0): ReSharper Format String Item: 
+(1): ReSharper Warning: Anonymous objects must be destructured

test/src/Analyzer/AnonymousTypeDestructureAnalyzerTests.cs

@@ -0,0 +1,13 @@
+using NUnit.Framework;
+
+namespace ReSharper.Structured.Logging.Tests.Analyzer
+{
+    public class AnonymousTypeDestructureAnalyzerTests : MessageTemplateAnalyzerTestBase
+    {
+        [Test]
+        public void TestSerilogAnonymousTypeWithoutDestructure()
+        {
+            DoNamedTest2();
+        }
+    }
+}

test/src/Analyzer/MessageTemplateTests.cs

@@ -24,6 +24,7 @@ protected override bool HighlightingPredicate(
                    || highlighting is TemplateFormatStringUnexistingArgumentWarning
                    || highlighting is StringEscapeCharacterHighlighting
                    || highlighting is DuplicateTemplatePropertyWarning
+                   || highlighting is AnonymousObjectDestructuringWarning
                    || highlighting is ExceptionPassedAsTemplateArgumentWarning;
         }
     }

test/src/ReSharper.Structured.Logging.Tests.csproj

@@ -322,6 +322,7 @@
     </Reference>
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Analyzer\AnonymousTypeDestructureAnalyzerTests.cs" />
     <Compile Include="Analyzer\CorrectExceptionPassingAnalyzerTests.cs" />
     <Compile Include="Analyzer\DuplicatePropertiesTemplateAnalyzerTests.cs" />
     <Compile Include="Analyzer\MessageTemplateTests.cs" />