コード例 #1
0
        /// <summary>
        /// Creates a queue that starts with some already parsed module and a pending module under construction
        /// </summary>
        public static ModuleParsingQueue CreateIncrementalQueue(
            WorkspaceProvider workspaceProvider,
            WorkspaceConfiguration workspaceConfiguration,
            IModuleReferenceResolver moduleReferenceResolver,
            ModuleDefinition designatedPrelude,
            ParsedModule configurationModule,
            IEnumerable <ParsedModule> parsedModules,
            IEnumerable <Failure> failures)
        {
            Contract.Requires(workspaceProvider != null);
            Contract.Requires(moduleReferenceResolver != null);
            Contract.Requires(parsedModules != null);
            Contract.Requires(failures != null);

            var parsedModulesDictionary =
                new ConcurrentDictionary <ModuleDescriptor, ParsedModule>(parsedModules.Select(parsedModule => new KeyValuePair <ModuleDescriptor, ParsedModule>(parsedModule.Descriptor, parsedModule)));

            var failureBag = new ConcurrentQueue <Failure>(failures);

            // For IDE mode it is very crucial to preserve trivias. For instance, without it, there is no way to check that the current position is inside a comment.
            var queue = new ModuleParsingQueue(
                workspaceProvider,
                workspaceConfiguration,
                moduleReferenceResolver,
                designatedPrelude,
                configurationModule,
                parsedModulesDictionary,
                failureBag,
                preserveTrivias: true);

            return(queue);
        }
コード例 #2
0
 /// <summary>
 /// Creates a special version of the parsing queue required for paring/binding spec files for fingerprint computation.
 /// </summary>
 public static ModuleParsingQueue CraeteFingerprintComputationQueue(
     WorkspaceProvider workspaceProvider,
     WorkspaceConfiguration workspaceConfiguration,
     IModuleReferenceResolver moduleReferenceResolver)
 {
     return(new FingerprintComputationParsingQueue(workspaceProvider, workspaceConfiguration, moduleReferenceResolver));
 }
コード例 #3
0
        private ModuleParsingQueue(
            WorkspaceProvider workspaceProvider,
            WorkspaceConfiguration workspaceConfiguration,
            IModuleReferenceResolver moduleReferenceResolver,
            ModuleDefinition designatedPrelude,
            ParsedModule configurationModule,
            ConcurrentDictionary <ModuleDescriptor, ParsedModule> alreadyParsedModules,
            ConcurrentQueue <Failure> failures,
            bool preserveTrivias = false)
        {
            Contract.Requires(workspaceProvider != null);
            Contract.Requires(workspaceConfiguration != null);
            Contract.Requires(moduleReferenceResolver != null);
            Contract.Requires(alreadyParsedModules != null, "alreadyParsedModules != null");
            Contract.Requires(failures != null, "failures != null");

            m_modulesToBeParsed    = new ConcurrentDictionary <ModuleDescriptor, ModuleUnderConstruction>();
            m_modulesAlreadyParsed = alreadyParsedModules;
            m_failures             = failures;

            m_workspaceProvider       = workspaceProvider;
            m_moduleReferenceResolver = moduleReferenceResolver;
            m_designatedPrelude       = designatedPrelude;
            m_configurationModule     = configurationModule;

            m_workspaceConfiguration = workspaceConfiguration;
            m_parsingOptions         = workspaceConfiguration.ParsingOptions;

            if (preserveTrivias)
            {
                m_parsingOptions = (m_parsingOptions ?? ParsingOptions.DefaultParsingOptions).WithTrivia(true);
            }

            DegreeOfParallelism = workspaceConfiguration.MaxDegreeOfParallelismForParsing;

            // WARNING: this is extremely subtle.
            // We need to keep a 'registration token' from the chained operation we are doing next to avoid memory leak.
            // The instance of this class stores the reference to key front-end objects, like resolvers,
            // that keeps the entire front-end in memory.
            // CancellationToken.Register registers the call back, that lead to a closure allocation of the current instance.
            // And this means that the lifetime of this instance is coupled to the lifetime of the the workspaceConfiguration.CancellationToken which is global.
            // This means that if we won't dispose the resistration we'll keep the entire front-end in memory for the entire app life time.
            cancellationTokenChain = workspaceConfiguration.CancellationToken.Register(() => m_cancellationTokenSource.Cancel());

            m_queueOptions = new ModuleParsingQueueOptions()
            {
                CancelOnFirstFailure   = workspaceConfiguration.CancelOnFirstFailure,
                MaxDegreeOfParallelism = DegreeOfParallelism,
                CancellationToken      = CancellationToken,
            };

            m_parseQueue = new ActionBlock <SpecWithOwningModule>(ProcessQueuedItemForParsing, m_queueOptions);

            Action <ParsedSpecWithOwningModule> action = ProcessQueueItemForBinding;

            m_bindQueue = new ActionBlock <ParsedSpecWithOwningModule>(action, m_queueOptions);
        }
