Esempio n. 1
0
        /// <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));
        }
Esempio n. 2
0
        /// <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;
        }
Esempio n. 3
0
        /// <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);
        }
Esempio n. 4
0
        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));
        }
Esempio n. 5
0
        /// <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);
Esempio n. 8
0
        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))));
        }
Esempio n. 9
0
        /// <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;
        }
Esempio n. 10
0
        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);
        }
Esempio n. 11
0
        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));
        }
Esempio n. 12
0
        /// <inheritdoc />
        void IConfigurationProcessor.Initialize(FrontEndHost host, FrontEndContext context)
        {
            Contract.Requires(host != null);
            Contract.Requires(context != null);

            InitializeInterpreter(host, context, new ConfigurationImpl());
        }
Esempio n. 13
0
 /// <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();
 }
Esempio n. 14
0
 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);
 }
Esempio n. 15
0
        /// <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));
        }
Esempio n. 16
0
        // 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);
        }
Esempio n. 17
0
        /// <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);
 }
Esempio n. 19
0
        /// <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);
        }
Esempio n. 20
0
 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));
 }
Esempio n. 21
0
 /// <nodoc/>
 public CMakeResolver(
     FrontEndHost host,
     FrontEndContext context,
     string frontEndName)
 {
     Contract.Requires(!string.IsNullOrEmpty(frontEndName));
     m_frontEndName = frontEndName;
     m_host         = host;
     m_context      = context;
 }
Esempio n. 22
0
 /// <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));
 }
Esempio n. 23
0
 /// <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)
 {
 }
Esempio n. 24
0
        /// <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;
        }
Esempio n. 26
0
 /// <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);
        }
Esempio n. 28
0
        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);
        }
Esempio n. 29
0
        /// <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;
        }
Esempio n. 30
0
 /// <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;
 }