Add compile result

Author: veblush

…e/IncrementalCompiler/CompilerOptions.cs …re/IncrementalCompiler/CompileOptions.cscore/IncrementalCompiler/CompilerOptions.cs renamed to core/IncrementalCompiler/CompileOptions.cs core/IncrementalCompiler/CompilerOptions.cs renamed to core/IncrementalCompiler/CompileOptions.cs

@@ -6,7 +6,7 @@
 namespace IncrementalCompiler
 {
     [DataContract]
-    public class CompilerOptions
+    public class CompileOptions
     {
         [DataMember] public string AssemblyName;
         [DataMember] public string Output;

core/IncrementalCompiler/CompileResult.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.Serialization;
+
+namespace IncrementalCompiler
+{
+    [DataContract]
+    public class CompileResult
+    {
+        [DataMember] public bool Succeeded;
+        [DataMember] public List<string> Warnings = new List<string>();
+        [DataMember] public List<string> Errors = new List<string>();
+    }
+}

core/IncrementalCompiler/Compiler.cs

@@ -5,35 +5,39 @@
 using Microsoft.CodeAnalysis.CSharp;
 using System.Linq;
 using System.Text;
+using NLog;
 
 namespace IncrementalCompiler
 {
     public class Compiler
     {
+        private Logger _logger = LogManager.GetLogger("Compiler");
         private CSharpCompilation _compilation;
-        private CompilerOptions _options;
+        private CompileOptions _options;
         private FileTimeList _referenceFileList;
         private FileTimeList _sourceFileList;
         private Dictionary<string, MetadataReference> _referenceMap;
         private Dictionary<string, SyntaxTree> _sourceMap;
 
-        public void Build(CompilerOptions options)
+        public CompileResult Build(CompileOptions options)
         {
             if (_compilation == null ||
                 _options.AssemblyName != options.AssemblyName ||
                 _options.Output != options.Output ||
                 Enumerable.SequenceEqual(_options.Defines, options.Defines) == false)
             {
-                BuildFull(options);
+                return BuildFull(options);
             }
             else
             {
-                BuildIncremental(options);
+                return BuildIncremental(options);
             }
         }
 
-        private void BuildFull(CompilerOptions options)
+        private CompileResult BuildFull(CompileOptions options)
         {
+            var result = new CompileResult();
+
             _options = options;
 
             _referenceFileList = new FileTimeList();
@@ -57,11 +61,15 @@ private void BuildFull(CompilerOptions options)
                 references: _referenceMap.Values,
                 options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
 
-            Emit();
+            Emit(result);
+
+            return result;
         }
 
-        private void BuildIncremental(CompilerOptions options)
+        private CompileResult BuildIncremental(CompileOptions options)
         {
+            var result = new CompileResult();
+
             _options = options;
 
             // TODO: guard failure of compilation, ...
@@ -111,7 +119,9 @@ private void BuildIncremental(CompilerOptions options)
                 _sourceMap.Remove(file);
             }
 
-            Emit();
+            Emit(result);
+
+            return result;
         }
 
         private MetadataReference CreateReference(string file)
@@ -127,30 +137,29 @@ private SyntaxTree ParseSource(string file, CSharpParseOptions parseOption)
                                               Encoding.UTF8);
         }
 
-        private void Emit()
+        private void Emit(CompileResult result)
         {
             using (var peStream = new FileStream(_options.Output, FileMode.Create))
             using (var pdbStream = new FileStream(Path.ChangeExtension(_options.Output, ".pdb"), FileMode.Create))
             {
-                var result = _compilation.Emit(peStream, pdbStream);
+                var r = _compilation.Emit(peStream, pdbStream);
 
-                if (!result.Success)
+                foreach (var d in r.Diagnostics)
                 {
-                    var failures = result.Diagnostics.Where(diagnostic =>
-                        diagnostic.IsWarningAsError ||
-                        diagnostic.Severity == DiagnosticSeverity.Error);
-
-                    foreach (var diagnostic in failures)
-                    {
-                        var line = diagnostic.Location.GetLineSpan();
-                        Console.Error.WriteLine("{0}({1}): {2} {3}",
-                            line.Path,
-                            line.StartLinePosition.Line + 1,
-                            diagnostic.Id,
-                            diagnostic.GetMessage());
-                    }
+                    if (d.Severity == DiagnosticSeverity.Warning && d.IsWarningAsError == false)
+                        result.Warnings.Add(GetDiagnosticString(d));
+                    else if (d.Severity == DiagnosticSeverity.Error || d.IsWarningAsError)
+                        result.Errors.Add(GetDiagnosticString(d));
                 }
+
+                result.Succeeded = r.Success;
             }
         }
+
+        private static string GetDiagnosticString(Diagnostic diagnostic)
+        {
+            var line = diagnostic.Location.GetLineSpan();
+            return $"{line.Path}({line.StartLinePosition.Line + 1}): {diagnostic.Id} {diagnostic.GetMessage()}";
+        }
     }
 }

