/// <summary>
/// Runs AST conversion on the given target path.
/// </summary>
/// <remarks>
/// The target path is assumed to already be part of the workspace contained by the given host
/// </remarks>
public static Task <SourceFileParseResult> RunAstConversionAsync(FrontEndHost host, FrontEndContext context, Script.Tracing.Logger logger, IFrontEndStatistics stats, Package package, AbsolutePath conversionTarget)
{
Contract.RequiresNotNull(host);
Contract.RequiresNotNull(context);
Contract.RequiresNotNull(logger);
Contract.RequiresNotNull(stats);
Contract.RequiresNotNull(package);
Contract.Requires(conversionTarget.IsValid);
var configuration = AstConversionConfiguration.FromConfiguration(host.Configuration.FrontEnd);
var linter = DiagnosticAnalyzer.Create(
logger,
context.LoggingContext,
new HashSet <string>(configuration.PolicyRules),
configuration.DisableLanguagePolicies);
var workspace = (Workspace)host.Workspace;
var factory = new RuntimeModelFactory(stats, configuration, linter, workspace);
var parserContext = new RuntimeModelContext(
host,
frontEndContext: context,
logger,
package: package,
origin: default(LocationData));
var sourceFile = workspace.GetSourceFile(conversionTarget);
return(factory.ConvertSourceFileAsync(parserContext, sourceFile));
}
/// <nodoc/>
public PipConstructor(
FrontEndContext context,
FrontEndHost frontEndHost,
ModuleDefinition moduleDefinition,
IMsBuildResolverSettings resolverSettings,
AbsolutePath pathToMsBuild,
AbsolutePath pathToDotnetExe,
string frontEndName,
IEnumerable <KeyValuePair <string, string> > userDefinedEnvironment,
IEnumerable <string> userDefinedPassthroughVariables)
{
Contract.Requires(context != null);
Contract.Requires(frontEndHost != null);
Contract.Requires(moduleDefinition != null);
Contract.Requires(resolverSettings != null);
Contract.Requires(pathToMsBuild.IsValid);
Contract.Requires(!resolverSettings.ShouldRunDotNetCoreMSBuild() || pathToDotnetExe.IsValid);
Contract.Requires(!string.IsNullOrEmpty(frontEndName));
Contract.Requires(userDefinedEnvironment != null);
Contract.Requires(userDefinedPassthroughVariables != null);
m_context = context;
m_frontEndHost = frontEndHost;
m_moduleDefinition = moduleDefinition;
m_resolverSettings = resolverSettings;
m_msBuildPath = pathToMsBuild;
m_dotnetExePath = pathToDotnetExe;
m_frontEndName = frontEndName;
m_userDefinedEnvironment = userDefinedEnvironment;
m_userDefinedPassthroughVariables = userDefinedPassthroughVariables;
}
/// <inheritdoc />
public bool TryInitialize([NotNull] FrontEndHost host, [NotNull] FrontEndContext context, [NotNull] IConfiguration configuration, [NotNull] IResolverSettings resolverSettings)
{
Contract.Requires(context != null);
Contract.Requires(host != null);
Contract.Requires(configuration != null);
Contract.Requires(resolverSettings != null);
var settings = resolverSettings as IDownloadResolverSettings;
Contract.Assert(settings != null);
m_context = context;
Name = resolverSettings.Name;
var resolverFolder = host.GetFolderForFrontEnd(resolverSettings.Name ?? Kind);
var downloads = new Dictionary <string, DownloadData>(StringComparer.Ordinal);
foreach (var downloadSettings in settings.Downloads)
{
if (!ValidateAndExtractDownloadData(context, downloadSettings, downloads, resolverFolder, out var downloadData))
{
return(false);
}
downloads.Add(downloadSettings.ModuleName, downloadData);
UpdateDataForDownloadData(downloadData);
}
Downloads = downloads;
return(true);
}
private async Task <Possible <Unit> > GenerateBuildDirectoryAsync()
{
Contract.Assert(m_buildDirectory.IsValid);
AbsolutePath outputDirectory = FrontEndHost.GetFolderForFrontEnd(m_frontEnd.Name);
AbsolutePath argumentsFile = outputDirectory.Combine(Context.PathTable, Guid.NewGuid().ToString());
if (!TryRetrieveCMakeSearchLocations(out IEnumerable <AbsolutePath> searchLocations))
{
return(new CMakeGenerationError(m_resolverSettings.ModuleName, m_buildDirectory.ToString(Context.PathTable)));
}
SandboxedProcessResult result = await ExecuteCMakeRunner(argumentsFile, searchLocations);
string standardError = result.StandardError.CreateReader().ReadToEndAsync().GetAwaiter().GetResult();
if (result.ExitCode != 0)
{
if (!Context.CancellationToken.IsCancellationRequested)
{
Tracing.Logger.Log.CMakeRunnerInternalError(
Context.LoggingContext,
m_resolverSettings.Location(Context.PathTable),
standardError);
}
return(new CMakeGenerationError(m_resolverSettings.ModuleName, m_buildDirectory.ToString(Context.PathTable)));
}
FrontEndUtilities.TrackToolFileAccesses(Engine, Context, m_frontEnd.Name, result.AllUnexpectedFileAccesses, outputDirectory);
return(Possible.Create(Unit.Void));
}
/// <inheritdoc/>
public override bool TryInitialize(FrontEndHost host, FrontEndContext context, IConfiguration configuration, IResolverSettings resolverSettings)
{
var success = base.TryInitialize(host, context, configuration, resolverSettings);
if (!success)
{
return(false);
}
if (!JavaScriptCommandsInterpreter.TryComputeAndValidateCommands(
m_context.LoggingContext,
resolverSettings.Location(m_context.PathTable),
((IJavaScriptResolverSettings)resolverSettings).Execute,
out IReadOnlyDictionary <string, IReadOnlyList <IJavaScriptCommandDependency> > computedCommands))
{
// Error has been logged
return(false);
}
m_computedCommands = computedCommands;
ExportsFile = m_resolverSettings.Root.Combine(m_context.PathTable, "exports.dsc");
AllProjectsSymbol = FullSymbol.Create(m_context.SymbolTable, "all");
return(true);
}
/// <nodoc/>
public JavaScriptPipConstructor(
FrontEndContext context,
FrontEndHost frontEndHost,
ModuleDefinition moduleDefinition,
IJavaScriptResolverSettings resolverSettings,
IEnumerable <KeyValuePair <string, string> > userDefinedEnvironment,
IEnumerable <string> userDefinedPassthroughVariables,
IReadOnlyDictionary <string, IReadOnlyList <JavaScriptArgument> > customCommands,
IEnumerable <JavaScriptProject> allProjectsToBuild)
{
Contract.RequiresNotNull(context);
Contract.RequiresNotNull(frontEndHost);
Contract.RequiresNotNull(moduleDefinition);
Contract.RequiresNotNull(resolverSettings);
Contract.RequiresNotNull(userDefinedEnvironment);
Contract.RequiresNotNull(userDefinedPassthroughVariables);
Contract.RequiresNotNull(customCommands);
Contract.RequiresNotNull(allProjectsToBuild);
m_context = context;
m_frontEndHost = frontEndHost;
m_moduleDefinition = moduleDefinition;
m_resolverSettings = resolverSettings;
m_userDefinedEnvironment = userDefinedEnvironment;
m_userDefinedPassthroughVariables = userDefinedPassthroughVariables;
m_customCommands = customCommands;
m_allProjectRoots = allProjectsToBuild.Select(project => project.ProjectFolder);
}
protected abstract IProjectToPipConstructor <TProject> CreateProjectToPipConstructor(
FrontEndContext context,
FrontEndHost frontEndHost,
ModuleDefinition moduleDefinition,
TResolverSettings resolverSettings,
IEnumerable <KeyValuePair <string, string> > userDefinedEnvironment,
IEnumerable <string> userDefinedPassthroughVariables);
public NinjaPipConstructor(FrontEndContext context, FrontEndHost frontEndHost, string frontEndName, ModuleDefinition moduleDefinition, QualifierId qualifierId, AbsolutePath projectRoot, AbsolutePath specPath, bool suppressDebugFlags, IUntrackingSettings untrackingSettings)
{
Contract.Requires(context != null);
Contract.Requires(frontEndHost != null);
Contract.Requires(moduleDefinition != null);
Contract.Requires(projectRoot.IsValid);
Contract.Requires(specPath.IsValid);
m_context = context;
m_frontEndHost = frontEndHost;
m_moduleDefinition = moduleDefinition;
m_projectRoot = projectRoot;
m_specPath = specPath;
m_suppressDebugFlags = suppressDebugFlags;
m_untrackingSettings = untrackingSettings;
m_pipConstructionHelper = GetPipConstructionHelperForModule(m_projectRoot, moduleDefinition, qualifierId);
m_frontEndName = frontEndName;
m_manuallyDroppedDependenciesPath = Lazy.Create(() => m_frontEndHost.Configuration.Layout.BuildEngineDirectory
.Combine(m_context.PathTable, RelativePath.Create(m_context.StringTable, @"tools\CMakeNinjaPipEnvironment")));
// Lazy initialization of environment variables and passthroughs
var allEnvironmentVariables = Lazy.Create(GetAllEnvironmentVariables);
m_environmentVariables = Lazy.Create(() => allEnvironmentVariables.Value.Where(kvp => SpecialEnvironmentVariables.PassThroughPrefixes.All(prefix => !kvp.Key.StartsWith(prefix))));
m_passThroughEnvironmentVariables = Lazy.Create(() => allEnvironmentVariables.Value.Where(kvp => SpecialEnvironmentVariables.PassThroughPrefixes.Any(prefix => kvp.Key.StartsWith(prefix))));
}
/// <nodoc/>
public RushPipConstructor(
FrontEndContext context,
FrontEndHost frontEndHost,
ModuleDefinition moduleDefinition,
RushConfiguration rushConfiguration,
IRushResolverSettings resolverSettings,
IEnumerable <KeyValuePair <string, string> > userDefinedEnvironment,
IEnumerable <string> userDefinedPassthroughVariables,
IReadOnlyDictionary <string, IReadOnlyList <RushArgument> > customCommands)
{
Contract.RequiresNotNull(context);
Contract.RequiresNotNull(frontEndHost);
Contract.RequiresNotNull(moduleDefinition);
Contract.RequiresNotNull(resolverSettings);
Contract.RequiresNotNull(userDefinedEnvironment);
Contract.RequiresNotNull(userDefinedPassthroughVariables);
Contract.RequiresNotNull(customCommands);
m_context = context;
m_frontEndHost = frontEndHost;
m_moduleDefinition = moduleDefinition;
m_rushConfiguration = rushConfiguration;
m_resolverSettings = resolverSettings;
m_userDefinedEnvironment = userDefinedEnvironment;
m_userDefinedPassthroughVariables = userDefinedPassthroughVariables;
m_customCommands = customCommands;
}
public NinjaPipConstructor(FrontEndContext context,
FrontEndHost frontEndHost,
string frontEndName,
ModuleDefinition moduleDefinition,
QualifierId qualifierId,
AbsolutePath projectRoot,
AbsolutePath specPath, bool suppressDebugFlags,
IEnumerable <KeyValuePair <string, string> > userDefinedEnvironment,
IEnumerable <string> userDefinedPassthroughVariables,
IUntrackingSettings untrackingSettings)
{
Contract.Requires(context != null);
Contract.Requires(frontEndHost != null);
Contract.Requires(moduleDefinition != null);
Contract.Requires(projectRoot.IsValid);
Contract.Requires(specPath.IsValid);
m_context = context;
m_frontEndHost = frontEndHost;
m_moduleDefinition = moduleDefinition;
m_projectRoot = projectRoot;
m_specPath = specPath;
m_suppressDebugFlags = suppressDebugFlags;
m_untrackingSettings = untrackingSettings;
m_pipConstructionHelper = GetPipConstructionHelperForModule(m_projectRoot, moduleDefinition, qualifierId);
m_frontEndName = frontEndName;
m_manuallyDroppedDependenciesPath = m_frontEndHost.Configuration.Layout.BuildEngineDirectory
.Combine(m_context.PathTable, RelativePath.Create(m_context.StringTable, @"tools\CMakeNinjaPipEnvironment"));
PrepareEnvironment(userDefinedEnvironment, userDefinedPassthroughVariables, out m_userDefinedEnvironment, out m_userDefinedPassthroughVariables);
}
private async Task <Possible <ProjectGraphResult> > TryComputeBuildGraphAsync(IEnumerable <AbsolutePath> searchLocations, IEnumerable <AbsolutePath> parsingEntryPoints, BuildParameters.IBuildParameters buildParameters)
{
// We create a unique output file on the obj folder associated with the current front end, and using a GUID as the file name
AbsolutePath outputDirectory = FrontEndHost.GetFolderForFrontEnd(MsBuildFrontEnd.Name);
AbsolutePath outputFile = outputDirectory.Combine(Context.PathTable, Guid.NewGuid().ToString());
// We create a unique response file that will contain the tool arguments
AbsolutePath responseFile = outputDirectory.Combine(Context.PathTable, Guid.NewGuid().ToString());
// Make sure the directories are there
FileUtilities.CreateDirectory(outputDirectory.ToString(Context.PathTable));
Possible <ProjectGraphWithPredictionsResult <AbsolutePath> > maybeProjectGraphResult = await ComputeBuildGraphAsync(responseFile, parsingEntryPoints, outputFile, searchLocations, buildParameters);
if (!maybeProjectGraphResult.Succeeded)
{
// A more specific error has been logged already
return(maybeProjectGraphResult.Failure);
}
var projectGraphResult = maybeProjectGraphResult.Result;
if (m_resolverSettings.KeepProjectGraphFile != true)
{
DeleteGraphBuilderRelatedFiles(outputFile, responseFile);
}
else
{
// Graph-related files are requested to be left on disk. Let's print a message with their location.
Tracing.Logger.Log.GraphBuilderFilesAreNotRemoved(Context.LoggingContext, outputFile.ToString(Context.PathTable), responseFile.ToString(Context.PathTable));
}
if (!projectGraphResult.Succeeded)
{
var failure = projectGraphResult.Failure;
Tracing.Logger.Log.ProjectGraphConstructionError(Context.LoggingContext, failure.HasLocation ? failure.Location : m_resolverSettings.Location(Context.PathTable), failure.Message);
return(new MsBuildGraphConstructionFailure(m_resolverSettings, Context.PathTable));
}
ProjectGraphWithPredictions <AbsolutePath> projectGraph = projectGraphResult.Result;
// The module contains all project files that are part of the graph
var projectFiles = new HashSet <AbsolutePath>();
foreach (ProjectWithPredictions <AbsolutePath> node in projectGraph.ProjectNodes)
{
projectFiles.Add(node.FullPath);
}
var moduleDescriptor = ModuleDescriptor.CreateWithUniqueId(m_resolverSettings.ModuleName, this);
var moduleDefinition = ModuleDefinition.CreateModuleDefinitionWithImplicitReferences(
moduleDescriptor,
m_resolverSettings.RootTraversal,
m_resolverSettings.File,
projectFiles,
allowedModuleDependencies: null, // no module policies
cyclicalFriendModules: null); // no whitelist of cycles
return(new ProjectGraphResult(projectGraph, moduleDefinition, projectGraphResult.PathToMsBuildExe));
}
/// <inheritdoc />
void IConfigurationProcessor.Initialize(FrontEndHost host, FrontEndContext context)
{
Contract.Requires(host != null);
Contract.Requires(context != null);
InitializeInterpreter(host, context, new ConfigurationImpl());
}
/// <nodoc/>
public virtual void InitializeInterpreter(FrontEndHost host, FrontEndContext context, IConfiguration configuration)
{
FrontEndHost = host;
Context = context;
m_configuration = configuration;
EmptyQualifier = QualifierValue.CreateEmpty(context.QualifierTable);
IsBeingDebugged = configuration.FrontEnd.DebugScript();
}
protected DScriptInterpreterBase(IFrontEndStatistics statistics, Logger logger,
FrontEndHost host, FrontEndContext context, IConfiguration configuration)
: this(statistics, logger)
{
// ReSharper disable once VirtualMemberCallInConstructor
// The call is safe and used only for testing purposes.
InitializeInterpreter(host, context, configuration);
}
/// <summary>
/// Get the output path for the JSON graph associated with this resolver
/// </summary>
private AbsolutePath GetToolOutputPath()
{
AbsolutePath outputDirectory = FrontEndHost.GetFolderForFrontEnd(NinjaFrontEnd.Name);
var now = DateTime.UtcNow.ToString("yyyy-MM-dd-THH-mm-ss.SSS-Z");
var uniqueName = $"ninja_graph_{now}.json";
return(outputDirectory.Combine(Context.PathTable, uniqueName));
}
// To avoid an issue from the ccrewrite, the method from the base class was renamed
// from Initialize to InitializeInterpreter.
// Otherwise there is no way to override the Initialize method in this case.
/// <inheritdoc />
public void InitializeFrontEnd(FrontEndHost host, FrontEndContext context, IConfiguration configuration)
{
Contract.Requires(host != null);
Contract.Requires(context != null);
Contract.Requires(configuration != null);
InitializeInterpreter(host, context, configuration);
}
/// <inheritdoc cref="IDScriptWorkspaceModuleResolver" />
public bool TryInitialize([NotNull] FrontEndHost host, [NotNull] FrontEndContext context, [NotNull] IConfiguration configuration, [NotNull] IResolverSettings resolverSettings, [NotNull] QualifierId[] requestedQualifiers)
{
InitializeInterpreter(host, context, configuration);
m_resolverSettings = resolverSettings as INinjaResolverSettings;
Contract.Assert(m_resolverSettings != null);
return(TryInitializeWorkspaceValues());
}
/// <inheritdoc />
public bool TryInitialize(
[NotNull] FrontEndHost host,
[NotNull] FrontEndContext context,
[NotNull] IConfiguration configuration,
[NotNull] IResolverSettings resolverSettings,
[NotNull] QualifierId[] requestedQualifiers)
{
return(true);
}
/// <inheritdoc />
/// <summary>
/// Initializes the workspace resolver
/// </summary>
public bool TryInitialize(
FrontEndHost host,
FrontEndContext context,
IConfiguration configuration,
IResolverSettings resolverSettings,
QualifierId[] requestedQualifiers)
{
m_host = host;
m_context = context;
m_resolverSettings = resolverSettings as INinjaResolverSettings;
Contract.Assert(m_resolverSettings != null);
var relativePathToGraphConstructionTool = RelativePath.Create(context.StringTable, NinjaGraphBuilderRelativePath);
m_pathToTool = configuration.Layout.BuildEngineDirectory.Combine(m_context.PathTable, relativePathToGraphConstructionTool);
if (!m_resolverSettings.ProjectRoot.IsValid)
{
if (!m_resolverSettings.SpecFile.IsValid)
{
Tracing.Logger.Log.InvalidResolverSettings(m_context.LoggingContext, m_resolverSettings.Location(m_context.PathTable), "Either a project root or a spec file location (or both) must be specified.");
return(false);
}
ProjectRoot = m_resolverSettings.SpecFile.GetParent(m_context.PathTable);
SpecFile = m_resolverSettings.SpecFile;
}
else
{
ProjectRoot = m_resolverSettings.ProjectRoot;
SpecFile = m_resolverSettings.SpecFile;
if (!m_resolverSettings.SpecFile.IsValid)
{
SpecFile = ProjectRoot.Combine(m_context.PathTable, "build.ninja");
}
}
string path;
if (!Directory.Exists(path = ProjectRoot.ToString(m_context.PathTable)))
{
Tracing.Logger.Log.ProjectRootDirectoryDoesNotExist(m_context.LoggingContext, m_resolverSettings.Location(m_context.PathTable), path);
return(false);
}
if (!File.Exists(path = SpecFile.ToString(m_context.PathTable)))
{
Tracing.Logger.Log.NinjaSpecFileDoesNotExist(m_context.LoggingContext, m_resolverSettings.Location(m_context.PathTable), path);
return(false);
}
m_targets = m_resolverSettings.Targets != null?m_resolverSettings.Targets.AsArray() : CollectionUtilities.EmptyArray <string>();
return(true);
}
protected override IProjectToPipConstructor <RushProject> CreateProjectToPipConstructor(
FrontEndContext context,
FrontEndHost frontEndHost,
ModuleDefinition moduleDefinition,
RushResolverSettings resolverSettings,
IEnumerable <KeyValuePair <string, string> > userDefinedEnvironment,
IEnumerable <string> userDefinedPassthroughVariables)
{
return(new RushPipConstructor(context, frontEndHost, moduleDefinition, resolverSettings, userDefinedEnvironment, userDefinedPassthroughVariables));
}
/// <nodoc/>
public CMakeResolver(
FrontEndHost host,
FrontEndContext context,
string frontEndName)
{
Contract.Requires(!string.IsNullOrEmpty(frontEndName));
m_frontEndName = frontEndName;
m_host = host;
m_context = context;
}
/// <inheritdoc/>
protected override IProjectToPipConstructor <JavaScriptProject> CreateGraphToPipGraphConstructor(
FrontEndHost host,
ModuleDefinition moduleDefinition,
RushResolverSettings resolverSettings,
RushConfiguration configuration,
IEnumerable <KeyValuePair <string, string> > userDefinedEnvironment,
IEnumerable <string> userDefinedPassthroughVariables,
IReadOnlyDictionary <string, IReadOnlyList <JavaScriptArgument> > customCommands)
{
return(new RushPipConstructor(Context, host, moduleDefinition, configuration, resolverSettings, userDefinedEnvironment, userDefinedPassthroughVariables, customCommands));
}
/// <nodoc />
public NugetResolver(
FrontEndHost host,
FrontEndContext context,
IConfiguration configuration,
IFrontEndStatistics statistics,
SourceFileProcessingQueue <bool> parseQueue,
Logger logger = null,
IDecorator <EvaluationResult> evaluationDecorator = null)
: base(host, context, configuration, statistics, parseQueue, logger, evaluationDecorator)
{
}
/// <nodoc/>
public JavaScriptResolver(
FrontEndHost host,
FrontEndContext context,
string frontEndName)
{
Contract.Requires(!string.IsNullOrEmpty(frontEndName));
m_frontEndName = frontEndName;
Context = context;
m_host = host;
m_logger = Script.Tracing.Logger.CreateLogger(preserveLogEvents: true);
}
/// <summary>
/// Sets DScript-specific objects that <see cref="IDScriptWorkspaceModuleResolver"/> need at creation time
/// </summary>
/// <remarks>
/// This is exposed as a separate methods since the set context is usually available after resolvers are registered.
/// </remarks>
public void Initialize(FrontEndContext context, FrontEndHost host, IConfiguration configuration)
{
Contract.Requires(context != null);
Contract.Requires(host != null);
Contract.Requires(!IsInitialized);
Contract.Ensures(IsInitialized);
IsInitialized = true;
m_frontEndContext = context;
m_frontEndHost = host;
m_configuration = configuration;
}
/// <nodoc />
public NugetResolver(
GlobalConstants constants,
ModuleRegistry sharedModuleRegistry,
FrontEndHost host,
FrontEndContext context,
IConfiguration configuration,
IFrontEndStatistics statistics,
SourceFileProcessingQueue <bool> parseQueue,
Logger logger = null,
IDecorator <EvaluationResult> evaluationDecorator = null)
: base(constants, sharedModuleRegistry, host, context, configuration, statistics, parseQueue, logger, evaluationDecorator)
{
}
/// <inheritdoc/>
public bool TryInitialize(
FrontEndHost host,
FrontEndContext context,
IConfiguration configuration,
IResolverSettings resolverSettings)
{
InitializeInterpreter(host, context, configuration);
m_resolverSettings = resolverSettings as IMsBuildResolverSettings;
Contract.Assert(m_resolverSettings != null);
return(true);
}
public ContextTree(
[NotNull] FrontEndHost frontEndHost,
[NotNull] FrontEndContext frontEndContext,
[NotNull] GlobalConstants constants,
[NotNull] ModuleRegistry moduleRegistry,
[NotNull] Logger logger,
[NotNull] EvaluationStatistics statistics,
QualifierValueCache qualifierValueCache,
bool isBeingDebugged,
IDecorator <EvaluationResult> decorator,
[NotNull] FileModuleLiteral module,
[NotNull] EvaluatorConfiguration configuration,
[NotNull] IEvaluationScheduler evaluationScheduler,
FileType fileType)
{
Contract.Requires(frontEndHost != null);
Contract.Requires(frontEndContext != null);
Contract.Requires(constants != null);
Contract.Requires(moduleRegistry != null);
Contract.Requires(logger != null);
Contract.Requires(statistics != null);
Contract.Requires(module != null);
EvaluationScheduler = evaluationScheduler;
FrontEndHost = frontEndHost;
FrontEndContext = frontEndContext;
Constants = constants;
ModuleRegistry = moduleRegistry;
Logger = logger;
Statistics = statistics;
IsBeingDebugged = isBeingDebugged;
Decorator = decorator;
EvaluationScheduler = evaluationScheduler;
QualifierValueCache = qualifierValueCache;
ToolDefinitionCache = new ConcurrentDictionary <ObjectLiteral, CachedToolDefinition>();
ValueCache = new ConcurrentDictionary <Fingerprint, EvaluationResult>();
CommonConstants = new CommonConstants(frontEndContext.StringTable);
RootContext =
new Context(
contextTree: this,
parent: null,
module: module,
topLevelValueInfo: null,
fileType: fileType,
configuration: configuration,
evaluationScheduler: evaluationScheduler);
Interlocked.Increment(ref statistics.ContextTrees);
}
/// <summary>
/// Sets DScript-specific objects that <see cref="IWorkspaceModuleResolver"/> need at creation time
/// </summary>
/// <remarks>
/// This is exposed as a separate methods since the set context is usually available after resolvers are registered.
/// </remarks>
public void Initialize(FrontEndContext context, FrontEndHost host, IConfiguration configuration, QualifierId[] requestedQualifiers)
{
Contract.Requires(context != null);
Contract.Requires(host != null);
Contract.Requires(requestedQualifiers?.Length > 0);
Contract.Requires(!IsInitialized);
Contract.Ensures(IsInitialized);
IsInitialized = true;
m_frontEndContext = context;
m_frontEndHost = host;
m_configuration = configuration;
m_requestedQualifiers = requestedQualifiers;
}
/// <nodoc/>
public NinjaResolver(
GlobalConstants constants,
ModuleRegistry sharedModuleRegistry,
IFrontEndStatistics statistics,
FrontEndHost host,
FrontEndContext context,
IConfiguration configuration,
Logger logger,
string frontEndName)
: base(constants, sharedModuleRegistry, statistics, logger, host, context, configuration)
{
Contract.Requires(!string.IsNullOrEmpty(frontEndName));
m_frontEndName = frontEndName;
}