コード例 #4
0
 /// <summary>
 /// Creates a module parsing queue. The queue options are specified by the provided queueOptions.
 /// </summary>
 public ModuleParsingQueue(
     [NotNull] WorkspaceProvider workspaceProvider,
     WorkspaceConfiguration workspaceConfiguration,
     IModuleReferenceResolver moduleReferenceResolver,
     ModuleDefinition designatedPrelude,
     ParsedModule configurationModule)
     : this(workspaceProvider, workspaceConfiguration, moduleReferenceResolver, designatedPrelude, configurationModule,
            new ConcurrentDictionary <ModuleDescriptor, ParsedModule>(), new ConcurrentQueue <Failure>())
 {
     Contract.Requires(moduleReferenceResolver != null);
 }
コード例 #5
0
        /// <summary>
        /// Creates a parsing queue for parsing specs in a regular BuildXL invocation.
        /// </summary>
        public static ModuleParsingQueue Create(
            [NotNull] WorkspaceProvider workspaceProvider,
            [NotNull] WorkspaceConfiguration workspaceConfiguration,
            [NotNull] IModuleReferenceResolver moduleReferenceResolver,
            [CanBeNull] ModuleDefinition designatedPrelude,
            [CanBeNull] ParsedModule configurationModule)
        {
            Contract.Requires(workspaceProvider != null);

            return(new ModuleParsingQueue(
                       workspaceProvider,
                       workspaceConfiguration,
                       moduleReferenceResolver,
                       designatedPrelude,
                       configurationModule));
        }
コード例 #6
0
        /// <nodoc/>
        public WorkspaceProvider(
            IWorkspaceStatistics workspaceStatistics,
            List <IWorkspaceModuleResolver> resolvers,
            IModuleReferenceResolver moduleReferenceResolver,
            WorkspaceConfiguration configuration,
            PathTable pathTable,
            SymbolTable symbolTable)
        {
            Contract.Requires(workspaceStatistics != null);
            Contract.Requires(configuration != null);
            Contract.Requires(moduleReferenceResolver != null);
            Contract.Requires(pathTable != null);

            Statistics = workspaceStatistics;
            m_moduleReferenceResolver = moduleReferenceResolver;
            PathTable     = pathTable;
            Configuration = configuration;
            SymbolTable   = symbolTable;
            m_resolvers   = resolvers;
        }
コード例 #7
0
 /// <nodoc />
 public FingerprintComputationParsingQueue(WorkspaceProvider workspaceProvider, WorkspaceConfiguration workspaceConfiguration, IModuleReferenceResolver moduleReferenceResolver)
     : base(workspaceProvider: workspaceProvider, workspaceConfiguration: workspaceConfiguration, moduleReferenceResolver: moduleReferenceResolver, designatedPrelude: null, configurationModule: null)
 {
 }