/// <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; }