public bool TryPrepareForPublish()
{
if (Framework != null)
{
NugetFramework = NuGetFramework.Parse(Framework);
if (NugetFramework.IsUnsupported)
{
Reporter.Output.WriteLine($"Unsupported framework {Framework}.".Red());
return(false);
}
}
ProjectContexts = ProjectContext.CreateContextForEachTarget(ProjectPath);
ProjectContexts = GetMatchingProjectContexts(ProjectContexts, NugetFramework, Runtime);
if (ProjectContexts.Count() == 0)
{
string errMsg = $"'{ProjectPath}' cannot be published for '{Framework ?? "<no framework provided>"}' '{Runtime ?? "<no runtime provided>"}'";
Reporter.Output.WriteLine(errMsg.Red());
return(false);
}
return(true);
}
private static List <ProjectContext> LoadProjectContexts(string[] projectFiles)
{
var projectContexts = new List <ProjectContext>();
foreach (var file in projectFiles)
{
var fileTargetContexts = ProjectContext.CreateContextForEachTarget(file);
projectContexts.AddRange(fileTargetContexts);
}
return(projectContexts);
}
private IEnumerable <ProjectContext> TryCreateRuntimeContextsFromScriptFiles()
{
_logger.LogInformation($"Attempting to create runtime context from script files. Default target framework {_targetFrameWork.Value}");
try
{
var scriptProjectInfo = _scriptProjectProvider.CreateProject(_env.TargetDirectory, _targetFrameWork.Value);
return(ProjectContext.CreateContextForEachTarget(Path.GetDirectoryName(scriptProjectInfo.PathToProjectJson)));
}
catch (Exception exception)
{
_logger.LogError(exception, "Unable to create runtime context from script files.");
}
return(null);
}
private ProjectContext GetProjectContextFromDirectoryForFirstTarget(string projectRootPath)
{
if (projectRootPath == null)
{
return(null);
}
if (!File.Exists(Path.Combine(projectRootPath, Project.FileName)))
{
return(null);
}
var projectContext = ProjectContext.CreateContextForEachTarget(projectRootPath).FirstOrDefault();
return(projectContext);
}
private IEnumerable <ProjectContext> SelectContexts(string projectPath, NuGetFramework framework, string runtime)
{
var allContexts = ProjectContext.CreateContextForEachTarget(projectPath).ToList();
var frameworks = framework == null?
allContexts.Select(c => c.TargetFramework).Distinct().ToArray() :
new[] { framework };
if (string.IsNullOrEmpty(runtime))
{
// For each framework, find the best matching RID item
var candidates = PlatformServices.Default.Runtime.GetAllCandidateRuntimeIdentifiers();
return(frameworks.Select(f => FindBestTarget(f, allContexts, candidates)));
}
else
{
return(frameworks.SelectMany(f => allContexts.Where(c =>
Equals(c.TargetFramework, f) &&
string.Equals(c.RuntimeIdentifier, runtime, StringComparison.Ordinal))));
}
}
public IEnumerable <RuntimeDependency> GetRuntimeDependencies(string projectFile)
{
var workingDirectory = Path.GetDirectoryName(projectFile);
var runtimeContext = ProjectContext.CreateContextForEachTarget(workingDirectory).FirstOrDefault();
var projectExporter = runtimeContext.CreateExporter("release");
var runtimeIdentifier = RuntimeHelper.GetPlatformIdentifier();
var runtimeDependencies = new HashSet <RuntimeDependency>();
var projectDependencies = projectExporter.GetDependencies();
foreach (var projectDependency in projectDependencies)
{
var runtimeAssemblyGroups = projectDependency.RuntimeAssemblyGroups;
foreach (var libraryAsset in runtimeAssemblyGroups.GetDefaultAssets())
{
var runtimeAssemblyPath = libraryAsset.ResolvedPath;
_logger.Verbose($"Discovered runtime dependency for '{runtimeAssemblyPath}'");
var runtimeDependency = new RuntimeDependency(libraryAsset.Name, libraryAsset.ResolvedPath);
runtimeDependencies.Add(runtimeDependency);
}
foreach (var runtimeAssemblyGroup in runtimeAssemblyGroups)
{
if (!string.IsNullOrWhiteSpace(runtimeAssemblyGroup.Runtime) && runtimeAssemblyGroup.Runtime == runtimeIdentifier)
{
foreach (var runtimeAsset in runtimeAssemblyGroups.GetRuntimeAssets(runtimeIdentifier))
{
var runtimeAssetPath = runtimeAsset.ResolvedPath;
_logger.Verbose($"Discovered runtime asset dependency ('{runtimeIdentifier}') for '{runtimeAssetPath}'");
var runtimeDependency = new RuntimeDependency(runtimeAsset.Name, runtimeAsset.ResolvedPath);
runtimeDependencies.Add(runtimeDependency);
}
}
}
}
return(runtimeDependencies);
}
private static IEnumerable <ProjectContext> SelectContexts(string projectPath, NuGetFramework framework, string runtime)
{
var allContexts = ProjectContext.CreateContextForEachTarget(projectPath);
if (string.IsNullOrEmpty(runtime))
{
// Nothing was specified, so figure out what the candidate runtime identifiers are and try each of them
// Temporary until #619 is resolved
foreach (var candidate in PlatformServices.Default.Runtime.GetAllCandidateRuntimeIdentifiers())
{
var contexts = GetMatchingProjectContexts(allContexts, framework, candidate);
if (contexts.Any())
{
return(contexts);
}
}
return(Enumerable.Empty <ProjectContext>());
}
else
{
return(GetMatchingProjectContexts(allContexts, framework, runtime));
}
}
public virtual ScriptCompilationContext <TReturn> CreateCompilationContext <TReturn, THost>(ScriptContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var runtimeIdentitfer = GetRuntimeIdentitifer();
_logger.Verbose($"Current runtime is '{runtimeIdentitfer}'.");
var opts = CreateScriptOptions(context);
var runtimeId = RuntimeEnvironment.GetRuntimeIdentifier();
var inheritedAssemblyNames = DependencyContext.Default.GetRuntimeAssemblyNames(runtimeId).Where(x =>
x.FullName.StartsWith("system.", StringComparison.OrdinalIgnoreCase) ||
x.FullName.StartsWith("microsoft.codeanalysis", StringComparison.OrdinalIgnoreCase) ||
x.FullName.StartsWith("mscorlib", StringComparison.OrdinalIgnoreCase));
foreach (var inheritedAssemblyName in inheritedAssemblyNames)
{
_logger.Verbose("Adding reference to an inherited dependency => " + inheritedAssemblyName.FullName);
var assembly = Assembly.Load(inheritedAssemblyName);
opts = opts.AddReferences(assembly);
}
var runtimeContext = File.Exists(Path.Combine(context.WorkingDirectory, Project.FileName)) ? ProjectContext.CreateContextForEachTarget(context.WorkingDirectory).FirstOrDefault() : null;
if (runtimeContext == null)
{
_logger.Verbose("Unable to find project context for CSX files. Will default to non-context usage.");
var scriptProjectProvider = ScriptProjectProvider.Create(new LoggerFactory());
var scriptProjectInfo = scriptProjectProvider.CreateProject(context.WorkingDirectory, "netcoreapp1.1");
runtimeContext = ProjectContext.CreateContextForEachTarget(scriptProjectInfo.PathToProjectJson).FirstOrDefault();
}
_logger.Verbose($"Found runtime context for '{runtimeContext.ProjectFile.ProjectFilePath}'.");
var projectExporter = runtimeContext.CreateExporter(context.Configuration);
var runtimeDependencies = new HashSet <string>();
var projectDependencies = projectExporter.GetDependencies();
foreach (var projectDependency in projectDependencies)
{
var runtimeAssemblyGroups = projectDependency.RuntimeAssemblyGroups;
foreach (var libraryAsset in runtimeAssemblyGroups.GetDefaultAssets())
{
var runtimeAssemblyPath = libraryAsset.ResolvedPath;
_logger.Verbose($"Discovered runtime dependency for '{runtimeAssemblyPath}'");
runtimeDependencies.Add(runtimeAssemblyPath);
}
foreach (var runtimeAssemblyGroup in runtimeAssemblyGroups)
{
if (!string.IsNullOrWhiteSpace(runtimeAssemblyGroup.Runtime) && runtimeAssemblyGroup.Runtime == runtimeIdentitfer)
{
foreach (var runtimeAsset in runtimeAssemblyGroups.GetRuntimeAssets(GetRuntimeIdentitifer()))
{
var runtimeAssetPath = runtimeAsset.ResolvedPath;
_logger.Verbose($"Discovered runtime asset dependency ('{runtimeIdentitfer}') for '{runtimeAssetPath}'");
runtimeDependencies.Add(runtimeAssetPath);
}
}
}
}
foreach (var runtimeDep in runtimeDependencies)
{
_logger.Verbose("Adding reference to a runtime dependency => " + runtimeDep);
opts = opts.AddReferences(MetadataReference.CreateFromFile(runtimeDep));
}
var loader = new InteractiveAssemblyLoader();
var script = CSharpScript.Create <TReturn>(context.Code.ToString(), opts, typeof(THost), loader);
var orderedDiagnostics = script.GetDiagnostics(SuppressedDiagnosticIds);
if (orderedDiagnostics.Any(d => d.Severity == DiagnosticSeverity.Error))
{
foreach (var diagnostic in orderedDiagnostics)
{
_logger.Log(diagnostic.ToString());
}
throw new CompilationErrorException("Script compilation failed due to one or more errors.",
orderedDiagnostics.ToImmutableArray());
}
return(new ScriptCompilationContext <TReturn>(script, context.Code, loader));
}
private static void RunScript(string file, string config, bool debugMode, List <string> scriptArgs)
{
if (debugMode)
{
Console.WriteLine($"Using debug mode.");
Console.WriteLine($"Using configuration: {config}");
}
if (!File.Exists(file))
{
Console.WriteLine($"Couldn't find file '{file}'");
return;
}
var directory = Path.IsPathRooted(file) ? Path.GetDirectoryName(file) : Directory.GetCurrentDirectory();
var runtimeContext = ProjectContext.CreateContextForEachTarget(directory).First();
if (debugMode)
{
Console.WriteLine($"Found runtime context for '{runtimeContext.ProjectFile.ProjectFilePath}'");
}
var projectExporter = runtimeContext.CreateExporter(config);
var runtimeDependencies = new HashSet <string>();
var projectDependencies = projectExporter.GetDependencies();
foreach (var projectDependency in projectDependencies)
{
var runtimeAssemblies = projectDependency.RuntimeAssemblyGroups;
foreach (var runtimeAssembly in runtimeAssemblies.GetDefaultAssets())
{
var runtimeAssemblyPath = runtimeAssembly.ResolvedPath;
if (debugMode)
{
Console.WriteLine($"Discovered runtime dependency for '{runtimeAssemblyPath}'");
}
runtimeDependencies.Add(runtimeAssemblyPath);
}
}
var code = File.ReadAllText(file);
var opts = ScriptOptions.Default.
AddImports(_namespaces).
AddReferences(_assemblies).
AddReferences(typeof(ScriptingHost).GetTypeInfo().Assembly).
WithSourceResolver(new RemoteFileResolver(directory));
var runtimeId = RuntimeEnvironment.GetRuntimeIdentifier();
var assemblyNames = DependencyContext.Default.GetRuntimeAssemblyNames(runtimeId).Where(x => x.FullName.ToLowerInvariant().StartsWith("system.") || x.FullName.ToLowerInvariant().StartsWith("mscorlib"));
foreach (var assemblyName in assemblyNames)
{
if (debugMode)
{
Console.WriteLine("Adding reference to a default dependency => " + assemblyName.FullName);
}
var assembly = Assembly.Load(assemblyName);
opts = opts.AddReferences(assembly);
}
foreach (var runtimeDep in runtimeDependencies)
{
if (debugMode)
{
Console.WriteLine("Adding reference to a runtime dependency => " + runtimeDep);
}
opts = opts.AddReferences(MetadataReference.CreateFromFile(runtimeDep));
}
var script = CSharpScript.Create(code, opts, typeof(ScriptingHost));
var compilation = script.GetCompilation();
var diagnostics = compilation.GetDiagnostics();
if (diagnostics.Any())
{
foreach (var diagnostic in diagnostics)
{
Console.Write("There is an error in the script.");
Console.WriteLine(diagnostic.GetMessage());
}
}
else
{
var host = new ScriptingHost
{
CurrentDirectory = directory,
CurrentScript = file,
ScriptArgs = scriptArgs
};
var scriptResult = script.RunAsync(host).Result;
if (scriptResult.Exception != null)
{
Console.Write("Script execution resulted in an exception.");
Console.WriteLine(scriptResult.Exception.Message);
Console.WriteLine(scriptResult.Exception.StackTrace);
}
}
}
public static void Main(string[] args)
{
var directory = args.Length == 0 ? Directory.GetCurrentDirectory() : Path.GetFullPath(args[0]);
// Pick the corret runtime id (based on something)
// Compile time context
var compileTimeContext = ProjectContext.CreateContextForEachFramework(directory).First();
Console.WriteLine($"TFM: {compileTimeContext.TargetFramework}");
var workspace = compileTimeContext.CreateWorkspace();
var projects = new Dictionary <string, ProjectId>();
foreach (var project in workspace.CurrentSolution.Projects)
{
// Projects have the name {name+tfm}
projects[project.AssemblyName] = project.Id;
}
// Runtime context
var runtimeContext = ProjectContext.CreateContextForEachTarget(directory).Last();
Console.WriteLine($"TFM + RID: {runtimeContext.TargetFramework} {runtimeContext.RuntimeIdentifier}");
var exporter = runtimeContext.CreateExporter("Debug");
var assemblies = new Dictionary <AssemblyName, string>(AssemblyNameComparer.OrdinalIgnoreCase);
var dllImports = new Dictionary <string, string>();
foreach (var export in exporter.GetAllExports())
{
if (export.Library is ProjectDescription)
{
continue;
}
// TODO: Handle resource assemblies
foreach (var asset in export.RuntimeAssemblies)
{
var assemblyName = new AssemblyName(asset.Name);
assemblies[assemblyName] = asset.ResolvedPath;
}
foreach (var asset in export.NativeLibraries)
{
dllImports[asset.Name] = asset.ResolvedPath;
}
}
var loadContext = new DynamicLoadContext(workspace, projects, dllImports);
// We need to force load all assemblies in the load context since we don't want
// things to transitively fall back to the default load context
foreach (var asm in assemblies)
{
try
{
// Force load the assemblies
loadContext.LoadFile(asm.Value);
}
catch
{
// It's in the TPA list
Console.WriteLine($"Failed to load assembly {asm.Key}. It's in the TPA list");
}
}
var assembly = loadContext.LoadFromAssemblyName(new AssemblyName(compileTimeContext.ProjectFile.Name));
if (assembly.EntryPoint != null)
{
assembly.EntryPoint.Invoke(null, new object[] { args.Skip(1).ToArray() });
}
}
public void Initalize(IConfiguration configuration)
{
var scriptHelper = new ScriptHelper(configuration);
_logger.LogInformation($"Detecting CSX files in '{_env.TargetDirectory}'.");
// Nothing to do if there are no CSX files
var allCsxFiles = Directory.GetFiles(_env.TargetDirectory, "*.csx", SearchOption.AllDirectories);
if (allCsxFiles.Length == 0)
{
_logger.LogInformation("Could not find any CSX files");
return;
}
_logger.LogInformation($"Found {allCsxFiles.Length} CSX files.");
// explicitly inherit scripting library references to all global script object (CommandLineScriptGlobals) to be recognized
var inheritedCompileLibraries = DependencyContext.Default.CompileLibraries.Where(x =>
x.Name.ToLowerInvariant().StartsWith("microsoft.codeanalysis")).ToList();
// explicitly include System.ValueTuple
inheritedCompileLibraries.AddRange(DependencyContext.Default.CompileLibraries.Where(x =>
x.Name.ToLowerInvariant().StartsWith("system.valuetuple")));
var runtimeContexts = File.Exists(Path.Combine(_env.TargetDirectory, "project.json")) ? ProjectContext.CreateContextForEachTarget(_env.TargetDirectory) : null;
if (!bool.TryParse(configuration["enableScriptNuGetReferences"], out var enableScriptNuGetReferences))
{
enableScriptNuGetReferences = false;
}
if (enableScriptNuGetReferences && (runtimeContexts == null || runtimeContexts.Any() == false))
{
runtimeContexts = TryCreateRuntimeContextsFromScriptFiles();
}
var runtimeContext = runtimeContexts?.FirstOrDefault();
var commonReferences = new HashSet <MetadataReference>();
// if we have no context, then we also have no dependencies
// we will assume desktop framework
// and add default CLR references
// same applies for having a context that is not a .NET Core app
AddDefaultClrMetadataReferences(runtimeContext, commonReferences);
if (runtimeContext == null)
{
_logger.LogInformation("Unable to find project context for CSX files. Will default to non-context usage (Destkop CLR scripts).");
}
// otherwise we will grab dependencies for the script from the runtime context
else
{
// assume the first one
_logger.LogInformation($"Found script runtime context '{runtimeContext.TargetFramework.Framework}' for '{runtimeContext.ProjectFile.ProjectFilePath}'.");
var projectExporter = runtimeContext.CreateExporter("Release");
var projectDependencies = projectExporter.GetDependencies();
// let's inject all compilation assemblies needed
var compilationAssemblies = projectDependencies.SelectMany(x => x.CompilationAssemblies);
foreach (var compilationAssembly in compilationAssemblies)
{
_logger.LogDebug("Discovered script compilation assembly reference: " + compilationAssembly.ResolvedPath);
AddMetadataReference(commonReferences, compilationAssembly.ResolvedPath);
}
}
// inject all inherited assemblies
foreach (var inheritedCompileLib in inheritedCompileLibraries.SelectMany(x => x.ResolveReferencePaths()))
{
_logger.LogDebug("Adding implicit reference: " + inheritedCompileLib);
AddMetadataReference(commonReferences, inheritedCompileLib);
}
// Each .CSX file becomes an entry point for it's own project
// Every #loaded file will be part of the project too
foreach (var csxPath in allCsxFiles)
{
try
{
var csxFileName = Path.GetFileName(csxPath);
var project = scriptHelper.CreateProject(csxFileName, commonReferences);
// add CSX project to workspace
_workspace.AddProject(project);
_workspace.AddDocument(project.Id, csxPath, SourceCodeKind.Script);
_projects[csxPath] = project;
_logger.LogInformation($"Added CSX project '{csxPath}' to the workspace.");
}
catch (Exception ex)
{
_logger.LogError(ex, $"{csxPath} will be ignored due to an following error");
}
}
}
public ScriptCompilationContext <TReturn> CreateCompilationContext <TReturn, THost>(ScriptContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var runtimeContext = ProjectContext.CreateContextForEachTarget(context.WorkingDirectory).First();
_logger.Verbose($"Found runtime context for '{runtimeContext.ProjectFile.ProjectFilePath}'");
var projectExporter = runtimeContext.CreateExporter(context.Configuration);
var runtimeDependencies = new HashSet <string>();
var projectDependencies = projectExporter.GetDependencies();
foreach (var projectDependency in projectDependencies)
{
var runtimeAssemblies = projectDependency.RuntimeAssemblyGroups;
foreach (var runtimeAssembly in runtimeAssemblies.GetDefaultAssets())
{
var runtimeAssemblyPath = runtimeAssembly.ResolvedPath;
_logger.Verbose($"Discovered runtime dependency for '{runtimeAssemblyPath}'");
runtimeDependencies.Add(runtimeAssemblyPath);
}
}
var opts = ScriptOptions.Default.
AddImports(DefaultNamespaces).
AddReferences(DefaultAssemblies).
WithSourceResolver(new RemoteFileResolver(context.WorkingDirectory));
if (!string.IsNullOrWhiteSpace(context.FilePath))
{
opts = opts.WithFilePath(context.FilePath);
}
var runtimeId = RuntimeEnvironment.GetRuntimeIdentifier();
var inheritedAssemblyNames = DependencyContext.Default.GetRuntimeAssemblyNames(runtimeId).Where(x =>
x.FullName.ToLowerInvariant().StartsWith("system.") ||
x.FullName.ToLowerInvariant().StartsWith("microsoft.codeanalysis") ||
x.FullName.ToLowerInvariant().StartsWith("mscorlib"));
foreach (var inheritedAssemblyName in inheritedAssemblyNames)
{
_logger.Verbose("Adding reference to an inherited dependency => " + inheritedAssemblyName.FullName);
var assembly = Assembly.Load(inheritedAssemblyName);
opts = opts.AddReferences(assembly);
}
foreach (var runtimeDep in runtimeDependencies)
{
_logger.Verbose("Adding reference to a runtime dependency => " + runtimeDep);
opts = opts.AddReferences(MetadataReference.CreateFromFile(runtimeDep));
}
var loader = new InteractiveAssemblyLoader();
var script = CSharpScript.Create <TReturn>(context.Code.ToString(), opts, typeof(THost), loader);
var compilation = script.GetCompilation();
var diagnostics = compilation.GetDiagnostics();
if (diagnostics.Any(d => d.Severity == DiagnosticSeverity.Error))
{
foreach (var diagnostic in diagnostics)
{
_logger.Log(diagnostic.ToString());
}
throw new CompilationErrorException("Script compilation failed due to one or more errors.",
diagnostics);
}
return(new ScriptCompilationContext <TReturn>(script, context.Code, loader));
}
public virtual ScriptCompilationContext <TReturn> CreateCompilationContext <TReturn, THost>(ScriptContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var runtimeContext = ProjectContext.CreateContextForEachTarget(context.WorkingDirectory).First();
var runtimeIdentitfer = GetRuntimeIdentitifer();
_logger.Verbose($"Current runtime is '{runtimeIdentitfer}'.");
_logger.Verbose($"Found runtime context for '{runtimeContext.ProjectFile.ProjectFilePath}'.");
var projectExporter = runtimeContext.CreateExporter(context.Configuration);
var runtimeDependencies = new HashSet <string>();
var projectDependencies = projectExporter.GetDependencies();
foreach (var projectDependency in projectDependencies)
{
var runtimeAssemblyGroups = projectDependency.RuntimeAssemblyGroups;
foreach (var libraryAsset in runtimeAssemblyGroups.GetDefaultAssets())
{
var runtimeAssemblyPath = libraryAsset.ResolvedPath;
_logger.Verbose($"Discovered runtime dependency for '{runtimeAssemblyPath}'");
runtimeDependencies.Add(runtimeAssemblyPath);
}
foreach (var runtimeAssemblyGroup in runtimeAssemblyGroups)
{
if (!string.IsNullOrWhiteSpace(runtimeAssemblyGroup.Runtime) && runtimeAssemblyGroup.Runtime == runtimeIdentitfer)
{
foreach (var runtimeAsset in runtimeAssemblyGroups.GetRuntimeAssets(GetRuntimeIdentitifer()))
{
var runtimeAssetPath = runtimeAsset.ResolvedPath;
_logger.Verbose($"Discovered runtime asset dependency ('{runtimeIdentitfer}') for '{runtimeAssetPath}'");
runtimeDependencies.Add(runtimeAssetPath);
}
}
}
}
var opts = CreateScriptOptions(context);
var runtimeId = RuntimeEnvironment.GetRuntimeIdentifier();
var inheritedAssemblyNames = DependencyContext.Default.GetRuntimeAssemblyNames(runtimeId).Where(x =>
x.FullName.StartsWith("system.", StringComparison.OrdinalIgnoreCase) ||
x.FullName.StartsWith("microsoft.codeanalysis", StringComparison.OrdinalIgnoreCase) ||
x.FullName.StartsWith("mscorlib", StringComparison.OrdinalIgnoreCase));
foreach (var inheritedAssemblyName in inheritedAssemblyNames)
{
_logger.Verbose("Adding reference to an inherited dependency => " + inheritedAssemblyName.FullName);
var assembly = Assembly.Load(inheritedAssemblyName);
opts = opts.AddReferences(assembly);
}
foreach (var runtimeDep in runtimeDependencies)
{
_logger.Verbose("Adding reference to a runtime dependency => " + runtimeDep);
opts = opts.AddReferences(MetadataReference.CreateFromFile(runtimeDep));
}
var loader = new InteractiveAssemblyLoader();
var script = CSharpScript.Create <TReturn>(context.Code.ToString(), opts, typeof(THost), loader);
var compilation = script.GetCompilation();
var diagnostics = compilation.GetDiagnostics();
var orderedDiagnostics = diagnostics.OrderBy((d1, d2) =>
{
var severityDiff = (int)d2.Severity - (int)d1.Severity;
return(severityDiff != 0 ? severityDiff : d1.Location.SourceSpan.Start - d2.Location.SourceSpan.Start);
});
if (orderedDiagnostics.Any(d => d.Severity == DiagnosticSeverity.Error))
{
foreach (var diagnostic in orderedDiagnostics)
{
_logger.Log(diagnostic.ToString());
}
throw new CompilationErrorException("Script compilation failed due to one or more errors.",
orderedDiagnostics.ToImmutableArray());
}
return(new ScriptCompilationContext <TReturn>(script, context.Code, loader));
}