core/IncrementalCompiler/CompilerService.cs

@@ -1,17 +1,15 @@
 using NLog;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
-using System.Linq;
 using System.ServiceModel;
 
 namespace IncrementalCompiler
 {
-    [ServiceContract(Namespace = "http://github.com/Unity3D.RoslynCompiler")]
+    [ServiceContract(Namespace = "https://github.com/SaladbowlCreative/Unity3D.IncrementalCompiler")]
     public interface ICompilerService
     {
         [OperationContract]
-        bool Build(string projectPath, CompilerOptions options);
+        CompileResult Build(string projectPath, CompileOptions options);
     }
 
     [ServiceBehavior(InstanceContextMode = InstanceContextMode.Single, IncludeExceptionDetailInFaults = true)]
@@ -21,7 +19,7 @@ public class CompilerService : ICompilerService
         private string _projectPath;
         private Dictionary<string, Compiler> _compilerMap;
 
-        public bool Build(string projectPath, CompilerOptions options)
+        public CompileResult Build(string projectPath, CompileOptions options)
         {
             _logger.Info("Build(projectPath={0}, output={1})", projectPath, options.Output);
 
@@ -45,15 +43,13 @@ public bool Build(string projectPath, CompilerOptions options)
 
             try
             {
-                compiler.Build(options);
+                return compiler.Build(options);
             }
             catch (Exception e)
             {
                 _logger.Error(e, "Error in build.");
                 throw;
             }
-
-            return true;
         }
     }
 }

core/IncrementalCompiler/CompilerServiceClient.cs

@@ -1,12 +1,10 @@
-using NLog;
-using System;
-using System.ServiceModel;
+using System.ServiceModel;
 
 namespace IncrementalCompiler
 {
     public class CompilerServiceClient
     {
-        public static void Request(int parentProcessId, string currentPath, CompilerOptions options)
+        public static CompileResult Request(int parentProcessId, string currentPath, CompileOptions options)
         {
             var address = "net.pipe://localhost/Unity3D.IncrementalCompiler/" + parentProcessId;
 
@@ -17,7 +15,7 @@ public static void Request(int parentProcessId, string currentPath, CompilerOpti
             };
             var ep = new EndpointAddress(address);
             var channel = ChannelFactory<ICompilerService>.CreateChannel(binding, ep);
-            channel.Build(currentPath, options);
+            return channel.Build(currentPath, options);
         }
     }
 }

core/IncrementalCompiler/IncrementalCompiler.csproj

@@ -64,13 +64,15 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="CompileOptions.cs" />
     <Compile Include="Compiler.cs" />
-    <Compile Include="CompilerOptions.cs" />
+    <Compile Include="CompileResult.cs" />
     <Compile Include="CompilerService.cs" />
     <Compile Include="CompilerServiceClient.cs" />
     <Compile Include="CompilerServiceServer.cs" />
     <Compile Include="FileTimeList.cs" />
     <Compile Include="Program.cs" />
+    <Compile Include="Program.Dev.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
   <ItemGroup>

core/IncrementalCompiler/Program.Dev.cs

