private static ScriptCompiler GetScriptCompiler(bool useRestoreCache, LogFactory logFactory)
{
var runtimeDependencyResolver = new RuntimeDependencyResolver(logFactory, useRestoreCache);
var compiler = new ScriptCompiler(logFactory, runtimeDependencyResolver);
return(compiler);
}
private static ScriptCompiler GetScriptCompiler(bool debugMode, LogFactory logFactory)
{
var runtimeDependencyResolver = new RuntimeDependencyResolver(logFactory);
var compiler = new ScriptCompiler(logFactory, runtimeDependencyResolver);
return(compiler);
}
public static async System.Threading.Tasks.Task RundotNetScript(string[] args, IStaticSite ctx)
{
var logger = new ScriptLogger(ScriptConsole.Default.Out, true);
var dependencyResolver = new RuntimeDependencyResolver(type => ((level, message) =>
{
if (level == LogLevel.Debug)
{
logger.Verbose(message);
}
if (level == LogLevel.Info)
{
logger.Log(message);
}
}));
var code = Microsoft.CodeAnalysis.Text.SourceText.From(File.ReadAllText("FlipLeaf.csx"));
var scriptContext = new ScriptContext(code, Environment.CurrentDirectory ?? Directory.GetCurrentDirectory(), args, scriptMode: Dotnet.Script.DependencyModel.Context.ScriptMode.REPL);
var compiler = new ScriptCompiler(logger, dependencyResolver);
var runner = new ScriptRunner(compiler, logger, ScriptConsole.Default);
await runner.Execute <int>(scriptContext);
}
private InteractiveTestContext GetRunner(string[] commands)
{
var reader = new StringReader(string.Join(Environment.NewLine, commands));
var writer = new StringWriter();
var error = new StringWriter();
var console = new ScriptConsole(writer, reader, error);
var logger = new ScriptLogger(console.Error, true);
var runtimeDependencyResolver = new RuntimeDependencyResolver(type => ((level, message) =>
{
if (level == LogLevel.Debug)
{
logger.Verbose(message);
}
if (level == LogLevel.Info)
{
logger.Log(message);
}
}));
var compiler = new ScriptCompiler(logger, runtimeDependencyResolver);
var runner = new InteractiveRunner(compiler, logger, console);
return(new InteractiveTestContext(console, runner));
}
public virtual ScriptCompilationContext <TReturn> CreateCompilationContext <TReturn, THost>(ScriptContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var platformIdentifier = RuntimeHelper.GetPlatformIdentifier();
Logger.Verbose($"Current runtime is '{platformIdentifier}'.");
var opts = CreateScriptOptions(context);
var runtimeId = RuntimeHelper.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)).ToArray();
IList <RuntimeDependency> runtimeDependencies =
RuntimeDependencyResolver.GetDependencies(context.WorkingDirectory).ToList();
foreach (var runtimeDependency in runtimeDependencies)
{
Logger.Verbose("Adding reference to a runtime dependency => " + runtimeDependency);
opts = opts.AddReferences(MetadataReference.CreateFromFile(runtimeDependency.Path));
}
foreach (var inheritedAssemblyName in inheritedAssemblyNames)
{
Logger.Verbose("Adding reference to an inherited dependency => " + inheritedAssemblyName.FullName);
// Always prefer the resolved runtime dependency rather than the inherited assembly.
if (runtimeDependencies.All(rd => rd.Name.Name != inheritedAssemblyName.Name))
{
var assembly = Assembly.Load(inheritedAssemblyName);
opts = opts.AddReferences(assembly);
}
}
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, opts));
}
private RuntimeDependency[] GetRuntimeDependencies(ScriptContext context)
{
if (context.ScriptMode == ScriptMode.Script)
{
return(RuntimeDependencyResolver.GetDependencies(context.FilePath, context.PackageSources).ToArray());
}
else
{
return(RuntimeDependencyResolver.GetDependencies(context.WorkingDirectory, context.ScriptMode, context.PackageSources, context.Code.ToString()).ToArray());
}
}
private ScriptCompiler(LogFactory logFactory, RuntimeDependencyResolver runtimeDependencyResolver)
{
_logger = logFactory(typeof(ScriptCompiler));
_scriptEnvironment = ScriptEnvironment.Default;
RuntimeDependencyResolver = runtimeDependencyResolver;
// nullable diagnostic options should be set to errors
for (var i = 8600; i <= 8655; i++)
{
SpecificDiagnosticOptions.Add($"CS{i}", ReportDiagnostic.Error);
}
}
private InteractiveTestContext GetRunner(string[] commands)
{
var reader = new StringReader(string.Join(Environment.NewLine, commands));
var writer = new StringWriter();
var error = new StringWriter();
var console = new ScriptConsole(writer, reader, error);
var logFactory = TestOutputHelper.CreateTestLogFactory();
var runtimeDependencyResolver = new RuntimeDependencyResolver(logFactory, useRestoreCache: false);
var compiler = new ScriptCompiler(logFactory, runtimeDependencyResolver);
var runner = new InteractiveRunner(compiler, logFactory, console, Array.Empty <string>());
return(new InteractiveTestContext(console, runner));
}
private static ScriptCompiler GetScriptCompiler(bool debugMode)
{
var logger = new ScriptLogger(ScriptConsole.Default.Error, debugMode);
var runtimeDependencyResolver = new RuntimeDependencyResolver(type => ((level, message) =>
{
if (level == LogLevel.Debug)
{
logger.Verbose(message);
}
if (level == LogLevel.Info)
{
logger.Log(message);
}
}));
var compiler = new ScriptCompiler(logger, runtimeDependencyResolver);
return(compiler);
}
private ScriptCompiler GetScriptCompiler()
{
var logger = new ScriptLogger(ScriptConsole.Default.Error, LogVerbosityDebug);
var runtimeDependencyResolver = new RuntimeDependencyResolver(type => ((level, message) =>
{
switch (level)
{
case LogLevel.Debug:
logger.Verbose(message);
break;
case LogLevel.Info:
logger.Log(message);
break;
}
}));
var compiler = new ScriptCompiler(logger, runtimeDependencyResolver);
return(compiler);
}
public InteractiveScriptEngine(string currentDir, ILogger logger)
{
_currentDirectory = currentDir;
_logger = logger;
_scriptOptions = CreateScriptOptions();
var referencesFile = RefsFilePath;
if (!string.IsNullOrEmpty(referencesFile) && File.Exists(referencesFile))
{
_references = File.ReadAllLines(referencesFile, Encoding.UTF8);
}
_runtimeDependencyResolver = new RuntimeDependencyResolver((t) => (level, m, e) =>
{
logger.Log(MapLogLevel(level), m, e);
}, true);
_interactiveOutput = new StringBuilder();
_globals = new InteractiveScriptGlobals(new StringWriter(_interactiveOutput), CSharpObjectFormatter.Instance);
}
public virtual ScriptCompilationContext <TReturn> CreateCompilationContext <TReturn, THost>(ScriptContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
Logger.Verbose($"Current runtime is '{RuntimeHelper.GetPlatformIdentifier()}'.");
var runtimeDependencies = RuntimeDependencyResolver.GetDependencies(context.WorkingDirectory, context.ScriptMode, context.Code.ToString()).ToArray();
var scriptOptions = CreateScriptOptions(context, runtimeDependencies.ToList());
var loadedAssembliesMap = CreateLoadedAssembliesMap();
var scriptDependenciesMap = CreateScriptDependenciesMap(runtimeDependencies);
scriptOptions = AddScriptReferences(scriptOptions, loadedAssembliesMap, scriptDependenciesMap);
LoadNativeAssets(runtimeDependencies);
AppDomain.CurrentDomain.AssemblyResolve +=
(sender, args) => MapUnresolvedAssemblyToRuntimeLibrary(scriptDependenciesMap, loadedAssembliesMap, args);
string code = GetScriptCode(context);
var loader = new InteractiveAssemblyLoader();
var script = CSharpScript.Create <TReturn>(code, scriptOptions, typeof(THost), loader);
SetOptimizationLevel(context, script);
EvaluateDiagnostics(script);
return(new ScriptCompilationContext <TReturn>(script, context.Code, loader, scriptOptions));
}
public ScriptCompiler(LogFactory logFactory, RuntimeDependencyResolver runtimeDependencyResolver)
{
_logger = logFactory(typeof(ScriptCompiler));
_scriptEnvironment = ScriptEnvironment.Default;
RuntimeDependencyResolver = runtimeDependencyResolver;
}
private RuntimeDependencyResolver CreateRuntimeDependencyResolver()
{
var resolver = new RuntimeDependencyResolver(TestOutputHelper.CreateTestLogFactory(), useRestoreCache: false);
return(resolver);
}
public ScriptCompiler(ScriptLogger logger, RuntimeDependencyResolver runtimeDependencyResolver)
{
Logger = logger;
RuntimeDependencyResolver = runtimeDependencyResolver;
_scriptEnvironment = ScriptEnvironment.Default;
}
public virtual ScriptCompilationContext <TReturn> CreateCompilationContext <TReturn, THost>(ScriptContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var platformIdentifier = RuntimeHelper.GetPlatformIdentifier();
Logger.Verbose($"Current runtime is '{platformIdentifier}'.");
var runtimeDependencies = RuntimeDependencyResolver.GetDependencies(context.WorkingDirectory, context.ScriptMode, context.Code.ToString()).ToArray();
var opts = CreateScriptOptions(context, runtimeDependencies.ToList());
var runtimeId = RuntimeHelper.GetRuntimeIdentifier();
var inheritedAssemblyNames = DependencyContext.Default.GetRuntimeAssemblyNames(runtimeId).Where(x =>
x.FullName.StartsWith("microsoft.codeanalysis", StringComparison.OrdinalIgnoreCase)).ToArray();
// Build up a dependency map that picks runtime assembly with the highest version.
// This aligns with the CoreCLR that uses the highest version strategy.
var dependencyMap = runtimeDependencies.SelectMany(rtd => rtd.Assemblies).Distinct().GroupBy(rdt => rdt.Name.Name, rdt => rdt)
.Select(gr => new { Name = gr.Key, ResolvedRuntimeAssembly = gr.OrderBy(rdt => rdt.Name.Version).Last() })
.ToDictionary(f => f.Name, f => f.ResolvedRuntimeAssembly, StringComparer.OrdinalIgnoreCase);
foreach (var runtimeAssembly in dependencyMap.Values)
{
Logger.Verbose("Adding reference to a runtime dependency => " + runtimeAssembly);
opts = opts.AddReferences(MetadataReference.CreateFromFile(runtimeAssembly.Path));
}
foreach (var nativeAsset in runtimeDependencies.SelectMany(rtd => rtd.NativeAssets).Distinct())
{
if (RuntimeHelper.IsWindows())
{
LoadLibrary(nativeAsset);
}
}
foreach (var inheritedAssemblyName in inheritedAssemblyNames)
{
// Always prefer the resolved runtime dependency rather than the inherited assembly.
if (!dependencyMap.ContainsKey(inheritedAssemblyName.Name))
{
Logger.Verbose($"Adding reference to an inherited dependency => {inheritedAssemblyName.FullName}");
var assembly = Assembly.Load(inheritedAssemblyName);
opts = opts.AddReferences(assembly);
}
}
AssemblyLoadContext.Default.Resolving +=
(assemblyLoadContext, assemblyName) => MapUnresolvedAssemblyToRuntimeLibrary(dependencyMap, assemblyLoadContext, assemblyName);
// when processing raw code, make sure we inject new lines after preprocessor directives
string code;
if (context.FilePath == null)
{
var syntaxTree = CSharpSyntaxTree.ParseText(context.Code, ParseOptions);
var syntaxRewriter = new PreprocessorLineRewriter();
var newSyntaxTree = syntaxRewriter.Visit(syntaxTree.GetRoot());
code = newSyntaxTree.ToFullString();
}
else
{
code = context.Code.ToString();
}
var loader = new InteractiveAssemblyLoader();
var script = CSharpScript.Create <TReturn>(code, opts, typeof(THost), loader);
var orderedDiagnostics = script.GetDiagnostics(SuppressedDiagnosticIds);
if (orderedDiagnostics.Any(d => d.Severity == DiagnosticSeverity.Error))
{
throw new CompilationErrorException("Script compilation failed due to one or more errors.",
orderedDiagnostics.ToImmutableArray());
}
return(new ScriptCompilationContext <TReturn>(script, context.Code, loader, opts));
}
public ScriptCompiler(ScriptLogger logger, RuntimeDependencyResolver runtimeDependencyResolver)
{
Logger = logger;
RuntimeDependencyResolver = runtimeDependencyResolver;
}
