Esempio n. 1
0
        private static async Task <VersionStamp> ComputeLatestDocumentVersionAsync(TextDocumentStates <DocumentState> documentStates, TextDocumentStates <TextDocumentState> additionalDocumentStates, CancellationToken cancellationToken)
        {
            // this may produce a version that is out of sync with the actual Document versions.
            var latestVersion = VersionStamp.Default;

            foreach (var state in documentStates.States)
            {
                cancellationToken.ThrowIfCancellationRequested();

                if (!state.IsGenerated)
                {
                    var version = await state.GetTextVersionAsync(cancellationToken).ConfigureAwait(false);

                    latestVersion = version.GetNewerVersion(latestVersion);
                }
            }

            foreach (var state in additionalDocumentStates.States)
            {
                cancellationToken.ThrowIfCancellationRequested();

                var version = await state.GetTextVersionAsync(cancellationToken).ConfigureAwait(false);

                latestVersion = version.GetNewerVersion(latestVersion);
            }

            return(latestVersion);
        }
Esempio n. 2
0
        private ProjectState(
            ProjectInfo projectInfo,
            HostLanguageServices languageServices,
            SolutionServices solutionServices,
            TextDocumentStates <DocumentState> documentStates,
            TextDocumentStates <TextDocumentState> additionalDocumentStates,
            TextDocumentStates <AnalyzerConfigDocumentState> analyzerConfigDocumentStates,
            AsyncLazy <VersionStamp> lazyLatestDocumentVersion,
            AsyncLazy <VersionStamp> lazyLatestDocumentTopLevelChangeVersion,
            ValueSource <CachingAnalyzerConfigSet> lazyAnalyzerConfigSet)
        {
            _solutionServices                        = solutionServices;
            _languageServices                        = languageServices;
            DocumentStates                           = documentStates;
            AdditionalDocumentStates                 = additionalDocumentStates;
            AnalyzerConfigDocumentStates             = analyzerConfigDocumentStates;
            _lazyLatestDocumentVersion               = lazyLatestDocumentVersion;
            _lazyLatestDocumentTopLevelChangeVersion = lazyLatestDocumentTopLevelChangeVersion;
            _lazyAnalyzerConfigSet                   = lazyAnalyzerConfigSet;

            // ownership of information on document has moved to project state. clear out documentInfo the state is
            // holding on. otherwise, these information will be held onto unnecessarily by projectInfo even after
            // the info has changed by DocumentState.
            _projectInfo = ClearAllDocumentsFromProjectInfo(projectInfo);

            _lazyChecksums = new AsyncLazy <ProjectStateChecksums>(ComputeChecksumsAsync, cacheResult: true);
        }
Esempio n. 3
0
 private AsyncLazy <VersionStamp> CreateLazyLatestDocumentTopLevelChangeVersion(
     TextDocumentState newDocument,
     TextDocumentStates <DocumentState> newDocumentStates,
     TextDocumentStates <TextDocumentState> newAdditionalDocumentStates
     )
 {
     if (_lazyLatestDocumentTopLevelChangeVersion.TryGetValue(out var oldVersion))
     {
         return(new AsyncLazy <VersionStamp>(
                    c => ComputeTopLevelChangeTextVersionAsync(oldVersion, newDocument, c),
                    cacheResult: true
                    ));
     }
     else
     {
         return(new AsyncLazy <VersionStamp>(
                    c =>
                    ComputeLatestDocumentTopLevelChangeVersionAsync(
                        newDocumentStates,
                        newAdditionalDocumentStates,
                        c
                        ),
                    cacheResult: true
                    ));
     }
 }
                public static State Create(
                    Compilation compilation,
                    TextDocumentStates <SourceGeneratedDocumentState> generatedDocuments,
                    ImmutableArray <
                        ValueTuple <ProjectState, CompilationAndGeneratorDriverTranslationAction>
                        > intermediateProjects
                    )
                {
                    Contract.ThrowIfTrue(intermediateProjects.IsDefault);

                    // If we don't have any intermediate projects to process, just initialize our
                    // DeclarationState now. We'll pass false for generatedDocumentsAreFinal because this is being called
                    // if our referenced projects are changing, so we'll have to rerun to consume changes.
                    return(intermediateProjects.Length == 0
                      ? new FullDeclarationState(
                               compilation,
                               generatedDocuments,
                               generatedDocumentsAreFinal: false
                               )
                      : (State) new InProgressState(
                               compilation,
                               generatedDocuments,
                               intermediateProjects
                               ));
                }
