public static CompilationResult GetAssemblyFromCompilation(
IAssemblyLoadContext loader,
Compilation compilation)
{
EmitResult result;
using (var ms = new MemoryStream())
{
using (var pdb = new MemoryStream())
{
if (PlatformHelper.IsMono)
{
result = compilation.Emit(ms, pdbStream: null);
}
else
{
result = compilation.Emit(ms, pdbStream: pdb);
}
if (!result.Success)
{
var formatter = new DiagnosticFormatter();
var errorMessages = result.Diagnostics
.Where(IsError)
.Select(d => formatter.Format(d));
return CompilationResult.FromErrorMessages(errorMessages);
}
ms.Seek(0, SeekOrigin.Begin);
Assembly assembly;
if (PlatformHelper.IsMono)
{
assembly = loader.LoadStream(ms, assemblySymbols: null);
}
else
{
pdb.Seek(0, SeekOrigin.Begin);
assembly = loader.LoadStream(ms, pdb);
}
return CompilationResult.FromAssembly(assembly);
}
}
}
public static CompiledAssemblyResult GetAssemblyFromCompilation(
[NotNull]CSharpCompilation compilation)
{
Check.NotNull(compilation, nameof(compilation));
EmitResult result;
using (var ms = new MemoryStream())
{
using (var pdb = new MemoryStream())
{
if (PlatformHelper.IsMono)
{
result = compilation.Emit(ms, pdbStream: null);
}
else
{
result = compilation.Emit(ms, pdbStream: pdb);
}
if (!result.Success)
{
var formatter = new DiagnosticFormatter();
var errorMessages = result.Diagnostics
.Where(IsError)
.Select(d => formatter.Format(d));
return CompiledAssemblyResult.FromErrorMessages(errorMessages);
}
Assembly assembly;
if (PlatformHelper.IsMono)
{
var assemblyLoadMethod = typeof(Assembly).GetTypeInfo().GetDeclaredMethods("Load")
.First(
m =>
{
var parameters = m.GetParameters();
return parameters.Length == 1 && parameters[0].ParameterType == typeof(byte[]);
});
assembly = (Assembly)assemblyLoadMethod.Invoke(null, new[] { ms.ToArray() });
}
else
{
var assemblyLoadMethod = typeof(Assembly).GetTypeInfo().GetDeclaredMethods("Load")
.First(
m =>
{
var parameters = m.GetParameters();
return parameters.Length == 2
&& parameters[0].ParameterType == typeof(byte[])
&& parameters[1].ParameterType == typeof(byte[]);
});
assembly = (Assembly)assemblyLoadMethod.Invoke(null, new[] { ms.ToArray(), pdb.ToArray() });
}
return CompiledAssemblyResult.FromAssembly(assembly);
}
}
}
internal bool PrintErrors(IEnumerable <Diagnostic> diagnostics, TextWriter consoleOutput)
{
bool hasErrors = false;
foreach (var diag in diagnostics)
{
if (_reportedDiagnostics.Contains(diag))
{
// TODO: This invariant fails (at least) in the case where we see a member declaration "x = 1;".
// First we attempt to parse a member declaration starting at "x". When we see the "=", we
// create an IncompleteMemberSyntax with return type "x" and an error at the location of the "x".
// Then we parse a member declaration starting at "=". This is an invalid member declaration start
// so we attach an error to the "=" and attach it (plus following tokens) to the IncompleteMemberSyntax
// we previously created.
//this assert isn't valid if we change the design to not bail out after each phase.
//System.Diagnostics.Debug.Assert(diag.Severity != DiagnosticSeverity.Error);
continue;
}
else if (diag.Severity == DiagnosticSeverity.Hidden)
{
// Not reported from the command-line compiler.
continue;
}
// Catch exceptions from diagnostic formatter as diagnostic descriptors for analyzer diagnostics can throw an exception while formatting diagnostic message.
try
{
consoleOutput.WriteLine(DiagnosticFormatter.Format(diag, this.Culture));
}
catch (Exception ex)
{
var exceptionDiagnostic = AnalyzerExecutor.GetDescriptorDiagnostic(diag.Id, ex);
consoleOutput.WriteLine(DiagnosticFormatter.Format(exceptionDiagnostic, this.Culture));
}
if (diag.Severity == DiagnosticSeverity.Error)
{
hasErrors = true;
}
_reportedDiagnostics.Add(diag);
}
return(hasErrors);
}
public bool ReportErrors(IEnumerable <Diagnostic> diagnostics, TextWriter consoleOutput, ErrorLogger2 errorLoggerOpt)
{
bool hasErrors = false;
foreach (var diag in diagnostics)
{
if (_reportedDiagnostics.Contains(diag))
{
// TODO: This invariant fails (at least) in the case where we see a member declaration "x = 1;".
// First we attempt to parse a member declaration starting at "x". When we see the "=", we
// create an IncompleteMemberSyntax with return type "x" and an error at the location of the "x".
// Then we parse a member declaration starting at "=". This is an invalid member declaration start
// so we attach an error to the "=" and attach it (plus following tokens) to the IncompleteMemberSyntax
// we previously created.
//this assert isn't valid if we change the design to not bail out after each phase.
//System.Diagnostics.Debug.Assert(diag.Severity != DiagnosticSeverity.Error);
continue;
}
else if (diag.Severity == DiagnosticSeverity.Hidden)
{
// Not reported from the command-line compiler.
continue;
}
// We want to report diagnostics with source suppression in the error log file.
// However, these diagnostics should not be reported on the console output.
errorLoggerOpt?.InvokeAction("LogDiagnostic", diag);
if (diag.IsSuppressed)
{
continue;
}
consoleOutput.WriteLine(DiagnosticFormatter.Format(diag));
if (diag.Severity == DiagnosticSeverity.Error)
{
hasErrors = true;
}
_reportedDiagnostics.Add(diag);
}
return(hasErrors);
}
internal bool PrintErrors(IEnumerable <Diagnostic> diagnostics, TextWriter consoleOutput)
{
bool hasErrors = false;
foreach (var diag in diagnostics)
{
if (reportedDiagnostics.Contains(diag))
{
// TODO: This invariant fails (at least) in the case where we see a member declaration "x = 1;".
// First we attempt to parse a member declaration starting at "x". When we see the "=", we
// create an IncompleteMemberSyntax with return type "x" and an error at the location of the "x".
// Then we parse a member declaration starting at "=". This is an invalid member declaration start
// so we attach an error to the "=" and attach it (plus following tokens) to the IncompleteMemberSyntax
// we previously created.
//this assert isn't valid if we change the design to not bail out after each phase.
//System.Diagnostics.Debug.Assert(diag.Severity != DiagnosticSeverity.Error);
continue;
}
else if (diag.Severity == DiagnosticSeverity.Info)
{
// Not reported from the command-line compiler.
continue;
}
consoleOutput.WriteLine(DiagnosticFormatter.Format(diag, this.Culture));
if (diag.Severity == DiagnosticSeverity.Error || diag.IsWarningAsError)
{
hasErrors = true;
}
reportedDiagnostics.Add(diag);
}
return(hasErrors);
}
protected virtual void PrintError(Diagnostic diagnostic, TextWriter consoleOutput)
{
consoleOutput.WriteLine(DiagnosticFormatter.Format(diagnostic, Culture));
}
private static DiagnosticResult CreateDiagnosticResult(bool success, IEnumerable<Diagnostic> diagnostics)
{
var formatter = new DiagnosticFormatter();
var errors = diagnostics.Where(IsError)
.Select(d => formatter.Format(d)).ToList();
var warnings = diagnostics.Where(d => d.Severity == DiagnosticSeverity.Warning)
.Select(d => formatter.Format(d)).ToList();
return new DiagnosticResult(success, warnings, errors);
}
internal static IEnumerable<string> Convert(IEnumerable<Diagnostic> diagnostics)
{
var formatter = new DiagnosticFormatter();
return diagnostics.Select(d => formatter.Format(d)).ToList();
}
private static AssemblyLoadResult ReportCompilationError(EmitResult result)
{
#if DESKTOP // TODO: Temporary due to CoreCLR and Desktop Roslyn being out of sync
var formatter = DiagnosticFormatter.Instance;
#else
var formatter = new DiagnosticFormatter();
#endif
var errors = new List<string>(result.Diagnostics.Select(d => formatter.Format(d)));
return new AssemblyLoadResult(errors);
}
private CompilationMessage GetCompilationMessage(DiagnosticFormatter formatter, Diagnostic diagnostic)
{
return new CompilationMessage(formatter.Format(diagnostic));
}
