27public abstract partial class CSharpSyntaxTree : SyntaxTree

22Inherits SyntaxTree

193SyntaxTree tree = await project.GetDocument(documentId).GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);

206var tree = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);

303foreach (var tree in compilation.SyntaxTrees)

80var tree = await document.GetSyntaxTreeAsync();

169var syntaxTree = compilation.SyntaxTrees.Single(t => t.FilePath.Contains("AbstractCaseCorrectionService")); 179var changedTree = syntaxTree.WithChangedText(changedText);

43var tree = SyntaxFactory.ParseSyntaxTree(SourceText.From(text, encoding: null, SourceHashAlgorithms.Default));

23private SyntaxTree _tree; 55var newTree = _tree.WithChangedText(newText); 64var newTree = _tree.WithChangedText(newText);

38private SyntaxTree _lastSeqPointTree; 1006internal void DefineSequencePoint(SyntaxTree syntaxTree, TextSpan span) 1046var lastDebugDocument = _lastSeqPointTree; 1075internal void SetInitialDebugDocument(SyntaxTree initialSequencePointTree)

16internal readonly SyntaxTree SyntaxTree; 23internal RawSequencePoint(SyntaxTree syntaxTree, int ilMarker, TextSpan span)

23private readonly SyntaxTree _tree; 37private SequencePointList(SyntaxTree tree, OffsetAndSpan[] points) 130SyntaxTree currentTree = current._tree;

309treeOptionsBuilder.Count > 0 ? treeOptionsBuilder.ToImmutable() : SyntaxTree.EmptyDiagnosticOptions,

429var embeddedTreeMap = new Dictionary<string, SyntaxTree>(Arguments.EmbeddedFiles.Length); 432foreach (var tree in compilation.SyntaxTrees) 456SyntaxTree? tree; 479SyntaxTree tree, 926IEnumerable<SyntaxTree> syntaxTrees, 933foreach (var syntaxTree in syntaxTrees) 1037foreach (var tree in generatedSyntaxTrees)

11internal readonly ImmutableArray<SyntaxTree> ExternalSyntaxTrees; 18ImmutableArray<SyntaxTree> externalSyntaxTrees,

90protected static IReadOnlyDictionary<string, string> SyntaxTreeCommonFeatures(IEnumerable<SyntaxTree> trees) 94foreach (var tree in trees) 190ImmutableArray<SyntaxTree> syntaxTrees, 307public SemanticModel GetSemanticModel(SyntaxTree syntaxTree, bool ignoreAccessibility = false) 312/// If <see cref="SemanticModelProvider"/> is non-null, it attempts to use <see cref="SemanticModelProvider.GetSemanticModel(SyntaxTree, Compilation, bool)"/> 313/// to get a semantic model. Otherwise, it creates a new semantic model using <see cref="CreateSemanticModel(SyntaxTree, bool)"/>. 318protected abstract SemanticModel CommonGetSemanticModel(SyntaxTree syntaxTree, bool ignoreAccessibility); 322/// Unlike the <see cref="GetSemanticModel(SyntaxTree, bool)"/> and <see cref="CommonGetSemanticModel(SyntaxTree, bool)"/>, 328internal abstract SemanticModel CreateSemanticModel(SyntaxTree syntaxTree, bool ignoreAccessibility); 537public IEnumerable<SyntaxTree> SyntaxTrees { get { return CommonSyntaxTrees; } } 538protected internal abstract ImmutableArray<SyntaxTree> CommonSyntaxTrees { get; } 545public Compilation AddSyntaxTrees(params SyntaxTree[] trees) 555public Compilation AddSyntaxTrees(IEnumerable<SyntaxTree> trees) 560protected abstract Compilation CommonAddSyntaxTrees(IEnumerable<SyntaxTree> trees); 568public Compilation RemoveSyntaxTrees(params SyntaxTree[] trees) 579public Compilation RemoveSyntaxTrees(IEnumerable<SyntaxTree> trees) 584protected abstract Compilation CommonRemoveSyntaxTrees(IEnumerable<SyntaxTree> trees); 604public Compilation ReplaceSyntaxTree(SyntaxTree oldTree, SyntaxTree newTree) 609protected abstract Compilation CommonReplaceSyntaxTree(SyntaxTree oldTree, SyntaxTree newTree); 615public bool ContainsSyntaxTree(SyntaxTree syntaxTree) 620protected abstract bool CommonContainsSyntaxTree(SyntaxTree? syntaxTree); 1047foreach (var tree in this.CommonSyntaxTrees) 2443foreach (var tree in CommonSyntaxTrees) 2479foreach (var tree in CommonSyntaxTrees) 2501foreach (var tree in CommonSyntaxTrees) 2511internal abstract void AddDebugSourceDocumentsForChecksumDirectives(DebugDocumentsBuilder documentsBuilder, SyntaxTree tree, DiagnosticBag diagnostics); 2541internal static bool ReportUnusedImportsInTree(SyntaxTree tree) 2555internal abstract void CompleteTrees(SyntaxTree? filterTree); 3447private ConcurrentDictionary<SyntaxTree, SmallConcurrentSetOfInts>? _lazyTreeToUsedImportDirectivesMap; 3448private static readonly Func<SyntaxTree, SmallConcurrentSetOfInts> s_createSetCallback = t => new SmallConcurrentSetOfInts(); 3450private ConcurrentDictionary<SyntaxTree, SmallConcurrentSetOfInts> TreeToUsedImportDirectivesMap 3463internal void MarkImportDirectiveAsUsed(SyntaxTree? syntaxTree, int position) 3473internal bool IsImportDirectiveUsed(SyntaxTree syntaxTree, int position) 3492internal int CompareSyntaxTreeOrdering(SyntaxTree tree1, SyntaxTree tree2) 3505internal abstract int GetSyntaxTreeOrdinal(SyntaxTree tree);

25public static SyntaxTreeKey Create(SyntaxTree tree) 30private readonly SyntaxTree _tree; 32public DefaultSyntaxTreeKey(SyntaxTree tree) 52ImmutableArray<SyntaxTree> syntaxTrees,

10/// It is unknown if the <see cref="SyntaxTree"/> is automatically generated. 14/// The <see cref="SyntaxTree"/> is not automatically generated. 18/// The <see cref="SyntaxTree"/> is marked as automatically generated.

60public SyntaxTree SyntaxTree 68protected abstract SyntaxTree SyntaxTreeCore { get; }

16public abstract SemanticModel GetSemanticModel(SyntaxTree tree, Compilation compilation, bool ignoreAccessibility = false);

16public abstract GeneratedKind IsGenerated(SyntaxTree tree, CancellationToken cancellationToken); 21public abstract bool TryGetDiagnosticValue(SyntaxTree tree, string diagnosticId, CancellationToken cancellationToken, out ReportDiagnostic severity); 45DiagnosticOptions = SyntaxTree.EmptyDiagnosticOptions; 51private readonly ImmutableDictionary<SyntaxTree, Options> _options; 56SyntaxTree?[] trees, 60var builder = ImmutableDictionary.CreateBuilder<SyntaxTree, Options>(); 74public override GeneratedKind IsGenerated(SyntaxTree tree, CancellationToken _) 77public override bool TryGetDiagnosticValue(SyntaxTree tree, string diagnosticId, CancellationToken _, out ReportDiagnostic severity)

491internal bool HasIntersectingLocation(SyntaxTree tree, TextSpan? filterSpanWithinTree = null) 514static bool isLocationWithinSpan(Location location, SyntaxTree tree, TextSpan? filterSpan)

42public virtual SyntaxTree? SourceTree { get { return null; } } 156/// Creates an instance of a <see cref="Location"/> for a span in a <see cref="SyntaxTree"/>. 158public static Location Create(SyntaxTree syntaxTree, TextSpan textSpan)

17private readonly SyntaxTree _syntaxTree; 20public SourceLocation(SyntaxTree syntaxTree, TextSpan span) 72public override SyntaxTree SourceTree

97sb.AppendLine($"{nameof(SyntaxTree)}: {_file.Value.SourceTree.FilePath}");

23ImmutableDictionary<SyntaxTree, ImmutableDictionary<DiagnosticAnalyzer, ImmutableArray<Diagnostic>>> localSyntaxDiagnostics, 24ImmutableDictionary<SyntaxTree, ImmutableDictionary<DiagnosticAnalyzer, ImmutableArray<Diagnostic>>> localSemanticDiagnostics, 45public ImmutableDictionary<SyntaxTree, ImmutableDictionary<DiagnosticAnalyzer, ImmutableArray<Diagnostic>>> SyntaxDiagnostics { get; } 50public ImmutableDictionary<SyntaxTree, ImmutableDictionary<DiagnosticAnalyzer, ImmutableArray<Diagnostic>>> SemanticDiagnostics { get; }

30private readonly Dictionary<SyntaxTree, HashSet<DiagnosticAnalyzer>> _completedSyntaxAnalyzersByTree; 31private readonly Dictionary<SyntaxTree, HashSet<DiagnosticAnalyzer>> _completedSemanticAnalyzersByTree; 36private Dictionary<SyntaxTree, Dictionary<DiagnosticAnalyzer, ImmutableArray<Diagnostic>.Builder>>? _localSemanticDiagnosticsOpt = null; 37private Dictionary<SyntaxTree, Dictionary<DiagnosticAnalyzer, ImmutableArray<Diagnostic>.Builder>>? _localSyntaxDiagnosticsOpt = null; 45_completedSyntaxAnalyzersByTree = new Dictionary<SyntaxTree, HashSet<DiagnosticAnalyzer>>(); 46_completedSemanticAnalyzersByTree = new Dictionary<SyntaxTree, HashSet<DiagnosticAnalyzer>>(); 302static SyntaxTree? getSourceTree(Diagnostic diagnostic) 458Dictionary<SyntaxTree, Dictionary<DiagnosticAnalyzer, ImmutableArray<Diagnostic>.Builder>>? localDiagnostics, 504ImmutableDictionary<SyntaxTree, ImmutableDictionary<DiagnosticAnalyzer, ImmutableArray<Diagnostic>>> localSyntaxDiagnostics; 505ImmutableDictionary<SyntaxTree, ImmutableDictionary<DiagnosticAnalyzer, ImmutableArray<Diagnostic>>> localSemanticDiagnostics;

33public IEnumerable<SyntaxTree> SyntaxTrees { get; } 77: this(filterFile.SourceTree != null ? SpecializedCollections.SingletonEnumerable(filterFile.SourceTree) : SpecializedCollections.EmptyEnumerable<SyntaxTree>(), 83private AnalysisScope(IEnumerable<SyntaxTree> trees, IEnumerable<AdditionalText> additionalFiles, ImmutableArray<DiagnosticAnalyzer> analyzers, bool isPartialAnalysis, SourceOrAdditionalFile? filterFile, TextSpan? filterSpanOpt, bool isSyntacticSingleFileAnalysis, bool concurrentAnalysis, bool categorizeDiagnostics) 152public bool ShouldAnalyze(SyntaxTree tree) 172var filterTree = FilterFileOpt.GetValueOrDefault().SourceTree;

20public abstract AnalyzerConfigOptions GetOptions(SyntaxTree tree);

38private readonly Func<SyntaxTree, CancellationToken, bool> _isGeneratedCode; 231private ConcurrentDictionary<SyntaxTree, bool>? _lazyGeneratedCodeFilesMap; 236private ConcurrentDictionary<SyntaxTree, bool> GeneratedCodeFilesMap 245private Dictionary<SyntaxTree, ImmutableHashSet<ISymbol>>? _lazyGeneratedCodeSymbolsForTreeMap; 250private Dictionary<SyntaxTree, ImmutableHashSet<ISymbol>> GeneratedCodeSymbolsForTreeMap 259private ConcurrentDictionary<SyntaxTree, ImmutableHashSet<DiagnosticAnalyzer>>? _lazySuppressedAnalyzersForTreeMap; 264private ConcurrentDictionary<SyntaxTree, ImmutableHashSet<DiagnosticAnalyzer>> SuppressedAnalyzersForTreeMap 306private ConcurrentDictionary<SyntaxTree, bool>? _lazyTreesWithHiddenRegionsMap; 410_lazyGeneratedCodeFilesMap = new ConcurrentDictionary<SyntaxTree, bool>(); 411_lazyGeneratedCodeSymbolsForTreeMap = new Dictionary<SyntaxTree, ImmutableHashSet<ISymbol>>(); 413_lazyTreesWithHiddenRegionsMap = new ConcurrentDictionary<SyntaxTree, bool>(); 414_lazySuppressedAnalyzersForTreeMap = new ConcurrentDictionary<SyntaxTree, ImmutableHashSet<DiagnosticAnalyzer>>(); 739foreach (var tree in analysisScope.SyntaxTrees) 930private SemanticModel GetOrCreateSemanticModel(SyntaxTree tree) 933protected SemanticModel GetOrCreateSemanticModel(SyntaxTree tree, Compilation compilation) 1208ImmutableHashSet<ISymbol> getOrComputeGeneratedCodeSymbolsInTree(SyntaxTree tree, Compilation compilation, CancellationToken cancellationToken) 1239static ImmutableHashSet<ISymbol> computeGeneratedCodeSymbolsInTree(SyntaxTree tree, Compilation compilation, INamedTypeSymbol generatedCodeAttribute, CancellationToken cancellationToken) 1273private bool IsAnalyzerSuppressedForTree(DiagnosticAnalyzer analyzer, SyntaxTree tree, SyntaxTreeOptionsProvider? options) 1283private ImmutableHashSet<DiagnosticAnalyzer> ComputeSuppressedAnalyzersForTree(SyntaxTree tree, SyntaxTreeOptionsProvider? options) 2199protected bool IsGeneratedCode(SyntaxTree tree) 2230protected bool IsGeneratedOrHiddenCodeLocation(SyntaxTree syntaxTree, TextSpan span) 2233protected bool IsHiddenSourceLocation(SyntaxTree syntaxTree, TextSpan span) 2240private bool HasHiddenRegions(SyntaxTree tree)

45private readonly Func<SyntaxTree, SemanticModel>? _getSemanticModel; 48private readonly Func<SyntaxTree, TextSpan, bool> _isGeneratedCodeLocation; 49private readonly Func<DiagnosticAnalyzer, SyntaxTree, SyntaxTreeOptionsProvider?, bool>? _isAnalyzerSuppressedForTree; 65private bool IsAnalyzerSuppressedForTree(DiagnosticAnalyzer analyzer, SyntaxTree tree) 113Func<SyntaxTree, TextSpan, bool> isGeneratedCodeLocation, 114Func<DiagnosticAnalyzer, SyntaxTree, SyntaxTreeOptionsProvider?, bool> isAnalyzerSuppressedForTree, 116Func<SyntaxTree, SemanticModel> getSemanticModel, 181Func<SyntaxTree, TextSpan, bool> isGeneratedCodeLocation, 182Func<DiagnosticAnalyzer, SyntaxTree, SyntaxTreeOptionsProvider?, bool>? isAnalyzerSuppressedForTree, 184Func<SyntaxTree, SemanticModel>? getSemanticModel, 602var tree = file.SourceTree; 1404private AnalyzerDiagnosticReporter GetAddSemanticDiagnostic(SyntaxTree tree, DiagnosticAnalyzer analyzer) 1411private AnalyzerDiagnosticReporter GetAddSemanticDiagnostic(SyntaxTree tree, TextSpan? span, DiagnosticAnalyzer analyzer)

384foreach (var tree in compilation.SyntaxTrees)

25/// A set of options keyed to <see cref="SyntaxTree"/> or <see cref="AdditionalText"/>.

32SyntaxTree tree,

14/// and should invoke <see cref="ClearCache(SyntaxTree, Compilation)"/> and <see cref="ClearCache(Compilation)"/> to clear entries when appropriate. 34public override SemanticModel GetSemanticModel(SyntaxTree tree, Compilation compilation, bool ignoreAccessibility = false) 37internal void ClearCache(SyntaxTree tree, Compilation compilation) 53private readonly ConcurrentDictionary<SyntaxTree, SemanticModel> _semanticModelsMap; 57private readonly Func<SyntaxTree, SemanticModel> _createSemanticModel; 62_semanticModelsMap = new ConcurrentDictionary<SyntaxTree, SemanticModel>(); 66public SemanticModel GetSemanticModel(SyntaxTree tree, bool ignoreAccessibility) 74public void ClearCachedSemanticModel(SyntaxTree tree)

13public CompilationUnitCompletedEvent(Compilation compilation, SyntaxTree compilationUnit, TextSpan? filterSpan = null) 22public SyntaxTree CompilationUnit { get; }

205private void VerifyTree(SyntaxTree tree) 402public async Task<ImmutableArray<Diagnostic>> GetAnalyzerSyntaxDiagnosticsAsync(SyntaxTree tree, CancellationToken cancellationToken) 418public async Task<ImmutableArray<Diagnostic>> GetAnalyzerSyntaxDiagnosticsAsync(SyntaxTree tree, ImmutableArray<DiagnosticAnalyzer> analyzers, CancellationToken cancellationToken) 432public Task<AnalysisResult> GetAnalysisResultAsync(SyntaxTree tree, CancellationToken cancellationToken) 446public Task<AnalysisResult> GetAnalysisResultAsync(SyntaxTree tree, ImmutableArray<DiagnosticAnalyzer> analyzers, CancellationToken cancellationToken) 491private async Task<ImmutableArray<Diagnostic>> GetAnalyzerSyntaxDiagnosticsCoreAsync(SyntaxTree tree, ImmutableArray<DiagnosticAnalyzer> analyzers, CancellationToken cancellationToken) 696var tree = analysisScope.FilterFileOpt!.Value.SourceTree!; 830SyntaxTree tree, 850var partialTrees = PooledHashSet<SyntaxTree>.GetInstance(); 875foreach (var partialTree in partialTrees) 888bool tryProcessTree(SyntaxTree partialTree, [NotNullWhen(true)] out (AnalysisScope scope, ImmutableArray<CompilationEvent> events)? scopeAndEvents) 1013var tree = analysisScope.FilterFileOpt!.Value.SourceTree!;

28public override AnalyzerConfigOptions GetOptions(SyntaxTree tree)

116/// A syntax tree action reports <see cref="Diagnostic"/>s about the <see cref="SyntaxTree"/> of a document. 411/// A syntax tree action reports <see cref="Diagnostic"/>s about the <see cref="SyntaxTree"/> of a document. 494/// <param name="tree"><see cref="SyntaxTree"/> instance for which the value is queried.</param> 498public bool TryGetValue<TValue>(SyntaxTree tree, SyntaxTreeValueProvider<TValue> valueProvider, [MaybeNullWhen(false)] out TValue value) 601/// <param name="tree"><see cref="SyntaxTree"/> for which the value is queried.</param> 605public bool TryGetValue<TValue>(SyntaxTree tree, SyntaxTreeValueProvider<TValue> valueProvider, [MaybeNullWhen(false)] out TValue value) 1343/// A syntax tree action can use a <see cref="SyntaxTreeAnalysisContext"/> to report <see cref="Diagnostic"/>s about a <see cref="SyntaxTree"/> for a code document. 1347private readonly SyntaxTree _tree; 1355/// <see cref="SyntaxTree"/> that is the subject of the analysis. 1357public SyntaxTree Tree => _tree; 1377public SyntaxTreeAnalysisContext(SyntaxTree tree, AnalyzerOptions options, Action<Diagnostic> reportDiagnostic, Func<Diagnostic, bool> isSupportedDiagnostic, CancellationToken cancellationToken) 1383SyntaxTree tree, 1401/// Report a <see cref="Diagnostic"/> about a <see cref="SyntaxTree"/>. 1675private readonly Func<SyntaxTree, SemanticModel> _getSemanticModel; 1710Func<SyntaxTree, SemanticModel> getSemanticModel, 1751/// Gets a <see cref="SemanticModel"/> for the given <see cref="SyntaxTree"/>, which is shared across all analyzers. 1753public SemanticModel GetSemanticModel(SyntaxTree syntaxTree) => _getSemanticModel(syntaxTree);

18public SyntaxTree? SourceTree { get; } 21public SourceOrAdditionalFile(SyntaxTree tree)

11/// Provides custom values associated with <see cref="SyntaxTree"/> instances using the given computeValue delegate. 15internal AnalysisValueProvider<SyntaxTree, TValue> CoreValueProvider { get; private set; } 18/// Provides values associated with <see cref="SyntaxTree"/> instances using the given <paramref name="computeValue"/>. 20/// <param name="computeValue">Delegate to compute the value associated with a given <see cref="SyntaxTree"/> instance.</param> 21/// <param name="syntaxTreeComparer">Optional equality comparer to determine equivalent <see cref="SyntaxTree"/> instances that have the same value. 23public SyntaxTreeValueProvider(Func<SyntaxTree, TValue> computeValue, IEqualityComparer<SyntaxTree>? syntaxTreeComparer = null) 25CoreValueProvider = new AnalysisValueProvider<SyntaxTree, TValue>(computeValue, syntaxTreeComparer ?? SyntaxTreeComparer.Instance);

37/// <remarks>See remarks of <see cref="SyntaxTree.FilePath"/></remarks>

49SyntaxTree tree, Func<SyntaxTrivia, bool> isComment, CancellationToken cancellationToken) 118SyntaxTree tree, Func<SyntaxTrivia, bool> isComment, CancellationToken cancellationToken)