Esempio n. 5
0
 public CompilationTrackerGeneratorInfo(
     TextDocumentStates <SourceGeneratedDocumentState> documents,
     GeneratorDriver?driver,
     bool documentsAreFinal)
 {
     Documents         = documents;
     Driver            = driver;
     DocumentsAreFinal = documentsAreFinal;
 }
Esempio n. 6
0
                public CompilationTrackerGeneratorInfo(
                    TextDocumentStates <SourceGeneratedDocumentState> documents,
                    GeneratorDriver?driver,
                    bool documentsAreFinal,
                    bool documentsAreFinalAndFrozen = false)
                {
                    Documents                  = documents;
                    Driver                     = driver;
                    DocumentsAreFinal          = documentsAreFinal;
                    DocumentsAreFinalAndFrozen = documentsAreFinalAndFrozen;

                    // If we're frozen, that implies final as well
                    Contract.ThrowIfTrue(documentsAreFinalAndFrozen && !documentsAreFinal);
                }
Esempio n. 7
0
                protected State(
                    ValueSource <Optional <Compilation> >?compilationWithoutGeneratedDocuments,
                    Compilation?declarationOnlyCompilation,
                    TextDocumentStates <SourceGeneratedDocumentState> generatedDocuments,
                    bool generatedDocumentsAreFinal)
                {
                    // Declaration-only compilations should never have any references
                    Contract.ThrowIfTrue(declarationOnlyCompilation != null && declarationOnlyCompilation.ExternalReferences.Any());

                    CompilationWithoutGeneratedDocuments = compilationWithoutGeneratedDocuments;
                    DeclarationOnlyCompilation           = declarationOnlyCompilation;
                    GeneratedDocuments         = generatedDocuments;
                    GeneratedDocumentsAreFinal = generatedDocumentsAreFinal;
                }
Esempio n. 8
0
        public ProjectState(ProjectInfo projectInfo, HostLanguageServices languageServices, SolutionServices solutionServices)
        {
            Contract.ThrowIfNull(projectInfo);
            Contract.ThrowIfNull(languageServices);
            Contract.ThrowIfNull(solutionServices);

            _languageServices = languageServices;
            _solutionServices = solutionServices;

            var projectInfoFixed = FixProjectInfo(projectInfo);

            // We need to compute our AnalyerConfigDocumentStates first, since we use those to produce our DocumentStates
            AnalyzerConfigDocumentStates = new TextDocumentStates <AnalyzerConfigDocumentState>(projectInfoFixed.AnalyzerConfigDocuments, info => new AnalyzerConfigDocumentState(info, solutionServices));

            _lazyAnalyzerConfigSet = ComputeAnalyzerConfigSetValueSource(AnalyzerConfigDocumentStates);

            // Add analyzer config information to the compilation options
            if (projectInfoFixed.CompilationOptions != null)
            {
                projectInfoFixed = projectInfoFixed.WithCompilationOptions(
                    projectInfoFixed.CompilationOptions.WithSyntaxTreeOptionsProvider(
                        new WorkspaceSyntaxTreeOptionsProvider(_lazyAnalyzerConfigSet)));
            }

            var parseOptions = projectInfoFixed.ParseOptions;

            DocumentStates           = new TextDocumentStates <DocumentState>(projectInfoFixed.Documents, info => CreateDocument(info, parseOptions));
            AdditionalDocumentStates = new TextDocumentStates <TextDocumentState>(projectInfoFixed.AdditionalDocuments, info => new TextDocumentState(info, solutionServices));

            _lazyLatestDocumentVersion = new AsyncLazy <VersionStamp>(c => ComputeLatestDocumentVersionAsync(DocumentStates, AdditionalDocumentStates, c), cacheResult: true);
            _lazyLatestDocumentTopLevelChangeVersion = new AsyncLazy <VersionStamp>(c => ComputeLatestDocumentTopLevelChangeVersionAsync(DocumentStates, AdditionalDocumentStates, c), cacheResult: true);

            // ownership of information on document has moved to project state. clear out documentInfo the state is
            // holding on. otherwise, these information will be held onto unnecessarily by projectInfo even after
            // the info has changed by DocumentState.
            // we hold onto the info so that we don't need to duplicate all information info already has in the state
            _projectInfo = ClearAllDocumentsFromProjectInfo(projectInfoFixed);

            _lazyChecksums = new AsyncLazy <ProjectStateChecksums>(ComputeChecksumsAsync, cacheResult: true);
        }
Esempio n. 9
0
 public InProgressState(
     Compilation inProgressCompilation,
     TextDocumentStates <SourceGeneratedDocumentState> generatedDocuments,
     Compilation?compilationWithGeneratedDocuments,
     ImmutableArray <(ProjectState state, CompilationAndGeneratorDriverTranslationAction action)> intermediateProjects)