dotnet-script · seesharper · Jun 13, 2018 · Jun 8, 2018 · Jun 9, 2018 · Jun 9, 2018
diff --git a/src/Dotnet.Script.Core/Dotnet.Script.Core.csproj b/src/Dotnet.Script.Core/Dotnet.Script.Core.csproj
@@ -22,12 +22,14 @@
     <None Remove="Templates\helloworld.csx.template" />
     <None Remove="Templates\launch.json.template" />
     <None Remove="Templates\omnisharp.json.template" />
+    <None Remove="Templates\program.publish.template" />
   </ItemGroup>
 
   <ItemGroup>
     <EmbeddedResource Include="Templates\helloworld.csx.template" />
     <EmbeddedResource Include="Templates\launch.json.template" />
     <EmbeddedResource Include="Templates\omnisharp.json.template" />
+    <EmbeddedResource Include="Templates\program.publish.template" />
   </ItemGroup>
 
   <ItemGroup>

diff --git a/src/Dotnet.Script.Core/ScriptCompiler.cs b/src/Dotnet.Script.Core/ScriptCompiler.cs
@@ -4,6 +4,7 @@
 using System.Linq;
 using System.Reflection;
 using System.Runtime.InteropServices;
+using System.Text;
 using System.Threading.Tasks;
 using Dotnet.Script.Core.Internal;
 using Dotnet.Script.DependencyModel.Context;
@@ -52,7 +53,7 @@ static ScriptCompiler()
         };
 
         // see: https://github.com/dotnet/roslyn/issues/5501
-        protected virtual IEnumerable<string> SuppressedDiagnosticIds => new[] { "CS1701", "CS1702", "CS1705" };        
+        protected virtual IEnumerable<string> SuppressedDiagnosticIds => new[] { "CS1701", "CS1702", "CS1705" };
 
         public CSharpParseOptions ParseOptions { get; } = new CSharpParseOptions(LanguageVersion.Latest, kind: SourceCodeKind.Script);
 
@@ -106,7 +107,9 @@ public virtual ScriptCompilationContext<TReturn> CreateCompilationContext<TRetur
             Logger.Verbose($"Current runtime is '{_scriptEnvironment.PlatformIdentifier}'.");
             RuntimeDependency[] runtimeDependencies = GetRuntimeDependencies(context);
 
-            var scriptOptions = CreateScriptOptions(context, runtimeDependencies.ToList());
+            var encoding = context.Code.Encoding ?? Encoding.UTF8; // encoding is required when emitting debug information
+            var scriptOptions = CreateScriptOptions(context, runtimeDependencies.ToList())
+                .WithFileEncoding(encoding);
 
             var loadedAssembliesMap = CreateLoadedAssembliesMap();
 
