Nov2016

UnityEngineAnalyzer.CLI/AnalyzerReport.cs

@@ -26,16 +26,28 @@ public void AppendDiagnostics(IEnumerable<Diagnostic> diagnosticResults)
 
             foreach (var diagnostic in diagnosticResults)
             {
-                var locationSpan = diagnostic.Location.SourceSpan;
-                var lineSpan = diagnostic.Location.SourceTree.GetLineSpan(locationSpan);
+                var location = diagnostic.Location;
+                var lineNumber = 0;
+                var characterPosition = 0;
+                var fileName = string.Empty;
+
+                if (location != Location.None)
+                {
+                    var locationSpan = location.SourceSpan;
+                    var lineSpan = location.SourceTree.GetLineSpan(locationSpan);
+                    lineNumber = lineSpan.StartLinePosition.Line;
+                    characterPosition = lineSpan.StartLinePosition.Character;
+                    fileName = location.SourceTree?.FilePath;
+                }
 
                 var diagnosticInfo = new DiagnosticInfo
                 {
                     Id = diagnostic.Id,
                     Message = diagnostic.GetMessage(),
-                    FileName = diagnostic.Location.SourceTree.FilePath,
-                    LineNumber = lineSpan.StartLinePosition.Line,
-                    Severity = (DiagnosticInfoSeverity)diagnostic.Severity
+                    FileName = fileName,
+                    LineNumber = lineNumber,
+                    CharacterPosition = characterPosition,
+                    Severity = (DiagnosticInfo.DiagnosticInfoSeverity)diagnostic.Severity
                 };
 
 
@@ -50,7 +62,7 @@ public void FinalizeReport(TimeSpan duration)
         {
             foreach (var exporter in _exporters)
             {
-                exporter.Finish(duration);
+                exporter.FinalizeExporter(duration);
             }
         }
 
@@ -61,5 +73,13 @@ public void InitializeReport(FileInfo projectFile)
                 exporter.InitializeExporter(projectFile);       
             }
         }
+
+        public void NotifyException(Exception exception)
+        {
+            foreach (var exporter in _exporters)
+            {
+                exporter.NotifyException(exception);
+            }
+        }
     }
 }

UnityEngineAnalyzer.CLI/Program.cs