1782foreach (var tree in Module.CommonCompilation.SyntaxTrees)

870var tree = location.SourceTree;

18public SyntaxTree Tree { get; } 20public GeneratedSyntaxTree(string hintName, SourceText text, SyntaxTree tree)

58ArrayBuilder<SyntaxTree> trees = ArrayBuilder<SyntaxTree>.GetInstance(); 205var constantSourcesBuilder = ArrayBuilder<SyntaxTree>.GetInstance(); 336var tree = ParseGeneratedSourceText(source, Path.Combine(prefix, source.HintName), cancellationToken); 415internal abstract SyntaxTree ParseGeneratedSourceText(GeneratedSourceText input, string fileName, CancellationToken cancellationToken);

26public static readonly InputNode<SyntaxTree> SyntaxTrees = new InputNode<SyntaxTree>(b => b.Compilation.SyntaxTrees.ToImmutableArray());

142var targetSyntaxTree = attributeTarget.SyntaxTree;

53/// cref="SyntaxTree"/>. 55internal IncrementalValuesProvider<(SyntaxTree tree, ImmutableArray<SyntaxNode> matches)> ForAttributeWithSimpleName( 126private static ImmutableArray<(SyntaxTree Tree, SourceGeneratorSyntaxTreeInfo Info)> GetSourceGeneratorInfo( 131foreach (var tree in compilation.CommonSyntaxTrees) 139var builder = ImmutableArray.CreateBuilder<(SyntaxTree Tree, SourceGeneratorSyntaxTreeInfo Info)>(count); 142foreach (var tree in compilation.CommonSyntaxTrees) 155SyntaxTree syntaxTree,

20private ImmutableArray<SyntaxTree> _lazyGeneratedTrees; 57/// The <see cref="SyntaxTree"/>s produced during this generation pass by parsing each <see cref="SourceText"/> added by each generator. 62public ImmutableArray<SyntaxTree> GeneratedTrees 156internal GeneratedSourceResult(SyntaxTree tree, SourceText text, string hintName) 166public SyntaxTree SyntaxTree { get; }

49public IStateTable GetSyntaxInputTable(SyntaxInputNode syntaxInputNode, NodeStateTable<SyntaxTree> syntaxTreeTable) 84NodeStateTable<SyntaxTree> syntaxTreeState = syntaxTreeTable;

19int CalculateLocalSyntaxOffset(int declaratorPosition, SyntaxTree declaratorTree);

22protected AbstractWarningStateMap(SyntaxTree syntaxTree) 32protected abstract WarningStateMapEntry[] CreateWarningStateMapEntries(SyntaxTree syntaxTree);

10/// Interface implemented by any node that is the root 'CompilationUnit' of a <see cref="SyntaxTree"/>. i.e. 11/// any node returned by <see cref="SyntaxTree.GetRoot"/> where <see cref="SyntaxTree.HasCompilationUnitRoot"/> 14/// This interface provides a common way to both easily find the root of a <see cref="SyntaxTree"/>

36protected LineDirectiveMap(SyntaxTree syntaxTree) 139private ImmutableArray<LineMappingEntry> CreateEntryMap(SyntaxTree tree, IList<TDirective> directives)

37internal static IList<TextChange> GetTextChanges(SyntaxTree before, SyntaxTree after) 71internal static IList<TextSpan> GetPossiblyDifferentTextSpans(SyntaxTree? before, SyntaxTree? after)

27protected override SyntaxTree SyntaxTreeCore => this.Parent!.SyntaxTree;

28internal SyntaxTree? _syntaxTree; 44internal SyntaxNode(GreenNode green, int position, SyntaxTree syntaxTree) 76public SyntaxTree SyntaxTree => this.SyntaxTreeCore; 352/// occurs when a <see cref="SyntaxTree"/> is incrementally parsed using <see cref="SyntaxTree.WithChangedText"/> 360/// from <see cref="SyntaxTree.WithChangedText"/>. This can happen as the parser is allowed to construct parse 688var tree = this.SyntaxTree; 1424protected abstract SyntaxTree SyntaxTreeCore { get; } 1645internal static T CloneNodeAsRoot<T>(T node, SyntaxTree syntaxTree) where T : SyntaxNode

434internal static SyntaxNode? AsRootOfNewTreeWithOptionsFrom(this SyntaxNode? node, SyntaxTree oldTree)

823public SyntaxTree? SyntaxTree => _nodeOrParent?.SyntaxTree;

19public abstract SyntaxTree SyntaxTree { get; }

640public SyntaxTree? SyntaxTree => Parent?.SyntaxTree; 647var tree = SyntaxTree; 666var tree = SyntaxTree; 692/// occurs when a <see cref="SyntaxTree"/> is incrementally parsed using <see cref="SyntaxTree.WithChangedText"/> 700/// from <see cref="SyntaxTree.WithChangedText"/>. This can happen as the parser is allowed to construct parse

171public abstract SyntaxTree WithChangedText(SourceText newText); 321public abstract IList<TextSpan> GetChangedSpans(SyntaxTree syntaxTree); 336public abstract bool IsEquivalentTo(SyntaxTree tree, bool topLevel = false); 351public abstract IList<TextChange> GetChanges(SyntaxTree oldTree); 376public abstract SyntaxTree WithRootAndOptions(SyntaxNode root, ParseOptions options); 381public abstract SyntaxTree WithFilePath(string path); 392public virtual SyntaxTree WithDiagnosticOptions(ImmutableDictionary<string, ReportDiagnostic> options) 398/// Returns a <see cref="String" /> that represents the entire source text of this <see cref="SyntaxTree"/>.

12internal class SyntaxTreeComparer : IEqualityComparer<SyntaxTree> 16public bool Equals(SyntaxTree? x, SyntaxTree? y) 31public int GetHashCode(SyntaxTree obj)

20internal static void VerifySource(this SyntaxTree tree, IEnumerable<TextChangeRange>? changes = null) 106public static bool IsHiddenPosition(this SyntaxTree tree, int position, CancellationToken cancellationToken = default)

398public SyntaxTree? SyntaxTree

29public sealed override SyntaxTree SyntaxTree

44/// Path of the source file (<see cref="SyntaxTree.FilePath"/>) or XML document that contains the <paramref name="path"/>.

84var syntaxTree = documentationComment.SyntaxTree;

43var tree = context.Tree;

35public readonly SyntaxTree Tree; 43SyntaxTree tree,

54var tree = switchBlock.SyntaxTree;

62var tree = model.SyntaxTree;

61var tree = context.SemanticModel.SyntaxTree; 143IEnumerable<TextSpan> contiguousSpans, SyntaxTree tree, 158IEnumerable<SyntaxNode> nodes, SyntaxTree tree, CancellationToken cancellationToken); 161IEnumerable<SyntaxNode> nodes, SyntaxTree tree, CancellationToken cancellationToken)

96var tree = semanticModel.SyntaxTree; 489static void AddAllCompilationDiagnosticsForTree(AnalysisResult analysisResult, SyntaxTree tree, ArrayBuilder<Diagnostic> reportedDiagnostics) 506SyntaxTree tree, 542SyntaxTree tree,

525foreach (var tree in namedTypeSymbol.Locations.Select(l => l.SourceTree))

104protected abstract bool SupportsDiscard(SyntaxTree tree); 195private bool TryGetOptions(SyntaxTree syntaxTree, AnalyzerOptions analyzerOptions, out Options options)

35SyntaxTree tree, TextSpan textSpan, bool allowPartialSelection, CancellationToken cancellationToken) 39SyntaxTree tree, TextSpan textSpan, bool allowPartialSelection, CancellationToken cancellationToken) 43SyntaxTree tree, TextSpan textSpan, bool allowPartialSelection,

138var syntaxTree = context.Node.SyntaxTree;

75var syntaxTree = assignment.SyntaxTree;

125var syntaxTree = context.Node.SyntaxTree;

15using TreeMap = ConcurrentDictionary<(SyntaxTree tree, int namespaceId), ImmutableDictionary<INamespaceOrTypeSymbol, IAliasSymbol>>;

129public static AnalyzerOptionsProvider GetAnalyzerOptions(this AnalyzerOptions analyzerOptions, SyntaxTree syntaxTree)

170var tree = token1.SyntaxTree;

44SyntaxTree tree, SyntaxToken token, int position, CancellationToken cancellationToken) 70public int? FromAlignTokensOperations(SyntaxTree tree, SyntaxToken token) 90SyntaxTree tree, SyntaxToken token, int position, CancellationToken cancellationToken) 96SyntaxTree tree, SyntaxToken token, int position, int extraSpaces, CancellationToken cancellationToken)

142public static int GetTokenColumn(this SyntaxTree tree, SyntaxToken token, int tabSize)

98internal Location GetLocation(SyntaxTree syntaxTree)

20var tree = context.Tree;

49SyntaxTree tree, Func<SyntaxTrivia, bool> isComment, CancellationToken cancellationToken) 118SyntaxTree tree, Func<SyntaxTrivia, bool> isComment, CancellationToken cancellationToken)

164bool IsPreProcessorDirectiveContext(SyntaxTree syntaxTree, int position, CancellationToken cancellationToken); 190bool IsEntirelyWithinStringOrCharOrNumericLiteral([NotNullWhen(true)] SyntaxTree? syntaxTree, int position, CancellationToken cancellationToken); 419TextSpan GetInactiveRegionSpanAroundPosition(SyntaxTree tree, int position, CancellationToken cancellationToken); 490bool IsInInactiveRegion(SyntaxTree syntaxTree, int position, CancellationToken cancellationToken);

20internal static void VerifySource(this SyntaxTree tree, IEnumerable<TextChangeRange>? changes = null) 106public static bool IsHiddenPosition(this SyntaxTree tree, int position, CancellationToken cancellationToken = default)

18public static bool OverlapsHiddenPosition([NotNullWhen(returnValue: true)] this SyntaxTree? tree, TextSpan span, CancellationToken cancellationToken) 36public static bool IsScript(this SyntaxTree syntaxTree) 44this SyntaxTree syntaxTree, 54this SyntaxTree syntaxTree, 63this SyntaxTree syntaxTree, 95public static bool IsEntirelyHidden(this SyntaxTree tree, TextSpan span, CancellationToken cancellationToken) 120public static bool IsBeforeFirstToken(this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 129this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 168this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken, bool findInsideTrivia = false) 201this SyntaxTree syntaxTree, 216this SyntaxTree syntaxTree, 227public static bool IsGeneratedCode(this SyntaxTree syntaxTree, AnalyzerOptions? analyzerOptions, ISyntaxFacts syntaxFacts, CancellationToken cancellationToken)

13public static SyntaxTree GetSourceTreeOrThrow(this Location location) 38var tree = loc.SourceTree;

131var sourceTree = symbol.Locations.FirstOrDefault()?.SourceTree;

162var tree = model.SyntaxTree; 221private readonly ConcurrentDictionary<SyntaxTree, (StrongBox<bool> completed, SimpleIntervalTree<TextSpan, TextSpanIntervalIntrospector>? intervalTree)> _codeBlockIntervals

37var syntaxTree = reader.GetSyntaxTree(filePath);

46var syntaxTree = location.SourceTree; 49failureReason = $"({nameof(AnonymousFunctionOrDelegateSymbolKey)} {nameof(SyntaxTree)} failed)";

78var syntaxTree = locations[0].SourceTree; 101private static SyntaxNode? TryGetContainerDeclaration(ISymbol container, SyntaxTree? syntaxTree, CancellationToken cancellationToken) 116Compilation compilation, SyntaxTree? syntaxTree, 182var firstSourceTree = locations[0]?.SourceTree; 203SyntaxNode? GetContainerDeclaration(SyntaxTree? syntaxTree) 274private static bool Contains(IEnumerable<SyntaxTree> trees, SyntaxTree tree) 276foreach (var current in trees)

75/// cref="SyntaxTree"/> is enumerated to list all the symbols with the same <see cref="ISymbol.Name"/> and <see

471internal SyntaxTree? GetSyntaxTree(string filePath) 473foreach (var tree in this.Compilation.SyntaxTrees) 688var syntaxTree = GetSyntaxTree(filePath);

136public bool TryResolve<TNode>(SyntaxTree syntaxTree, CancellationToken cancellationToken, [NotNullWhen(true)] out TNode? node)

244var destinationTree = destinationDeclaration.SyntaxTree;

66var syntaxTree = destination.SyntaxTree;

21protected abstract Task<Tuple<SyntaxTree, SyntaxNode>> GetRootInOtherSyntaxTreeAsync(SyntaxNode node, SemanticModel semanticModel, Diagnostic diagnostic, CancellationToken cancellationToken); 70var syntaxTree = result.Item1;

60var tree = await document.GetRequiredSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);

27var syntaxTree = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false); 31private static bool IsGeneratedCode(SyntaxTree syntaxTree, Document document, CancellationToken cancellationToken)

43var syntaxTree = await context.Document.GetRequiredSyntaxTreeAsync(context.CancellationToken).ConfigureAwait(false);

17var syntaxTree = await document.GetRequiredSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);

19var syntaxTree = await document.GetRequiredSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);

43public static async ValueTask<SyntaxTree> GetRequiredSyntaxTreeAsync(this Document document, CancellationToken cancellationToken) 45if (document.TryGetSyntaxTree(out var syntaxTree)) 211var syntaxTree = await document.GetRequiredSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);

17internal static async Task<SyntaxTree> FixOneAsync(SyntaxTree syntaxTree, FormattingProvider formattingProvider, SyntaxFormattingOptions options, Diagnostic diagnostic, CancellationToken cancellationToken)

67var tree = await context.Document.GetRequiredSyntaxTreeAsync(cancellationToken).ConfigureAwait(false); 68var updatedTree = await FormattingCodeFixHelper.FixOneAsync(tree, SyntaxFormatting, formattingOptions, diagnostic, cancellationToken).ConfigureAwait(false);

33public static Document GetRequiredDocument(this Solution solution, SyntaxTree syntaxTree)

17bool IsInNonUserCode(SyntaxTree syntaxTree, int position, CancellationToken cancellationToken); 20Task<ImmutableArray<SyntaxNode>> GetSelectedFieldsAndPropertiesAsync(SyntaxTree syntaxTree, TextSpan textSpan, bool allowPartialSelection, CancellationToken cancellationToken);

29public SyntaxTree SyntaxTree => Root.SyntaxTree;

26public SyntaxTree SyntaxTree => Root.SyntaxTree;

16public SyntaxTree SyntaxTree { get; }

251internal bool AreNullableAnnotationsEnabled(SyntaxTree syntaxTree, int position)

400protected bool IsAttributeConditionallyOmitted(NamedTypeSymbol attributeType, SyntaxTree? syntaxTree, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)

194var syntaxTree = syntaxRef.SyntaxTree;

2705internal static bool CheckFeatureAvailability(SyntaxTree tree, MessageID feature, BindingDiagnosticBag diagnostics, Location location) 2710internal static bool CheckFeatureAvailability(SyntaxTree tree, MessageID feature, DiagnosticBag? diagnostics, Location location)

49private SyntaxTree syntaxTree 616private static bool InSpan(Location location, SyntaxTree syntaxTree, TextSpan span) 625private static bool InSpan(ImmutableArray<Location> locations, SyntaxTree syntaxTree, TextSpan span)

51private readonly SyntaxTree _syntaxTree; 60internal BinderFactory(CSharpCompilation compilation, SyntaxTree syntaxTree, bool ignoreAccessibility) 80internal SyntaxTree SyntaxTree

13private readonly SyntaxTree _syntaxTree; 16internal WithNullableContextBinder(SyntaxTree syntaxTree, int position, Binder next)

138public SyntaxTree? SyntaxTree

455private void EmitStepThroughSequencePoint(SyntaxTree syntaxTree, TextSpan span) 496private TextSpan EmitSequencePoint(SyntaxTree syntaxTree, TextSpan span)