@@ -209,7 +212,7 @@ private void SetOptimizationLevel<TReturn>(ScriptContext context, Script<TReturn
         private string GetScriptCode(ScriptContext context)
         {
             string code;
-            
+
             // when processing raw code, make sure we inject new lines after preprocessor directives
             if (context.FilePath == null)
             {
@@ -259,7 +262,7 @@ private Assembly MapUnresolvedAssemblyToRuntimeLibrary(IDictionary<string, Runti
             {
                 if (runtimeAssembly.Name.Version > assemblyName.Version)
                 {
-                    loadedAssemblyMap.TryGetValue(assemblyName.Name, out var loadedAssembly);                    
+                    loadedAssemblyMap.TryGetValue(assemblyName.Name, out var loadedAssembly);
                     if(loadedAssembly != null)
                     {
                         Logger.Log($"Redirecting {assemblyName} to already loaded {loadedAssembly.GetName().Name}");

diff --git a/src/Dotnet.Script.Core/ScriptEmitResult.cs b/src/Dotnet.Script.Core/ScriptEmitResult.cs
@@ -0,0 +1,35 @@
+using Microsoft.CodeAnalysis;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.IO;
+using System.Linq;
+
+namespace Dotnet.Script.Core
+{
+    public class ScriptEmitResult
+    {
+        private ScriptEmitResult() { }
+
+        public ScriptEmitResult(MemoryStream peStream, MemoryStream pdbStream, IEnumerable<MetadataReference> directiveReferences)
+        {
+            PeStream = peStream;
+            PdbStream = pdbStream;
+            DirectiveReferences = directiveReferences.ToImmutableArray();
+        }
+
+        public MemoryStream PeStream { get; }
+        public MemoryStream PdbStream { get; }
+        public ImmutableArray<Diagnostic> Diagnostics { get; private set; } = ImmutableArray.Create<Diagnostic>();
+        public ImmutableArray<MetadataReference> DirectiveReferences { get; } = ImmutableArray.Create<MetadataReference>();
+        public bool Success => !Diagnostics.Any(d => d.Severity == DiagnosticSeverity.Error);
+
+        public static ScriptEmitResult Error(IEnumerable<Diagnostic> diagnostics)
+        {
+            var result = new ScriptEmitResult
+            {
+                Diagnostics = diagnostics.ToImmutableArray()
+            };
+            return result;
+        }
+    }
+}
diff --git a/src/Dotnet.Script.Core/ScriptEmitter.cs b/src/Dotnet.Script.Core/ScriptEmitter.cs
@@ -0,0 +1,58 @@
+using Microsoft.CodeAnalysis.Emit;
+using Microsoft.CodeAnalysis.Scripting;
+using Microsoft.CodeAnalysis.Scripting.Hosting;
+using System.IO;
+
+namespace Dotnet.Script.Core
+{
+    public class ScriptEmitter
+    {
+        private readonly ScriptConsole _scriptConsole;
+        private readonly ScriptCompiler _scriptCompiler;
+
+        public ScriptEmitter(ScriptConsole scriptConsole, ScriptCompiler scriptCompiler)
+        {
+            _scriptConsole = scriptConsole;
+            _scriptCompiler = scriptCompiler;
+        }
+
+        public virtual ScriptEmitResult Emit<TReturn>(ScriptContext context, string assemblyName = null)
+        {
+            try
+            {
+                var compilationContext = _scriptCompiler.CreateCompilationContext<TReturn, CommandLineScriptGlobals>(context);
+
+                var compilation = compilationContext.Script.GetCompilation();
+                if (!string.IsNullOrEmpty(assemblyName))
+                {
+                    var compilationOptions = compilationContext.Script.GetCompilation().Options
+                        .WithScriptClassName(assemblyName);
+                    compilation = compilationContext.Script.GetCompilation()
+                        .WithOptions(compilationOptions)
+                        .WithAssemblyName(assemblyName);
+                }
+
+                var peStream = new MemoryStream();
+                var pdbStream = new MemoryStream();
+                var result = compilation.Emit(peStream, pdbStream: pdbStream, options: new EmitOptions().
+                    WithDebugInformationFormat(DebugInformationFormat.PortablePdb));
+
+                if (result.Success)
+                {
+                    return new ScriptEmitResult(peStream, pdbStream, compilation.DirectiveReferences);
+                }
+
+                return ScriptEmitResult.Error(result.Diagnostics);
+            }
+            catch (CompilationErrorException e)
+            {
+                foreach (var diagnostic in e.Diagnostics)
+                {
+                    _scriptConsole.WritePrettyError(diagnostic.ToString());
+                }
+
+                throw;
+            }
+        }
+    }
+}
diff --git a/src/Dotnet.Script.Core/ScriptPublisher.cs b/src/Dotnet.Script.Core/ScriptPublisher.cs
@@ -0,0 +1,124 @@
+using Dotnet.Script.DependencyModel.Environment;
+using Dotnet.Script.DependencyModel.Logging;
+using Dotnet.Script.DependencyModel.Process;
+using Dotnet.Script.DependencyModel.ProjectSystem;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Scripting;
+using System;
+using System.IO;
+using System.Reflection;
+
+namespace Dotnet.Script.Core
+{
+    public class ScriptPublisher
+    {
+        const string AssemblyName = "scriptAssembly";
+        const string ScriptingVersion = "2.8.2";
+
+        private readonly ScriptProjectProvider _scriptProjectProvider;
+        private readonly ScriptEmitter _scriptEmitter;
+        private readonly ScriptConsole _scriptConsole;
+        private readonly ScriptEnvironment _scriptEnvironment;
+
+        public ScriptPublisher(ScriptProjectProvider scriptProjectProvider, ScriptEmitter scriptEmitter, ScriptConsole scriptConsole)
+        {
+            _scriptProjectProvider = scriptProjectProvider ?? throw new ArgumentNullException(nameof(scriptProjectProvider));
+            _scriptEmitter = scriptEmitter ?? throw new ArgumentNullException(nameof(scriptEmitter));
+            _scriptConsole = scriptConsole ?? throw new ArgumentNullException(nameof(scriptConsole));
+            _scriptEnvironment = ScriptEnvironment.Default;
+        }
+
+        public ScriptPublisher(LogFactory logFactory, ScriptEmitter scriptEmitter)
+            : this
+            (
+                new ScriptProjectProvider(logFactory),
+                scriptEmitter,
+                ScriptConsole.Default
+            )
+        {
+        }
+
+        public void CreateExecutable(ScriptContext context, LogFactory logFactory)
+        {
+            var tempProjectPath = _scriptProjectProvider.CreateProjectForScriptFile(context.FilePath);
+            var tempProjectDirecory = Path.GetDirectoryName(tempProjectPath);
+
+            var scriptAssemblyPath = CreateScriptAssembly(context, tempProjectDirecory);
+
+            var projectFile = new ProjectFile(File.ReadAllText(tempProjectPath));
+            projectFile.AddPackageReference(new PackageReference("Microsoft.CodeAnalysis.Scripting", ScriptingVersion, PackageOrigin.ReferenceDirective));
+            projectFile.AddAssemblyReference(scriptAssemblyPath);
+            projectFile.Save(tempProjectPath);
+
+            CopyProgramTemplate(tempProjectDirecory);
+
+            var runtimeIdentifier = _scriptEnvironment.RuntimeIdentifier;
+
+            var commandRunner = new CommandRunner(logFactory);
+            // todo: may want to add ability to return dotnet.exe errors
+            var exitcode = commandRunner.Execute("dotnet", $"publish \"{tempProjectPath}\" -c Release -r {runtimeIdentifier} -o {context.WorkingDirectory}");
+            if (exitcode != 0) throw new Exception($"dotnet publish failed with result '{exitcode}'");
+        }
+
+        private string CreateScriptAssembly(ScriptContext context, string tempProjectDirecory)
+        {
+            try
+            {
+                var emitResult = _scriptEmitter.Emit<int>(context, AssemblyName);
+                if (!emitResult.Success)
+                {
+                    throw new CompilationErrorException("One or more errors occurred when emitting the assembly", emitResult.Diagnostics);
+                }
+
+                var assemblyPath = Path.Combine(tempProjectDirecory, $"{AssemblyName}.dll");
+                using (var peFileStream = new FileStream(assemblyPath, FileMode.Create))
+                using (emitResult.PeStream)
+                {
+                    emitResult.PeStream.WriteTo(peFileStream);
+                }
+
+                var pdbPath = Path.Combine(tempProjectDirecory, $"{AssemblyName}.pdb");
+                using (var pdbFileStream = new FileStream(pdbPath, FileMode.Create))
+                using (emitResult.PdbStream)
+                {
+                    emitResult.PdbStream.WriteTo(pdbFileStream);
+                }
+
+                foreach (var reference in emitResult.DirectiveReferences)
+                {
+                    if (reference.Display.EndsWith(".NuGet.dll")) continue;
+                    var refInfo = new FileInfo(reference.Display);
+                    var newAssemblyPath = Path.Combine(tempProjectDirecory, refInfo.Name);
+                    File.Copy(refInfo.FullName, newAssemblyPath, true);
+                }
+
+                return assemblyPath;
+            }
+            catch (CompilationErrorException ex)
+            {
+                _scriptConsole.WritePrettyError(ex.Message);
+                foreach (var diagnostic in ex.Diagnostics)
+                {
+                    _scriptConsole.WritePrettyError(diagnostic.ToString());
+                }
+                throw;
+            }
+        }
+
+        private void CopyProgramTemplate(string tempProjectDirecory)
+        {
+            const string resourceName = "Dotnet.Script.Core.Templates.program.publish.template";
+
+            var resourceStream = typeof(ScriptPublisher).GetTypeInfo().Assembly.GetManifestResourceStream(resourceName);
+            if (resourceStream == null) throw new FileNotFoundException($"Unable to locate resource '{resourceName}'");
+
+            string program;
+            using (var streamReader = new StreamReader(resourceStream))
+            {
+                program = streamReader.ReadToEnd();
+            }
+            var programcsPath = Path.Combine(tempProjectDirecory, "Program.cs");
+            File.WriteAllText(programcsPath, program);
+        }
+    }
+}
diff --git a/src/Dotnet.Script.Core/Templates/program.publish.template b/src/Dotnet.Script.Core/Templates/program.publish.template
@@ -0,0 +1,43 @@
+using System;
+using Microsoft.CodeAnalysis.CSharp.Scripting.Hosting;
+using Microsoft.CodeAnalysis.Scripting.Hosting;
+using System.Threading.Tasks;
+using static System.Console;
+
+namespace dotnetPublishCode
+{
+    class Program
+    {
+        static async Task Main(string[] args)
+        {
+            try
+            {
+                var globals = new CommandLineScriptGlobals(Console.Out, CSharpObjectFormatter.Instance);
+                foreach (var arg in args)
+                    globals.Args.Add(arg);
+
+                var factoryMethod = typeof(scriptAssembly).GetMethod("<Factory>");
+                if (factoryMethod == null) throw new Exception("couldn't find factory method to initiate script");
+
+                var invokeTask = factoryMethod.Invoke(null, new object[] { new object[] { globals, null } }) as Task<int>;
+                var invokeResult = await invokeTask;
+                if (invokeResult != 0) WritePrettyError($"Error result: '{invokeResult}'");
+            }
+            catch (Exception ex)
+            {
+                if (ex is AggregateException aggregateEx)
+                {
+                    ex = aggregateEx.Flatten().InnerException;
+                }
+                WritePrettyError(ex.ToString());
+            }
+        }
+
+        public static void WritePrettyError(string value)
+        {
+            Console.ForegroundColor = ConsoleColor.Red;
+            Error.WriteLine(value.TrimEnd(Environment.NewLine.ToCharArray()));
+            Console.ResetColor();
+        }
+    }
+}
diff --git a/src/Dotnet.Script.DependencyModel/ProjectSystem/ProjectFile.cs b/src/Dotnet.Script.DependencyModel/ProjectSystem/ProjectFile.cs
@@ -15,6 +15,11 @@ public ProjectFile()
             _document = XDocument.Parse(template);
         }
 
+        public ProjectFile(string xmlText)
+        {
+            _document = XDocument.Parse(xmlText);
+        }
+
         public void AddPackageReference(PackageReference packageReference)
         {
             var itemGroupElement = _document.Descendants("ItemGroup").Single();
@@ -24,6 +29,14 @@ public void AddPackageReference(PackageReference packageReference)
             itemGroupElement.Add(packageReferenceElement);
         }
 
+        public void AddAssemblyReference(string assemblyPath)
+        {
+            var itemGroupElement = _document.Descendants("ItemGroup").Single();
+            var packageReferenceElement = new XElement("Reference");
+            packageReferenceElement.Add(new XAttribute("Include", assemblyPath));
+            itemGroupElement.Add(packageReferenceElement);
+        }
+
         public void SetTargetFramework(string targetFramework)
         {
             var targetFrameworkElement = _document.Descendants("TargetFramework").Single();

diff --git a/src/Dotnet.Script.DependencyModel/ProjectSystem/csproj.template b/src/Dotnet.Script.DependencyModel/ProjectSystem/csproj.template
@@ -1,7 +1,8 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>netcoreapp2.0</TargetFramework>  
+    <TargetFramework>netcoreapp2.0</TargetFramework>
+    <LangVersion>latest</LangVersion>
   </PropertyGroup>
   <ItemGroup>    
   </ItemGroup>