Add compile time constant analyzer

Author: olsh

README.md

@@ -1,3 +1,60 @@
-# resharper-structured-logging
+# ReSharper Structured Logging
+[![Build status](https://ci.appveyor.com/api/projects/status/c4riih64hbd4sebw?svg=true)](https://ci.appveyor.com/project/olsh/resharper-structured-logging)
+[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=resharper-structured-logging&metric=alert_status)](https://sonarcloud.io/dashboard?id=resharper-structured-logging)
 
 An extension for ReSharper that highlights structured logging templates and contains some useful analyzers
+
+At the moment it supports Serilog, NLog, and Microsoft.Extensions.Logging
+
+## Highlighting
+
+![Highlighting](https://github.com/olsh/resharper-structured-logging/raw/master/images/highlighting.png)
+
+## Analyzers
+
+### Duplicate template property 
+
+Noncompliant Code Example:
+```csharp
+Log.Error("Disk quota {Quota} MB exceeded by {Quota}", quota, user);
+```
+
+Compliant Solution:
+```csharp
+Log.Error("Disk quota {Quota} MB exceeded by {User}", quota, user);
+```
+
+### Exception passed as a template argument
+
+Noncompliant Code Example:
+```csharp
+catch (Exception exception)
+{
+   Log.Error(ex, "Disk quota {Quota} MB exceeded {Exception}", quota, exception);
+}
+```
+
+Compliant Solution:
+```csharp
+catch (Exception exception)
+{
+   Log.Error(exception, "Disk quota {Quota} MB exceeded", quota);
+}
+```
+
+### Message template is not a compile time constant
+
+Noncompliant Code Examples:
+```csharp
+Log.Error($"Disk quota {quota} MB exceeded by {user}");
+```
+
+```csharp
+Log.Error(string.Format("Disk quota {0} MB exceeded by {1}", quota, user));
+```
+
+
+Compliant Solution:
+```csharp
+Log.Error("Disk quota {Quota} MB exceeded by {User}", quota, user);
+```

images/highlighting.png

@@ -0,0 +1,32 @@
+using JetBrains.ReSharper.Feature.Services.Daemon;
+using JetBrains.ReSharper.Psi.CSharp.Tree;
+using JetBrains.ReSharper.Psi.Tree;
+
+using ReSharper.Structured.Logging.Extensions;
+using ReSharper.Structured.Logging.Highlighting;
+
+namespace ReSharper.Structured.Logging.Analyzer
+{
+    [ElementProblemAnalyzer(typeof(IInvocationExpression))]
+    public class CompileTimeConstantTemplateAnalyzer : ElementProblemAnalyzer<IInvocationExpression>
+    {
+        protected override void Run(
+            IInvocationExpression element,
+            ElementProblemAnalyzerData data,
+            IHighlightingConsumer consumer)
+        {
+            var templateArgument = element.GetTemplateArgument();
+            if (templateArgument == null)
+            {
+                return;
+            }
+
+            if (templateArgument.Value.IsConstantValue())
+            {
+                return;
+            }
+
+            consumer.AddHighlighting(new TemplateIsNotCompileTimeConstantWarning(templateArgument.Expression.GetDocumentRange()));
+        }
+    }
+}

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

@@ -24,12 +24,6 @@ protected override void Run(
                 return;
             }
 
-            var stringLiteral = StringLiteralAltererUtil.TryCreateStringLiteralByExpression(templateArgument.Value);
-            if (stringLiteral == null)
-            {
-                return;
-            }
-
             var templateArgumentIndex = templateArgument.IndexOf();
             var exceptionType = element.PsiModule.GetPredefinedType().TryGetType(PredefinedType.EXCEPTION_FQN);
             if (exceptionType == null)

src/ReSharper.Structured.Logging/Analyzer/CorrectExceptionPassingAnalyzer.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(TemplateIsNotCompileTimeConstantWarning.SeverityId, null, HighlightingGroupIds.CompilerWarnings,
+        TemplateIsNotCompileTimeConstantWarning.Message, TemplateIsNotCompileTimeConstantWarning.Message,
+        Severity.WARNING)]
+
+namespace ReSharper.Structured.Logging.Highlighting
+{
+    [ConfigurableSeverityHighlighting(
+        SeverityId,
+        CSharpLanguage.Name,
+        OverlapResolve = OverlapResolveKind.WARNING,
+        ToolTipFormatString = Message)]
+    public class TemplateIsNotCompileTimeConstantWarning : IHighlighting
+    {
+        public const string SeverityId = "TemplateIsNotCompileTimeConstantProblem";
+
+        public const string Message = "Message template should be compile time constant";
+
+        private readonly DocumentRange _documentRange;
+
+        public TemplateIsNotCompileTimeConstantWarning(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/TemplateIsNotCompileTimeConstantWarning.cs

@@ -324,6 +324,7 @@
     </Reference>
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Analyzer\CompileTimeConstantTemplateAnalyzer.cs" />
     <Compile Include="Analyzer\CorrectExceptionPassingAnalyzer.cs" />
     <Compile Include="Analyzer\DuplicatePropertiesTemplateAnalyzer.cs" />
     <Compile Include="Analyzer\TemplateFormatAnalyzer.cs" />
@@ -333,6 +334,7 @@
     <Compile Include="Highlighting\TemplateFormatStringArgumentIsNotUsedWarning.cs" />
     <Compile Include="Highlighting\TemplateFormatStringInexistingArgumentWarning.cs" />
     <Compile Include="Highlighting\TemplateFormatItemAndMatchingArgumentHighlighter.cs" />
+    <Compile Include="Highlighting\TemplateIsNotCompileTimeConstantWarning.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Serilog\Core\IMessageTemplateParser.cs" />
     <Compile Include="Serilog\Events\MessageTemplate.cs" />

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

@@ -0,0 +1,13 @@
+using System;
+using Serilog;
+
+namespace ConsoleApp
+{
+    public static class Program
+    {
+        public static void Main()
+        {
+            Log.Logger.Information($"{DateTime.Now} {{Error}}", new Exception());
+        }
+    }
+}

test/data/Analyzers/SerilogIncorrectExceptionPassingDynamicTemplate.cs

@@ -0,0 +1,18 @@
+using System;
+using Serilog;
+
+namespace ConsoleApp
+{
+    public static class Program
+    {
+        public static void Main()
+        {
+            Log.Logger.Information($"{DateTime.Now} |{{|(0)Error|}}|(1)", |new Exception()|(2));
+        }
+    }
+}
+
+---------------------------------------------------------
+(0): ReSharper String Escape Character 1: 
+(1): ReSharper String Escape Character 1: 
+(2): ReSharper Warning: Exception should be passed to the exception argument

test/data/Analyzers/SerilogIncorrectExceptionPassingDynamicTemplate.cs.gold

@@ -21,5 +21,11 @@ public void TestSerilogMultipleExceptionPassing()
         {
             DoNamedTest2();
         }
+
+        [Test]
+        public void TestSerilogIncorrectExceptionPassingDynamicTemplate()
+        {
+            DoNamedTest2();
+        }
     }
 }