@@ -3,16 +3,29 @@
 using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
 using UnityEngineAnalyzer.CLI.Reporting;
 
 namespace UnityEngineAnalyzer.CLI
 {
     public class Program
     {
+        private static readonly Dictionary<string, Type> AvailableExporters = new Dictionary<string, Type>();
+
+        static Program()
+        {
+            AvailableExporters.Add(nameof(JsonAnalyzerExporter), typeof(JsonAnalyzerExporter));
+            AvailableExporters.Add(nameof(StandardOutputAnalyzerReporter), typeof(StandardOutputAnalyzerReporter));
+            AvailableExporters.Add(nameof(ConsoleAnalyzerExporter), typeof(ConsoleAnalyzerExporter));
+        }
+
+
         public static void Main(string[] args)
         {
             try
             {
+                //TODO: Use a proper parser for the commands
+
                 if (args.Length <= 0)
                 {
                     return;
@@ -25,8 +38,19 @@ public static void Main(string[] args)
 
                 //NOTE: This could be configurable via the CLI at some point
                 var report = new AnalyzerReport();
-                report.AddExporter(new ConsoleAnalyzerExporter());
-                report.AddExporter(new JsonAnalyzerExporter());
+
+                if (args.Length > 1 && AvailableExporters.ContainsKey(args[1]))
+                {
+                    var exporterInstance = Activator.CreateInstance(AvailableExporters[args[1]]);
+                    report.AddExporter(exporterInstance as IAnalyzerExporter);
+                }
+                else
+                {
+                    //It's generally a good idea to make sure that the Console Exporter is last since it is interactive
+                    report.AddExporter(new JsonAnalyzerExporter());
+                    report.AddExporter(new ConsoleAnalyzerExporter());
+                }
+
 
 
                 report.InitializeReport(fileInfo);
@@ -46,18 +70,13 @@ public static void Main(string[] args)
 
                 report.FinalizeReport(duration);
 
-                Console.WriteLine("Press any key to exit...");
-                Console.ReadKey();
             }
             catch (Exception generalException)
             {
 
                 Console.WriteLine("There was an exception running the analysis");
                 Console.WriteLine(generalException.ToString());
             }
-
-
-
         }
 
 

UnityEngineAnalyzer.CLI/Reporting/ConsoleAnalyzerExporter.cs

@@ -3,57 +3,20 @@
 
 namespace UnityEngineAnalyzer.CLI.Reporting
 {
-    public class ConsoleAnalyzerExporter : IAnalyzerExporter
+    public class ConsoleAnalyzerExporter : StandardOutputAnalyzerReporter
     {
-        private const string ConsoleSeparator = "\t";
-        private const DiagnosticInfoSeverity MinimalSeverity = DiagnosticInfoSeverity.Warning;
 
-        public void AppendDiagnostic(DiagnosticInfo diagnosticInfo)
-        {
-            if (diagnosticInfo.Severity < MinimalSeverity)
-            {
-                return;
-            }
-
-            Console.Write(diagnosticInfo.Id);
-            Console.Write(ConsoleSeparator);
-
-            Console.ForegroundColor = ConsoleColorFromSeverity(diagnosticInfo.Severity);
-            Console.Write(diagnosticInfo.Severity.ToString());
-            Console.Write(ConsoleSeparator);
-
-            Console.ForegroundColor = ConsoleColor.Cyan;
-            Console.Write(diagnosticInfo.Message);
-            Console.ResetColor();
-            Console.Write(ConsoleSeparator);
-            Console.WriteLine(@"{0}({1})",diagnosticInfo.FileName,diagnosticInfo.LineNumber);
-        }
-
-        private ConsoleColor ConsoleColorFromSeverity(DiagnosticInfoSeverity severity)
-        {
-            switch (severity)
-            {
-                case DiagnosticInfoSeverity.Hidden:
-                    return ConsoleColor.Gray;
-                case DiagnosticInfoSeverity.Info:
-                    return ConsoleColor.Green;
-                case DiagnosticInfoSeverity.Warning:
-                    return ConsoleColor.Yellow;
-                case DiagnosticInfoSeverity.Error:
-                    return ConsoleColor.Red;
-                default:
-                    return ConsoleColor.White;
-            }
-        }
-
-        public void Finish(TimeSpan duration)
+        public override void FinalizeExporter(TimeSpan duration)
         {
             Console.ForegroundColor = ConsoleColor.Green;
             Console.WriteLine("Console Export Finished ({0})", duration);
             Console.ResetColor();
+
+            Console.WriteLine("Press any key to exit");
+            Console.ReadKey();
         }
 
-        public void InitializeExporter(FileInfo projectFile)
+        public override void InitializeExporter(FileInfo projectFile)
         {
             Console.ForegroundColor = ConsoleColor.Green;
             Console.WriteLine("Unity Syntax Analyzer");

UnityEngineAnalyzer.CLI/Reporting/DiagnosticInfo.cs

@@ -1,19 +1,24 @@
 namespace UnityEngineAnalyzer.CLI.Reporting
 {
-    public enum DiagnosticInfoSeverity
-    {
-        Hidden = 0,
-        Info = 1,
-        Warning = 2,
-        Error = 3
-    }
+
 
     public class DiagnosticInfo
     {
+        //TODO: Rename this to something like AnalysisResult
+
         public string Id { get; set; }
         public string Message { get; set; }
         public string FileName { get; set; }
         public int LineNumber { get; set; }
+        public int CharacterPosition { get; set; }
         public DiagnosticInfoSeverity Severity { get; set; }
+
+        public enum DiagnosticInfoSeverity
+        {
+            Hidden = 0,
+            Info = 1,
+            Warning = 2,
+            Error = 3
+        }
     }
 }

UnityEngineAnalyzer.CLI/Reporting/IAnalyzerExporter.cs

@@ -6,7 +6,8 @@ namespace UnityEngineAnalyzer.CLI.Reporting
     public interface IAnalyzerExporter
     {
         void AppendDiagnostic(DiagnosticInfo diagnosticInfo);
-        void Finish(TimeSpan duration);
+        void FinalizeExporter(TimeSpan duration);
         void InitializeExporter(FileInfo projectFile);
+        void NotifyException(Exception exception);
     }
 }

UnityEngineAnalyzer.CLI/Reporting/JsonAnalyzerExporter.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
 using Newtonsoft.Json;
@@ -9,11 +10,12 @@ public class JsonAnalyzerExporter : IAnalyzerExporter
     {
         private const string JsonReportFileName = "report.json";
         private const string HtmlReportFileName = "UnityReport.html";
-        private const DiagnosticInfoSeverity MinimalSeverity = DiagnosticInfoSeverity.Warning;
+        private const DiagnosticInfo.DiagnosticInfoSeverity MinimalSeverity = DiagnosticInfo.DiagnosticInfoSeverity.Warning;
 
 
         private JsonTextWriter _jsonWriter;
         private readonly JsonSerializer _jsonSerializer = new JsonSerializer();
+        private readonly List<Exception> _exceptions = new List<Exception>();
         private string _destinationReportFile;
 
 
@@ -25,13 +27,23 @@ public void AppendDiagnostic(DiagnosticInfo diagnosticInfo)
             }
         }
 
-        public void Finish(TimeSpan duration)
+        public void FinalizeExporter(TimeSpan duration)
         {
             _jsonWriter.WriteEndArray();
+
+            _jsonWriter.WritePropertyName("Exceptions");
+            _jsonWriter.WriteStartArray();
+
+            foreach (var exception in _exceptions)
+            {
+                _jsonSerializer.Serialize(_jsonWriter, exception);
+            }
+            _jsonWriter.WriteEndArray();
+
             _jsonWriter.WriteEndObject();
             _jsonWriter.Close();
 
-
+            //Console.WriteLine(Process.GetCurrentProcess().StartInfo.WorkingDirectory);
             File.Copy(HtmlReportFileName, _destinationReportFile, true);
 
             //NOTE: This code might be temporary as it assumes that the CLI is being executed interactively
@@ -68,5 +80,10 @@ public void InitializeExporter(FileInfo projectFile)
 
             _jsonSerializer.Formatting = Formatting.Indented;
         }
+
+        public void NotifyException(Exception exception)
+        {
+            _exceptions.Add(exception);
+        }
     }
 }

UnityEngineAnalyzer.CLI/Reporting/StandardOutputAnalyzerReporter.cs

@@ -0,0 +1,76 @@
+using System;
+using System.IO;
+
+namespace UnityEngineAnalyzer.CLI.Reporting
+{
+    public class StandardOutputAnalyzerReporter : IAnalyzerExporter
+    {
+        protected const string ConsoleSeparator = "\t";
+        protected const DiagnosticInfo.DiagnosticInfoSeverity MinimalSeverity = DiagnosticInfo.DiagnosticInfoSeverity.Warning;
+
+        protected const string FailurePrefix = "# ";
+
+        public void AppendDiagnostic(DiagnosticInfo diagnosticInfo)
+        {
+            if (diagnosticInfo.Severity < MinimalSeverity)
+            {
+                return;
+            }
+
+            Console.Write(diagnosticInfo.Id);
+            Console.Write(ConsoleSeparator);
+
+            Console.ForegroundColor = ConsoleColorFromSeverity(diagnosticInfo.Severity);
+            Console.Write(diagnosticInfo.Severity.ToString());
+            Console.Write(ConsoleSeparator);
+
+            Console.ForegroundColor = ConsoleColor.Cyan;
+            Console.Write(diagnosticInfo.Message);
+            Console.ResetColor();
+            Console.WriteLine(@"{0}{1}{0}{2},{3}", ConsoleSeparator,diagnosticInfo.FileName, diagnosticInfo.LineNumber, diagnosticInfo.CharacterPosition);
+
+        }
+
+        private ConsoleColor ConsoleColorFromSeverity(DiagnosticInfo.DiagnosticInfoSeverity severity)
+        {
+            switch (severity)
+            {
+                case DiagnosticInfo.DiagnosticInfoSeverity.Hidden:
+                    return ConsoleColor.Gray;
+                case DiagnosticInfo.DiagnosticInfoSeverity.Info:
+                    return ConsoleColor.Green;
+                case DiagnosticInfo.DiagnosticInfoSeverity.Warning:
+                    return ConsoleColor.Yellow;
+                case DiagnosticInfo.DiagnosticInfoSeverity.Error:
+                    return ConsoleColor.Red;
+                default:
+                    return ConsoleColor.White;
+            }
+        }
+
+        public virtual void FinalizeExporter(TimeSpan duration)
+        {
+        }
+
+        public virtual void InitializeExporter(FileInfo projectFile)
+        {
+        }
+
+        public virtual void NotifyException(Exception exception)
+        {
+            Console.ForegroundColor = ConsoleColor.Red;
+
+            var delimeters = new[] {"\r", "\n", Environment.NewLine };
+            var exceptionLines = exception.ToString().Split(delimeters, StringSplitOptions.RemoveEmptyEntries);
+
+            foreach (var exceptionLine in exceptionLines)
+            {
+                Console.WriteLine(FailurePrefix + exceptionLine);
+            }
+
+            Console.WriteLine(FailurePrefix);
+
+            Console.ResetColor();
+        }
+    }
+}

UnityEngineAnalyzer.CLI/SolutionAnalyzer.cs

@@ -44,13 +44,22 @@ private ImmutableArray<DiagnosticAnalyzer> GetAnalyzers()
             return analyzers;
         }
 
-        private async Task AnalyzeProject(Project project, ImmutableArray<DiagnosticAnalyzer> analyzers, AnalyzerReport report)
+        private async Task AnalyzeProject(Project project, ImmutableArray<DiagnosticAnalyzer> analyzers,
+            AnalyzerReport report)
         {
-            var compilation = await project.GetCompilationAsync();
+            try
+            {
+                var compilation = await project.GetCompilationAsync();
+
+                var diagnosticResults = await compilation.WithAnalyzers(analyzers).GetAnalyzerDiagnosticsAsync();
 
-            var diagnosticResults = await compilation.WithAnalyzers(analyzers).GetAnalyzerDiagnosticsAsync();
+                report.AppendDiagnostics(diagnosticResults);
+            }
+            catch (Exception exception)
+            {
+                report.NotifyException(exception);
+            }
 
-            report.AppendDiagnostics(diagnosticResults);
 
         }
     }