@@ -0,0 +1,100 @@
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Threading;
+using NLog;
+using NLog.Config;
+using NLog.Targets;
+using System.ServiceModel;
+
+namespace IncrementalCompiler
+{
+    partial class Program
+    {
+        static int RunAsDev(string[] args)
+        {
+            SetupLogger("IncrementalCompiler.log");
+
+            var logger = LogManager.GetLogger("Dev");
+            logger.Info("Started");
+
+            Directory.SetCurrentDirectory(@"..\..\..\..\samples\Basic");
+            var curPath = Directory.GetCurrentDirectory();
+
+            var options = new CompileOptions();
+            options.ParseArgument(new string[]
+            {
+                "-nostdlib+",
+                "-noconfig",
+                "-r:" + @"C:/Program Files/Unity/Editor/Data\Mono/lib/mono/2.0/mscorlib.dll",
+                "-r:" + @"C:/Program Files/Unity/Editor/Data\Mono/lib/mono/2.0/System.dll",
+                "-r:" + @"C:/Program Files/Unity/Editor/Data\Mono/lib/mono/2.0/System.Core.dll",
+                "-r:" + @"C:/Program Files/Unity/Editor/Data\Mono/lib/mono/2.0/System.Xml.dll",
+                @"@Temp/UnityTempFile-abde314464ae1bc4cae691cbf128cb26",
+            },
+            curPath);
+            options.References = options.References.Distinct().ToList();
+            options.Files = options.Files.Distinct().ToList();
+
+            var parentProcessId = Process.GetCurrentProcess().Id;
+
+            Process serverProcess = null;
+
+            while (true)
+            {
+                try
+                {
+                    var w = new Stopwatch();
+                    w.Start();
+                    Console.WriteLine("Run");
+
+                    var result = CompilerServiceClient.Request(parentProcessId, curPath, options);
+
+                    w.Stop();
+
+                    Console.WriteLine("Done: Succeeded={0}. Duration={1}sec. ", result.Succeeded, w.Elapsed.TotalSeconds);
+                    foreach (var warning in result.Warnings)
+                        Console.WriteLine(warning);
+                    foreach (var error in result.Errors)
+                        Console.WriteLine(error);
+
+                    Console.ReadLine();
+                }
+                catch (EndpointNotFoundException)
+                {
+                    if (serverProcess == null)
+                    {
+                        var a = new Thread(() => CompilerServiceServer.Run(logger, parentProcessId));
+                        a.Start();
+                        serverProcess = Process.GetCurrentProcess();
+                        /*
+                        serverProcess = Process.Start(
+                            new ProcessStartInfo
+                            {
+                                FileName = Assembly.GetEntryAssembly().Location,
+                                Arguments = "-server " + parentProcessId,
+                                WindowStyle = ProcessWindowStyle.Hidden
+                            });
+                        */
+                        Thread.Sleep(100);
+                    }
+                    else
+                    {
+                        if (serverProcess.HasExited == false)
+                            Thread.Sleep(100);
+                        else
+                            serverProcess = null;
+                    }
+                }
+                catch (Exception e)
+                {
+                    Console.WriteLine(e);
+                    return 1;
+                }
+            }
+            return 0;
+        }
+    }
+}

core/IncrementalCompiler/Program.cs

@@ -11,11 +11,15 @@
 
 namespace IncrementalCompiler
 {
-    class Program
+    partial class Program
     {
         static int Main(string[] args)
         {
-            if (args.Length > 0 && args[0] == "-server")
+            if (args.Length > 0 && args[0] == "-dev")
+            {
+                return RunAsDev(args);
+            }
+            else if (args.Length > 0 && args[0] == "-server")
             {
                 return RunAsServer(args);
             }
@@ -33,7 +37,7 @@ static int RunAsClient(string[] args)
             logger.Info("Started");
 
             var currentPath = Directory.GetCurrentDirectory();
-            var options = new CompilerOptions();
+            var options = new CompileOptions();
             options.ParseArgument(args, currentPath);
             options.References = options.References.Distinct().ToList();
             options.Files = options.Files.Distinct().ToList();
@@ -80,10 +84,14 @@ static int RunAsClient(string[] args)
                     var w = new Stopwatch();
                     w.Start();
                     logger.Info("Request to server");
-                    CompilerServiceClient.Request(parentProcessId, currentPath, options);
+                    var result = CompilerServiceClient.Request(parentProcessId, currentPath, options);
                     w.Stop();
-                    logger.Info("Done: " + w.Elapsed.TotalSeconds + "sec");
-                    return 0;
+                    logger.Info("Done: Succeeded={0}. Duration={1}sec.", result.Succeeded, w.Elapsed.TotalSeconds);
+                    foreach (var warning in result.Warnings)
+                        logger.Info(warning);
+                    foreach (var error in result.Errors)
+                        logger.Info(error);
+                    return result.Succeeded ? 0 : 1;
                 }
                 catch (EndpointNotFoundException)
                 {