54var trees = new SyntaxTree?[sourceFiles.Length]; 173private SyntaxTree? ParseFile( 201private static SyntaxTree ParseFile( 207var tree = SyntaxFactory.ParseSyntaxTree( 344SyntaxTree tree,

134private HashSet<SyntaxTree>? _lazyCompilationUnitCompletedTrees; 140private ImmutableHashSet<SyntaxTree>? _usageOfUsingsRecordedInTrees = ImmutableHashSet<SyntaxTree>.Empty; 149internal ImmutableHashSet<SyntaxTree>? UsageOfUsingsRecordedInTrees => Volatile.Read(ref _usageOfUsingsRecordedInTrees); 333IEnumerable<SyntaxTree>? syntaxTrees = null, 353SyntaxTree? syntaxTree = null, 366(syntaxTree != null) ? new[] { syntaxTree } : SpecializedCollections.EmptyEnumerable<SyntaxTree>(), 377IEnumerable<SyntaxTree>? syntaxTrees, 409ImmutableArray<SyntaxTree>.Empty, 517private static LanguageVersion CommonLanguageVersion(ImmutableArray<SyntaxTree> syntaxTrees) 520foreach (var tree in syntaxTrees) 757var tree = _syntaxAndDeclarations.ExternalSyntaxTrees.SingleOrDefault(); 803public new ImmutableArray<SyntaxTree> SyntaxTrees 811public new bool ContainsSyntaxTree(SyntaxTree? syntaxTree) 819public new CSharpCompilation AddSyntaxTrees(params SyntaxTree[] trees) 821return AddSyntaxTrees((IEnumerable<SyntaxTree>)trees); 827public new CSharpCompilation AddSyntaxTrees(IEnumerable<SyntaxTree> trees) 843var externalSyntaxTrees = PooledHashSet<SyntaxTree>.GetInstance(); 891public new CSharpCompilation RemoveSyntaxTrees(params SyntaxTree[] trees) 893return RemoveSyntaxTrees((IEnumerable<SyntaxTree>)trees); 900public new CSharpCompilation RemoveSyntaxTrees(IEnumerable<SyntaxTree> trees) 912var removeSet = PooledHashSet<SyntaxTree>.GetInstance(); 917var externalSyntaxTrees = PooledHashSet<SyntaxTree>.GetInstance(); 959syntaxAndDeclarations: syntaxAndDeclarations.WithExternalSyntaxTrees(ImmutableArray<SyntaxTree>.Empty)); 965public new CSharpCompilation ReplaceSyntaxTree(SyntaxTree oldTree, SyntaxTree? newTree) 1019internal override int GetSyntaxTreeOrdinal(SyntaxTree tree) 1445internal bool IsSubmissionSyntaxTree(SyntaxTree tree) 1507var tree = _syntaxAndDeclarations.ExternalSyntaxTrees.SingleOrDefault(); 2257public new SemanticModel GetSemanticModel(SyntaxTree syntaxTree, bool ignoreAccessibility) 2279internal override SemanticModel CreateSemanticModel(SyntaxTree syntaxTree, bool ignoreAccessibility) 2292internal BinderFactory GetBinderFactory(SyntaxTree syntaxTree, bool ignoreAccessibility = false) 2302private BinderFactory GetBinderFactory(SyntaxTree syntaxTree, bool ignoreAccessibility, ref WeakReference<BinderFactory>[]? cachedBinderFactories) 2324private BinderFactory AddNewFactory(SyntaxTree syntaxTree, bool ignoreAccessibility, [NotNull] ref WeakReference<BinderFactory>? slot) 2356private void CompleteTree(SyntaxTree tree) 2358if (_lazyCompilationUnitCompletedTrees == null) Interlocked.CompareExchange(ref _lazyCompilationUnitCompletedTrees, new HashSet<SyntaxTree>(), null); 2380private void ReportUnusedImports(SyntaxTree? filterTree, BindingDiagnosticBag diagnostics, CancellationToken cancellationToken) 2396SyntaxTree infoTree = info.Tree; 2473internal override void CompleteTrees(SyntaxTree? filterTree) 2486foreach (var tree in this.SyntaxTrees) 2524public readonly SyntaxTree Tree; 2528public ImportInfo(SyntaxTree tree, SyntaxKind kind, TextSpan span) 2684var syntaxTree = syntaxTrees[i]; 2692foreach (var syntaxTree in syntaxTrees) 2703foreach (var syntaxTree in syntaxTrees) 2758private static void AppendLoadDirectiveDiagnostics(DiagnosticBag builder, SyntaxAndDeclarationManager syntaxAndDeclarations, SyntaxTree syntaxTree, Func<IEnumerable<Diagnostic>, IEnumerable<Diagnostic>>? locationFilterOpt = null) 2804private static bool IsDefinedOrImplementedInSourceTree(Symbol symbol, SyntaxTree tree, TextSpan? span) 2820private ImmutableArray<Diagnostic> GetDiagnosticsForMethodBodiesInTree(SyntaxTree tree, TextSpan? span, CancellationToken cancellationToken) 2873foreach (var otherTree in SyntaxTrees) 2901void compileMethodBodiesAndDocComments(SyntaxTree? filterTree, TextSpan? filterSpan, BindingDiagnosticBag bindingDiagnostics, CancellationToken cancellationToken) 2916void registeredUsageOfUsingsInTree(SyntaxTree tree) 2952private ImmutableBindingDiagnostic<AssemblySymbol> GetSourceDeclarationDiagnostics(SyntaxTree? syntaxTree = null, TextSpan? filterSpanWithinTree = null, Func<IEnumerable<Diagnostic>, SyntaxTree, TextSpan?, IEnumerable<Diagnostic>>? locationFilterOpt = null, CancellationToken cancellationToken = default) 2993private ImmutableBindingDiagnostic<AssemblySymbol> GetClsComplianceDiagnostics(SyntaxTree? syntaxTree, TextSpan? filterSpanWithinTree, CancellationToken cancellationToken) 3016private static IEnumerable<Diagnostic> FilterDiagnosticsByLocation(IEnumerable<Diagnostic> diagnostics, SyntaxTree tree, TextSpan? filterSpanWithinTree) 3029SyntaxTree syntaxTree, 3290public bool CheckDuplicateFilePathsAndFree(ImmutableArray<SyntaxTree> syntaxTrees, NamespaceSymbol globalNamespace) 3293foreach (var tree in syntaxTrees) 3492SyntaxTree tree, 3591foreach (var syntaxTree in this.SyntaxTrees) 3632protected override SemanticModel CommonGetSemanticModel(SyntaxTree syntaxTree, bool ignoreAccessibility) 3634return this.GetSemanticModel((SyntaxTree)syntaxTree, ignoreAccessibility); 3637protected internal override ImmutableArray<SyntaxTree> CommonSyntaxTrees 3645protected override Compilation CommonAddSyntaxTrees(IEnumerable<SyntaxTree> trees) 3650protected override Compilation CommonRemoveSyntaxTrees(IEnumerable<SyntaxTree> trees) 3660protected override Compilation CommonReplaceSyntaxTree(SyntaxTree oldTree, SyntaxTree? newTree) 3675protected override bool CommonContainsSyntaxTree(SyntaxTree? syntaxTree)

24/// cref="Compilation.GetSemanticModel(SyntaxTree, bool)"/>. 2782public new abstract SyntaxTree SyntaxTree 4915protected sealed override SyntaxTree SyntaxTreeCore

1138public override SyntaxTree SyntaxTree

23private NodeMapBuilder(OrderPreservingMultiDictionary<SyntaxNode, BoundNode> map, SyntaxTree tree, SyntaxNode thisSyntaxNodeOnly) 31private readonly SyntaxTree _tree; 41public static void AddToMap(BoundNode root, Dictionary<SyntaxNode, ImmutableArray<BoundNode>> map, SyntaxTree tree, SyntaxNode node = null)

128public override SyntaxTree SyntaxTree => _memberModel.SyntaxTree;

23ImmutableArray<SyntaxTree> externalSyntaxTrees, 45ImmutableArray<SyntaxTree> externalSyntaxTrees, 51var treesBuilder = ArrayBuilder<SyntaxTree>.GetInstance(); 52var ordinalMapBuilder = PooledDictionary<SyntaxTree, int>.GetInstance(); 53var loadDirectiveMapBuilder = PooledDictionary<SyntaxTree, ImmutableArray<LoadDirective>>.GetInstance(); 54var loadedSyntaxTreeMapBuilder = PooledDictionary<string, SyntaxTree>.GetInstance(); 55var declMapBuilder = PooledDictionary<SyntaxTree, Lazy<RootSingleNamespaceDeclaration>>.GetInstance(); 58foreach (var tree in externalSyntaxTrees) 83public SyntaxAndDeclarationManager AddSyntaxTrees(IEnumerable<SyntaxTree> trees) 103var treesBuilder = ArrayBuilder<SyntaxTree>.GetInstance(); 106foreach (var tree in trees) 143ArrayBuilder<SyntaxTree> treesBuilder, 144SyntaxTree tree, 149IDictionary<SyntaxTree, int> ordinalMapBuilder, 150IDictionary<SyntaxTree, ImmutableArray<LoadDirective>> loadDirectiveMapBuilder, 151IDictionary<string, SyntaxTree> loadedSyntaxTreeMapBuilder, 152IDictionary<SyntaxTree, Lazy<RootSingleNamespaceDeclaration>> declMapBuilder, 169ArrayBuilder<SyntaxTree> treesBuilder, 170SyntaxTree tree, 175IDictionary<SyntaxTree, int> ordinalMapBuilder, 176IDictionary<SyntaxTree, ImmutableArray<LoadDirective>> loadDirectiveMapBuilder, 177IDictionary<string, SyntaxTree> loadedSyntaxTreeMapBuilder, 178IDictionary<SyntaxTree, Lazy<RootSingleNamespaceDeclaration>> declMapBuilder, 220var loadedTree = SyntaxFactory.ParseSyntaxTree( 270SyntaxTree tree, 273IDictionary<SyntaxTree, Lazy<RootSingleNamespaceDeclaration>> declMapBuilder, 281public SyntaxAndDeclarationManager RemoveSyntaxTrees(HashSet<SyntaxTree> trees) 293var removeSet = PooledHashSet<SyntaxTree>.GetInstance(); 294foreach (var tree in trees) 310var treesBuilder = ArrayBuilder<SyntaxTree>.GetInstance(); 311var ordinalMapBuilder = PooledDictionary<SyntaxTree, int>.GetInstance(); 314foreach (var tree in syntaxTrees) 357SyntaxTree oldTree, 359ImmutableArray<SyntaxTree> syntaxTrees, 360ImmutableDictionary<SyntaxTree, int> syntaxTreeOrdinalMap, 361ImmutableDictionary<SyntaxTree, ImmutableArray<LoadDirective>> loadDirectiveMap, 362ImmutableDictionary<string, SyntaxTree> loadedSyntaxTreeMap, 363HashSet<SyntaxTree> removeSet, 388var tree = syntaxTrees[i]; 395SyntaxTree loadedTree; 408ImmutableDictionary<SyntaxTree, ImmutableArray<LoadDirective>> loadDirectiveMap, 409ImmutableDictionary<string, SyntaxTree> loadedSyntaxTreeMap, 410HashSet<SyntaxTree> removeSet) 416SyntaxTree loadedTree; 431SyntaxTree tree, 432IDictionary<SyntaxTree, Lazy<RootSingleNamespaceDeclaration>> declMap, 440public SyntaxAndDeclarationManager ReplaceSyntaxTree(SyntaxTree oldTree, SyntaxTree newTree) 455var removeSet = PooledHashSet<SyntaxTree>.GetInstance(); 473foreach (var tree in removeSet) 482ImmutableArray<SyntaxTree> newTrees; 491var treesBuilder = ArrayBuilder<SyntaxTree>.GetInstance(); 492var ordinalMapBuilder = PooledDictionary<SyntaxTree, int>.GetInstance(); 495var tree = syntaxTrees[i]; 515var tree = syntaxTrees[i]; 570internal SyntaxAndDeclarationManager WithExternalSyntaxTrees(ImmutableArray<SyntaxTree> trees) 575internal static bool IsLoadedSyntaxTree(SyntaxTree tree, ImmutableDictionary<string, SyntaxTree> loadedSyntaxTreeMap) 577SyntaxTree loadedTree; 582ArrayBuilder<SyntaxTree> treesBuilder, 583SyntaxTree tree, 584IDictionary<SyntaxTree, int> ordinalMapBuilder, 585ImmutableDictionary<SyntaxTree, ImmutableArray<LoadDirective>> loadDirectiveMap, 586ImmutableDictionary<string, SyntaxTree> loadedSyntaxTreeMap) 604SyntaxTree loadedTree; 635private static bool TryGetLoadedSyntaxTree(ImmutableDictionary<string, SyntaxTree> loadedSyntaxTreeMap, LoadDirective directive, out SyntaxTree loadedTree)

20internal readonly ImmutableArray<SyntaxTree> SyntaxTrees; // In ordinal order. 21internal readonly ImmutableDictionary<SyntaxTree, int> OrdinalMap; // Inverse of syntaxTrees array (i.e. maps tree to index) 22internal readonly ImmutableDictionary<SyntaxTree, ImmutableArray<LoadDirective>> LoadDirectiveMap; 23internal readonly ImmutableDictionary<string, SyntaxTree> LoadedSyntaxTreeMap; 24internal readonly ImmutableDictionary<SyntaxTree, Lazy<RootSingleNamespaceDeclaration>> RootNamespaces; 28ImmutableArray<SyntaxTree> syntaxTrees, 29ImmutableDictionary<SyntaxTree, int> syntaxTreeOrdinalMap, 30ImmutableDictionary<SyntaxTree, ImmutableArray<LoadDirective>> loadDirectiveMap, 31ImmutableDictionary<string, SyntaxTree> loadedSyntaxTreeMap, 32ImmutableDictionary<SyntaxTree, Lazy<RootSingleNamespaceDeclaration>> rootNamespaces, 36Debug.Assert(syntaxTrees.SetEquals(rootNamespaces.Keys.AsImmutable(), EqualityComparer<SyntaxTree>.Default));

27private readonly SyntaxTree _syntaxTree; 44internal SyntaxTreeSemanticModel(CSharpCompilation compilation, SyntaxTree syntaxTree, bool ignoreAccessibility = false) 53internal SyntaxTreeSemanticModel(CSharpCompilation parentCompilation, SyntaxTree parentSyntaxTree, SyntaxTree speculatedSyntaxTree, bool ignoreAccessibility) 86public override SyntaxTree SyntaxTree

27private readonly SyntaxTree _filterTree; //if not null, limit analysis to types residing in this tree 39SyntaxTree filterTree, 73public static void CheckCompliance(CSharpCompilation compilation, BindingDiagnosticBag diagnostics, CancellationToken cancellationToken, SyntaxTree filterTree = null, TextSpan? filterSpanWithinTree = null)

37private readonly SyntaxTree _filterTree; //if not null, limit analysis to types residing in this tree 55SyntaxTree filterTree, 86public static void WriteDocumentationCommentXml(CSharpCompilation compilation, string? assemblyName, Stream? xmlDocStream, BindingDiagnosticBag diagnostics, CancellationToken cancellationToken, SyntaxTree? filterTree = null, TextSpan? filterSpanWithinTree = null) 124foreach (SyntaxTree tree in compilation.SyntaxTrees)

547private static Binder MakeNameBinder(bool isParameter, bool isTypeParameterRef, Symbol memberSymbol, CSharpCompilation compilation, SyntaxTree syntaxTree) 636if (treelessSyntax.ContainsDiagnostics && ((SyntaxTree)sourceLocation.SourceTree).ReportDocumentationCommentDiagnostics()) 652if (((SyntaxTree)sourceLocation.SourceTree).ReportDocumentationCommentDiagnostics())

29public static void ReportUnprocessed(SyntaxTree tree, TextSpan? filterSpanWithinTree, DiagnosticBag diagnostics, CancellationToken cancellationToken)

395public static CompilationUnitSyntax GetCompilationUnitRoot(this SyntaxTree tree, CancellationToken cancellationToken = default(CancellationToken)) 400internal static bool HasReferenceDirectives([NotNullWhen(true)] this SyntaxTree? tree) 406internal static bool HasReferenceOrLoadDirectives([NotNullWhen(true)] this SyntaxTree? tree) 412internal static bool IsAnyPreprocessorSymbolDefined([NotNullWhen(true)] this SyntaxTree? tree, ImmutableArray<string> conditionalSymbols) 418internal static bool IsPreprocessorSymbolDefined([NotNullWhen(true)] this SyntaxTree? tree, string symbolName, int position) 425internal static PragmaWarningState GetPragmaDirectiveWarningState(this SyntaxTree tree, string id, int position)

22private readonly SyntaxTree _syntaxTree; 32private DeclarationTreeBuilder(SyntaxTree syntaxTree, string scriptClassName, bool isSubmission) 40SyntaxTree syntaxTree,

76var tree = (SyntaxTree)trivia.SyntaxTree;

223internal override int CalculateLocalSyntaxOffset(int localPosition, SyntaxTree localTree)

254internal override int CalculateLocalSyntaxOffset(int localPosition, SyntaxTree localTree)

51internal override int CalculateLocalSyntaxOffset(int localPosition, SyntaxTree localTree)

70internal override SyntaxTree ParseGeneratedSourceText(GeneratedSourceText input, string fileName, CancellationToken cancellationToken)

62/// <param name="position">A position within the <see cref="SyntaxTree"/> or <paramref name="semanticModel"/>.</param> 150/// <param name="position">A position within the <see cref="SyntaxTree"/> or <paramref name="semanticModel"/>.</param>

230internal sealed override int CalculateLocalSyntaxOffset(int localPosition, SyntaxTree localTree)

37var binderFactory = compilation.GetBinderFactory((SyntaxTree)symbol.Locations[0].SourceTree);

267internal override int CalculateLocalSyntaxOffset(int localPosition, SyntaxTree localTree)

20public static FileIdentifier Create(SyntaxTree tree)

841internal override int CalculateLocalSyntaxOffset(int localPosition, SyntaxTree localTree) => throw ExceptionUtilities.Unreachable();

62private LexicalSortKey(SyntaxTree tree, int position, CSharpCompilation compilation) 75: this((SyntaxTree)location.SourceTree, location.SourceSpan.Start, compilation) 91: this((SyntaxTree)token.SyntaxTree, token.SpanStart, compilation)

1522internal override int CalculateLocalSyntaxOffset(int localPosition, SyntaxTree localTree)

507internal virtual bool CallsAreOmitted(SyntaxTree syntaxTree) 520private bool CallsAreConditionallyOmitted(SyntaxTree syntaxTree) 1133internal abstract int CalculateLocalSyntaxOffset(int localPosition, SyntaxTree localTree); 1183int IMethodSymbolInternal.CalculateLocalSyntaxOffset(int localPosition, SyntaxTree localTree) => CalculateLocalSyntaxOffset(localPosition, localTree);

354internal override int CalculateLocalSyntaxOffset(int localPosition, SyntaxTree localTree)

134var syntaxTree = CSharpSyntaxTree.Dummy; 543internal override bool CallsAreOmitted(SyntaxTree syntaxTree) 570internal override int CalculateLocalSyntaxOffset(int localPosition, SyntaxTree localTree)

372internal override int CalculateLocalSyntaxOffset(int localPosition, SyntaxTree localTree)

173internal override int CalculateLocalSyntaxOffset(int localPosition, SyntaxTree localTree) { throw ExceptionUtilities.Unreachable(); }

410internal override int CalculateLocalSyntaxOffset(int localPosition, SyntaxTree localTree)

349internal override int CalculateLocalSyntaxOffset(int localPosition, SyntaxTree localTree)

1549var tree = rootNs.Location.SourceTree;

191internal sealed override int CalculateLocalSyntaxOffset(int position, SyntaxTree tree)

415internal SyntaxTree SyntaxTree

189public SyntaxTree SyntaxTree

838internal SyntaxTree AssociatedSyntaxTree => declaration.Declarations[0].Location.SourceTree; 989internal override bool IsDefinedInSourceTree(SyntaxTree tree, TextSpan? definedWithinSpan, CancellationToken cancellationToken) 1071internal int CalculateSyntaxOffsetInSynthesizedConstructor(int position, SyntaxTree tree, bool isStatic) 1114internal bool TryCalculateSyntaxOffsetOfPositionInInitializer(int position, SyntaxTree tree, bool isStatic, int ctorInitializerLength, out int syntaxOffset) 1145static bool findInitializer(ImmutableArray<ImmutableArray<FieldOrPropertyInitializer>> initializers, int position, SyntaxTree tree, 1299var conflictDict = new Dictionary<(string name, int arity, SyntaxTree? syntaxTree), SourceNamedTypeSymbol>(); 1780var tree = declaration.Declarations[0].SyntaxReference.SyntaxTree;

629internal override bool IsDefinedInSourceTree(SyntaxTree tree, TextSpan? definedWithinSpan, CancellationToken cancellationToken = default(CancellationToken))

1016internal override int CalculateLocalSyntaxOffset(int localPosition, SyntaxTree localTree)

89internal SyntaxTree SyntaxTree

160var syntaxTree = syntaxRef.SyntaxTree; 1191var syntaxTree = list.Node.SyntaxTree;

826static PooledHashSet<NamespaceOrTypeSymbol> getOrCreateUniqueGlobalUsingsNotInTree(ref PooledHashSet<NamespaceOrTypeSymbol>? uniqueUsings, ImmutableArray<NamespaceOrTypeAndUsingDirective> globalUsingNamespacesOrTypes, SyntaxTree tree)

414var leftTree = possibleFileLocalType.MergedDeclaration.Declarations[0].Location.SourceTree; 480internal override bool IsDefinedInSourceTree(SyntaxTree tree, TextSpan? definedWithinSpan, CancellationToken cancellationToken = default(CancellationToken))

616SyntaxTree tree, 797internal override bool CallsAreOmitted(SyntaxTree syntaxTree)

429var syntaxTree = SyntaxTree;

649internal SyntaxTree SyntaxTree

301internal sealed override bool CallsAreOmitted(SyntaxTree syntaxTree) 353internal override int CalculateLocalSyntaxOffset(int localPosition, SyntaxTree localTree)

800internal virtual bool IsDefinedInSourceTree(SyntaxTree tree, TextSpan? definedWithinSpan, CancellationToken cancellationToken = default(CancellationToken))

168var tree = syntaxReferences[0].SyntaxTree;

280internal override int CalculateLocalSyntaxOffset(int localPosition, SyntaxTree localTree) 287var syntaxTree = CSharpSyntaxTree.Dummy;

332internal override int CalculateLocalSyntaxOffset(int localPosition, SyntaxTree localTree)

268internal sealed override int CalculateLocalSyntaxOffset(int localPosition, SyntaxTree localTree)

69internal override int CalculateLocalSyntaxOffset(int localPosition, SyntaxTree localTree)

233internal override int CalculateLocalSyntaxOffset(int localPosition, SyntaxTree localTree)

410internal override int CalculateLocalSyntaxOffset(int localPosition, SyntaxTree localTree)

192internal override int CalculateLocalSyntaxOffset(int localPosition, SyntaxTree localTree) 255internal override bool IsDefinedInSourceTree(SyntaxTree tree, TextSpan? definedWithinSpan, CancellationToken cancellationToken)

375internal override int CalculateLocalSyntaxOffset(int localPosition, SyntaxTree localTree)

16public CSharpLineDirectiveMap(SyntaxTree syntaxTree)

39public CSharpPragmaWarningStateMap(SyntaxTree syntaxTree) : 44protected override WarningStateMapEntry[] CreateWarningStateMapEntries(SyntaxTree syntaxTree) 58private static void GetAllPragmaWarningDirectives(SyntaxTree syntaxTree, ArrayBuilder<DirectiveTriviaSyntax> directiveList)

36internal CSharpSyntaxNode(GreenNode green, int position, SyntaxTree syntaxTree) 47internal new SyntaxTree SyntaxTree 51var result = this._syntaxTree ?? ComputeSyntaxTree(this); 57private static SyntaxTree ComputeSyntaxTree(CSharpSyntaxNode node) 60SyntaxTree? tree = null; 100var existingTree = n._syntaxTree; 474protected override SyntaxTree SyntaxTreeCore

29internal static readonly SyntaxTree Dummy = new DummySyntaxTree(); 110/// Ensure that <see cref="SyntaxTree.HasCompilationUnitRoot"/> is true for this tree prior to invoking this method. 112/// <exception cref="InvalidCastException">Throws this exception if <see cref="SyntaxTree.HasCompilationUnitRoot"/> is false.</exception> 126public override bool IsEquivalentTo(SyntaxTree tree, bool topLevel = false) 314public static SyntaxTree Create(CSharpSyntaxNode root, CSharpParseOptions? options = null, string? path = "", Encoding? encoding = null) 330public static SyntaxTree Create( 357internal static SyntaxTree Create( 380internal static SyntaxTree CreateForDebugger(CSharpSyntaxNode root, SourceText text, CSharpParseOptions options) 395internal static SyntaxTree CreateWithoutClone(CSharpSyntaxNode root) 415internal static SyntaxTree ParseTextLazy( 430public static SyntaxTree ParseText( 451public static SyntaxTree ParseText( 470public static SyntaxTree ParseText( 490public static SyntaxTree ParseText( 534public override SyntaxTree WithChangedText(SourceText newText) 553private SyntaxTree WithChanges(SourceText newText, IReadOnlyList<TextChangeRange> changes) 597public override IList<TextSpan> GetChangedSpans(SyntaxTree oldTree) 612public override IList<TextChange> GetChanges(SyntaxTree oldTree) 658/// otherwise it's <see cref="SyntaxTree.FilePath"/>. 919public static SyntaxTree ParseText( 930public static SyntaxTree ParseText( 942public static SyntaxTree Create(

94public override SyntaxTree WithRootAndOptions(SyntaxNode root, ParseOptions options) 97public override SyntaxTree WithFilePath(string path)

70var tree = SyntaxFactory.ParseSyntaxTree(_text, _options, _path, cancellationToken); 109public override SyntaxTree WithRootAndOptions(SyntaxNode root, ParseOptions options) 128public override SyntaxTree WithFilePath(string path) 155public override SyntaxTree WithDiagnosticOptions(ImmutableDictionary<string, ReportDiagnostic> options)

123public override SyntaxTree WithRootAndOptions(SyntaxNode root, ParseOptions options) 142public override SyntaxTree WithFilePath(string path) 162public override SyntaxTree WithDiagnosticOptions(ImmutableDictionary<string, ReportDiagnostic> options)

44internal static NullableContextStateMap Create(SyntaxTree tree) 136private static ImmutableArray<NullableContextState> GetContexts(SyntaxTree tree)

22public override SyntaxTree SyntaxTree

15internal static bool AreEquivalent(SyntaxTree? before, SyntaxTree? after, Func<SyntaxKind, bool>? ignoreChildNode, bool topLevel)

177internal static bool ReportDocumentationCommentDiagnostics(this SyntaxTree tree)

1546public static SyntaxTree SyntaxTree(SyntaxNode root, ParseOptions? options = null, string path = "", Encoding? encoding = null) 1554public static SyntaxTree ParseSyntaxTree( 1566public static SyntaxTree ParseSyntaxTree( 1926public static bool AreEquivalent(SyntaxTree? oldTree, SyntaxTree? newTree, bool topLevel) 2303public static bool IsCompleteSubmission(SyntaxTree tree) 2770public static SyntaxTree ParseSyntaxTree( 2784public static SyntaxTree ParseSyntaxTree( 2797public static SyntaxTree ParseSyntaxTree( 2812public static SyntaxTree ParseSyntaxTree(

16private readonly SyntaxTree? _syntaxTree; 22internal SyntaxTreeDiagnosticEnumerator(SyntaxTree syntaxTree, GreenNode? node, int position)

46var tree = context.Tree;

35var syntaxTree = namespaceDeclaration.SyntaxTree;

131public static CSharpAnalyzerOptionsProvider GetCSharpAnalyzerOptions(this AnalyzerOptions options, SyntaxTree syntaxTree) 149public static CSharpAnalyzerOptionsProvider GetCSharpAnalyzerOptions(this SymbolStartAnalysisContext context, SyntaxTree syntaxTree)

55var syntaxTree = node.SyntaxTree;

62var syntaxTree = context.Node.SyntaxTree;

51IEnumerable<SyntaxNode> nodes, SyntaxTree tree, CancellationToken cancellationToken)

64var syntaxTree = semanticModel.SyntaxTree;

188public static SyntaxTreeState Create(bool defaultCompleted, NullableContextOptions compilationOptions, SyntaxTree tree, CancellationToken cancellationToken) 268private readonly ConcurrentDictionary<SyntaxTree, SyntaxTreeState> _codeBlockIntervals 311private SyntaxTreeState GetOrCreateSyntaxTreeState(SyntaxTree tree, bool defaultCompleted, SemanticModel semanticModel, CancellationToken cancellationToken)

26protected override bool SupportsDiscard(SyntaxTree tree)

117public bool IsPreProcessorDirectiveContext(SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 121public bool IsEntirelyWithinStringOrCharOrNumericLiteral([NotNullWhen(true)] SyntaxTree? syntaxTree, int position, CancellationToken cancellationToken) 1094public TextSpan GetInactiveRegionSpanAroundPosition(SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 1523public bool IsInInactiveRegion(SyntaxTree syntaxTree, int position, CancellationToken cancellationToken)

37var syntaxTree = context.Node.SyntaxTree;

39var syntaxTree = context.Node.SyntaxTree;

190var tree = semanticModel.SyntaxTree; 201var newTree = tree.WithRootAndOptions(newRoot, tree.Options);

44var syntaxTree = context.Node.SyntaxTree;

63var syntaxTree = expression.SyntaxTree;

299var tree = token1.SyntaxTree;

132var tree = syntaxContext.SemanticModel.SyntaxTree; 174var tree = syntaxContext.Node.SyntaxTree; 319var tree = semanticModel.SyntaxTree;

20public static bool IsPreProcessorDirectiveContext(this SyntaxTree syntaxTree, int position, SyntaxToken preProcessorTokenOnLeftOfPosition, CancellationToken cancellationToken)

17public static ISet<SyntaxKind> GetPrecedingModifiers(this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 21this SyntaxTree syntaxTree, 85this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 91this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 97this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 123this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 134public static bool IsRightOfDotOrArrowOrColonColon(this SyntaxTree syntaxTree, int position, SyntaxToken targetToken, CancellationToken cancellationToken) 141public static bool IsRightOfDotOrArrow(this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 145this SyntaxTree syntaxTree, int position, Func<SyntaxKind, bool> predicate, CancellationToken cancellationToken) 158public static bool IsRightOfNumericLiteral(this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 164public static bool IsAfterKeyword(this SyntaxTree syntaxTree, int position, SyntaxKind kind, CancellationToken cancellationToken) 172public static bool IsEntirelyWithinNonUserCodeComment(this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 184public static bool IsEntirelyWithinComment(this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 194public static bool IsCrefContext(this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 207public static bool IsEntirelyWithinCrefSyntax(this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 219this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 263this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 281this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 298this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 312this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 336this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 408this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 416this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 459this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 487this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 549public static bool IsPreProcessorKeywordContext(this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 557public static bool IsPreProcessorKeywordContext(this SyntaxTree syntaxTree, int position, SyntaxToken preProcessorTokenOnLeftOfPosition)

154this SyntaxTrivia trivia, SyntaxTree syntaxTree, CancellationToken cancellationToken, bool findInsideTrivia = false)

40var syntaxTree = context.SemanticModel.SyntaxTree;

122var syntaxTree = document.SyntaxTree; 138SyntaxTree tree, SourceText text, string indentation, TextLine textLine, CancellationToken cancellationToken)

47var tree = await document.GetRequiredSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);

72var syntaxTree = destination.SyntaxTree; 81var tree = node.SyntaxTree.WithRootAndOptions(node, syntaxTree.Options); 199var contextTree = contextLocation != null && contextLocation.IsInSource

47protected override async Task<Tuple<SyntaxTree, SyntaxNode>?> GetRootInOtherSyntaxTreeAsync(

183var syntaxTree = semanticModel.SyntaxTree;

28public bool IsInNonUserCode(SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 116public Task<ImmutableArray<SyntaxNode>> GetSelectedFieldsAndPropertiesAsync(SyntaxTree tree, TextSpan textSpan, bool allowPartialSelection, CancellationToken cancellationToken)

194var syntaxTree = SemanticModel.SyntaxTree;

28public static bool IsAttributeNameContext(this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 77this SyntaxTree syntaxTree, 137this SyntaxTree syntaxTree, int position, SyntaxToken tokenOnLeftOfPosition) 239this SyntaxTree syntaxTree, 319this SyntaxTree syntaxTree, 335public static bool IsLocalFunctionDeclarationContext(this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 339this SyntaxTree syntaxTree, 368this SyntaxTree syntaxTree, int position, SyntaxToken tokenOnLeftOfPosition, CancellationToken cancellationToken) 528this SyntaxTree syntaxTree, 614this SyntaxTree syntaxTree, 667public static bool IsNamespaceDeclarationNameContext(this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 684public static bool IsPartialTypeDeclarationNameContext(this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken, [NotNullWhen(true)] out TypeDeclarationSyntax? declarationSyntax) 705public static bool IsDefinitelyNotTypeContext(this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 716this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken, SemanticModel? semanticModel = null) 766public static bool IsBaseClassOrInterfaceContext(this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 787public static bool IsUsingAliasTypeContext(this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 803public static bool IsUsingStaticContext(this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 814this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 842this SyntaxTree syntaxTree, int position, SyntaxToken tokenOnLeftOfPosition) 860public static bool IsTypeParameterConstraintContext(this SyntaxTree syntaxTree, int position, SyntaxToken tokenOnLeftOfPosition) 891public static bool IsTypeOfExpressionContext(this SyntaxTree syntaxTree, int position, SyntaxToken tokenOnLeftOfPosition) 903public static bool IsDefaultExpressionContext(this SyntaxTree syntaxTree, int position, SyntaxToken tokenOnLeftOfPosition) 916this SyntaxTree syntaxTree, int position, SyntaxToken tokenOnLeftOfPosition) 929this SyntaxTree syntaxTree, 954public static bool IsGenericConstraintContext(this SyntaxTree syntaxTree, SyntaxToken targetToken) 959this SyntaxTree syntaxTree, 1032this SyntaxTree syntaxTree, 1113this SyntaxTree syntaxTree, 1141this SyntaxTree syntaxTree, int position, SyntaxToken tokenOnLeftOfPosition) 1156this SyntaxTree syntaxTree, int position, SyntaxToken tokenOnLeftOfPosition) 1173public static bool IsParameterTypeContext(this SyntaxTree syntaxTree, int position, SyntaxToken tokenOnLeftOfPosition) 1197public static bool IsPossibleExtensionMethodContext(this SyntaxTree syntaxTree, SyntaxToken tokenOnLeftOfPosition) 1209this SyntaxTree syntaxTree, int position, SyntaxToken tokenOnLeftOfPosition, CancellationToken cancellationToken) 1241this SyntaxTree syntaxTree, int position, SyntaxToken tokenOnLeftOfPosition) 1268this SyntaxTree syntaxTree, int position, SyntaxToken tokenOnLeftOfPosition, CancellationToken cancellationToken) 1293public static bool IsPossibleTupleContext(this SyntaxTree syntaxTree, SyntaxToken leftToken, int position) 1348public static bool IsAtStartOfPattern(this SyntaxTree syntaxTree, SyntaxToken leftToken, int position) 1442public static bool IsAtEndOfPattern(this SyntaxTree syntaxTree, SyntaxToken leftToken, int position) 1583public static bool IsPossibleDeconstructionDesignation(this SyntaxTree syntaxTree, 1693this SyntaxTree syntaxTree, 1733this SyntaxTree syntaxTree, int position, SyntaxToken tokenOnLeftOfPosition) 1750this SyntaxTree syntaxTree, int position, SyntaxToken tokenOnLeftOfPosition, CancellationToken cancellationToken) 1868this SyntaxTree syntaxTree, int position, SyntaxToken tokenOnLeftOfPosition) 1885public static bool IsCatchVariableDeclarationContext(this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 1902public static bool IsIsOrAsTypeContext(this SyntaxTree syntaxTree, int position, SyntaxToken tokenOnLeftOfPosition) 1917this SyntaxTree syntaxTree, int position, SyntaxToken tokenOnLeftOfPosition, CancellationToken cancellationToken) 1935private static bool IsNonConstantExpressionContext(SyntaxTree syntaxTree, int position, SyntaxToken tokenOnLeftOfPosition, CancellationToken cancellationToken) 1942public static bool IsPreProcessorDirectiveContext(this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 1949public static bool IsStatementContext(this SyntaxTree syntaxTree, int position, SyntaxToken tokenOnLeftOfPosition, CancellationToken cancellationToken) 1967public static bool IsGlobalStatementContext(this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 1990public static bool IsInstanceContext(this SyntaxTree syntaxTree, SyntaxToken targetToken, SemanticModel semanticModel, CancellationToken cancellationToken) 2021this SyntaxTree syntaxTree, int position, SyntaxToken tokenOnLeftOfPosition, CancellationToken cancellationToken) 2034public static bool IsDefiniteCastTypeContext(this SyntaxTree syntaxTree, int position, SyntaxToken tokenOnLeftOfPosition) 2048public static bool IsConstantExpressionContext(this SyntaxTree syntaxTree, int position, 2129public static bool IsLabelContext(this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 2155this SyntaxTree syntaxTree, 2739public static bool IsNameOfContext(this SyntaxTree syntaxTree, int position, SemanticModel? semanticModelOpt = null, CancellationToken cancellationToken = default) 2806this SyntaxTree syntaxTree, 2926this SyntaxTree syntaxTree, int position, SyntaxToken tokenOnLeftOfPosition) 2963public static bool IsCatchFilterContext(this SyntaxTree syntaxTree, int position, SyntaxToken tokenOnLeftOfPosition) 2988public static bool IsEnumBaseListContext(this SyntaxTree syntaxTree, int position, SyntaxToken tokenOnLeftOfPosition) 3003public static bool IsEnumTypeMemberAccessContext(this SyntaxTree syntaxTree, SemanticModel semanticModel, int position, CancellationToken cancellationToken) 3058public static bool IsFunctionPointerCallingConventionContext(this SyntaxTree syntaxTree, SyntaxToken targetToken)

21var syntaxTree = genericIdentifier.SyntaxTree!; 38/// <remarks>This is related to the code in <see cref="SyntaxTreeExtensions.IsInPartiallyWrittenGeneric(SyntaxTree, int, CancellationToken)"/></remarks>

15public static bool IsPrimaryFunctionExpressionContext(this SyntaxTree syntaxTree, int position, SyntaxToken tokenOnLeftOfPosition) 23public static bool IsInNonUserCode(this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 33this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 39this SyntaxTree syntaxTree, 48this SyntaxTree syntaxTree,

249var tree = comp.SyntaxTrees.Single(); 698var compilation = CreateCompilation(new SyntaxTree[0]); 822var compilation = CreateCompilation(new SyntaxTree[0]); 9191var tree = SyntaxFactory.ParseSyntaxTree("class C public { }", path: "goo"); 9438var syntaxTree = SyntaxFactory.ParseSyntaxTree(sampleProgram, path: "filename.cs"); 11961new SyntaxTree[] { SyntaxFactory.ParseSyntaxTree(analyzerSource) }, 14147var tree = comp.SyntaxTrees.Single();

147var tree = document.SyntaxTree; 182private static SyntaxNode? ParseNode(SyntaxTree tree, SyntaxNode owningNode, string textToParse)

282var syntaxTree = document.GetRequiredSyntaxTreeSynchronously(cancellationToken);

38var tree = document.GetRequiredSyntaxTreeSynchronously(cancellationToken);

201var syntaxTree = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);

31var tree = SyntaxFactory.ParseSyntaxTree(SourceText.From(code, encoding: null, SourceHashAlgorithms.Default), options);

3086var oldTree = await document.GetSyntaxTreeAsync();

42private static SyntaxTree GetTree() 45private static SyntaxTree GetTreeFromCode(string code) 51var tree = GetTreeFromCode(@"using System;

22var tree = GetTree(); 33var tree = GetTree(); 44var tree = GetTree(); 55var tree = GetTree(); 66var tree = GetTree(); 77var tree = GetTree(); 88var tree = GetTree(); 99var tree = GetTree(); 110var tree = GetTree(); 121var tree = GetTree(); 132var tree = GetTree(); 144var tree = GetTree(); 156var tree = GetTree(); 168var tree = GetTree(); 179var tree = GetTree(); 190var tree = GetTree(); 201var tree = GetTree(); 213var tree = GetTree(); 225var tree = GetTree(); 237var tree = GetTree(); 249var tree = GetTree(); 261var tree = GetTree(); 272var tree = GetTree(); 284var tree = GetTree(); 296var tree = GetTree(); 308var tree = GetTree(); 320var tree = GetTree(); 332var tree = GetTree(); 344var tree = GetTree(); 356var tree = GetTree(); 368var tree = GetTree(); 380var tree = GetTree(); 392var tree = GetTree(); 404var tree = GetTree(); 416var tree = GetTree(); 428var tree = GetTree(); 439var tree = GetTree(); 450var tree = GetTree(); 462var tree = GetTree(); 474var tree = GetTree(); 486var tree = GetTree(); 498var tree = GetTree(); 510var tree = GetTree(); 521var tree = GetTree(); 533var tree = GetTree(); 545var tree = GetTree(); 557var tree = GetTree(); 569var tree = GetTree(); 581var tree = GetTree(); 593var tree = GetTree(); 605var tree = GetTree(); 617var tree = GetTree(); 629var tree = GetTree(); 641var tree = GetTree(); 653var tree = GetTree(); 665var tree = GetTree(); 677var tree = GetTree(); 689var tree = GetTree(); 701var tree = GetTree(); 713var tree = GetTree(); 725var tree = GetTree(); 737var tree = GetTree(); 749var tree = GetTree(); 761var tree = GetTree(); 773var tree = GetTree(); 785var tree = GetTree(); 797var tree = GetTree(); 809var tree = GetTree(); 821var tree = GetTree(); 833var tree = GetTree(); 845var tree = GetTree(); 857var tree = GetTree(); 869var tree = GetTree(); 881var tree = GetTree(); 893var tree = GetTree(); 905var tree = GetTree(); 917var tree = GetTree(); 929var tree = GetTree(); 941var tree = GetTree(); 953var tree = GetTree(); 965var tree = GetTree(); 977var tree = GetTree(); 989var tree = GetTree(); 1001var tree = GetTree(); 1013var tree = GetTree(); 1025var tree = GetTree(); 1037var tree = GetTree(); 1049var tree = GetTree(); 1061var tree = GetTree(); 1073var tree = GetTree(); 1085var tree = GetTree(); 1097var tree = GetTree(); 1109var tree = GetTree(); 1121var tree = GetTree(); 1133var tree = GetTree(); 1145var tree = GetTree(); 1157var tree = GetTree(); 1169var tree = GetTree(); 1181var tree = GetTree(); 1193var tree = GetTree(); 1205var tree = GetTree(); 1217var tree = GetTree(); 1229var tree = GetTree(); 1241var tree = GetTree(); 1252var tree = GetTree(); 1264var tree = GetTree(); 1276var tree = GetTree(); 1288var tree = GetTree(); 1300var tree = GetTree(); 1312var tree = GetTree(); 1323var tree = GetTree(); 1335var tree = GetTree(); 1347var tree = GetTree(); 1359var tree = GetTree(); 1371var tree = GetTree(); 1383var tree = GetTree(); 1394var tree = GetTree(); 1406var tree = GetTree(); 1418var tree = GetTree(); 1430var tree = GetTree(); 1441var tree = GetTree(); 1452var tree = GetTree(); 1464var tree = GetTree(); 1476var tree = GetTree(); 1488var tree = GetTree(); 1500var tree = GetTree(); 1512var tree = GetTree(); 1524var tree = GetTree(); 1536var tree = GetTree(); 1548var tree = GetTree(); 1560var tree = GetTree(); 1572var tree = GetTree(); 1584var tree = GetTree(); 1596var tree = GetTree(); 1608var tree = GetTree(); 1620var tree = GetTree(); 1632var tree = GetTree(); 1644var tree = GetTree(); 1656var tree = GetTree(); 1668var tree = GetTree(); 1680var tree = GetTree(); 1692var tree = GetTree(); 1704var tree = GetTree(); 1716var tree = GetTree(); 1728var tree = GetTree(); 1740var tree = GetTree(); 1752var tree = GetTree(); 1764var tree = GetTree(); 1776var tree = GetTree(); 1788var tree = GetTree(); 1800var tree = GetTree(); 1812var tree = GetTree(); 1824var tree = GetTree(); 1835var tree = GetTree(); 1846var tree = GetTree(); 1858var tree = GetTree(); 1870var tree = GetTree(); 1882var tree = GetTree(); 1894var tree = GetTree(); 1906var tree = GetTree(); 1918var tree = GetTree(); 1930var tree = GetTree(); 1942var tree = GetTree(); 1954var tree = GetTree(); 1966var tree = GetTree(); 1978var tree = GetTree(); 1990var tree = GetTree(); 2002var tree = GetTree(); 2014var tree = GetTree(); 2026var tree = GetTree(); 2038var tree = GetTree(); 2050var tree = GetTree(); 2062var tree = GetTree(); 2074var tree = GetTree(); 2086var tree = GetTree(); 2097var tree = GetTree(); 2108var tree = GetTree(); 2120var tree = GetTree(); 2132var tree = GetTree(); 2144var tree = GetTree(); 2156var tree = GetTree(); 2168var tree = GetTree(); 2180var tree = GetTree(); 2192var tree = GetTree(); 2204var tree = GetTree(); 2216var tree = GetTree(); 2228var tree = GetTree(); 2240var tree = GetTree(); 2252var tree = GetTree(); 2264var tree = GetTree(); 2276var tree = GetTree(); 2288var tree = GetTree(); 2300var tree = GetTree(); 2312var tree = GetTree(); 2324var tree = GetTree(); 2336var tree = GetTree(); 2348var tree = GetTree(); 2360var tree = GetTree(); 2371var tree = GetTree(); 2382var tree = GetTree(); 2394var tree = GetTree(); 2406var tree = GetTree(); 2418var tree = GetTree(); 2430var tree = GetTree(); 2442var tree = GetTree(); 2454var tree = GetTree(); 2466var tree = GetTree(); 2478var tree = GetTree(); 2490var tree = GetTree(); 2502var tree = GetTree(); 2514var tree = GetTree(); 2526var tree = GetTree(); 2538var tree = GetTree(); 2550var tree = GetTree(); 2562var tree = GetTree(); 2574var tree = GetTree(); 2586var tree = GetTree(); 2598var tree = GetTree(); 2609var tree = GetTree(); 2620var tree = GetTree(); 2632var tree = GetTree(); 2644var tree = GetTree(); 2656var tree = GetTree(); 2668var tree = GetTree(); 2680var tree = GetTree(); 2692var tree = GetTree(); 2704var tree = GetTree(); 2716var tree = GetTree(); 2728var tree = GetTree(); 2740var tree = GetTree(); 2752var tree = GetTree(); 2764var tree = GetTree(); 2776var tree = GetTree(); 2788var tree = GetTree(); 2800var tree = GetTree(); 2812var tree = GetTree(); 2824var tree = GetTree(); 2836var tree = GetTree(); 2848var tree = GetTree(); 2860var tree = GetTree(); 2871var tree = GetTree(); 2882var tree = GetTree(); 2894var tree = GetTree(); 2906var tree = GetTree(); 2918var tree = GetTree(); 2930var tree = GetTree(); 2942var tree = GetTree(); 2954var tree = GetTree(); 2966var tree = GetTree(); 2978var tree = GetTree(); 2990var tree = GetTree(); 3002var tree = GetTree(); 3014var tree = GetTree(); 3026var tree = GetTree(); 3038var tree = GetTree(); 3050var tree = GetTree(); 3062var tree = GetTree(); 3074var tree = GetTree(); 3086var tree = GetTree(); 3097var tree = GetTree(); 3108var tree = GetTree(); 3120var tree = GetTree(); 3132var tree = GetTree(); 3144var tree = GetTree(); 3156var tree = GetTree(); 3168var tree = GetTree(); 3180var tree = GetTree(); 3192var tree = GetTree(); 3204var tree = GetTree(); 3216var tree = GetTree(); 3228var tree = GetTree(); 3240var tree = GetTree(); 3252var tree = GetTree(); 3264var tree = GetTree(); 3276var tree = GetTree(); 3288var tree = GetTree(); 3300var tree = GetTree(); 3312var tree = GetTree(); 3324var tree = GetTree(); 3336var tree = GetTree(); 3348var tree = GetTree(); 3360var tree = GetTree(); 3372var tree = GetTree(); 3384var tree = GetTree(); 3397var tree = GetTree(); 3409var tree = GetTree(); 3421var tree = GetTree(); 3433var tree = GetTree(); 3445var tree = GetTree(); 3457var tree = GetTree(); 3469var tree = GetTree(); 3481var tree = GetTree(); 3493var tree = GetTree(); 3505var tree = GetTree(); 3517var tree = GetTree(); 3528var tree = GetTree(); 3539var tree = GetTree(); 3551var tree = GetTree(); 3563var tree = GetTree(); 3575var tree = GetTree(); 3587var tree = GetTree(); 3599var tree = GetTree(); 3611var tree = GetTree(); 3623var tree = GetTree(); 3635var tree = GetTree(); 3647var tree = GetTree(); 3659var tree = GetTree(); 3671var tree = GetTree(); 3683var tree = GetTree(); 3695var tree = GetTree(); 3707var tree = GetTree(); 3719var tree = GetTree(); 3731var tree = GetTree(); 3743var tree = GetTree(); 3755var tree = GetTree(); 3767var tree = GetTree(); 3779var tree = GetTree(); 3791var tree = GetTree(); 3803var tree = GetTree(); 3814var tree = GetTree(); 3825var tree = GetTree(); 3837var tree = GetTree(); 3849var tree = GetTree(); 3861var tree = GetTree(); 3873var tree = GetTree(); 3885var tree = GetTree(); 3897var tree = GetTree(); 3909var tree = GetTree(); 3921var tree = GetTree(); 3933var tree = GetTree(); 3944var tree = GetTree(); 3955var tree = GetTree();

25var tree = GetTree(); 39var tree = GetTree(); 53var tree = GetTree(); 67var tree = GetTree(); 81var tree = GetTree(); 95var tree = GetTree(); 109var tree = GetTree(); 123var tree = GetTree(); 137var tree = GetTree(); 151var tree = GetTree(); 165var tree = GetTree(); 179var tree = GetTree(); 193var tree = GetTree(); 207var tree = GetTree(); 221var tree = GetTree(); 235var tree = GetTree(); 249var tree = GetTree(); 263var tree = GetTree(); 277var tree = GetTree(); 291var tree = GetTree(); 305var tree = GetTree(); 319var tree = GetTree(); 333var tree = GetTree(); 347var tree = GetTree(); 361var tree = GetTree(); 375var tree = GetTree(); 389var tree = GetTree(); 403var tree = GetTree(); 417var tree = GetTree(); 431var tree = GetTree(); 445var tree = GetTree(); 459var tree = GetTree(); 473var tree = GetTree(); 487var tree = GetTree(); 501var tree = GetTree(); 515var tree = GetTree(); 529var tree = GetTree(); 543var tree = GetTree(); 557var tree = GetTree(); 571var tree = GetTree(); 585var tree = GetTree(); 599var tree = GetTree(); 613var tree = GetTree(); 627var tree = GetTree(); 641var tree = GetTree(); 655var tree = GetTree(); 669var tree = GetTree(); 683var tree = GetTree(); 697var tree = GetTree(); 711var tree = GetTree(); 725var tree = GetTree(); 739var tree = GetTree(); 753var tree = GetTree(); 767var tree = GetTree(); 781var tree = GetTree(); 795var tree = GetTree(); 809var tree = GetTree(); 823var tree = GetTree(); 837var tree = GetTree(); 851var tree = GetTree(); 865var tree = GetTree(); 879var tree = GetTree(); 893var tree = GetTree(); 907var tree = GetTree(); 921var tree = GetTree(); 935var tree = GetTree(); 949var tree = GetTree(); 963var tree = GetTree(); 977var tree = GetTree(); 991var tree = GetTree(); 1005var tree = GetTree(); 1019var tree = GetTree(); 1033var tree = GetTree(); 1047var tree = GetTree(); 1061var tree = GetTree(); 1075var tree = GetTree(); 1089var tree = GetTree(); 1103var tree = GetTree(); 1117var tree = GetTree(); 1131var tree = GetTree(); 1145var tree = GetTree(); 1159var tree = GetTree(); 1173var tree = GetTree(); 1187var tree = GetTree(); 1201var tree = GetTree(); 1215var tree = GetTree(); 1229var tree = GetTree(); 1243var tree = GetTree(); 1257var tree = GetTree(); 1271var tree = GetTree(); 1285var tree = GetTree(); 1299var tree = GetTree(); 1313var tree = GetTree(); 1327var tree = GetTree(); 1341var tree = GetTree(); 1355var tree = GetTree(); 1369var tree = GetTree(); 1383var tree = GetTree(); 1397var tree = GetTree(); 1411var tree = GetTree(); 1425var tree = GetTree(); 1439var tree = GetTree(); 1453var tree = GetTree(); 1467var tree = GetTree(); 1481var tree = GetTree(); 1495var tree = GetTree(); 1509var tree = GetTree(); 1523var tree = GetTree(); 1537var tree = GetTree(); 1551var tree = GetTree(); 1565var tree = GetTree(); 1579var tree = GetTree(); 1593var tree = GetTree(); 1607var tree = GetTree(); 1621var tree = GetTree(); 1635var tree = GetTree(); 1649var tree = GetTree(); 1663var tree = GetTree(); 1677var tree = GetTree(); 1691var tree = GetTree(); 1705var tree = GetTree(); 1719var tree = GetTree(); 1733var tree = GetTree(); 1747var tree = GetTree(); 1761var tree = GetTree(); 1775var tree = GetTree(); 1789var tree = GetTree(); 1803var tree = GetTree(); 1817var tree = GetTree(); 1831var tree = GetTree(); 1845var tree = GetTree(); 1859var tree = GetTree(); 1873var tree = GetTree(); 1887var tree = GetTree(); 1901var tree = GetTree(); 1915var tree = GetTree(); 1929var tree = GetTree(); 1943var tree = GetTree(); 1957var tree = GetTree(); 1971var tree = GetTree(); 1985var tree = GetTree(); 1999var tree = GetTree();

40var tree = SyntaxFactory.ParseSyntaxTree(source, options); 74var tree = SyntaxFactory.ParseSyntaxTree(source);

52var tree = SyntaxFactory.ParseSyntaxTree(source); 748var newSyntaxTree = await newDocument.GetSyntaxTreeAsync().ConfigureAwait(false);

81private static SyntaxTree ParseSource(string markedSource, int documentIndex = 0) 89var tree1 = ParseSource(src1, documentIndex); 90var tree2 = ParseSource(src2, documentIndex); 155var tree = ParseSource(source);

163var tree = SyntaxFactory.ParseSyntaxTree(@" 224var tree = SyntaxFactory.ParseSyntaxTree(@"

14protected abstract void CheckResult(bool validLocation, int position, SyntaxTree syntaxTree); 39var tree = SyntaxFactory.ParseSyntaxTree(text, options: options); 61var tree = SyntaxFactory.ParseSyntaxTree(text, options: options); 88var tree = SyntaxFactory.ParseSyntaxTree(text, options: options);

18protected override void CheckResult(bool expected, int position, SyntaxTree syntaxTree)

17protected override void CheckResult(bool validLocation, int position, SyntaxTree syntaxTree)

18protected override void CheckResult(bool validLocation, int position, SyntaxTree syntaxTree)

17protected override void CheckResult(bool validLocation, int position, SyntaxTree syntaxTree)

16private static void VerifyWholeLineIsActive(SyntaxTree tree, int lineNumber) 25private static void VerifyWholeLineIsInactive(SyntaxTree tree, int lineNumber) 43var tree = CSharpSyntaxTree.ParseText(code); 57var tree = CSharpSyntaxTree.ParseText(code); 71var tree = CSharpSyntaxTree.ParseText(code);

34var sourceTree = diagnostic.Location.SourceTree; 103var sourceTree = diagnostic.Location.SourceTree; 159var sourceTree = diagnostic.Location.SourceTree;

2019var tree = SyntaxFactory.ParseSyntaxTree(code, options: TestOptions.Script); 2314var syntaxTree = CSharpSyntaxTree.ParseText(text);

501protected override SyntaxTree Parse(string text) 507protected override Compilation CreateCompilation(SyntaxTree tree)

308var src1 = SyntaxFactory.ParseSyntaxTree(@"using System; 316var src2 = SyntaxFactory.ParseSyntaxTree(@"

250foreach (var tree in comp.SyntaxTrees)

290var tree = bodyCompilation.SyntaxTrees.Single();

43internal static T DigToFirstNodeOfType<T>(this SyntaxTree syntaxTree) 49internal static TypeDeclarationSyntax DigToFirstTypeDeclaration(this SyntaxTree syntaxTree)

223var tree1 = await workspace.CurrentSolution 230var tree2 = await workspace.CurrentSolution 247var tree = await currentSnapshot.Projects.First().Documents.First().GetSyntaxTreeAsync(); 648var syntaxTree = await doc.GetSyntaxTreeAsync(CancellationToken.None);

63var tree = SyntaxFactory.ParseSyntaxTree(text, options: options);

197var tree = Parse(text, options: TestOptions.RegularWithDocumentationComments); 216var tree = Parse(text, options: TestOptions.RegularWithDocumentationComments);

893var tree = compilation.SyntaxTrees.Single(); 945var tree = compilation.SyntaxTrees.Single();

934var tree = comp.SyntaxTrees.Single(); 1659var tree = comp.SyntaxTrees.Single(); 1705var tree = comp.SyntaxTrees.Single(); 1736var tree = comp.SyntaxTrees.Single(); 1773var tree = comp.SyntaxTrees.Single(); 1813var tree = comp.SyntaxTrees.Single(); 1850var tree = comp.SyntaxTrees.Single(); 1884var tree = comp.SyntaxTrees.Single(); 2121var tree = comp.SyntaxTrees.Single(); 2186var tree = comp.SyntaxTrees.First(); 2271var tree = comp.SyntaxTrees.First(); 2389var tree = comp.SyntaxTrees.First(); 2444var tree = comp.SyntaxTrees.Single(); 2502var tree = comp.SyntaxTrees.Single(); 2692var tree = comp.SyntaxTrees.Single(); 2740var tree = comp.SyntaxTrees.Single(); 2861var tree = comp.SyntaxTrees.First(); 3385var tree = comp.SyntaxTrees.Single(); 3608var tree = comp.SyntaxTrees.Single(); 3682var tree = comp.SyntaxTrees.Single(); 3792var tree = comp.SyntaxTrees.Single(); 3891var tree = comp.SyntaxTrees.Single(); 4118var tree = comp.SyntaxTrees.Single(); 4199var tree = comp.SyntaxTrees.Single(); 4420var tree = comp.SyntaxTrees.Single(); 5503var tree = comp.SyntaxTrees.Single(); 8163var tree = comp.SyntaxTrees.First(); 8239var tree = comp.SyntaxTrees.First(); 8317var tree = comp.SyntaxTrees.First(); 8378var tree = comp.SyntaxTrees.First(); 8449var tree = comp.SyntaxTrees.First();

2913var tree = comp.SyntaxTrees.Single(); 2945var tree = comp.SyntaxTrees.Single();

93var tree = compilation.SyntaxTrees.First(); 253var tree = comp.Compilation.SyntaxTrees.First(); 309var tree = comp.SyntaxTrees.First(); 1109var tree = comp.Compilation.SyntaxTrees.First(); 1364var tree = compilation.SyntaxTrees.First(); 1421var tree = compilation.SyntaxTrees.First(); 1465var tree = comp.SyntaxTrees.First(); 1506var tree = comp.SyntaxTrees.First(); 1559var tree = comp.SyntaxTrees.First(); 1666var tree = compilation.SyntaxTrees.First(); 2285var tree = comp.Compilation.SyntaxTrees.First(); 2685var tree = compilation.SyntaxTrees.First(); 3127var tree = compilation.SyntaxTrees.First(); 3175var tree = compilation.SyntaxTrees.First(); 3239var tree = compilation.SyntaxTrees.First(); 3277var tree = compilation.SyntaxTrees.First(); 3327var tree = compilation.SyntaxTrees.First(); 3365var tree = compilation.SyntaxTrees.First(); 3440var tree = compilation.SyntaxTrees.First(); 3476var tree = compilation.SyntaxTrees.First(); 3541var tree = compilation.SyntaxTrees.First(); 3633private static SingleVariableDesignationSyntax GetDeconstructionVariable(SyntaxTree tree, string name) 3638private static IEnumerable<DiscardDesignationSyntax> GetDiscardDesignations(SyntaxTree tree) 3643private static IEnumerable<IdentifierNameSyntax> GetDiscardIdentifiers(SyntaxTree tree) 3648private static IdentifierNameSyntax GetReference(SyntaxTree tree, string name) 3653private static IdentifierNameSyntax[] GetReferences(SyntaxTree tree, string name, int count) 3660private static IEnumerable<IdentifierNameSyntax> GetReferences(SyntaxTree tree, string name) 3687var tree = compilation.SyntaxTrees.First(); 3732var tree = compilation.SyntaxTrees.First(); 3789var tree = compilation.SyntaxTrees.First(); 3839var tree = compilation.SyntaxTrees.First(); 3885var tree = compilation.SyntaxTrees.First(); 3929var tree = compilation.SyntaxTrees.First(); 3975var tree = compilation.SyntaxTrees.First(); 4024var tree = compilation.SyntaxTrees.First(); 4130var tree = compilation.SyntaxTrees.First(); 4215var tree = compilation.SyntaxTrees.First(); 4326var tree = compilation.SyntaxTrees.First(); 4402var tree = compilation.SyntaxTrees.First(); 4435var tree = compilation.SyntaxTrees.First(); 4589var tree = compilation.SyntaxTrees.First(); 5018var tree = compilation.SyntaxTrees.First(); 5170var tree = compilation.SyntaxTrees.First(); 5307var tree = compilation.SyntaxTrees.First(); 5343var tree = compilation.SyntaxTrees.First(); 5398var tree = comp.SyntaxTrees.First(); 5431var tree = comp.SyntaxTrees.First(); 5469var tree = comp.SyntaxTrees.First(); 5501var tree = comp.SyntaxTrees.First(); 5532var tree = comp.SyntaxTrees.First(); 5561var tree = comp.SyntaxTrees.First(); 5601var tree = comp.SyntaxTrees.First(); 5640var tree = comp.SyntaxTrees.First(); 5684var tree = comp.SyntaxTrees.First(); 5723var tree = comp.SyntaxTrees.First(); 5765var tree = comp.SyntaxTrees.First(); 5801var tree = comp.SyntaxTrees.First(); 5851var tree = comp.SyntaxTrees.First(); 5905var tree = comp.SyntaxTrees.First(); 5996var tree = comp.SyntaxTrees.First(); 6028var tree = comp.SyntaxTrees.First(); 6081var tree = comp.SyntaxTrees.First(); 6130var tree = comp.SyntaxTrees.First(); 6179var tree = comp.SyntaxTrees.First(); 6209var tree = comp.SyntaxTrees.First(); 6251var tree = comp.SyntaxTrees.First(); 6302var tree = comp.SyntaxTrees.First(); 6334var tree = comp.SyntaxTrees.First(); 6364var tree = comp.SyntaxTrees.First(); 6391var tree = comp.SyntaxTrees.First(); 6436var tree = compilation.SyntaxTrees.First(); 6559var tree = comp.SyntaxTrees.First(); 6857var tree = compilation.SyntaxTrees.First(); 6929var tree = compilation.SyntaxTrees.First(); 6972var tree = comp.SyntaxTrees.First(); 7065var tree = comp.SyntaxTrees.Single(); 7120var tree = compilation.SyntaxTrees.First(); 7173var tree = compilation.SyntaxTrees.First(); 7228var tree = compilation.SyntaxTrees.First(); 7266var tree = compilation.SyntaxTrees.First(); 7303var tree = compilation.SyntaxTrees.First(); 7351var tree = compilation.SyntaxTrees.First(); 7390var tree = compilation.SyntaxTrees.First(); 7426var tree = compilation.SyntaxTrees.First(); 7503var tree = compilation.SyntaxTrees.First(); 7560var tree = compilation.SyntaxTrees.First(); 8357var tree = comp.SyntaxTrees.Single(); 8584var tree = compilation.SyntaxTrees.Single(); 8628var tree = compilation.SyntaxTrees.Single(); 9008var tree = comp.SyntaxTrees.First();

650var trees = new List<SyntaxTree>();

1750var tree = comp.SyntaxTrees.Single();

3051var syntaxTree = comp.SyntaxTrees[0]; 3103var syntaxTree = comp.SyntaxTrees[0]; 3328var syntaxTree = comp.SyntaxTrees[0]; 3399var syntaxTree = comp.SyntaxTrees[0]; 3446var syntaxTree = comp.SyntaxTrees[0]; 3557var tree = comp.SyntaxTrees[0]; 3609var tree = comp.SyntaxTrees[0]; 3660var tree = comp.SyntaxTrees[0]; 3699var tree = comp.SyntaxTrees[0]; 4104var syntaxTree = comp.SyntaxTrees[0]; 4906var syntaxTree = comp.SyntaxTrees[0]; 7399var tree = comp.SyntaxTrees[0]; 7501var tree = comp.SyntaxTrees[0]; 7557var tree = allInCoreLib.SyntaxTrees[0]; 7626var tree = allInCoreLib.SyntaxTrees[0]; 7713var tree = comp1.SyntaxTrees[0]; 10754var tree = comp.SyntaxTrees[0];

36var tree = comp.SyntaxTrees.Single();

144var tree = comp.SyntaxTrees.Single(); 5745var syntaxTree = comp.SyntaxTrees.Single(); 5820var syntaxTree = comp.SyntaxTrees.Single(); 5895var syntaxTree = comp.SyntaxTrees.Single(); 6160var tree = comp.SyntaxTrees[0];

5250var tree = result.Compilation.SyntaxTrees.Single(); 5538var tree = compilation.SyntaxTrees.Single(); 5576var tree = compilation.SyntaxTrees.Single();

3254var tree = comp.SyntaxTrees.Single(); 3291var tree = comp.SyntaxTrees.Single(); 3325var tree = comp.SyntaxTrees.Single();

25var tree = SyntaxFactory.ParseSyntaxTree(test, options: TestOptions.Script); 44var tree = SyntaxFactory.ParseSyntaxTree(test, options: TestOptions.Script); 62var tree = SyntaxFactory.ParseSyntaxTree(test, options: TestOptions.Script); 88var tree = SyntaxFactory.ParseSyntaxTree(test, options: TestOptions.Script); 113var tree = SyntaxFactory.ParseSyntaxTree(test, options: TestOptions.Script); 138var tree = SyntaxFactory.ParseSyntaxTree(test, options: TestOptions.Script); 169var tree = SyntaxFactory.ParseSyntaxTree(test, options: TestOptions.Script); 197var tree = SyntaxFactory.ParseSyntaxTree(test, options: TestOptions.Script); 636var tree = SyntaxFactory.ParseSyntaxTree(test, options: TestOptions.Script);

475var tree = Parse(source);

358var tree = comp.Compilation.SyntaxTrees.First(); 700var tree = comp.Compilation.SyntaxTrees.First(); 731var tree = comp.Compilation.SyntaxTrees.First(); 788var tree = comp.SyntaxTrees.First(); 810var tree = comp.SyntaxTrees[0]; 872var tree = comp.SyntaxTrees[0]; 920var tree = comp.SyntaxTrees[0]; 969var tree = comp.SyntaxTrees[0]; 1019var tree = comp.SyntaxTrees[0]; 1073var tree = comp.SyntaxTrees[0]; 1107var tree = comp.SyntaxTrees[0]; 1139var tree = comp.SyntaxTrees[0]; 1170var tree = comp.SyntaxTrees[0]; 1230var tree = comp.SyntaxTrees[0]; 1330var tree = comp.SyntaxTrees[0]; 1416var tree = comp.SyntaxTrees[0]; 1481var tree = comp.SyntaxTrees[0]; 1514var tree = comp.SyntaxTrees[0]; 1575var tree = comp.SyntaxTrees[0]; 1612var tree = comp.SyntaxTrees[0]; 1637var tree = comp.SyntaxTrees[0]; 1692var tree = comp.SyntaxTrees[0]; 1794var tree = comp.SyntaxTrees[0]; 1936var tree = comp.SyntaxTrees[0]; 2591var tree = comp.SyntaxTrees.First(); 2659var tree = comp.SyntaxTrees.First(); 3296var tree = comp.SyntaxTrees.First(); 3702var tree = comp.SyntaxTrees.First(); 3826var tree = comp.SyntaxTrees.First(); 3929var tree = comp.SyntaxTrees.First(); 4054var tree = comp.SyntaxTrees.First(); 4101var tree = comp.SyntaxTrees.First(); 4202var tree = comp.SyntaxTrees[0]; 4295var tree = comp.SyntaxTrees.First(); 5140var tree = comp.SyntaxTrees.First(); 5176var tree = comp.SyntaxTrees.First();

1600var tree = Parse(source, options: TestOptions.Regular); 3216var tree = compilation.SyntaxTrees.First(); 3249var tree = compilation.SyntaxTrees.First(); 3456var tree = compilation.SyntaxTrees.First(); 3628var tree = compilation.SyntaxTrees.First(); 3679var tree = compilation.SyntaxTrees.First(); 3925var tree = compilation.SyntaxTrees.First(); 3982var tree = compilation.SyntaxTrees.First(); 4015var tree = compilation.SyntaxTrees.First(); 4147var tree = compilation.SyntaxTrees.First(); 4832var tree = comp.SyntaxTrees.Single(); 5068var tree = comp.SyntaxTrees.Single(); 5112var tree = comp.SyntaxTrees.Single(); 5153var tree = comp.SyntaxTrees.Single(); 5197var tree = comp.SyntaxTrees.Single(); 5464var tree = Parse(source); 5793var tree = CSharpSyntaxTree.ParseText("class C { }"); 5904var tree = CSharpSyntaxTree.ParseText("class C { }"); 6345var syntaxTree = CSharpSyntaxTree.ParseText("class C { }"); 6381var syntaxTree = CSharpSyntaxTree.ParseText("class C { }"); 7501var tree = comp.SyntaxTrees.Single(); 7534var tree = comp.SyntaxTrees.Single(); 7571var tree = comp.SyntaxTrees.Single(); 7634var tree = comp.SyntaxTrees.Single(); 8293var tree = Parse(source, options: TestOptions.Regular); 8324var tree = Parse(source, options: TestOptions.Regular); 8379var tree = Parse(source, options: TestOptions.Regular); 8408var tree = Parse(source, options: TestOptions.Regular); 8437var tree = Parse(source, options: TestOptions.Regular); 8485var tree = Parse(source, options: TestOptions.Regular); 8519var tree = Parse(source, options: TestOptions.Regular); 8552var tree = Parse(source, options: TestOptions.Regular); 8581var tree = Parse(source, options: TestOptions.Regular); 8628var tree = Parse(source, options: TestOptions.Regular); 8663var tree = Parse(source, options: TestOptions.Regular); 8692var tree = Parse(source, options: TestOptions.Regular); 8721var tree = Parse(source, options: TestOptions.Regular); 8751var tree = Parse(source, options: TestOptions.Regular); 8806var tree = Parse(source, options: TestOptions.Regular); 8836var tree = Parse(source, options: TestOptions.Regular); 8895var tree = Parse(source, options: TestOptions.Regular); 8942var tree = Parse(source, options: TestOptions.Regular); 9013var tree = Parse(source, options: TestOptions.Regular); 9065var tree = Parse(source, options: TestOptions.Regular); 9142var tree = Parse(source, options: TestOptions.Regular); 9223var tree = Parse(source, options: TestOptions.Regular); 9306var tree = Parse(source, options: TestOptions.Regular); 9360var tree = Parse(source, options: TestOptions.Regular); 9858var tree = comp.SyntaxTrees.First(); 9909var tree = comp.SyntaxTrees.First(); 9951var tree = comp.SyntaxTrees.First(); 9997var tree = comp.SyntaxTrees.First(); 10063var tree = comp.SyntaxTrees.First(); 10102var tree = comp.SyntaxTrees.First(); 10136var tree = comp.SyntaxTrees.First(); 12696var tree = c.SyntaxTrees.Single(); 13977var tree = c.SyntaxTrees.Single(); 14248var tree = c.SyntaxTrees.Single(); 14436var tree = comp.SyntaxTrees.Single(); 16543var tree = comp.SyntaxTrees.Single(); 16568var tree = Parse(source, options: TestOptions.Regular); 16605var tree = Parse(source, options: TestOptions.Regular); 17211var tree = Parse(source, options: TestOptions.Regular); 17272var tree = Parse(source, options: TestOptions.Regular); 17331var tree = Parse(source, options: TestOptions.Regular); 17370var tree = Parse(source, options: TestOptions.Regular); 17402var tree = Parse(source, options: TestOptions.Regular7_1); 17435var tree = Parse(source, options: TestOptions.Regular7_1); 19064var tree = Parse(text); 19103var tree = Parse(text); 19142var tree = Parse(text); 19181var tree = Parse(text); 19233var tree = comp.SyntaxTrees.First(); 19295var tree = comp.SyntaxTrees.First(); 19398var tree = comp.SyntaxTrees.First(); 19429var tree = comp.SyntaxTrees.First(); 19483var tree = comp.SyntaxTrees.First(); 19541var tree = comp.SyntaxTrees.First(); 19664var tree = comp.SyntaxTrees.First(); 19708var tree = comp.SyntaxTrees.First(); 19739var tree = comp.SyntaxTrees.First(); 20361var tree = comp.SyntaxTrees.First(); 21350var tree = comp.SyntaxTrees.First(); 22645var startTree = SyntaxFactory.ParseSyntaxTree(text); 22650var newTree = startTree.WithChangedText(newText); 22885var tree = compilation.SyntaxTrees.First(); 24047var tree = SyntaxFactory.ParseSyntaxTree(text, CSharpParseOptions.Default); 24216var tree = compilation.SyntaxTrees.First(); 24295var tree = comp.SyntaxTrees.Single(); 24358var tree = comp.SyntaxTrees.Single(); 24422var tree = comp.SyntaxTrees.Single(); 24495var tree = comp.SyntaxTrees.Single(); 24568var tree = comp.SyntaxTrees.Single(); 24642var tree = comp.SyntaxTrees.Single(); 25060var tree = comp.SyntaxTrees.Single(); 25088var tree = comp.SyntaxTrees.Single(); 25119var tree = comp.SyntaxTrees.Single(); 25739var tree = comp.SyntaxTrees.Single(); 25810var tree = comp.SyntaxTrees.Single(); 25875var tree = comp.SyntaxTrees.Single(); 25917var tree = comp.SyntaxTrees.Single(); 25947var tree = comp.SyntaxTrees.Single(); 26258var tree = comp.SyntaxTrees[0]; 26331var tree = comp.SyntaxTrees.First(); 26364var tree = comp.SyntaxTrees.First(); 26397var tree = comp.SyntaxTrees.First(); 26430var tree = comp.SyntaxTrees.First(); 27603var tree = comp.SyntaxTrees.Single();

1037var tree = Parse(source, options: TestOptions.Script); 1050var tree = Parse(source, options: TestOptions.Script);

30var syntaxTree = comp.SyntaxTrees[0]; 3530var tree = comp.SyntaxTrees.First();

5010var tree = compilation.SyntaxTrees[0]; 5136var tree = compilation.SyntaxTrees[0]; 5285var tree = compilation.SyntaxTrees[0];

1280var source = Parse(""); 1293var source = Parse("");

264var tree = CSharpSyntaxTree.ParseText("class Program { static void Main() { } }");

3582var trees = ArrayBuilder<SyntaxTree>.GetInstance();

3307var asyncStreamsTree = Parse(AsyncStreamsTypes, options: (CSharpParseOptions)source0.Tree.Options); 5815var asyncStreamsTree = Parse(AsyncStreamsTypes, options: (CSharpParseOptions)source0.Tree.Options);

80var tree1 = method1.Locations[0].SourceTree; 81var tree0 = method0.Locations[0].SourceTree; 329internal static CSharpCompilation WithSource(this CSharpCompilation compilation, SyntaxTree newTree) 334internal static CSharpCompilation WithSource(this CSharpCompilation compilation, SyntaxTree[] newTrees)

751var asyncStreamsTree = Parse(AsyncStreamsTypes, options: (CSharpParseOptions)source0.Tree.Options); 844var asyncStreamsTree = Parse(AsyncStreamsTypes, options: (CSharpParseOptions)source0.Tree.Options);

2229var syntax = SyntaxFactory.ParseSyntaxTree(@"class C {}", TestOptions.Regular.WithNoRefSafetyRulesAttribute()); 2418var syntax = SyntaxFactory.ParseSyntaxTree(@"class C { static void Main() { } }", TestOptions.Regular.WithNoRefSafetyRulesAttribute());

448var sourceTree = SyntaxFactory.ParseSyntaxTree("");

34var tree1 = SyntaxFactory.ParseSyntaxTree(StringText.From(source1, Encoding.UTF8, SourceHashAlgorithm.Sha1), path: "sha1.cs"); 35var tree256 = SyntaxFactory.ParseSyntaxTree(StringText.From(source256, Encoding.UTF8, SourceHashAlgorithm.Sha256), path: "sha256.cs");

55SyntaxTree[] syntaxTrees, 99var sourceOne = Parse(@" 111var sourceTwo = Parse(@" 116var sourceThree = Parse(@" 159var sourceOne = Parse(@" 171var sourceTwo = Parse(@" 176var sourceThree = Parse(@" 223var sourceOne = Parse(@" 235var sourceTwo = Parse(@" 240var sourceThree = Parse(@"

42var tree1 = Parse(source1, "f:/build/goo.cs"); 43var tree2 = Parse(source2, "f:/build/nocode.cs"); 103var tree = Parse(source, "f:/build/goo.cs");

38var tree1 = SyntaxFactory.ParseSyntaxTree("class A { }", encoding: null, path: "Foo.cs"); 39var tree2 = SyntaxFactory.ParseSyntaxTree("class B { }", encoding: null, path: ""); 40var tree3 = SyntaxFactory.ParseSyntaxTree(SourceText.From("class C { }", encoding: null), path: "Bar.cs"); 41var tree4 = SyntaxFactory.ParseSyntaxTree("class D { }", encoding: Encoding.UTF8, path: "Baz.cs"); 58var tree1 = SyntaxFactory.ParseSyntaxTree("class A { public void F() { } }", encoding: Encoding.Unicode, path: "Foo.cs"); 59var tree2 = SyntaxFactory.ParseSyntaxTree("class B { public void F() { } }", encoding: null, path: ""); 60var tree3 = SyntaxFactory.ParseSyntaxTree("class C { public void F() { } }", encoding: new UTF8Encoding(true, false), path: "Bar.cs"); 61var tree4 = SyntaxFactory.ParseSyntaxTree(SourceText.From("class D { public void F() { } }", new UTF8Encoding(false, false)), path: "Baz.cs"); 125var tree1 = SyntaxFactory.ParseCompilationUnit(@" 129var tree2 = SyntaxFactory.ParseCompilationUnit(@" 520var tree1 = Parse(source1, @"foo.cs"); 521var tree2 = Parse(source2, @"foo.cs"); 4878var compilation = CreateCompilation(new SyntaxTree[] { Parse(text1, "a.cs"), Parse(text2, "b.cs") }); 12290var tree = SyntaxFactory.ParseSyntaxTree(source, encoding: Encoding.UTF8, path: "HIDDEN.cs"); 12892var tree1 = Parse(source1, "f:/build/goo.cs"); 12893var tree2 = Parse(source2, "f:/build/nocode.cs"); 12931var tree = Parse(source, "f:/build/nocode.cs");

706var tree = comp.SyntaxTrees[0]; 747var tree = comp.SyntaxTrees[0]; 811var tree = comp.SyntaxTrees[0]; 853var tree = comp.SyntaxTrees[0]; 894var tree = comp.SyntaxTrees[0]; 933var tree = comp.SyntaxTrees[0]; 7238var tree = compilation.SyntaxTrees.Single(); 7279var tree = compilation.SyntaxTrees.Single();

5279var compilation = CreateCompilationWithMscorlib45(new SyntaxTree[] { SyntaxFactory.ParseSyntaxTree(source, options: TestOptions.Regular7, path: @"C:\filename") }).VerifyDiagnostics(

251var syntaxTree = SyntaxFactory.SyntaxTree(root); 462var syntaxTree = SyntaxFactory.SyntaxTree(root);

31var compilation = CreateEmptyCompilation(new SyntaxTree[0], new[] { assembly.GetReference() }, 64new SyntaxTree[0],

1376var tree = compilation.SyntaxTrees.Single(); 1418var tree = compilation.SyntaxTrees.Single(); 1447var tree = compilation.SyntaxTrees.Single(); 1474var tree = compilation.SyntaxTrees.Single();

1501var syntaxTree = Parse(source); 1619var syntaxTree = Parse(source);

1959var comp = CreateEmptyCompilation(new SyntaxTree[] { Parse("", options: parseOptions) }, references: new[] { diagLibRef, mslibNoStringRef });

5014var syntaxTree = Parse(source, filename: "test.cs"); 5053var syntaxTree = Parse(source, filename: "test.cs", options: parseOptions); 5676var tree = compilation.SyntaxTrees.Single(); 9461var tree = comp.SyntaxTrees.Single(); 9510var tree = comp.SyntaxTrees.Single(); 9566var tree = comp2.SyntaxTrees.Single(); 11259var tree = comp.SyntaxTrees[0]; 11284var tree = comp.SyntaxTrees[0]; 11315var tree = comp.SyntaxTrees[0];

131var syntaxTree = Parse(s, @"IVTAndStrongNameTests\AnotherTempDir\temp.cs", parseOptions); 160var syntaxTree = Parse(s, @"IVTAndStrongNameTests\AnotherTempDir\temp.cs", parseOptions); 188var syntaxTree = Parse(s, @"IVTAndStrongNameTests\AnotherTempDir\temp.cs", TestOptions.RegularWithLegacyStrongName); 256var syntaxTree = Parse(s, @"IVTAndStrongNameTests\AnotherTempDir\temp.cs"); 298var syntaxTree = Parse(s, @"IVTAndStrongNameTests\AnotherTempDir\temp.cs");

1011var treeInAnotherCompilation = anotherCompilation.SyntaxTrees.Single(); 1101var treeInAnotherCompilation = compilation.SyntaxTrees.Single(); 1473var builder = ImmutableArray.CreateBuilder<SyntaxTree>(); 1477var tree = CSharpSyntaxTree.ParseText(string.Format(source, treeNum++), path: "SourceFileRegular.cs"); 1569var tree = CSharpSyntaxTree.ParseText(source, path: "SourceFileRegular.cs"); 1611var tree1 = CSharpSyntaxTree.ParseText(source1, path: "SourceFileRegular.cs"); 1612var tree2 = CSharpSyntaxTree.ParseText(source2, path: "SourceFileRegular.Designer.cs"); 1904var tree1 = CSharpSyntaxTree.ParseText(source1, path: "Source1_File1.cs"); 1905var tree2 = CSharpSyntaxTree.ParseText(source1, path: "Source1_File2.cs"); 1906var tree3 = CSharpSyntaxTree.ParseText(source2, path: "Source2_File3.cs"); 1907var tree4 = CSharpSyntaxTree.ParseText(source3, path: "Source3_File4.generated.cs"); 1908var tree5 = CSharpSyntaxTree.ParseText(source3, path: "Source3_File5.designer.cs"); 1942var tree = CSharpSyntaxTree.ParseText(source, path: "Source.cs"); 1963var tree = CSharpSyntaxTree.ParseText(source, path: "Source.cs"); 1986var tree = CSharpSyntaxTree.ParseText(source, path: "Source.cs"); 2007var tree = CSharpSyntaxTree.ParseText(source, path: "Source.cs"); 2032var tree = CSharpSyntaxTree.ParseText(source, path: "Source.cs"); 2052var tree = CSharpSyntaxTree.ParseText(source, path: "Source.cs"); 2071var tree = CSharpSyntaxTree.ParseText(source, path: "Source.cs"); 2094var tree = CSharpSyntaxTree.ParseText(source, path: "Source.cs"); 2115var tree = CSharpSyntaxTree.ParseText(source, path: "Source.cs"); 2141var tree = CSharpSyntaxTree.ParseText(source, path: "Source.cs"); 2174var tree = CSharpSyntaxTree.ParseText(source, path: "Source.cs"); 2239var tree = CSharpSyntaxTree.ParseText(source, path: "Source.cs"); 2531var tree = CSharpSyntaxTree.ParseText(source); 2560var tree = CSharpSyntaxTree.ParseText(source); 2588var tree = CSharpSyntaxTree.ParseText(source); 2606var tree = CSharpSyntaxTree.ParseText(source); 2624var tree = CSharpSyntaxTree.ParseText(source); 2652var tree = CSharpSyntaxTree.ParseText(source); 2848var tree = CSharpSyntaxTree.ParseText(source); 3252var tree1 = compilation.SyntaxTrees[0]; 3276var tree1 = Parse("partial class A { }"); 3277var tree2 = Parse("partial class A { private class B { } }"); 3319var tree1 = Parse("partial class A { }"); 3320var tree2 = Parse("partial class A { private class B { } }"); 3372var tree1 = Parse("partial class A { }"); 3373var tree2 = Parse("partial class A { private class B { } }"); 3423var tree1 = Parse("partial class A { }"); 3424var tree2 = Parse("partial class A { private class B { } }"); 3498var tree = CSharpSyntaxTree.ParseText(source); 3529var tree = CSharpSyntaxTree.ParseText(source); 3550var tree = CSharpSyntaxTree.ParseText(source); 3589var tree1 = compilation.SyntaxTrees[0]; 3656var tree = compilation.SyntaxTrees[0]; 3718var tree = compilation.SyntaxTrees[0]; 3787var tree = CSharpSyntaxTree.ParseText(string.Empty); 3822var tree = CSharpSyntaxTree.ParseText(string.Empty); 3945var tree = CSharpSyntaxTree.ParseText(@"class C { }"); 3962private readonly ConcurrentDictionary<SyntaxTree, SemanticModel> _cache = new ConcurrentDictionary<SyntaxTree, SemanticModel>(); 3964public override SemanticModel GetSemanticModel(SyntaxTree tree, Compilation compilation, bool ignoreAccessibility = false) 3969public void VerifyCachedModel(SyntaxTree tree, SemanticModel model) 4029var tree1 = compilation.SyntaxTrees[0]; 4038var tree2 = compilation.SyntaxTrees[1]; 4039var tree3 = compilation.SyntaxTrees[2]; 4101var tree = compilation.SyntaxTrees[0]; 4111public override GeneratedKind IsGenerated(SyntaxTree tree, CancellationToken cancellationToken) 4117public override bool TryGetDiagnosticValue(SyntaxTree tree, string diagnosticId, CancellationToken cancellationToken, out ReportDiagnostic severity)

165var tree1 = CSharpSyntaxTree.ParseText(source1, path: "file1"); 166var tree2 = CSharpSyntaxTree.ParseText(source2, path: "file2"); 214var tree1 = CSharpSyntaxTree.ParseText(source1, path: "file1"); 215var tree2 = CSharpSyntaxTree.ParseText(source2, path: "file2"); 253var tree = CSharpSyntaxTree.ParseText(source, path: "file1"); 368var syntaxTree1 = Parse(string.Empty, options: new CSharpParseOptions().WithPreprocessorSymbols(new[] { "1" })); 369var syntaxTree2 = Parse(string.Empty, options: new CSharpParseOptions().WithPreprocessorSymbols(new[] { "2" })); 370var syntaxTree3 = Parse(string.Empty, options: new CSharpParseOptions().WithPreprocessorSymbols(new[] { "3" })); 397var syntaxTree1 = Parse(string.Empty, options: parseOptions1); 398var syntaxTree2 = Parse(string.Empty, options: parseOptions2); 399var syntaxTree3 = Parse(string.Empty, options: parseOptions2); 421var tree1 = Parse(string.Empty, options: parseOptions); 422var tree2 = Parse("ref struct X {}", options: parseOptions); 609var tree = compilation.SyntaxTrees.First(); 662var tree = compilation.SyntaxTrees.First(); 680var tree = compilation.SyntaxTrees.First(); 717var syntaxTree = compilation.SyntaxTrees[0]; 774var syntaxTree = compilation.SyntaxTrees[0]; 996var syntaxTree = compilation.SyntaxTrees[0]; 1126var tree1 = compilation.SyntaxTrees[0]; 1127var tree2 = compilation.SyntaxTrees[1]; 1139var analyzedTree = Assert.Single(analyzer.AnalyzedTrees); 1179var expectedSemanticModelTreeCallbacks = new HashSet<SyntaxTree>();

697var tree = comp.SyntaxTrees[0]; 1881var tree = comp.SyntaxTrees[0]; 1933var tree = comp.SyntaxTrees[0]; 5973var tree = comp.SyntaxTrees[0]; 6209var tree = comp.SyntaxTrees[0]; 6582var tree = comp.SyntaxTrees[0]; 6816var tree = comp.SyntaxTrees[0]; 8090var tree = comp.SyntaxTrees[0]; 10511var tree = comp.SyntaxTrees[0]; 10650var tree = comp.SyntaxTrees[0]; 11137var tree = comp.SyntaxTrees.Single(); 11160var tree = comp.SyntaxTrees.Single(); 11188var tree = comp.SyntaxTrees.Single(); 11213var tree = comp.SyntaxTrees.Single(); 11258var tree = comp.SyntaxTrees.Single();

110var tree = comp.SyntaxTrees[0]; 131var tree = comp.SyntaxTrees[0]; 152var tree = comp.SyntaxTrees[0]; 173var tree = comp.SyntaxTrees[0]; 194protected T GetFirstNode<T>(SyntaxTree tree, int offset) 200protected T GetLastNode<T>(SyntaxTree tree, int offset)

5839var tree = compilation.SyntaxTrees[0];

900var tree = SyntaxFactory.ParseSyntaxTree(@"

4425var tree = compilation.SyntaxTrees.First(); 4523var tree = compilation.SyntaxTrees[0]; 5483var tree = SyntaxFactory.ParseSyntaxTree(source); 5532var tree = comp.SyntaxTrees.Single(); 5576var tree = comp.SyntaxTrees.Single(); 5619var tree = comp.SyntaxTrees.Single(); 6214var tree = comp.SyntaxTrees.Single(); 6312var tree = compilation.SyntaxTrees[0]; 6351var tree = compilation.SyntaxTrees[0]; 6378var tree = compilation.SyntaxTrees[0]; 6416var tree = compilation.SyntaxTrees[0]; 6444var tree = compilation.SyntaxTrees[0]; 6479var tree = compilation.SyntaxTrees[0]; 7905var tree = compilation.SyntaxTrees[0]; 8097var tree = compilation.SyntaxTrees[0]; 8125var tree = compilation.SyntaxTrees[0];

25protected IEnumerable<SingleVariableDesignationSyntax> GetPatternDeclarations(SyntaxTree tree, string v) 30protected SingleVariableDesignationSyntax GetPatternDeclaration(SyntaxTree tree, string v) 35protected IEnumerable<SingleVariableDesignationSyntax> GetPatternDeclarations(SyntaxTree tree) 40protected IEnumerable<VariableDeclaratorSyntax> GetVariableDeclarations(SyntaxTree tree, string v) 45protected IEnumerable<VariableDeclaratorSyntax> GetVariableDeclarations(SyntaxTree tree) 50protected static IEnumerable<DiscardDesignationSyntax> GetDiscardDesignations(SyntaxTree tree) 55protected static IdentifierNameSyntax GetReference(SyntaxTree tree, string name) 60protected static IEnumerable<IdentifierNameSyntax> GetReferences(SyntaxTree tree, string name) 417protected static void AssertNoGlobalStatements(SyntaxTree tree) 449var tree = comp.SyntaxTrees.First();

692var tree = compilation.SyntaxTrees.Single(); 736var tree = compilation.SyntaxTrees.Single(); 776var tree = compilation.SyntaxTrees.Single(); 842var tree = compilation.SyntaxTrees.Single(); 889var tree = compilation.SyntaxTrees.Single(); 1151var tree = compilation.SyntaxTrees.Single(); 1220var tree = compilation.SyntaxTrees.Single(); 1270var tree = compilation.SyntaxTrees.Single(); 1314var tree = compilation.SyntaxTrees.Single(); 1429var tree = compilation.SyntaxTrees.Single(); 1479var tree = compilation.SyntaxTrees.Single(); 1536var tree = compilation.SyntaxTrees.Single(); 1588var tree = compilation.SyntaxTrees.Single(); 1653var tree = compilation.SyntaxTrees.Single(); 1730var tree = compilation.SyntaxTrees.Single(); 1783var tree = compilation.SyntaxTrees.Single(); 1827var tree = compilation.SyntaxTrees.Single(); 1881var tree = compilation.SyntaxTrees.Single(); 1935var tree = compilation.SyntaxTrees.Single(); 1992var tree = compilation.SyntaxTrees.Single(); 2030var tree = compilation.SyntaxTrees.Single(); 2076var tree = compilation.SyntaxTrees.Single(); 2130var tree = compilation.SyntaxTrees.Single(); 2178var tree = compilation.SyntaxTrees.Single(); 2234var tree = compilation.SyntaxTrees.Single(); 2294var tree = compilation.SyntaxTrees.Single(); 2352var tree = compilation.SyntaxTrees.Single(); 2413var tree = compilation.SyntaxTrees.Single(); 2458var tree = compilation.SyntaxTrees.Single(); 2497var tree = compilation.SyntaxTrees.Single(); 2541var tree = compilation.SyntaxTrees.Single(); 2613var tree = compilation.SyntaxTrees.Single(); 2661var tree = compilation.SyntaxTrees.Single(); 2699var tree = compilation.SyntaxTrees.Single(); 2744var tree = compilation.SyntaxTrees.Single(); 2788var tree = compilation.SyntaxTrees.Single(); 2840var tree = compilation.SyntaxTrees.Single(); 2882var tree = compilation.SyntaxTrees.Single(); 3037var tree = compilation.SyntaxTrees.Single(); 3084var tree = compilation.SyntaxTrees.Single(); 3263var tree = compilation.SyntaxTrees[0]; 3441var tree = compilation.SyntaxTrees[0]; 3477var tree = compilation.SyntaxTrees.Single(); 3576var tree = compilation.SyntaxTrees.Single(); 4247var tree = compilation.SyntaxTrees.Single(); 4288var tree = compilation.SyntaxTrees.Single(); 4789var tree = compilation.SyntaxTrees.Single(); 4825var tree = compilation.SyntaxTrees.Single(); 6570var tree = compilation.SyntaxTrees.Single(); 11359var tree = comp.SyntaxTrees.Single(); 11383var tree = comp.SyntaxTrees.Single(); 11404var tree = comp.SyntaxTrees.Single(); 11461var tree = comp.SyntaxTrees.Single();

76var tree = compilation.SyntaxTrees.Single(); 120var tree = compilation.SyntaxTrees.Single(); 198var tree = compilation.SyntaxTrees.Single(); 242var tree = compilation.SyntaxTrees.Single(); 292var tree = compilation.SyntaxTrees.Single(); 368var tree = compilation.SyntaxTrees.Single(); 428var tree = compilation.SyntaxTrees.Single(); 520var tree = compilation.SyntaxTrees.Single(); 577var tree = compilation.SyntaxTrees.Single(); 639var tree = compilation.SyntaxTrees.Single(); 681var tree = compilation.SyntaxTrees.Single(); 757var tree = compilation.SyntaxTrees.Single(); 804var tree = compilation.SyntaxTrees.Single(); 894var tree = compilation.SyntaxTrees.Single(); 942var tree = compilation.SyntaxTrees.Single(); 1021var tree = compilation.SyntaxTrees.Single(); 1074var tree = compilation.SyntaxTrees.Single(); 1153var tree = compilation.SyntaxTrees.Single(); 1206var tree = compilation.SyntaxTrees.Single(); 1262var tree = compilation.SyntaxTrees.Single(); 1327var tree = compilation.SyntaxTrees.Single(); 1371var tree = compilation.SyntaxTrees.Single(); 1452var tree = compilation.SyntaxTrees.Single(); 1497var tree = compilation.SyntaxTrees.Single(); 1584var tree = compilation.SyntaxTrees.Single(); 1638var tree = compilation.SyntaxTrees.Single(); 1732var tree = compilation.SyntaxTrees.Single(); 1786var tree = compilation.SyntaxTrees.Single(); 1850var tree = compilation.SyntaxTrees.Single(); 1924var tree = compilation.SyntaxTrees.Single(); 1994var tree = compilation.SyntaxTrees.Single(); 2095var tree = compilation.SyntaxTrees.Single(); 2165var tree = compilation.SyntaxTrees.Single(); 2224var tree = compilation.SyntaxTrees.Single(); 2298var tree = compilation.SyntaxTrees.Single(); 2368var tree = compilation.SyntaxTrees.Single(); 2470var tree = compilation.SyntaxTrees.Single(); 2540var tree = compilation.SyntaxTrees.Single(); 2609var tree = compilation.SyntaxTrees.Single(); 2679var tree = compilation.SyntaxTrees.Single(); 2733var tree = compilation.SyntaxTrees.Single(); 2825var tree = compilation.SyntaxTrees.Single(); 2879var tree = compilation.SyntaxTrees.Single(); 2941var tree = compilation.SyntaxTrees.Single(); 2987var tree = compilation.SyntaxTrees.Single(); 3068var tree = compilation.SyntaxTrees.Single(); 3127var tree = compilation.SyntaxTrees.Single(); 3227var tree = compilation.SyntaxTrees.Single(); 3283var tree = compilation.SyntaxTrees.Single(); 3373var tree = compilation.SyntaxTrees.Single(); 3429var tree = compilation.SyntaxTrees.Single(); 3489var tree = compilation.SyntaxTrees.Single(); 3570var tree = compilation.SyntaxTrees.Single(); 3637var tree = compilation.SyntaxTrees.Single(); 3741var tree = compilation.SyntaxTrees.Single(); 3808var tree = compilation.SyntaxTrees.Single(); 3872var tree = compilation.SyntaxTrees.Single(); 3966var tree = compilation.SyntaxTrees.Single(); 4042var tree = compilation.SyntaxTrees.Single(); 4164var tree = compilation.SyntaxTrees.Single(); 4240var tree = compilation.SyntaxTrees.Single(); 4311var tree = compilation.SyntaxTrees.Single(); 4392var tree = compilation.SyntaxTrees.Single(); 4453var tree = compilation.SyntaxTrees.Single(); 4559var tree = compilation.SyntaxTrees.Single(); 4620var tree = compilation.SyntaxTrees.Single(); 4675var tree = compilation.SyntaxTrees.Single(); 4721var tree = compilation.SyntaxTrees.Single(); 4760var tree = compilation.SyntaxTrees.Single(); 4799var tree = compilation.SyntaxTrees.Single(); 4831var tree = compilation.SyntaxTrees.Single(); 4906var tree = compilation.SyntaxTrees.Single(); 4975var tree = compilation.SyntaxTrees.Single(); 5072var tree = compilation.SyntaxTrees.Single(); 5141var tree = compilation.SyntaxTrees.Single(); 5196var tree = compilation.SyntaxTrees.Single(); 5242var tree = compilation.SyntaxTrees.Single(); 5281var tree = compilation.SyntaxTrees.Single(); 5320var tree = compilation.SyntaxTrees.Single(); 5399var tree = compilation.SyntaxTrees.Single(); 5475var tree = compilation.SyntaxTrees.Single(); 5584var tree = compilation.SyntaxTrees.Single(); 5660var tree = compilation.SyntaxTrees.Single(); 5725var tree = compilation.SyntaxTrees.Single(); 5776var tree = compilation.SyntaxTrees.Single(); 5815var tree = compilation.SyntaxTrees.Single(); 5854var tree = compilation.SyntaxTrees.Single(); 5891var tree = compilation.SyntaxTrees.Single(); 5937var tree = compilation.SyntaxTrees.Single(); 5975var tree = compilation.SyntaxTrees.Single(); 6025var tree = compilation.SyntaxTrees.Single(); 6062var tree = compilation.SyntaxTrees.Single(); 6109var tree = compilation.SyntaxTrees.Single(); 6141var tree = compilation.SyntaxTrees.Single(); 6195var tree = compilation.SyntaxTrees.Single(); 6233var tree = compilation.SyntaxTrees.Single(); 6268var tree = compilation.SyntaxTrees.Single(); 6297var tree = compilation.SyntaxTrees.Single(); 6319var tree = compilation.SyntaxTrees.Single(); 6348var tree = compilation.SyntaxTrees.Single(); 6372var tree = compilation.SyntaxTrees.Single(); 6395var tree = compilation.SyntaxTrees.Single(); 6512var tree = compilation.SyntaxTrees.Single(); 6600var tree = compilation.SyntaxTrees.Single(); 6684var tree = compilation.SyntaxTrees.Single(); 6727var tree = compilation.SyntaxTrees.Single(); 6760var tree = compilation.SyntaxTrees.Single(); 6802var tree = compilation.SyntaxTrees.Single(); 6940var tree = compilation.SyntaxTrees.Single(); 7038var tree = compilation.SyntaxTrees.Single(); 7130var tree = compilation.SyntaxTrees.Single(); 7257var tree = compilation.SyntaxTrees.Single(); 7361var tree = compilation.SyntaxTrees.Single(); 7450var tree = compilation.SyntaxTrees.Single(); 7526var tree = compilation.SyntaxTrees.Single(); 7620var tree = compilation.SyntaxTrees.Single(); 7707var tree = compilation.SyntaxTrees.Single(); 7732var tree = compilation.SyntaxTrees.Single(); 7928var tree = compilation.SyntaxTrees.Single(); 8187var tree = compilation.SyntaxTrees.Single(); 8372var tree = compilation.SyntaxTrees.Single(); 8479var tree = compilation.SyntaxTrees.Single(); 8578var tree = compilation.SyntaxTrees.Single();

3319var tree = compilation.SyntaxTrees.First(); 3619var tree = compilation.SyntaxTrees[0]; 3676var tree = compilation.SyntaxTrees[0]; 3720var tree = compilation.SyntaxTrees.First(); 4086var tree = compilation.SyntaxTrees.First(); 4173var tree = compilation.SyntaxTrees.First(); 4250var tree = compilation.SyntaxTrees.First(); 4364var tree = compilation.SyntaxTrees.First(); 4406var tree = compilation.SyntaxTrees.Single(); 4557var tree = compilation.SyntaxTrees.First();

202var tree = compilation.SyntaxTrees.Single(); 283var tree = compilation.SyntaxTrees.Single(); 329var tree = compilation.SyntaxTrees.Single(); 370var tree = compilation.SyntaxTrees.Single(); 400var tree = compilation.SyntaxTrees.Single(); 587var tree = compilation.SyntaxTrees.Single(); 675var tree = compilation.SyntaxTrees.Single(); 705var tree = compilation.SyntaxTrees.Single(); 857var tree = compilation.SyntaxTrees.Single(); 944var tree = compilation.SyntaxTrees.Single(); 974var tree = compilation.SyntaxTrees.Single(); 1155var tree = compilation.SyntaxTrees.Single(); 1248var tree = compilation.SyntaxTrees.Single(); 1278var tree = compilation.SyntaxTrees.Single(); 1518var tree = compilation.SyntaxTrees.Single(); 1818var tree = compilation.SyntaxTrees.Single(); 2069var tree = compilation.SyntaxTrees.Single(); 2215var tree = compilation.SyntaxTrees.Single(); 2351var tree = compilation.SyntaxTrees.Single(); 2416var tree = compilation.SyntaxTrees.Single(); 2479var tree = compilation.SyntaxTrees.Single(); 2549var tree = compilation.SyntaxTrees.Single(); 2705var tree = compilation.SyntaxTrees.Single(); 2788var tree = compilation.SyntaxTrees.Single(); 2984var tree = compilation.SyntaxTrees.Single(); 3153var tree = compilation.SyntaxTrees.Single(); 3268var tree = compilation.SyntaxTrees.Single(); 3357var tree = compilation.SyntaxTrees.Single(); 3445var tree = compilation.SyntaxTrees.Single(); 3532var tree = compilation.SyntaxTrees.Single(); 3608var tree = compilation.SyntaxTrees.Single(); 3705var tree = compilation.SyntaxTrees.Single(); 3796var tree = compilation.SyntaxTrees.Single(); 3886var tree = compilation.SyntaxTrees.Single(); 3978var tree = compilation.SyntaxTrees.Single(); 4074var tree = compilation.SyntaxTrees.Single(); 4220var tree = compilation.SyntaxTrees.Single(); 4502var tree = compilation.SyntaxTrees.Single(); 4902var tree = compilation.SyntaxTrees.Single(); 5211var tree = compilation.SyntaxTrees.Single(); 5304var tree = compilation.SyntaxTrees.Single(); 5334var tree = compilation.SyntaxTrees.Single(); 5499var tree = compilation.SyntaxTrees.Single(); 5706var tree = compilation.SyntaxTrees.Single(); 5913var tree = compilation.SyntaxTrees.Single(); 6022var tree = compilation.SyntaxTrees.Single(); 6103var tree = compilation.SyntaxTrees.Single(); 6186var tree = compilation.SyntaxTrees.Single(); 6273var tree = compilation.SyntaxTrees.Single(); 6347var tree = compilation.SyntaxTrees.Single(); 6417var tree = compilation.SyntaxTrees.Single(); 6464var tree = compilation.SyntaxTrees.Single(); 6517var tree = compilation.SyntaxTrees.Single(); 6587var tree = compilation.SyntaxTrees.Single(); 6676var tree = compilation.SyntaxTrees.Single(); 6752var tree = compilation.SyntaxTrees.Single(); 6827var tree = compilation.SyntaxTrees.Single(); 6877var tree = compilation.SyntaxTrees.Single(); 6927var tree = compilation.SyntaxTrees.Single(); 7084var tree = compilation.SyntaxTrees.Single(); 7174var tree = compilation.SyntaxTrees.Single(); 7204var tree = compilation.SyntaxTrees.Single(); 7406var tree = compilation.SyntaxTrees.Single(); 7497var tree = compilation.SyntaxTrees.Single(); 7527var tree = compilation.SyntaxTrees.Single(); 7721var tree = compilation.SyntaxTrees.Single(); 7950var tree = compilation.SyntaxTrees.Single(); 8200var tree = compilation.SyntaxTrees.Single(); 8440var tree = compilation.SyntaxTrees.Single(); 8672var tree = compilation.SyntaxTrees.Single(); 8988var tree = compilation.SyntaxTrees.Single(); 9131var tree = compilation.SyntaxTrees.Single(); 9303var tree = compilation.SyntaxTrees.Single(); 9512var tree = compilation.SyntaxTrees.Single(); 9603var tree = compilation.SyntaxTrees.Single(); 9633var tree = compilation.SyntaxTrees.Single(); 9798var tree = compilation.SyntaxTrees.Single(); 9927var tree = compilation.SyntaxTrees.Single(); 10075var tree = compilation.SyntaxTrees.Single(); 10163var tree = compilation.SyntaxTrees.Single(); 10196var tree = compilation.SyntaxTrees.Single(); 10365var tree = compilation.SyntaxTrees.Single(); 10586var tree = compilation.SyntaxTrees.Single(); 10682var tree = compilation.SyntaxTrees.Single(); 10712var tree = compilation.SyntaxTrees.Single(); 10999var tree = compilation.SyntaxTrees.Single(); 11129var tree = compilation.SyntaxTrees.Single(); 11177var tree = compilation.SyntaxTrees.Single(); 11227var tree = compilation.SyntaxTrees.Single(); 11270var tree = compilation.SyntaxTrees.Single(); 11313var tree = compilation.SyntaxTrees.Single(); 11359var tree = compilation.SyntaxTrees.Single(); 11402var tree = compilation.SyntaxTrees.Single(); 11448var tree = compilation.SyntaxTrees.Single(); 11494var tree = compilation.SyntaxTrees.Single(); 11546var tree = compilation.SyntaxTrees.Single(); 11609var tree = compilation.SyntaxTrees.Single(); 11664var tree = compilation.SyntaxTrees.Single(); 11724var tree = compilation.SyntaxTrees.Single(); 11804var tree = compilation.SyntaxTrees.Single(); 11901var tree = compilation.SyntaxTrees.Single(); 11990var tree = compilation.SyntaxTrees.Single(); 12088var tree = compilation.SyntaxTrees.Single(); 12139var tree = compilation.SyntaxTrees.Single(); 12201var tree = compilation.SyntaxTrees.Single(); 12245var tree = compilation.SyntaxTrees.Single(); 12440var tree = compilation.SyntaxTrees.Single(); 12593var tree = compilation.SyntaxTrees.Single(); 12783var tree = compilation.SyntaxTrees.Single(); 12904var tree = compilation.SyntaxTrees.Single(); 12996var tree = compilation.SyntaxTrees.Single(); 13178var tree = compilation.SyntaxTrees.Single(); 13321var tree = compilation.SyntaxTrees.Single(); 13395var tree = compilation.SyntaxTrees.Single(); 13483var tree = compilation.SyntaxTrees.Single(); 13560var tree = compilation.SyntaxTrees.Single(); 13639var tree = compilation.SyntaxTrees.Single(); 13706var tree = compilation.SyntaxTrees.Single(); 13736var tree = compilation.SyntaxTrees.Single(); 13771var tree = comp.SyntaxTrees.First(); 13968var tree = compilation.SyntaxTrees.Single();

723var tree = compilation.SyntaxTrees[0]; 2022var tree = compilation.SyntaxTrees[0]; 2063var tree = compilation.SyntaxTrees[0]; 2161var tree = compilation.SyntaxTrees[0]; 2253var tree = compilation.SyntaxTrees[0]; 2297var tree = compilation.SyntaxTrees[0]; 2343var tree = compilation.SyntaxTrees[0]; 2886var tree = comp.SyntaxTrees[0];

46var tree = compilation.SyntaxTrees[0]; 106var tree = compilation.SyntaxTrees[0]; 157var tree = compilation.SyntaxTrees[0]; 202var tree = compilation.SyntaxTrees[0]; 253var tree = compilation.SyntaxTrees[0]; 296var tree = compilation.SyntaxTrees[0]; 343var tree = compilation.SyntaxTrees[0]; 1610var tree = compilation.SyntaxTrees.Single(); 1886var tree = compilation.SyntaxTrees.Single(); 1934var tree = compilation.SyntaxTrees.Single(); 4104var tree = compilation.SyntaxTrees[0]; 4331var tree = compilation.SyntaxTrees[0];

1009var tree = compilation.SyntaxTrees[0]; 3965var tree = comp.SyntaxTrees.Single(); 4034var tree = comp.SyntaxTrees.Single(); 4107var tree = comp.SyntaxTrees.First(); 4179var tree = comp.SyntaxTrees.First(); 4223var tree = comp.SyntaxTrees.First(); 4270var tree = comp.SyntaxTrees.First(); 4352var tree = comp.SyntaxTrees.First(); 4434var tree = comp.SyntaxTrees.First(); 4516var tree = comp.SyntaxTrees.First(); 4598var tree = comp.SyntaxTrees.First(); 4682var tree = comp.SyntaxTrees.First();

425var tree = comp.SyntaxTrees.Single(); 562var tree = comp.SyntaxTrees.Single(); 793var tree = comp.SyntaxTrees.Single(); 839var tree = comp.SyntaxTrees.Single(); 893var tree = comp.SyntaxTrees.Single(); 1103var tree = compilation.SyntaxTrees[0]; 1183var tree = compilation.SyntaxTrees[0]; 1234var tree = compilation.SyntaxTrees[0]; 1286var tree = compilation.SyntaxTrees[0];

1511var tree = compilation.SyntaxTrees.Single(); 1894var tree = compilation.SyntaxTrees.Single(); 1929var tree = compilation.SyntaxTrees.Single(); 3248var tree = compilation.SyntaxTrees[0]; 3279var tree = compilation.SyntaxTrees[0];

71internal override int CalculateLocalSyntaxOffset(int localPosition, SyntaxTree localTree)

750internal override int CalculateLocalSyntaxOffset(int localPosition, SyntaxTree localTree)

273internal override int CalculateLocalSyntaxOffset(int localPosition, SyntaxTree localTree)

66var syntaxTree = expression.CreateSyntaxTree(text); 222var syntaxTree = statement.CreateSyntaxTree(source); 226private static SyntaxTree CreateSyntaxTree(this InternalSyntax.CSharpSyntaxNode root, SourceText text) 233var syntaxTree = InternalSyntax.SyntaxFactory.ExpressionStatement(attributeLists: default, expression, InternalSyntax.SyntaxFactory.Token(SyntaxKind.SemicolonToken)).CreateSyntaxTree(text);

108var tree = await document.GetRequiredSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);

56var tree = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);

59var syntaxTree = await document.GetRequiredSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);

79protected override SyntaxNode? GetExpressionToPlaceAwaitInFrontOf(SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 95protected override SyntaxToken? GetDotTokenLeftOfPosition(SyntaxTree syntaxTree, int position, CancellationToken cancellationToken)

44public static SyntaxToken? GetDotTokenLeftOfPosition(SyntaxTree syntaxTree, int position, CancellationToken cancellationToken)

96var tree = await document.GetRequiredSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);

43var tree = await document.GetRequiredSyntaxTreeAsync(cancellationToken).ConfigureAwait(false); 113private static bool IsLambdaExpression(SemanticModel semanticModel, SyntaxTree tree, int position, SyntaxToken token, ITypeInferenceService typeInferrer, CancellationToken cancellationToken)

78var tree = await document.GetRequiredSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);

69var tree = await document.GetRequiredSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);

49var syntaxTree = await document.GetRequiredSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);

48var tree = await document.GetRequiredSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);

53var syntaxTree = await document.GetRequiredSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);

69var syntaxTree = await document.GetRequiredSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);

62var syntaxTree = await document.GetRequiredSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);

65var tree = await document.GetRequiredSyntaxTreeAsync(cancellationToken).ConfigureAwait(false); 111var tree = semanticModel.SyntaxTree; 175protected override HashSet<string> GetInitializedMembers(SyntaxTree tree, int position, CancellationToken cancellationToken)

42protected override SyntaxNode? GetObjectCreationNewExpression(SyntaxTree tree, int position, CancellationToken cancellationToken)

49protected override SyntaxToken GetToken(CompletionItem completionItem, SyntaxTree tree, CancellationToken cancellationToken) 191public override SyntaxToken FindStartingToken(SyntaxTree tree, int position, CancellationToken cancellationToken)

71protected override SyntaxToken GetToken(CompletionItem completionItem, SyntaxTree tree, CancellationToken cancellationToken) 89protected override bool IsPartialMethodCompletionContext(SyntaxTree tree, int position, CancellationToken cancellationToken, out DeclarationModifiers modifiers, out SyntaxToken token) 109private static bool VerifyModifiers(SyntaxTree tree, int position, CancellationToken cancellationToken, out DeclarationModifiers modifiers)

57protected override SyntaxNode? GetPartialTypeSyntaxNode(SyntaxTree tree, int position, CancellationToken cancellationToken)

48var tree = await document.GetRequiredSyntaxTreeAsync(cancellationToken).ConfigureAwait(false); 171private static (PropertyPatternClauseSyntax?, ExpressionSyntax?) TryGetPropertyPatternClause(SyntaxTree tree, int position, CancellationToken cancellationToken)

12internal static bool TryGetStringLiteralToken(SyntaxTree tree, int position, SyntaxKind directiveKind, out SyntaxToken stringLiteral, CancellationToken cancellationToken)

28protected override bool TryGetStringLiteralToken(SyntaxTree tree, int position, out SyntaxToken stringLiteral, CancellationToken cancellationToken)

27protected override bool TryGetStringLiteralToken(SyntaxTree tree, int position, out SyntaxToken stringLiteral, CancellationToken cancellationToken)

88var syntaxTree = await document.GetRequiredSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);

69var syntaxTree = await document.GetRequiredSyntaxTreeAsync(cancellationToken).ConfigureAwait(false); 102private static bool IsStartOfSpeculativeTContext(SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 113private static int WalkOutOfGenericType(SyntaxTree syntaxTree, int position, SemanticModel semanticModel, CancellationToken cancellationToken) 142private static int WalkOutOfRefType(SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 155private static int WalkOutOfTupleType(SyntaxTree syntaxTree, int position, CancellationToken cancellationToken)

54var tree = await document.GetRequiredSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);

47var syntaxTree = context.SyntaxTree;

23var syntaxTree = context.SyntaxTree;

23var syntaxTree = context.SyntaxTree;

23var syntaxTree = context.SyntaxTree;

35var syntaxTree = context.SyntaxTree;

23var syntaxTree = context.SyntaxTree;

23var syntaxTree = context.SyntaxTree;

37var syntaxTree = context.SyntaxTree;

43var syntaxTree = context.SyntaxTree;

52var syntaxTree = context.SyntaxTree;

23var syntaxTree = context.SyntaxTree;

19var syntaxTree = context.SyntaxTree;

21var syntaxTree = context.SyntaxTree;

22var syntaxTree = context.SyntaxTree;

23var syntaxTree = context.SyntaxTree;

20var syntaxTree = context.SyntaxTree;

23var syntaxTree = context.SyntaxTree;

22var syntaxTree = context.SyntaxTree;

23var syntaxTree = context.SyntaxTree;

19var syntaxTree = context.SyntaxTree;

20var syntaxTree = context.SyntaxTree;

80var syntaxTree = context.SyntaxTree; 112private static bool IsValidNewByRefContext(SyntaxTree syntaxTree, int position, CSharpSyntaxContext context, CancellationToken cancellationToken)

23var syntaxTree = context.SyntaxTree;

23var syntaxTree = context.SyntaxTree;

23var syntaxTree = context.SyntaxTree;

27var syntaxTree = context.SyntaxTree;

33var syntaxTree = context.SyntaxTree;

23var syntaxTree = context.SyntaxTree;

23var syntaxTree = context.SyntaxTree;

20var syntaxTree = context.SyntaxTree;

70var syntaxTree = context.SyntaxTree;

30var syntaxTree = context.SyntaxTree;

44var syntaxTree = context.SyntaxTree;

28protected override bool IsInstanceContext(SyntaxTree syntaxTree, SyntaxToken targetToken, SemanticModel semanticModel, CancellationToken cancellationToken)

46var tree = context.Tree;

122var syntaxTree = document.SyntaxTree; 138SyntaxTree tree, SourceText text, string indentation, TextLine textLine, CancellationToken cancellationToken)

35var syntaxTree = namespaceDeclaration.SyntaxTree;

131public static CSharpAnalyzerOptionsProvider GetCSharpAnalyzerOptions(this AnalyzerOptions options, SyntaxTree syntaxTree) 149public static CSharpAnalyzerOptionsProvider GetCSharpAnalyzerOptions(this SymbolStartAnalysisContext context, SyntaxTree syntaxTree)

47var tree = await document.GetRequiredSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);

55var syntaxTree = node.SyntaxTree;

47protected override async Task<Tuple<SyntaxTree, SyntaxNode>?> GetRootInOtherSyntaxTreeAsync(

62var syntaxTree = context.Node.SyntaxTree;

51IEnumerable<SyntaxNode> nodes, SyntaxTree tree, CancellationToken cancellationToken)

64var syntaxTree = semanticModel.SyntaxTree;

188public static SyntaxTreeState Create(bool defaultCompleted, NullableContextOptions compilationOptions, SyntaxTree tree, CancellationToken cancellationToken) 268private readonly ConcurrentDictionary<SyntaxTree, SyntaxTreeState> _codeBlockIntervals 311private SyntaxTreeState GetOrCreateSyntaxTreeState(SyntaxTree tree, bool defaultCompleted, SemanticModel semanticModel, CancellationToken cancellationToken)

26protected override bool SupportsDiscard(SyntaxTree tree)

37var syntaxTree = context.Node.SyntaxTree;

39var syntaxTree = context.Node.SyntaxTree;

44var syntaxTree = context.Node.SyntaxTree;

63var syntaxTree = expression.SyntaxTree;

41var tree = location.SourceTree;

35var tree = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);

94var tree = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false); 103public static IList<string> GetProximityExpressions(SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 107private static IList<string> Do(SyntaxTree syntaxTree, int position, CancellationToken cancellationToken)

21private readonly SyntaxTree _syntaxTree; 28public Worker(SyntaxTree syntaxTree, int position)

24var tree = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);

46protected override MemberDeclarationSyntax? GetContainingMember(SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 231SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 243SyntaxTree syntaxTree, int position, CancellationToken cancellationToken)

17public static bool TryGetBreakpointSpan(SyntaxTree tree, int position, CancellationToken cancellationToken, out TextSpan breakpointSpan)

839internal override bool ExperimentalFeaturesEnabled(SyntaxTree tree)

36var tree = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);

51var syntaxTree = simpleName.SyntaxTree;

46var syntaxTree = semanticDocument.SyntaxTree;

202var syntaxTree = semanticModel.SyntaxTree;

132var tree = syntaxContext.SemanticModel.SyntaxTree; 174var tree = syntaxContext.Node.SyntaxTree; 319var tree = semanticModel.SyntaxTree;

40var tree = await document.GetRequiredSyntaxTreeAsync(cancellationToken).ConfigureAwait(false); 328private static bool IsLegalSpanForLineSeparator(SyntaxTree syntaxTree, TextSpan textSpan, CancellationToken cancellationToken)

29var syntaxTree = (await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false))!;

102var tree = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);

53var tree = await document.GetRequiredSyntaxTreeAsync(cancellationToken).ConfigureAwait(false); 58Solution solution, SyntaxTree tree, IEnumerable<INamedTypeSymbol> types, CancellationToken cancellationToken) 187Solution solution, ISymbol member, SyntaxTree tree, CancellationToken cancellationToken) 202Solution solution, ISymbol symbol, SyntaxTree tree, CancellationToken cancellationToken)

50var syntaxTree = await document.GetRequiredSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);

35var syntaxTree = await document.GetRequiredSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);

41var tree = await document.GetRequiredSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);

28var syntaxTree = await document.GetRequiredSyntaxTreeAsync(cancellationToken).ConfigureAwait(false); 36var syntaxTree = await document.GetRequiredSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);