27public abstract partial class CSharpSyntaxTree : SyntaxTree

22Inherits SyntaxTree

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

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

64public static ReportDiagnostic GetEffectiveSeverity(this DiagnosticDescriptor descriptor, CompilationOptions compilationOptions, SyntaxTree tree, AnalyzerOptions analyzerOptions) 148(SyntaxTreeOptionsProvider provider, SyntaxTree tree)? providerAndTree = null) 157var tree = providerAndTree.Value.tree;

303foreach (var tree in compilation.SyntaxTrees)

179SyntaxTree operationSyntaxTree = invocation.Syntax.SyntaxTree;

30private static readonly SyntaxTree s_implicitUsingsSyntaxTree = SyntaxFactory.ParseSyntaxTree(SourceText.From( 42private static readonly SyntaxTree s_attributesSyntaxTree = CSharpSyntaxTree.ParseText(File.ReadAllText("ConfigurationSchemaAttributes.cs")); 1561var sourceSyntaxTree = SyntaxFactory.ParseSyntaxTree(SourceText.From(sourceText));

80var tree = await document.GetSyntaxTreeAsync();

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

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

47SyntaxTree tree = SyntaxFactory.ParseSyntaxTree(codeStr); 79SyntaxTree tree = SyntaxFactory.ParseSyntaxTree(codeStr); 142SyntaxTree tree = SyntaxFactory.ParseSyntaxTree(codeStr); 173SyntaxTree tree = SyntaxFactory.ParseSyntaxTree(codeStr);

98var tree = await document.GetSyntaxTreeAsync();

121var tree = await document.GetSyntaxTreeAsync();

30var syntaxTree = semanticModel.SyntaxTree;

74var tree = CSharpSyntaxTree.ParseText(code);

75var tree = document.GetSyntaxTreeAsync().Result;

75var tree = document.GetSyntaxTreeAsync().Result;

68var syntaxTree = CSharpSyntaxTree.ParseText(GetMapActionString(updatedSource), path: $"TestMapActions.cs", options: ParseOptions); 134foreach (var syntaxTree in compilation.SyntaxTrees) 142var newSyntaxTree = CSharpSyntaxTree.Create(syntaxRootNode, options: ParseOptions, encoding: encoding, path: syntaxTree.FilePath); 360var generatedSyntaxTree = compilation.SyntaxTrees.Last();

68var syntaxTree = CSharpSyntaxTree.ParseText(GetMapActionString(updatedSource), path: $"TestMapActions.cs", options: ParseOptions); 134foreach (var syntaxTree in compilation.SyntaxTrees) 142var newSyntaxTree = CSharpSyntaxTree.Create(syntaxRootNode, options: ParseOptions, encoding: encoding, path: syntaxTree.FilePath); 360var generatedSyntaxTree = compilation.SyntaxTrees.Last();

12internal static string GetInterceptorFilePath(this SyntaxTree tree, SourceReferenceResolver? resolver) =>

73public SyntaxTree CreateSyntaxTree(SourceText sourceText)

375var syntaxTree = _csharpCompiler.CreateSyntaxTree(sourceText).WithFilePath(assemblyName);

51var syntaxTree = CSharpSyntaxTree.ParseText("@class Test { public string Test { get; set; } }");

38private SyntaxTree _lastSeqPointTree; 1017internal void DefineSequencePoint(SyntaxTree syntaxTree, TextSpan span) 1057var lastDebugDocument = _lastSeqPointTree; 1086internal 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;

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

432var embeddedTreeMap = new Dictionary<string, SyntaxTree>(Arguments.EmbeddedFiles.Length); 435foreach (var tree in compilation.SyntaxTrees) 459SyntaxTree? tree; 482SyntaxTree tree, 806/// <param name="generatedFilesBaseDirectory">The base directory for the <see cref="SyntaxTree.FilePath"/> of generated files.</param> 1017IEnumerable<SyntaxTree> syntaxTrees, 1024foreach (var syntaxTree in syntaxTrees) 1159foreach (var tree in generatedSyntaxTrees)

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

96protected static IReadOnlyDictionary<string, string> SyntaxTreeCommonFeatures(IEnumerable<SyntaxTree> trees) 100foreach (var tree in trees) 196ImmutableArray<SyntaxTree> syntaxTrees, 314public SemanticModel GetSemanticModel(SyntaxTree syntaxTree, bool ignoreAccessibility = false) 321public SemanticModel GetSemanticModel(SyntaxTree syntaxTree, SemanticModelOptions options) 326/// If <see cref="SemanticModelProvider"/> is non-null, it attempts to use <see cref="SemanticModelProvider.GetSemanticModel(SyntaxTree, Compilation, SemanticModelOptions)"/> 327/// to get a semantic model. Otherwise, it creates a new semantic model using <see cref="CreateSemanticModel(SyntaxTree, SemanticModelOptions)"/>. 330protected abstract SemanticModel CommonGetSemanticModel(SyntaxTree syntaxTree, SemanticModelOptions options); 334/// Unlike the <see cref="GetSemanticModel(SyntaxTree, bool)"/> and <see cref="CommonGetSemanticModel(SyntaxTree, SemanticModelOptions)"/>, 338internal abstract SemanticModel CreateSemanticModel(SyntaxTree syntaxTree, SemanticModelOptions options); 556public IEnumerable<SyntaxTree> SyntaxTrees { get { return CommonSyntaxTrees; } } 557protected internal abstract ImmutableArray<SyntaxTree> CommonSyntaxTrees { get; } 564public Compilation AddSyntaxTrees(params SyntaxTree[] trees) 574public Compilation AddSyntaxTrees(IEnumerable<SyntaxTree> trees) 579protected abstract Compilation CommonAddSyntaxTrees(IEnumerable<SyntaxTree> trees); 587public Compilation RemoveSyntaxTrees(params SyntaxTree[] trees) 598public Compilation RemoveSyntaxTrees(IEnumerable<SyntaxTree> trees) 603protected abstract Compilation CommonRemoveSyntaxTrees(IEnumerable<SyntaxTree> trees); 623public Compilation ReplaceSyntaxTree(SyntaxTree oldTree, SyntaxTree newTree) 628protected abstract Compilation CommonReplaceSyntaxTree(SyntaxTree oldTree, SyntaxTree newTree); 634public bool ContainsSyntaxTree(SyntaxTree syntaxTree) 639protected abstract bool CommonContainsSyntaxTree(SyntaxTree? syntaxTree); 1074foreach (var tree in this.CommonSyntaxTrees) 2495foreach (var tree in CommonSyntaxTrees) 2531foreach (var tree in CommonSyntaxTrees) 2553foreach (var tree in CommonSyntaxTrees) 2563internal abstract void AddDebugSourceDocumentsForChecksumDirectives(DebugDocumentsBuilder documentsBuilder, SyntaxTree tree, DiagnosticBag diagnostics); 2593internal static bool ReportUnusedImportsInTree(SyntaxTree tree) 2607internal abstract void CompleteTrees(SyntaxTree? filterTree); 3524private ConcurrentDictionary<SyntaxTree, SmallConcurrentSetOfInts>? _lazyTreeToUsedImportDirectivesMap; 3525private static readonly Func<SyntaxTree, SmallConcurrentSetOfInts> s_createSetCallback = t => new SmallConcurrentSetOfInts(); 3527private ConcurrentDictionary<SyntaxTree, SmallConcurrentSetOfInts> TreeToUsedImportDirectivesMap 3540internal void MarkImportDirectiveAsUsed(SyntaxTree? syntaxTree, int position) 3550internal bool IsImportDirectiveUsed(SyntaxTree syntaxTree, int position) 3569internal int CompareSyntaxTreeOrdering(SyntaxTree tree1, SyntaxTree tree2) 3582internal 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.

18/// an instance is obtained by a call to <see cref="Compilation.GetSemanticModel(SyntaxTree, SemanticModelOptions)"/>. 60public SyntaxTree SyntaxTree 68protected abstract SyntaxTree SyntaxTreeCore { get; }

18public abstract SemanticModel GetSemanticModel(SyntaxTree tree, Compilation compilation, SemanticModelOptions options = default);

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)

493internal bool HasIntersectingLocation(SyntaxTree tree, TextSpan? filterSpanWithinTree = null) 516static 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) 457Dictionary<SyntaxTree, Dictionary<DiagnosticAnalyzer, ImmutableArray<Diagnostic>.Builder>>? localDiagnostics, 503ImmutableDictionary<SyntaxTree, ImmutableDictionary<DiagnosticAnalyzer, ImmutableArray<Diagnostic>>> localSyntaxDiagnostics; 504ImmutableDictionary<SyntaxTree, ImmutableDictionary<DiagnosticAnalyzer, ImmutableArray<Diagnostic>>> localSemanticDiagnostics;

55public ImmutableArray<SyntaxTree> SyntaxTrees { get; } 123var trees = filterFile.SourceTree != null ? ImmutableArray.Create(filterFile.SourceTree) : ImmutableArray<SyntaxTree>.Empty; 131ImmutableArray<SyntaxTree> trees, 226public bool ShouldAnalyze(SyntaxTree tree) 246var filterTree = FilterFileOpt.GetValueOrDefault().SourceTree;

20public abstract AnalyzerConfigOptions GetOptions(SyntaxTree tree);

40private readonly Func<SyntaxTree, CancellationToken, bool> _isGeneratedCode; 233private ConcurrentDictionary<SyntaxTree, bool>? _lazyGeneratedCodeFilesMap; 238private ConcurrentDictionary<SyntaxTree, bool> GeneratedCodeFilesMap 247private Dictionary<SyntaxTree, ImmutableHashSet<ISymbol>>? _lazyGeneratedCodeSymbolsForTreeMap; 252private Dictionary<SyntaxTree, ImmutableHashSet<ISymbol>> GeneratedCodeSymbolsForTreeMap 261private ConcurrentDictionary<SyntaxTree, ImmutableHashSet<DiagnosticAnalyzer>>? _lazySuppressedAnalyzersForTreeMap; 266private ConcurrentDictionary<SyntaxTree, ImmutableHashSet<DiagnosticAnalyzer>> SuppressedAnalyzersForTreeMap 308private ConcurrentDictionary<SyntaxTree, bool>? _lazyTreesWithHiddenRegionsMap; 418_lazyGeneratedCodeFilesMap = new ConcurrentDictionary<SyntaxTree, bool>(); 419_lazyGeneratedCodeSymbolsForTreeMap = new Dictionary<SyntaxTree, ImmutableHashSet<ISymbol>>(); 421_lazyTreesWithHiddenRegionsMap = new ConcurrentDictionary<SyntaxTree, bool>(); 422_lazySuppressedAnalyzersForTreeMap = new ConcurrentDictionary<SyntaxTree, ImmutableHashSet<DiagnosticAnalyzer>>(); 743foreach (var tree in analysisScope.SyntaxTrees) 976foreach (var tree in compilation.SyntaxTrees) 1002private SemanticModel GetOrCreateSemanticModel(SyntaxTree tree) 1005protected SemanticModel GetOrCreateSemanticModel(SyntaxTree tree, Compilation compilation) 1287ImmutableHashSet<ISymbol> getOrComputeGeneratedCodeSymbolsInTree(SyntaxTree tree, Compilation compilation, CancellationToken cancellationToken) 1318static ImmutableHashSet<ISymbol> computeGeneratedCodeSymbolsInTree(SyntaxTree tree, Compilation compilation, INamedTypeSymbol generatedCodeAttribute, CancellationToken cancellationToken) 1355private bool IsAnalyzerSuppressedForTree(DiagnosticAnalyzer analyzer, SyntaxTree tree, SyntaxTreeOptionsProvider? options, CancellationToken cancellationToken) 1365private ImmutableHashSet<DiagnosticAnalyzer> ComputeSuppressedAnalyzersForTree(SyntaxTree tree, SyntaxTreeOptionsProvider? options, CancellationToken cancellationToken) 2140SyntaxTree? filterTree, 2167async ValueTask<IGroupedAnalyzerActions> getAllActionsAsync(AnalyzerDriver driver, ISymbol symbol, DiagnosticAnalyzer analyzer, SyntaxTree? filterTree, TextSpan? filterSpan, CancellationToken cancellationToken) 2183async ValueTask<IGroupedAnalyzerActions> getInheritedActionsAsync(AnalyzerDriver driver, ISymbol symbol, DiagnosticAnalyzer analyzer, SyntaxTree? filterTree, TextSpan? filterSpan, CancellationToken cancellationToken) 2207static async ValueTask<AnalyzerActions> getSymbolActionsCoreAsync(AnalyzerDriver driver, ISymbol symbol, DiagnosticAnalyzer analyzer, SyntaxTree? filterTree, TextSpan? filterSpan, CancellationToken cancellationToken) 2300protected bool IsGeneratedCode(SyntaxTree tree, CancellationToken cancellationToken) 2331protected bool IsGeneratedOrHiddenCodeLocation(SyntaxTree syntaxTree, TextSpan span, CancellationToken cancellationToken) 2334protected bool IsHiddenSourceLocation(SyntaxTree syntaxTree, TextSpan span) 2341private bool HasHiddenRegions(SyntaxTree tree)

42private readonly Func<SyntaxTree, SemanticModel> _getSemanticModel; 45private readonly Func<SyntaxTree, TextSpan, CancellationToken, bool> _isGeneratedCodeLocation; 46private readonly Func<DiagnosticAnalyzer, SyntaxTree, SyntaxTreeOptionsProvider?, CancellationToken, bool> _isAnalyzerSuppressedForTree; 61private bool IsAnalyzerSuppressedForTree(DiagnosticAnalyzer analyzer, SyntaxTree tree, CancellationToken cancellationToken) 108Func<SyntaxTree, TextSpan, CancellationToken, bool> isGeneratedCodeLocation, 109Func<DiagnosticAnalyzer, SyntaxTree, SyntaxTreeOptionsProvider?, CancellationToken, bool> isAnalyzerSuppressedForTree, 111Func<SyntaxTree, SemanticModel> getSemanticModel, 140Func<SyntaxTree, TextSpan, CancellationToken, bool> isGeneratedCodeLocation, 141Func<DiagnosticAnalyzer, SyntaxTree, SyntaxTreeOptionsProvider?, CancellationToken, bool> isAnalyzerSuppressedForTree, 143Func<SyntaxTree, SemanticModel> getSemanticModel, 250SyntaxTree? filterTree, 359SyntaxTree? filterTree, 414SyntaxTree? filterTree, 451SyntaxTree? filterTree, 468SyntaxTree? filterTree, 567var tree = file.SourceTree; 1444private AnalyzerDiagnosticReporter GetAddSemanticDiagnostic(SyntaxTree tree, DiagnosticAnalyzer analyzer, CancellationToken cancellationToken) 1451private AnalyzerDiagnosticReporter GetAddSemanticDiagnostic(SyntaxTree tree, TextSpan? span, DiagnosticAnalyzer analyzer, CancellationToken cancellationToken)

142SyntaxTree? filterTree,

94SyntaxTree? filterTree, 108SyntaxTree? filterTree, 188SyntaxTree? filterTree, 319foreach (var tree in analysisScope.SyntaxTrees)

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

31SyntaxTree tree,

16/// and should invoke <see cref="ClearCache(SyntaxTree, Compilation)"/> and <see cref="ClearCache(Compilation)"/> to clear entries when appropriate. 36public override SemanticModel GetSemanticModel(SyntaxTree tree, Compilation compilation, SemanticModelOptions options = default) 39internal void ClearCache(SyntaxTree tree, Compilation compilation) 55private readonly ConcurrentDictionary<SyntaxTree, SemanticModel> _semanticModelsMap; 59private readonly Func<SyntaxTree, SemanticModel> _createSemanticModel; 64_semanticModelsMap = new ConcurrentDictionary<SyntaxTree, SemanticModel>(); 68public SemanticModel GetSemanticModel(SyntaxTree tree, SemanticModelOptions options) 76public void ClearCachedSemanticModel(SyntaxTree tree)

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

199private void VerifyTree(SyntaxTree tree) 395public async Task<ImmutableArray<Diagnostic>> GetAnalyzerSyntaxDiagnosticsAsync(SyntaxTree tree, CancellationToken cancellationToken) 411public async Task<ImmutableArray<Diagnostic>> GetAnalyzerSyntaxDiagnosticsAsync(SyntaxTree tree, TextSpan? filterSpan, CancellationToken cancellationToken) 427public async Task<ImmutableArray<Diagnostic>> GetAnalyzerSyntaxDiagnosticsAsync(SyntaxTree tree, ImmutableArray<DiagnosticAnalyzer> analyzers, CancellationToken cancellationToken) 445public async Task<ImmutableArray<Diagnostic>> GetAnalyzerSyntaxDiagnosticsAsync(SyntaxTree tree, TextSpan? filterSpan, ImmutableArray<DiagnosticAnalyzer> analyzers, CancellationToken cancellationToken) 459public Task<AnalysisResult> GetAnalysisResultAsync(SyntaxTree tree, CancellationToken cancellationToken) 474public Task<AnalysisResult> GetAnalysisResultAsync(SyntaxTree tree, TextSpan? filterSpan, CancellationToken cancellationToken) 488public Task<AnalysisResult> GetAnalysisResultAsync(SyntaxTree tree, ImmutableArray<DiagnosticAnalyzer> analyzers, CancellationToken cancellationToken) 505public Task<AnalysisResult> GetAnalysisResultAsync(SyntaxTree tree, TextSpan? filterSpan, ImmutableArray<DiagnosticAnalyzer> analyzers, CancellationToken cancellationToken) 584private async Task<ImmutableArray<Diagnostic>> GetAnalyzerSyntaxDiagnosticsCoreAsync(SyntaxTree tree, ImmutableArray<DiagnosticAnalyzer> analyzers, TextSpan? filterSpan, CancellationToken cancellationToken) 896var partialTrees = PooledHashSet<SyntaxTree>.GetInstance(); 897var tree = originalFile.SourceTree!; 922foreach (var partialTree in partialTrees) 935bool tryProcessTree(SyntaxTree partialTree, [NotNullWhen(true)] out (AnalysisScope scope, ImmutableArray<CompilationEvent> events)? scopeAndEvents) 1060var tree = analysisScope.FilterFileOpt!.Value.SourceTree!; 1106static bool shouldIncludeSymbol(ISymbolInternal symbol, SyntaxTree tree, CancellationToken cancellationToken)

28public override AnalyzerConfigOptions GetOptions(SyntaxTree tree)

117/// A syntax tree action reports <see cref="Diagnostic"/>s about the <see cref="SyntaxTree"/> of a document. 433/// A syntax tree action reports <see cref="Diagnostic"/>s about the <see cref="SyntaxTree"/> of a document. 531/// <param name="tree"><see cref="SyntaxTree"/> instance for which the value is queried.</param> 535public bool TryGetValue<TValue>(SyntaxTree tree, SyntaxTreeValueProvider<TValue> valueProvider, [MaybeNullWhen(false)] out TValue value) 653/// <param name="tree"><see cref="SyntaxTree"/> for which the value is queried.</param> 657public bool TryGetValue<TValue>(SyntaxTree tree, SyntaxTreeValueProvider<TValue> valueProvider, [MaybeNullWhen(false)] out TValue value) 707public SyntaxTree FilterTree { get; } 792public SyntaxTree? FilterTree { get; } 827SyntaxTree? filterTree, 888public SyntaxTree? FilterTree { get; } 909internal SymbolStartAnalysisContext(ISymbol symbol, Compilation compilation, AnalyzerOptions options, bool isGeneratedCode, SyntaxTree? filterTree, TextSpan? filterSpan, CancellationToken cancellationToken) 1049public SyntaxTree FilterTree { get; } 1159public SyntaxTree FilterTree { get; } 1269public SyntaxTree FilterTree { get; } 1306SyntaxTree filterTree, 1411public SyntaxTree FilterTree { get; } 1452SyntaxTree filterTree, 1505/// 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. 1509private readonly SyntaxTree _tree; 1517/// <see cref="SyntaxTree"/> that is the subject of the analysis. 1519public SyntaxTree Tree => _tree; 1546public SyntaxTreeAnalysisContext(SyntaxTree tree, AnalyzerOptions options, Action<Diagnostic> reportDiagnostic, Func<Diagnostic, bool> isSupportedDiagnostic, CancellationToken cancellationToken) 1552SyntaxTree tree, 1572/// Report a <see cref="Diagnostic"/> about a <see cref="SyntaxTree"/>. 1696public SyntaxTree FilterTree { get; } 1802public SyntaxTree FilterTree { get; } 1885private readonly Func<SyntaxTree, SemanticModel> _getSemanticModel; 1920Func<SyntaxTree, SemanticModel> getSemanticModel, 1961/// Gets a <see cref="SemanticModel"/> for the given <see cref="SyntaxTree"/>, which is shared across all analyzers. 1963public SemanticModel GetSemanticModel(SyntaxTree syntaxTree) => _getSemanticModel(syntaxTree);

233SyntaxTree? filterTree, 332SyntaxTree filterTree,

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>

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

870var tree = location.SourceTree;

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

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

73ArrayBuilder<SyntaxTree> trees = ArrayBuilder<SyntaxTree>.GetInstance(); 225var constantSourcesBuilder = ArrayBuilder<SyntaxTree>.GetInstance(); 375var tree = ParseGeneratedSourceText(source, Path.Combine(prefix, source.HintName), cancellationToken); 461internal abstract SyntaxTree ParseGeneratedSourceText(GeneratedSourceText input, string fileName, CancellationToken cancellationToken);

79/// The base directory for the <see cref="SyntaxTree.FilePath"/> of generated files.

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( 125private static ImmutableArray<(SyntaxTree Tree, SourceGeneratorSyntaxTreeInfo Info)> GetSourceGeneratorInfo( 130foreach (var tree in compilation.CommonSyntaxTrees) 138var builder = ImmutableArray.CreateBuilder<(SyntaxTree Tree, SourceGeneratorSyntaxTreeInfo Info)>(count); 141foreach (var tree in compilation.CommonSyntaxTrees) 154SyntaxTree syntaxTree,

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

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

58int CalculateLocalSyntaxOffset(int declaratorPosition, SyntaxTree declaratorTree);

174bool IsDefinedInSourceTree(SyntaxTree tree, TextSpan? definedWithinSpan, CancellationToken cancellationToken = default);

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;

29internal SyntaxTree? _syntaxTree; 45internal SyntaxNode(GreenNode green, int position, SyntaxTree syntaxTree) 77public SyntaxTree SyntaxTree => this.SyntaxTreeCore; 353/// occurs when a <see cref="SyntaxTree"/> is incrementally parsed using <see cref="SyntaxTree.WithChangedText"/> 361/// from <see cref="SyntaxTree.WithChangedText"/>. This can happen as the parser is allowed to construct parse 691var tree = this.SyntaxTree; 1429protected abstract SyntaxTree SyntaxTreeCore { get; } 1650internal 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; }

637public SyntaxTree? SyntaxTree => Parent?.SyntaxTree; 644var tree = SyntaxTree; 663var tree = SyntaxTree; 689/// occurs when a <see cref="SyntaxTree"/> is incrementally parsed using <see cref="SyntaxTree.WithChangedText"/> 697/// from <see cref="SyntaxTree.WithChangedText"/>. This can happen as the parser is allowed to construct parse

171public abstract SyntaxTree WithChangedText(SourceText newText); 335public abstract IList<TextSpan> GetChangedSpans(SyntaxTree syntaxTree); 350public abstract bool IsEquivalentTo(SyntaxTree tree, bool topLevel = false); 365public abstract IList<TextChange> GetChanges(SyntaxTree oldTree); 390public abstract SyntaxTree WithRootAndOptions(SyntaxNode root, ParseOptions options); 395public abstract SyntaxTree WithFilePath(string path); 406public virtual SyntaxTree WithDiagnosticOptions(ImmutableDictionary<string, ReportDiagnostic> options) 412/// 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"/>.

109SyntaxTree tree, 117SyntaxTree tree, 147SyntaxTree tree,

47var tree = context.Tree;

98internal Location GetLocation(SyntaxTree syntaxTree)

46var tree = context.Tree;

60var sourceTree = symbolContext.Symbol.Locations.FirstOrDefault()?.SourceTree; 114SyntaxTree sourceTree,

65var tree = model.SyntaxTree;

87var tree = context.SemanticModel.SyntaxTree; 127var tree = compilation.SyntaxTrees.FirstOrDefault(tree => !GeneratedCodeUtilities.IsGeneratedCode(tree, IsRegularCommentOrDocComment, context.CancellationToken)); 194IEnumerable<TextSpan> contiguousSpans, SyntaxTree tree, 209IEnumerable<SyntaxNode> nodes, SyntaxTree tree, CancellationToken cancellationToken); 212IEnumerable<SyntaxNode> nodes, SyntaxTree tree, CancellationToken cancellationToken)

98var tree = semanticModel.SyntaxTree; 491static void AddAllCompilationDiagnosticsForTree(AnalysisResult analysisResult, SyntaxTree tree, ArrayBuilder<Diagnostic> reportedDiagnostics) 508SyntaxTree tree, 545SyntaxTree tree,

595foreach (var tree in namedTypeSymbol.Locations.Select(l => l.SourceTree).Distinct().WhereNotNull())

111protected abstract bool SupportsDiscard(SyntaxTree tree); 202private bool TryGetOptions(SyntaxTree syntaxTree, AnalyzerOptions analyzerOptions, CompilationOptions compilationOptions, CancellationToken cancellationToken, out Options options)

163var tree = model.SyntaxTree; 222private readonly ConcurrentDictionary<SyntaxTree, (StrongBox<bool> completed, TextSpanMutableIntervalTree? intervalTree)> _codeBlockIntervals = [];

27var syntaxTree = match.SyntaxTree;

79var syntaxTree = assignment.SyntaxTree;

140var syntaxTree = context.Node.SyntaxTree;

49SyntaxTree tree, Func<SyntaxTrivia, bool> isComment, CancellationToken cancellationToken) 118SyntaxTree tree, Func<SyntaxTrivia, bool> isComment, 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)

44public static bool ShouldAnalyzeSpan(this SymbolStartAnalysisContext context, TextSpan span, SyntaxTree tree) 64public static bool ShouldAnalyzeSpan(this SymbolAnalysisContext context, TextSpan span, SyntaxTree tree)

64public static ReportDiagnostic GetEffectiveSeverity(this DiagnosticDescriptor descriptor, CompilationOptions compilationOptions, SyntaxTree tree, AnalyzerOptions analyzerOptions) 148(SyntaxTreeOptionsProvider provider, SyntaxTree tree)? providerAndTree = null) 157var tree = providerAndTree.Value.tree;

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

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) 249public static SyntaxNode FindNode(this SyntaxTree syntaxTree, TextSpan? span, bool findInTrivia, bool getInnermostNodeForTie, CancellationToken cancellationToken)

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)

170var tree = token1.SyntaxTree;

35public readonly SyntaxTree Tree; 43SyntaxTree tree,

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

84var syntaxTree = documentationComment.SyntaxTree;

158bool IsPreProcessorDirectiveContext(SyntaxTree syntaxTree, int position, CancellationToken cancellationToken); 184bool IsEntirelyWithinStringOrCharOrNumericLiteral([NotNullWhen(true)] SyntaxTree? syntaxTree, int position, CancellationToken cancellationToken); 415TextSpan GetInactiveRegionSpanAroundPosition(SyntaxTree tree, int position, CancellationToken cancellationToken); 486bool IsInInactiveRegion(SyntaxTree syntaxTree, int position, CancellationToken cancellationToken);

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, 203SyntaxNode? GetContainerDeclaration(SyntaxTree? syntaxTree) 274private static bool Contains(IEnumerable<SyntaxTree> trees, SyntaxTree tree) 276foreach (var current in trees)

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

453internal SyntaxTree? GetSyntaxTree(string filePath)

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

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

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

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

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);

80var tree = await this.Document.GetRequiredSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);

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

242var destinationTree = destinationDeclaration.SyntaxTree;

66var syntaxTree = destination.SyntaxTree;

16public SyntaxTree SyntaxTree { get; }

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

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

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

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

30public SyntaxTree SyntaxTree => Root.SyntaxTree;

26public SyntaxTree SyntaxTree => Root.SyntaxTree;

252internal bool AreNullableAnnotationsEnabled(SyntaxTree syntaxTree, int position)

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

194var syntaxTree = syntaxRef.SyntaxTree;

2742internal static bool CheckFeatureAvailability(SyntaxTree tree, MessageID feature, BindingDiagnosticBag diagnostics, Location location) 2751private static bool CheckFeatureAvailability(SyntaxTree tree, MessageID feature, DiagnosticBag? diagnostics, Location location) 2757private static bool CheckFeatureAvailability<TData>(SyntaxTree tree, MessageID feature, DiagnosticBag? diagnostics, TData data, Func<TData, Location> getLocation, bool forceWarning = false)

53private SyntaxTree syntaxTree 640private static bool InSpan(Location location, SyntaxTree syntaxTree, TextSpan span) 649private static bool InSpan(ImmutableArray<Location> locations, SyntaxTree syntaxTree, TextSpan span)

51private readonly SyntaxTree _syntaxTree; 63internal BinderFactory(CSharpCompilation compilation, SyntaxTree syntaxTree, bool ignoreAccessibility, ObjectPool<BinderFactoryVisitor> binderFactoryVisitorPoolOpt = null) 82internal SyntaxTree SyntaxTree

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

145public 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( 345SyntaxTree tree,

137private HashSet<SyntaxTree>? _lazyCompilationUnitCompletedTrees; 143private ImmutableHashSet<SyntaxTree>? _usageOfUsingsRecordedInTrees = ImmutableHashSet<SyntaxTree>.Empty; 145internal ImmutableHashSet<SyntaxTree>? UsageOfUsingsRecordedInTrees => Volatile.Read(ref _usageOfUsingsRecordedInTrees); 154private ImmutableSegmentedDictionary<string, OneOrMany<SyntaxTree>> _mappedPathToSyntaxTree; 158private ImmutableSegmentedDictionary<string, OneOrMany<SyntaxTree>> _pathToSyntaxTree; 161private ImmutableSegmentedDictionary<ReadOnlyMemory<byte>, OneOrMany<SyntaxTree>> _contentHashToSyntaxTree; 358IEnumerable<SyntaxTree>? syntaxTrees = null, 378SyntaxTree? syntaxTree = null, 391(syntaxTree != null) ? new[] { syntaxTree } : SpecializedCollections.EmptyEnumerable<SyntaxTree>(), 402IEnumerable<SyntaxTree>? syntaxTrees, 434ImmutableArray<SyntaxTree>.Empty, 534private static LanguageVersion CommonLanguageVersion(ImmutableArray<SyntaxTree> syntaxTrees) 537foreach (var tree in syntaxTrees) 820public new ImmutableArray<SyntaxTree> SyntaxTrees 828public new bool ContainsSyntaxTree(SyntaxTree? syntaxTree) 836public new CSharpCompilation AddSyntaxTrees(params SyntaxTree[] trees) 838return AddSyntaxTrees((IEnumerable<SyntaxTree>)trees); 844public new CSharpCompilation AddSyntaxTrees(IEnumerable<SyntaxTree> trees) 860var externalSyntaxTrees = PooledHashSet<SyntaxTree>.GetInstance(); 908public new CSharpCompilation RemoveSyntaxTrees(params SyntaxTree[] trees) 910return RemoveSyntaxTrees((IEnumerable<SyntaxTree>)trees); 917public new CSharpCompilation RemoveSyntaxTrees(IEnumerable<SyntaxTree> trees) 929var removeSet = PooledHashSet<SyntaxTree>.GetInstance(); 934var externalSyntaxTrees = PooledHashSet<SyntaxTree>.GetInstance(); 976syntaxAndDeclarations: syntaxAndDeclarations.WithExternalSyntaxTrees(ImmutableArray<SyntaxTree>.Empty)); 982public new CSharpCompilation ReplaceSyntaxTree(SyntaxTree oldTree, SyntaxTree? newTree) 1036internal override int GetSyntaxTreeOrdinal(SyntaxTree tree) 1051internal OneOrMany<SyntaxTree> GetSyntaxTreesByMappedPath(string mappedPath) 1066return mappedPathToSyntaxTree.TryGetValue(mappedPath, out var value) ? value : OneOrMany<SyntaxTree>.Empty; 1068ImmutableSegmentedDictionary<string, OneOrMany<SyntaxTree>> computeMappedPathToSyntaxTree() 1070var builder = ImmutableSegmentedDictionary.CreateBuilder<string, OneOrMany<SyntaxTree>>(); 1072foreach (var tree in SyntaxTrees) 1081internal OneOrMany<SyntaxTree> GetSyntaxTreesByContentHash(ReadOnlyMemory<byte> contentHash) 1092return contentHashToSyntaxTree.TryGetValue(contentHash, out var value) ? value : OneOrMany<SyntaxTree>.Empty; 1094ImmutableSegmentedDictionary<ReadOnlyMemory<byte>, OneOrMany<SyntaxTree>> computeHashToSyntaxTree() 1096var builder = ImmutableSegmentedDictionary.CreateBuilder<ReadOnlyMemory<byte>, OneOrMany<SyntaxTree>>(ContentHashComparer.Instance); 1097foreach (var tree in SyntaxTrees) 1107internal OneOrMany<SyntaxTree> GetSyntaxTreesByPath(string path) 1119return pathToSyntaxTree.TryGetValue(path, out var value) ? value : OneOrMany<SyntaxTree>.Empty; 1121ImmutableSegmentedDictionary<string, OneOrMany<SyntaxTree>> computePathToSyntaxTree() 1123var builder = ImmutableSegmentedDictionary.CreateBuilder<string, OneOrMany<SyntaxTree>>(); 1124foreach (var tree in SyntaxTrees) 1557internal bool IsSubmissionSyntaxTree(SyntaxTree tree) 2485public new SemanticModel GetSemanticModel(SyntaxTree syntaxTree, bool ignoreAccessibility) 2494public new SemanticModel GetSemanticModel(SyntaxTree syntaxTree, SemanticModelOptions options) 2517internal override SemanticModel CreateSemanticModel(SyntaxTree syntaxTree, SemanticModelOptions options) 2531internal BinderFactory GetBinderFactory(SyntaxTree syntaxTree, bool ignoreAccessibility = false) 2541private BinderFactory GetBinderFactory(SyntaxTree syntaxTree, bool ignoreAccessibility, ref WeakReference<BinderFactory>[]? cachedBinderFactories) 2563private BinderFactory AddNewFactory(SyntaxTree syntaxTree, bool ignoreAccessibility, [NotNull] ref WeakReference<BinderFactory>? slot) 2595private void CompleteTree(SyntaxTree tree) 2597if (_lazyCompilationUnitCompletedTrees == null) Interlocked.CompareExchange(ref _lazyCompilationUnitCompletedTrees, new HashSet<SyntaxTree>(), null); 2624private void ReportUnusedImports(SyntaxTree? filterTree, BindingDiagnosticBag diagnostics, CancellationToken cancellationToken) 2640SyntaxTree infoTree = info.Tree; 2717internal override void CompleteTrees(SyntaxTree? filterTree) 2730foreach (var tree in this.SyntaxTrees) 2768public readonly SyntaxTree Tree; 2772public ImportInfo(SyntaxTree tree, SyntaxKind kind, TextSpan span) 2933var syntaxTree = syntaxTrees[i]; 2941foreach (var syntaxTree in syntaxTrees) 2952foreach (var syntaxTree in syntaxTrees) 3005private static void AppendLoadDirectiveDiagnostics(DiagnosticBag builder, SyntaxAndDeclarationManager syntaxAndDeclarations, SyntaxTree syntaxTree, Func<IEnumerable<Diagnostic>, IEnumerable<Diagnostic>>? locationFilterOpt = null) 3051private static bool IsDefinedOrImplementedInSourceTree(Symbol symbol, SyntaxTree tree, TextSpan? span) 3067private ImmutableArray<Diagnostic> GetDiagnosticsForMethodBodiesInTree(SyntaxTree tree, TextSpan? span, CancellationToken cancellationToken) 3120foreach (var otherTree in SyntaxTrees) 3148void compileMethodBodiesAndDocComments(SyntaxTree? filterTree, TextSpan? filterSpan, BindingDiagnosticBag bindingDiagnostics, CancellationToken cancellationToken) 3163void registeredUsageOfUsingsInTree(SyntaxTree tree) 3199private ReadOnlyBindingDiagnostic<AssemblySymbol> GetSourceDeclarationDiagnostics(SyntaxTree? syntaxTree = null, TextSpan? filterSpanWithinTree = null, Func<IEnumerable<Diagnostic>, SyntaxTree, TextSpan?, IEnumerable<Diagnostic>>? locationFilterOpt = null, Predicate<Symbol>? symbolFilter = null, CancellationToken cancellationToken = default) 3248private ReadOnlyBindingDiagnostic<AssemblySymbol> GetClsComplianceDiagnostics(SyntaxTree? syntaxTree, TextSpan? filterSpanWithinTree, CancellationToken cancellationToken) 3271private static IEnumerable<Diagnostic> FilterDiagnosticsByLocation(IEnumerable<Diagnostic> diagnostics, SyntaxTree tree, TextSpan? filterSpanWithinTree) 3284SyntaxTree syntaxTree, 3551public bool CheckDuplicateFilePathsAndFree(ImmutableArray<SyntaxTree> syntaxTrees, NamespaceSymbol globalNamespace) 3554foreach (var tree in syntaxTrees) 3785SyntaxTree tree, 3884foreach (var syntaxTree in this.SyntaxTrees) 3926protected override SemanticModel CommonGetSemanticModel(SyntaxTree syntaxTree, SemanticModelOptions options) 3931protected internal override ImmutableArray<SyntaxTree> CommonSyntaxTrees 3939protected override Compilation CommonAddSyntaxTrees(IEnumerable<SyntaxTree> trees) 3944protected override Compilation CommonRemoveSyntaxTrees(IEnumerable<SyntaxTree> trees) 3954protected override Compilation CommonReplaceSyntaxTree(SyntaxTree oldTree, SyntaxTree? newTree) 3969protected override bool CommonContainsSyntaxTree(SyntaxTree? syntaxTree)

24/// cref="Compilation.GetSemanticModel(SyntaxTree, bool)"/>. 2789public new abstract SyntaxTree SyntaxTree 4940protected sealed override SyntaxTree SyntaxTreeCore 5223var tree = nameSyntax.SyntaxTree;

1147public override SyntaxTree SyntaxTree

21private NodeMapBuilder(OrderPreservingMultiDictionary<SyntaxNode, BoundNode> map, SyntaxTree tree, SyntaxNode thisSyntaxNodeOnly) 29private readonly SyntaxTree _tree; 39public static void AddToMap(BoundNode root, Dictionary<SyntaxNode, OneOrMany<BoundNode>> map, SyntaxTree tree, SyntaxNode node = null)

129public override SyntaxTree SyntaxTree => _memberModel.SyntaxTree;

28ImmutableArray<SyntaxTree> externalSyntaxTrees, 50ImmutableArray<SyntaxTree> externalSyntaxTrees, 56var treesBuilder = ArrayBuilder<SyntaxTree>.GetInstance(); 57var ordinalMapBuilder = PooledDictionary<SyntaxTree, int>.GetInstance(); 58var loadDirectiveMapBuilder = PooledDictionary<SyntaxTree, ImmutableArray<LoadDirective>>.GetInstance(); 59var loadedSyntaxTreeMapBuilder = PooledDictionary<string, SyntaxTree>.GetInstance(); 60var declMapBuilder = PooledDictionary<SyntaxTree, Lazy<RootSingleNamespaceDeclaration>>.GetInstance(); 61var lastComputedMemberNamesMap = PooledDictionary<SyntaxTree, OneOrMany<WeakReference<StrongBox<ImmutableSegmentedHashSet<string>>>>>.GetInstance(); 64foreach (var tree in externalSyntaxTrees) 91public SyntaxAndDeclarationManager AddSyntaxTrees(IEnumerable<SyntaxTree> trees) 112var treesBuilder = ArrayBuilder<SyntaxTree>.GetInstance(); 115foreach (var tree in trees) 154ArrayBuilder<SyntaxTree> treesBuilder, 155SyntaxTree tree, 160IDictionary<SyntaxTree, int> ordinalMapBuilder, 161IDictionary<SyntaxTree, ImmutableArray<LoadDirective>> loadDirectiveMapBuilder, 162IDictionary<string, SyntaxTree> loadedSyntaxTreeMapBuilder, 163IDictionary<SyntaxTree, Lazy<RootSingleNamespaceDeclaration>> declMapBuilder, 164IDictionary<SyntaxTree, OneOrMany<WeakReference<StrongBox<ImmutableSegmentedHashSet<string>>>>> lastComputedMemberNamesMap, 189ArrayBuilder<SyntaxTree> treesBuilder, 190SyntaxTree tree, 195IDictionary<SyntaxTree, int> ordinalMapBuilder, 196IDictionary<SyntaxTree, ImmutableArray<LoadDirective>> loadDirectiveMapBuilder, 197IDictionary<string, SyntaxTree> loadedSyntaxTreeMapBuilder, 198IDictionary<SyntaxTree, Lazy<RootSingleNamespaceDeclaration>> declMapBuilder, 199IDictionary<SyntaxTree, OneOrMany<WeakReference<StrongBox<ImmutableSegmentedHashSet<string>>>>> lastComputedMemberNamesMap, 241var loadedTree = SyntaxFactory.ParseSyntaxTree( 292SyntaxTree tree, 295IDictionary<SyntaxTree, Lazy<RootSingleNamespaceDeclaration>> declMapBuilder, 304public SyntaxAndDeclarationManager RemoveSyntaxTrees(HashSet<SyntaxTree> trees) 316var removeSet = PooledHashSet<SyntaxTree>.GetInstance(); 317foreach (var tree in trees) 333var treesBuilder = ArrayBuilder<SyntaxTree>.GetInstance(); 334var ordinalMapBuilder = PooledDictionary<SyntaxTree, int>.GetInstance(); 338foreach (var tree in syntaxTrees) 383SyntaxTree oldTree, 385ImmutableArray<SyntaxTree> syntaxTrees, 386ImmutableDictionary<SyntaxTree, int> syntaxTreeOrdinalMap, 387ImmutableDictionary<SyntaxTree, ImmutableArray<LoadDirective>> loadDirectiveMap, 388ImmutableDictionary<string, SyntaxTree> loadedSyntaxTreeMap, 389HashSet<SyntaxTree> removeSet, 414var tree = syntaxTrees[i]; 421SyntaxTree loadedTree; 434ImmutableDictionary<SyntaxTree, ImmutableArray<LoadDirective>> loadDirectiveMap, 435ImmutableDictionary<string, SyntaxTree> loadedSyntaxTreeMap, 436HashSet<SyntaxTree> removeSet) 442SyntaxTree loadedTree; 457SyntaxTree tree, 458IDictionary<SyntaxTree, Lazy<RootSingleNamespaceDeclaration>> declMap, 466public SyntaxAndDeclarationManager ReplaceSyntaxTree(SyntaxTree oldTree, SyntaxTree newTree) 481var removeSet = PooledHashSet<SyntaxTree>.GetInstance(); 514ImmutableArray<SyntaxTree> newTrees; 523var treesBuilder = ArrayBuilder<SyntaxTree>.GetInstance(); 524var ordinalMapBuilder = PooledDictionary<SyntaxTree, int>.GetInstance(); 527var tree = syntaxTrees[i]; 548var tree = syntaxTrees[i]; 606SyntaxTree oldTree, 607ImmutableDictionary<SyntaxTree, Lazy<RootSingleNamespaceDeclaration>>.Builder declMapBuilder, 608ImmutableDictionary<SyntaxTree, OneOrMany<WeakReference<StrongBox<ImmutableSegmentedHashSet<string>>>>>.Builder lastComputedMemberNamesMap) 663internal SyntaxAndDeclarationManager WithExternalSyntaxTrees(ImmutableArray<SyntaxTree> trees) 668internal static bool IsLoadedSyntaxTree(SyntaxTree tree, ImmutableDictionary<string, SyntaxTree> loadedSyntaxTreeMap) 670SyntaxTree loadedTree; 675ArrayBuilder<SyntaxTree> treesBuilder, 676SyntaxTree tree, 677IDictionary<SyntaxTree, int> ordinalMapBuilder, 678ImmutableDictionary<SyntaxTree, ImmutableArray<LoadDirective>> loadDirectiveMap, 679ImmutableDictionary<string, SyntaxTree> loadedSyntaxTreeMap) 697SyntaxTree loadedTree; 728private 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; 43internal readonly ImmutableDictionary<SyntaxTree, OneOrMany<WeakReference<StrongBox<ImmutableSegmentedHashSet<string>>>>> LastComputedMemberNames; 47ImmutableArray<SyntaxTree> syntaxTrees, 48ImmutableDictionary<SyntaxTree, int> syntaxTreeOrdinalMap, 49ImmutableDictionary<SyntaxTree, ImmutableArray<LoadDirective>> loadDirectiveMap, 50ImmutableDictionary<string, SyntaxTree> loadedSyntaxTreeMap, 51ImmutableDictionary<SyntaxTree, Lazy<RootSingleNamespaceDeclaration>> rootNamespaces, 52ImmutableDictionary<SyntaxTree, OneOrMany<WeakReference<StrongBox<ImmutableSegmentedHashSet<string>>>>> lastComputedMemberNames, 56Debug.Assert(syntaxTrees.SetEquals(rootNamespaces.Keys.AsImmutable(), EqualityComparer<SyntaxTree>.Default));

28private readonly SyntaxTree _syntaxTree; 44internal SyntaxTreeSemanticModel(CSharpCompilation compilation, SyntaxTree syntaxTree, SemanticModelOptions options) 53internal SyntaxTreeSemanticModel(CSharpCompilation parentCompilation, SyntaxTree parentSyntaxTree, SyntaxTree speculatedSyntaxTree, SemanticModelOptions options) 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)

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)

41private readonly SyntaxTree _syntaxTree; 76SyntaxTree syntaxTree, 88SyntaxTree syntaxTree,

76var tree = 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)

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

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

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

92public static FileIdentifier Create(SyntaxTree syntaxTree, SourceReferenceResolver? resolver)

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

62private LexicalSortKey(SyntaxTree tree, int position, CSharpCompilation compilation)

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

511internal virtual bool CallsAreOmitted(SyntaxTree syntaxTree) 524private bool CallsAreConditionallyOmitted(SyntaxTree syntaxTree) 1143internal abstract int CalculateLocalSyntaxOffset(int localPosition, SyntaxTree localTree); 1234int IMethodSymbolInternal.CalculateLocalSyntaxOffset(int localPosition, SyntaxTree localTree) => CalculateLocalSyntaxOffset(localPosition, localTree);

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

139var syntaxTree = CSharpSyntaxTree.Dummy; 551internal override bool CallsAreOmitted(SyntaxTree syntaxTree) 578internal override int CalculateLocalSyntaxOffset(int localPosition, SyntaxTree localTree)

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

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

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

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

1558var tree = rootNs.Location.SourceTree;

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

423internal SyntaxTree SyntaxTree

189public SyntaxTree SyntaxTree 228public override bool IsDefinedInSourceTree(SyntaxTree tree, TextSpan? definedWithinSpan, CancellationToken cancellationToken = default)

862private SyntaxTree? AssociatedSyntaxTree => IsFileLocal ? declaration.Declarations[0].Location.SourceTree : null; 868if (AssociatedSyntaxTree is not SyntaxTree syntaxTree) 1011public override bool IsDefinedInSourceTree(SyntaxTree tree, TextSpan? definedWithinSpan, CancellationToken cancellationToken) 1093internal int CalculateSyntaxOffsetInSynthesizedConstructor(int position, SyntaxTree tree, bool isStatic) 1136internal bool TryCalculateSyntaxOffsetOfPositionInInitializer(int position, SyntaxTree tree, bool isStatic, int ctorInitializerLength, out int syntaxOffset) 1167static bool findInitializer(ImmutableArray<ImmutableArray<FieldOrPropertyInitializer>> initializers, int position, SyntaxTree tree, 1321var conflictDict = new Dictionary<(string name, int arity, SyntaxTree? syntaxTree), SourceNamedTypeSymbol>(); 1879var tree = declaration.Declarations[0].SyntaxReference.SyntaxTree;

633public override bool IsDefinedInSourceTree(SyntaxTree tree, TextSpan? definedWithinSpan, CancellationToken cancellationToken = default(CancellationToken))

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

93internal SyntaxTree SyntaxTree 1068SyntaxTree? matchingTree = matchingTrees[0]; 1261SyntaxTree? matchingTree = matchingTrees[0];

153var syntaxTree = syntaxRef.SyntaxTree;

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

108public override bool HasLocationContainedWithin(SyntaxTree tree, TextSpan declarationSpan, out bool wasZeroWidthMatch) 386var leftTree = possibleFileLocalType.MergedDeclaration.Declarations[0].Location.SourceTree; 456public override bool IsDefinedInSourceTree(SyntaxTree tree, TextSpan? definedWithinSpan, CancellationToken cancellationToken = default(CancellationToken))

442SyntaxTree tree, 620internal sealed override bool CallsAreOmitted(SyntaxTree syntaxTree)

544var syntaxTree = SyntaxTree;

847internal SyntaxTree SyntaxTree

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

440public virtual bool HasLocationContainedWithin(SyntaxTree tree, TextSpan declarationSpan, out bool wasZeroWidthMatch) 452protected static bool IsLocationContainedWithin(Location loc, SyntaxTree tree, TextSpan declarationSpan, out bool wasZeroWidthMatch) 932public virtual bool IsDefinedInSourceTree(SyntaxTree tree, TextSpan? definedWithinSpan, CancellationToken cancellationToken = default(CancellationToken)) 953protected static bool IsDefinedInSourceTree(SyntaxReference syntaxRef, SyntaxTree tree, TextSpan? definedWithinSpan)

168var tree = syntaxReferences[0].SyntaxTree;

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

346internal 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)

193internal override int CalculateLocalSyntaxOffset(int localPosition, SyntaxTree localTree) 254public 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)

37internal CSharpSyntaxNode(GreenNode green, int position, SyntaxTree syntaxTree) 48internal new SyntaxTree SyntaxTree 58private static SyntaxTree ComputeSyntaxTree(CSharpSyntaxNode node) 61SyntaxTree? tree = null; 456protected 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"/>. 910public static SyntaxTree ParseText( 921public static SyntaxTree ParseText( 933public 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

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

177internal static bool ReportDocumentationCommentDiagnostics(this SyntaxTree tree)

1547public static SyntaxTree SyntaxTree(SyntaxNode root, ParseOptions? options = null, string path = "", Encoding? encoding = null) 1555public static SyntaxTree ParseSyntaxTree( 1567public static SyntaxTree ParseSyntaxTree( 1938public static bool AreEquivalent(SyntaxTree? oldTree, SyntaxTree? newTree, bool topLevel) 2315public static bool IsCompleteSubmission(SyntaxTree tree) 2782public static SyntaxTree ParseSyntaxTree( 2796public static SyntaxTree ParseSyntaxTree( 2809public static SyntaxTree ParseSyntaxTree( 2824public static SyntaxTree ParseSyntaxTree(

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

35var syntaxTree = namespaceDeclaration.SyntaxTree;

70var syntaxTree = context.Node.SyntaxTree;

131var tree = syntaxContext.SemanticModel.SyntaxTree; 173var tree = syntaxContext.Node.SyntaxTree; 319var tree = semanticModel.SyntaxTree;

47var tree = context.Tree;

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

64var syntaxTree = semanticModel.SyntaxTree;

187public static SyntaxTreeState Create(bool defaultCompleted, NullableContextOptions compilationOptions, SyntaxTree tree, CancellationToken cancellationToken) 267private readonly ConcurrentDictionary<SyntaxTree, SyntaxTreeState> _codeBlockIntervals = []; 324private SyntaxTreeState GetOrCreateSyntaxTreeState(SyntaxTree tree, bool defaultCompleted, SemanticModel semanticModel, CancellationToken cancellationToken)

29protected override bool SupportsDiscard(SyntaxTree tree)

38var syntaxTree = semanticModel.SyntaxTree; 141var syntaxTree = semanticModel.SyntaxTree; 205SyntaxNodeAnalysisContext context, SyntaxTree syntaxTree, NotificationOption2 notification, ExpressionSyntax expression, bool changesSemantics)

29var syntaxTree = semanticModel.SyntaxTree;

42var syntaxTree = semanticModel.SyntaxTree;

44var syntaxTree = semanticModel.SyntaxTree; 86var syntaxTree = semanticModel.SyntaxTree;

41var syntaxTree = context.Node.SyntaxTree;

40var syntaxTree = context.SemanticModel.SyntaxTree;

41var syntaxTree = context.Node.SyntaxTree;

44var syntaxTree = context.Node.SyntaxTree;

64var syntaxTree = expression.SyntaxTree;

60var syntaxTree = node.SyntaxTree;

83SyntaxTree? currentSyntaxTree = null; 102var fieldSyntaxTree = fieldSyntaxReference.SyntaxTree;

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

238var syntaxTree = genericIdentifier.SyntaxTree!;

17public static ISet<SyntaxKind> GetPrecedingModifiers(this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 21this SyntaxTree syntaxTree, 42this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 48this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 54this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 80this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 91public static bool IsRightOfDotOrArrowOrColonColon(this SyntaxTree syntaxTree, int position, SyntaxToken targetToken, CancellationToken cancellationToken) 98public static bool IsRightOfDotOrArrow(this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 102this SyntaxTree syntaxTree, int position, Func<SyntaxKind, bool> predicate, CancellationToken cancellationToken) 115public static bool IsRightOfNumericLiteral(this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 121public static bool IsAfterKeyword(this SyntaxTree syntaxTree, int position, SyntaxKind kind, CancellationToken cancellationToken) 129public static bool IsEntirelyWithinNonUserCodeComment(this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 141public static bool IsEntirelyWithinComment(this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 151public static bool IsCrefContext(this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 164public static bool IsEntirelyWithinCrefSyntax(this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 176this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 220this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 238this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 255this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 269this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 293this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 378this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 385public static bool IsEntirelyWithinStringLiteral(this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 389this SyntaxTree syntaxTree, int position, out SyntaxToken stringLiteral, CancellationToken cancellationToken) 438this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 466this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 528public static bool IsPreProcessorKeywordContext(this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 536public static bool IsPreProcessorKeywordContext(this SyntaxTree syntaxTree, int position, SyntaxToken preProcessorTokenOnLeftOfPosition)

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

116public bool IsPreProcessorDirectiveContext(SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 120public bool IsEntirelyWithinStringOrCharOrNumericLiteral([NotNullWhen(true)] SyntaxTree? syntaxTree, int position, CancellationToken cancellationToken) 1106public TextSpan GetInactiveRegionSpanAroundPosition(SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 1526public bool IsInInactiveRegion(SyntaxTree syntaxTree, int position, CancellationToken cancellationToken)

299var tree = token1.SyntaxTree;

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

214SyntaxTree tree, SyntaxNode root, string indentation, TextLine textLine, CancellationToken cancellationToken)

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

492var syntaxTree = group.Key;

75var syntaxTree = destination.SyntaxTree; 84var tree = node.SyntaxTree.WithRootAndOptions(node, syntaxTree.Options); 202var contextTree = contextLocation != null && contextLocation.IsInSource

185var syntaxTree = semanticModel.SyntaxTree; 355var modifiers = SyntaxTree.GetPrecedingModifiers(positionBeforeRecordKeyword, cancellationToken); 377if (SyntaxTree.IsMemberDeclarationContext( 427=> IsGlobalStatementContext && SyntaxTree.Options.Kind is SourceCodeKind.Regular; 462return SyntaxTree.IsGlobalStatementContext(targetToken.SpanStart, cancellationToken); 464else if (SyntaxTree.IsScript() 469return SyntaxTree.IsGlobalStatementContext(targetToken.SpanStart, cancellationToken);

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, 668public static bool IsNamespaceDeclarationNameContext(this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 685public static bool IsPartialTypeDeclarationNameContext(this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken, [NotNullWhen(true)] out TypeDeclarationSyntax? declarationSyntax) 707public static bool IsDefinitelyNotTypeContext(this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 718this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken, SemanticModel? semanticModel = null) 768public static bool IsBaseClassOrInterfaceContext(this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 786public static bool IsUsingAliasTypeContext(this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 802public 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, 1047this SyntaxTree syntaxTree, 1137this SyntaxTree syntaxTree, 1165this SyntaxTree syntaxTree, int position, SyntaxToken tokenOnLeftOfPosition) 1180this SyntaxTree syntaxTree, int position, SyntaxToken tokenOnLeftOfPosition) 1194public static bool IsParameterTypeContext(this SyntaxTree syntaxTree, int position, SyntaxToken tokenOnLeftOfPosition) 1211public static bool IsPossibleExtensionMethodContext(this SyntaxTree syntaxTree, SyntaxToken tokenOnLeftOfPosition) 1223this SyntaxTree syntaxTree, int position, SyntaxToken tokenOnLeftOfPosition, CancellationToken cancellationToken) 1255this SyntaxTree syntaxTree, int position, SyntaxToken tokenOnLeftOfPosition) 1282this SyntaxTree syntaxTree, int position, SyntaxToken tokenOnLeftOfPosition, CancellationToken cancellationToken) 1307public static bool IsPossibleTupleContext(this SyntaxTree syntaxTree, SyntaxToken leftToken, int position) 1362public static bool IsAtStartOfPattern(this SyntaxTree syntaxTree, SyntaxToken leftToken, int position) 1456public static bool IsAtEndOfPattern(this SyntaxTree syntaxTree, SyntaxToken leftToken, int position) 1599public static bool IsPossibleDeconstructionDesignation(this SyntaxTree syntaxTree, 1709this SyntaxTree syntaxTree, 1749this SyntaxTree syntaxTree, int position, SyntaxToken tokenOnLeftOfPosition) 1766this SyntaxTree syntaxTree, int position, SyntaxToken tokenOnLeftOfPosition, CancellationToken cancellationToken) 1880this SyntaxTree syntaxTree, int position, SyntaxToken tokenOnLeftOfPosition) 1897public static bool IsCatchVariableDeclarationContext(this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 1914public static bool IsIsOrAsTypeContext(this SyntaxTree syntaxTree, int position, SyntaxToken tokenOnLeftOfPosition) 1926this SyntaxTree syntaxTree, int position, SyntaxToken tokenOnLeftOfPosition, CancellationToken cancellationToken) 1944private static bool IsNonConstantExpressionContext(SyntaxTree syntaxTree, int position, SyntaxToken tokenOnLeftOfPosition, CancellationToken cancellationToken) 1951public static bool IsPreProcessorDirectiveContext(this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 1958public static bool IsStatementContext(this SyntaxTree syntaxTree, int position, SyntaxToken tokenOnLeftOfPosition, CancellationToken cancellationToken) 1976public static bool IsGlobalStatementContext(this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 1999public static bool IsInstanceContext(this SyntaxTree syntaxTree, SyntaxToken targetToken, SemanticModel semanticModel, CancellationToken cancellationToken) 2030this SyntaxTree syntaxTree, int position, SyntaxToken tokenOnLeftOfPosition, CancellationToken cancellationToken) 2043public static bool IsDefiniteCastTypeContext(this SyntaxTree syntaxTree, int position, SyntaxToken tokenOnLeftOfPosition) 2057public static bool IsConstantExpressionContext(this SyntaxTree syntaxTree, int position, 2137public static bool IsLabelContext(this SyntaxTree syntaxTree, int position, CancellationToken cancellationToken) 2163this SyntaxTree syntaxTree, 2741public static bool IsNameOfContext(this SyntaxTree syntaxTree, int position, SemanticModel? semanticModelOpt = null, CancellationToken cancellationToken = default) 2808this SyntaxTree syntaxTree, 2928this SyntaxTree syntaxTree, int position, SyntaxToken tokenOnLeftOfPosition) 2963public static bool IsCatchFilterContext(this SyntaxTree syntaxTree, int position, SyntaxToken tokenOnLeftOfPosition) 2988public static bool IsEnumBaseListContext(this SyntaxTree syntaxTree, SyntaxToken targetToken) 3000public static bool IsEnumTypeMemberAccessContext(this SyntaxTree syntaxTree, SemanticModel semanticModel, int position, CancellationToken cancellationToken) 3055public static bool IsFunctionPointerCallingConventionContext(this SyntaxTree syntaxTree, SyntaxToken targetToken)

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,

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

192var syntaxTree = SemanticModel.SyntaxTree;

305var tree = comp.SyntaxTrees.Single(); 754var compilation = CreateCompilation(new SyntaxTree[0]); 878var compilation = CreateCompilation(new SyntaxTree[0]); 12228new SyntaxTree[] { SyntaxFactory.ParseSyntaxTree(analyzerSource) },

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

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

38private static SyntaxTree GetTree() 41private static SyntaxTree GetTreeFromCode(string code) 47var 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();

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) 44var tree = CSharpSyntaxTree.ParseText(code); 59var tree = CSharpSyntaxTree.ParseText(code); 74var tree = CSharpSyntaxTree.ParseText(code);

34var sourceTree = diagnostic.Location.SourceTree;

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

521protected override SyntaxTree Parse(string text) 527protected override Compilation CreateCompilation(SyntaxTree tree)

344var src1 = SyntaxFactory.ParseSyntaxTree(""" 353var src2 = SyntaxFactory.ParseSyntaxTree("""

250foreach (var tree in comp.SyntaxTrees)

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

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

250var tree = await currentSnapshot.Projects.First().Documents.First().GetSyntaxTreeAsync(); 707var 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);

8745var tree = comp.SyntaxTrees.Single(); 8811var tree = comp.SyntaxTrees.Single();

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

934var tree = comp.SyntaxTrees.Single(); 1659var tree = comp.SyntaxTrees.Single(); 1719var tree = comp.SyntaxTrees.Single(); 1863var tree = comp.SyntaxTrees.Single(); 1900var tree = comp.SyntaxTrees.Single(); 1940var tree = comp.SyntaxTrees.Single(); 1977var tree = comp.SyntaxTrees.Single(); 2011var tree = comp.SyntaxTrees.Single(); 2967var tree = comp.SyntaxTrees.Single(); 3032var tree = comp.SyntaxTrees.First(); 3117var tree = comp.SyntaxTrees.First(); 3235var tree = comp.SyntaxTrees.First(); 3290var tree = comp.SyntaxTrees.Single(); 3348var tree = comp.SyntaxTrees.Single(); 3544var tree = comp.SyntaxTrees.Single(); 3592var tree = comp.SyntaxTrees.Single(); 3713var tree = comp.SyntaxTrees.First(); 4237var tree = comp.SyntaxTrees.Single(); 4460var tree = comp.SyntaxTrees.Single(); 4534var tree = comp.SyntaxTrees.Single(); 4644var tree = comp.SyntaxTrees.Single(); 4743var tree = comp.SyntaxTrees.Single(); 5047var tree = comp.SyntaxTrees.Single(); 5128var tree = comp.SyntaxTrees.Single(); 5354var tree = comp.SyntaxTrees.Single(); 6437var tree = comp.SyntaxTrees.Single(); 9105var tree = comp.SyntaxTrees.First(); 9181var tree = comp.SyntaxTrees.First(); 9259var tree = comp.SyntaxTrees.First(); 9320var tree = comp.SyntaxTrees.First(); 9391var 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();

1847var tree = comp.SyntaxTrees.Single(); 1884var tree = comp.SyntaxTrees.Single();

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

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

3059var syntaxTree = comp.SyntaxTrees[0]; 3111var syntaxTree = comp.SyntaxTrees[0]; 3336var syntaxTree = comp.SyntaxTrees[0]; 3407var syntaxTree = comp.SyntaxTrees[0]; 3454var syntaxTree = comp.SyntaxTrees[0]; 3565var tree = comp.SyntaxTrees[0]; 3617var tree = comp.SyntaxTrees[0]; 3668var tree = comp.SyntaxTrees[0]; 3707var tree = comp.SyntaxTrees[0]; 4112var syntaxTree = comp.SyntaxTrees[0]; 4914var syntaxTree = comp.SyntaxTrees[0]; 7412var tree = comp.SyntaxTrees[0]; 7514var tree = comp.SyntaxTrees[0]; 7570var tree = allInCoreLib.SyntaxTrees[0]; 7639var tree = allInCoreLib.SyntaxTrees[0]; 7726var tree = comp1.SyntaxTrees[0]; 10801var 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];

5406var tree = result.Compilation.SyntaxTrees.Single(); 5694var tree = compilation.SyntaxTrees.Single(); 5732var tree = compilation.SyntaxTrees.Single();

4030var tree = comp.SyntaxTrees.Single(); 4067var tree = comp.SyntaxTrees.Single(); 4101var 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(); 679var tree = comp.Compilation.SyntaxTrees.First(); 710var tree = comp.Compilation.SyntaxTrees.First(); 767var tree = comp.SyntaxTrees.First(); 789var tree = comp.SyntaxTrees[0]; 851var tree = comp.SyntaxTrees[0]; 899var tree = comp.SyntaxTrees[0]; 948var tree = comp.SyntaxTrees[0]; 998var tree = comp.SyntaxTrees[0]; 1052var tree = comp.SyntaxTrees[0]; 1086var tree = comp.SyntaxTrees[0]; 1118var tree = comp.SyntaxTrees[0]; 1149var tree = comp.SyntaxTrees[0]; 1209var tree = comp.SyntaxTrees[0]; 1309var tree = comp.SyntaxTrees[0]; 1395var tree = comp.SyntaxTrees[0]; 1460var tree = comp.SyntaxTrees[0]; 1493var tree = comp.SyntaxTrees[0]; 1554var tree = comp.SyntaxTrees[0]; 1591var tree = comp.SyntaxTrees[0]; 1616var tree = comp.SyntaxTrees[0]; 1671var tree = comp.SyntaxTrees[0]; 1773var tree = comp.SyntaxTrees[0]; 1915var tree = comp.SyntaxTrees[0]; 2570var tree = comp.SyntaxTrees.First(); 2638var tree = comp.SyntaxTrees.First(); 3275var tree = comp.SyntaxTrees.First(); 3681var tree = comp.SyntaxTrees.First(); 3805var tree = comp.SyntaxTrees.First(); 3908var tree = comp.SyntaxTrees.First(); 4033var tree = comp.SyntaxTrees.First(); 4080var tree = comp.SyntaxTrees.First(); 4181var tree = comp.SyntaxTrees[0]; 4274var tree = comp.SyntaxTrees.First(); 5119var tree = comp.SyntaxTrees.First(); 5155var tree = comp.SyntaxTrees.First();

1600var tree = Parse(source, options: TestOptions.Regular); 3216var tree = compilation.SyntaxTrees.First(); 3249var tree = compilation.SyntaxTrees.First(); 3462var tree = compilation.SyntaxTrees.First(); 3633var tree = compilation.SyntaxTrees.First(); 3684var tree = compilation.SyntaxTrees.First(); 3930var tree = compilation.SyntaxTrees.First(); 3987var tree = compilation.SyntaxTrees.First(); 4020var tree = compilation.SyntaxTrees.First(); 4152var tree = compilation.SyntaxTrees.First(); 4837var tree = comp.SyntaxTrees.Single(); 5073var tree = comp.SyntaxTrees.Single(); 5117var tree = comp.SyntaxTrees.Single(); 5158var tree = comp.SyntaxTrees.Single(); 5202var tree = comp.SyntaxTrees.Single(); 5469var tree = Parse(source); 5798var tree = CSharpSyntaxTree.ParseText("class C { }"); 5909var tree = CSharpSyntaxTree.ParseText("class C { }"); 6350var syntaxTree = CSharpSyntaxTree.ParseText("class C { }"); 6386var syntaxTree = CSharpSyntaxTree.ParseText("class C { }"); 7495var tree = comp.SyntaxTrees.Single(); 7528var tree = comp.SyntaxTrees.Single(); 7565var tree = comp.SyntaxTrees.Single(); 7628var tree = comp.SyntaxTrees.Single(); 8287var tree = Parse(source, options: TestOptions.Regular); 8318var tree = Parse(source, options: TestOptions.Regular); 8373var tree = Parse(source, options: TestOptions.Regular); 8402var tree = Parse(source, options: TestOptions.Regular); 8431var tree = Parse(source, options: TestOptions.Regular); 8479var tree = Parse(source, options: TestOptions.Regular); 8513var tree = Parse(source, options: TestOptions.Regular); 8546var tree = Parse(source, options: TestOptions.Regular); 8575var tree = Parse(source, options: TestOptions.Regular); 8622var tree = Parse(source, options: TestOptions.Regular); 8657var tree = Parse(source, options: TestOptions.Regular); 8686var tree = Parse(source, options: TestOptions.Regular); 8715var tree = Parse(source, options: TestOptions.Regular); 8745var tree = Parse(source, options: TestOptions.Regular); 8800var tree = Parse(source, options: TestOptions.Regular); 8830var tree = Parse(source, options: TestOptions.Regular); 8889var tree = Parse(source, options: TestOptions.Regular); 8936var tree = Parse(source, options: TestOptions.Regular); 9007var tree = Parse(source, options: TestOptions.Regular); 9059var tree = Parse(source, options: TestOptions.Regular); 9136var tree = Parse(source, options: TestOptions.Regular); 9217var tree = Parse(source, options: TestOptions.Regular); 9300var tree = Parse(source, options: TestOptions.Regular); 9354var tree = Parse(source, options: TestOptions.Regular); 9852var tree = comp.SyntaxTrees.First(); 9903var tree = comp.SyntaxTrees.First(); 9945var tree = comp.SyntaxTrees.First(); 9991var tree = comp.SyntaxTrees.First(); 10057var tree = comp.SyntaxTrees.First(); 10096var tree = comp.SyntaxTrees.First(); 10130var tree = comp.SyntaxTrees.First(); 12690var tree = c.SyntaxTrees.Single(); 13971var tree = c.SyntaxTrees.Single(); 14242var tree = c.SyntaxTrees.Single(); 14430var tree = comp.SyntaxTrees.Single(); 16537var tree = comp.SyntaxTrees.Single(); 16562var tree = Parse(source, options: TestOptions.Regular); 16599var tree = Parse(source, options: TestOptions.Regular); 17205var tree = Parse(source, options: TestOptions.Regular); 17266var tree = Parse(source, options: TestOptions.Regular); 17325var tree = Parse(source, options: TestOptions.Regular); 17364var tree = Parse(source, options: TestOptions.Regular); 17396var tree = Parse(source, options: TestOptions.Regular7_1); 17429var tree = Parse(source, options: TestOptions.Regular7_1); 19058var tree = Parse(text); 19097var tree = Parse(text); 19136var tree = Parse(text); 19175var tree = Parse(text); 19227var tree = comp.SyntaxTrees.First(); 19289var tree = comp.SyntaxTrees.First(); 19392var tree = comp.SyntaxTrees.First(); 19423var tree = comp.SyntaxTrees.First(); 19477var tree = comp.SyntaxTrees.First(); 19535var tree = comp.SyntaxTrees.First(); 19658var tree = comp.SyntaxTrees.First(); 19702var tree = comp.SyntaxTrees.First(); 19733var tree = comp.SyntaxTrees.First(); 20355var tree = comp.SyntaxTrees.First(); 21348var tree = comp.SyntaxTrees.First(); 22613var startTree = SyntaxFactory.ParseSyntaxTree(text); 22618var newTree = startTree.WithChangedText(newText); 22853var tree = compilation.SyntaxTrees.First(); 24009var tree = SyntaxFactory.ParseSyntaxTree(text, CSharpParseOptions.Default); 24178var tree = compilation.SyntaxTrees.First(); 24257var tree = comp.SyntaxTrees.Single(); 24320var tree = comp.SyntaxTrees.Single(); 24384var tree = comp.SyntaxTrees.Single(); 24457var tree = comp.SyntaxTrees.Single(); 24530var tree = comp.SyntaxTrees.Single(); 24604var tree = comp.SyntaxTrees.Single(); 25022var tree = comp.SyntaxTrees.Single(); 25050var tree = comp.SyntaxTrees.Single(); 25081var tree = comp.SyntaxTrees.Single(); 25701var tree = comp.SyntaxTrees.Single(); 25772var tree = comp.SyntaxTrees.Single(); 25837var tree = comp.SyntaxTrees.Single(); 25879var tree = comp.SyntaxTrees.Single(); 25909var tree = comp.SyntaxTrees.Single(); 26220var tree = comp.SyntaxTrees[0]; 26293var tree = comp.SyntaxTrees.First(); 26326var tree = comp.SyntaxTrees.First(); 26359var tree = comp.SyntaxTrees.First(); 26392var tree = comp.SyntaxTrees.First(); 27565var tree = comp.SyntaxTrees.Single();

1685var tree = comp.SyntaxTrees[0];

1146var tree = Parse(source, options: TestOptions.Script); 1159var tree = Parse(source, options: TestOptions.Script);

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

1105var tree = comp.SyntaxTrees.Single(); 3587var tree = comp.SyntaxTrees.First();

5001var tree = compilation.SyntaxTrees[0]; 5127var tree = compilation.SyntaxTrees[0]; 5276var tree = compilation.SyntaxTrees[0];

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

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

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

89var tree = comp.SyntaxTrees.Single(); 330var tree = comp.SyntaxTrees.Single(); 417var tree = comp.SyntaxTrees.Single(); 504var tree = comp.SyntaxTrees.Single(); 622var tree = comp.SyntaxTrees.Single(); 1571var tree = comp.SyntaxTrees.Single(); 1806var tree = comp.SyntaxTrees.Single(); 2261var tree = comp.SyntaxTrees.Single(); 2676var tree = comp.SyntaxTrees.First(); 2839var tree = comp.SyntaxTrees.First(); 3017var tree = comp.SyntaxTrees.Single(); 3131var tree = comp.SyntaxTrees.Single(); 3302var tree = comp.SyntaxTrees.First(); 3453var tree = comp.SyntaxTrees.First(); 3639var tree = comp.SyntaxTrees.First(); 3729var tree = comp.SyntaxTrees.First(); 3815var tree = comp.SyntaxTrees.First(); 3888var tree = comp.SyntaxTrees.First();

33protected override Compilation CreateCompilation(SyntaxTree tree)

86var tree1 = method1.Locations[0].SourceTree; 87var tree0 = method0.Locations[0].SourceTree; 270internal static CSharpCompilation WithSource(this CSharpCompilation compilation, SyntaxTree newTree) 275internal static CSharpCompilation WithSource(this CSharpCompilation compilation, SyntaxTree[] newTrees)

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

697var tree = comp.SyntaxTrees[0]; 1915var tree = comp.SyntaxTrees[0]; 1967var tree = comp.SyntaxTrees[0]; 6007var tree = comp.SyntaxTrees[0]; 6243var tree = comp.SyntaxTrees[0]; 6616var tree = comp.SyntaxTrees[0]; 6850var tree = comp.SyntaxTrees[0]; 8124var tree = comp.SyntaxTrees[0]; 10545var tree = comp.SyntaxTrees[0]; 10684var tree = comp.SyntaxTrees[0]; 11171var tree = comp.SyntaxTrees.Single(); 11194var tree = comp.SyntaxTrees.Single(); 11222var tree = comp.SyntaxTrees.Single(); 11247var tree = comp.SyntaxTrees.Single(); 11292var tree = comp.SyntaxTrees.Single();

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");

45var tree1 = SyntaxFactory.ParseSyntaxTree("class A { }", encoding: null, path: "Foo.cs"); 46var tree2 = SyntaxFactory.ParseSyntaxTree("class B { }", encoding: null, path: ""); 47var tree3 = SyntaxFactory.ParseSyntaxTree(SourceText.From("class C { }", encoding: null), path: "Bar.cs"); 48var tree4 = SyntaxFactory.ParseSyntaxTree("class D { }", encoding: Encoding.UTF8, path: "Baz.cs"); 65var tree1 = SyntaxFactory.ParseSyntaxTree("class A { public void F() { } }", encoding: Encoding.Unicode, path: "Foo.cs"); 66var tree2 = SyntaxFactory.ParseSyntaxTree("class B { public void F() { } }", encoding: null, path: ""); 67var tree3 = SyntaxFactory.ParseSyntaxTree("class C { public void F() { } }", encoding: new UTF8Encoding(true, false), path: "Bar.cs"); 68var tree4 = SyntaxFactory.ParseSyntaxTree(SourceText.From("class D { public void F() { } }", new UTF8Encoding(false, false)), path: "Baz.cs"); 132var tree1 = SyntaxFactory.ParseCompilationUnit(@" 136var tree2 = SyntaxFactory.ParseCompilationUnit(@" 608var tree1 = Parse(source1, @"foo.cs"); 609var tree2 = Parse(source2, @"foo.cs"); 4966var compilation = CreateCompilation(new SyntaxTree[] { Parse(text1, "a.cs"), Parse(text2, "b.cs") }); 12307var tree = SyntaxFactory.ParseSyntaxTree(source, encoding: Encoding.UTF8, path: "HIDDEN.cs"); 12909var tree1 = Parse(source1, "f:/build/goo.cs"); 12910var tree2 = Parse(source2, "f:/build/nocode.cs"); 12948var tree = Parse(source, "f:/build/nocode.cs");

705var tree = comp.SyntaxTrees[0]; 746var tree = comp.SyntaxTrees[0]; 810var tree = comp.SyntaxTrees[0]; 852var tree = comp.SyntaxTrees[0]; 893var tree = comp.SyntaxTrees[0]; 932var tree = comp.SyntaxTrees[0]; 7534var tree = compilation.SyntaxTrees.Single(); 7575var tree = compilation.SyntaxTrees.Single(); 11634var tree = comp.SyntaxTrees[0];

5292var compilation = CreateCompilationWithMscorlib461(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 });

5103var syntaxTree = Parse(source, filename: "test.cs"); 5142var syntaxTree = Parse(source, filename: "test.cs", options: parseOptions); 5765var tree = compilation.SyntaxTrees.Single(); 9547var tree = comp.SyntaxTrees.Single(); 9596var tree = comp.SyntaxTrees.Single(); 9652var tree = comp2.SyntaxTrees.Single(); 11396var tree = comp.SyntaxTrees[0]; 11421var tree = comp.SyntaxTrees[0]; 11452var tree = comp.SyntaxTrees[0];

138var syntaxTree = Parse(s, @"IVTAndStrongNameTests\AnotherTempDir\temp.cs", parseOptions); 167var syntaxTree = Parse(s, @"IVTAndStrongNameTests\AnotherTempDir\temp.cs", parseOptions); 227var syntaxTree = Parse(s, @"IVTAndStrongNameTests\AnotherTempDir\temp.cs", TestOptions.RegularWithLegacyStrongName); 295var syntaxTree = Parse(s, @"IVTAndStrongNameTests\AnotherTempDir\temp.cs"); 337var syntaxTree = Parse(s, @"IVTAndStrongNameTests\AnotherTempDir\temp.cs");

1012var treeInAnotherCompilation = anotherCompilation.SyntaxTrees.Single(); 1102var treeInAnotherCompilation = compilation.SyntaxTrees.Single(); 1474var builder = ImmutableArray.CreateBuilder<SyntaxTree>(); 1478var tree = CSharpSyntaxTree.ParseText(string.Format(source, treeNum++), path: "SourceFileRegular.cs"); 1570var tree = CSharpSyntaxTree.ParseText(source, path: "SourceFileRegular.cs"); 1612var tree1 = CSharpSyntaxTree.ParseText(source1, path: "SourceFileRegular.cs"); 1613var tree2 = CSharpSyntaxTree.ParseText(source2, path: "SourceFileRegular.Designer.cs"); 1905var tree1 = CSharpSyntaxTree.ParseText(source1, path: "Source1_File1.cs"); 1906var tree2 = CSharpSyntaxTree.ParseText(source1, path: "Source1_File2.cs"); 1907var tree3 = CSharpSyntaxTree.ParseText(source2, path: "Source2_File3.cs"); 1908var tree4 = CSharpSyntaxTree.ParseText(source3, path: "Source3_File4.generated.cs"); 1909var tree5 = CSharpSyntaxTree.ParseText(source3, path: "Source3_File5.designer.cs"); 1943var tree = CSharpSyntaxTree.ParseText(source, path: "Source.cs"); 1964var tree = CSharpSyntaxTree.ParseText(source, path: "Source.cs"); 1987var tree = CSharpSyntaxTree.ParseText(source, path: "Source.cs"); 2008var tree = CSharpSyntaxTree.ParseText(source, path: "Source.cs"); 2033var tree = CSharpSyntaxTree.ParseText(source, path: "Source.cs"); 2053var tree = CSharpSyntaxTree.ParseText(source, path: "Source.cs"); 2072var tree = CSharpSyntaxTree.ParseText(source, path: "Source.cs"); 2095var tree = CSharpSyntaxTree.ParseText(source, path: "Source.cs"); 2116var tree = CSharpSyntaxTree.ParseText(source, path: "Source.cs"); 2142var tree = CSharpSyntaxTree.ParseText(source, path: "Source.cs"); 2175var tree = CSharpSyntaxTree.ParseText(source, path: "Source.cs"); 2240var tree = CSharpSyntaxTree.ParseText(source, path: "Source.cs"); 2532var tree = CSharpSyntaxTree.ParseText(source); 2561var tree = CSharpSyntaxTree.ParseText(source); 2589var tree = CSharpSyntaxTree.ParseText(source); 2607var tree = CSharpSyntaxTree.ParseText(source); 2625var tree = CSharpSyntaxTree.ParseText(source); 2653var tree = CSharpSyntaxTree.ParseText(source); 2849var tree = CSharpSyntaxTree.ParseText(source); 3345var tree1 = compilation.SyntaxTrees[0]; 3369var tree1 = Parse("partial class A { }"); 3370var tree2 = Parse("partial class A { private class B { } }"); 3412var tree1 = Parse("partial class A { }"); 3413var tree2 = Parse("partial class A { private class B { } }"); 3465var tree1 = Parse("partial class A { }"); 3466var tree2 = Parse("partial class A { private class B { } }"); 3516var tree1 = Parse("partial class A { }"); 3517var tree2 = Parse("partial class A { private class B { } }"); 3591var tree = CSharpSyntaxTree.ParseText(source); 3621var tree = CSharpSyntaxTree.ParseText(source); 3642var tree = CSharpSyntaxTree.ParseText(source); 3681var tree1 = compilation.SyntaxTrees[0]; 3748var tree = compilation.SyntaxTrees[0]; 3810var tree = compilation.SyntaxTrees[0]; 3879var tree = CSharpSyntaxTree.ParseText(string.Empty); 3914var tree = CSharpSyntaxTree.ParseText(string.Empty); 4037var tree = CSharpSyntaxTree.ParseText(@"class C { }"); 4054private readonly ConcurrentDictionary<SyntaxTree, SemanticModel> _cache = new ConcurrentDictionary<SyntaxTree, SemanticModel>(); 4056public override SemanticModel GetSemanticModel(SyntaxTree tree, Compilation compilation, SemanticModelOptions options) 4061public void VerifyCachedModel(SyntaxTree tree, SemanticModel model) 4150var tree = compilation.SyntaxTrees[0]; 4183var tree1 = compilation.SyntaxTrees[0]; 4192var tree2 = compilation.SyntaxTrees[1]; 4193var tree3 = compilation.SyntaxTrees[2]; 4255var tree = compilation.SyntaxTrees[0]; 4265public override GeneratedKind IsGenerated(SyntaxTree tree, CancellationToken cancellationToken) 4271public override bool TryGetDiagnosticValue(SyntaxTree tree, string diagnosticId, CancellationToken cancellationToken, out ReportDiagnostic severity) 4309var tree = compilation.SyntaxTrees[0]; 4393var tree = CSharpSyntaxTree.ParseText(@"class C { }"); 4418var tree = CSharpSyntaxTree.ParseText(source);

716var tree = compilation.SyntaxTrees[0];

166var tree1 = CSharpSyntaxTree.ParseText(source1, path: "file1"); 167var tree2 = CSharpSyntaxTree.ParseText(source2, path: "file2"); 215var tree1 = CSharpSyntaxTree.ParseText(source1, path: "file1"); 216var tree2 = CSharpSyntaxTree.ParseText(source2, path: "file2"); 267var tree1 = CSharpSyntaxTree.ParseText(source1, path: "file1"); 268var tree2 = CSharpSyntaxTree.ParseText(source2, path: "file2"); 319var tree = CSharpSyntaxTree.ParseText(source, path: "file1"); 429var syntaxTree1 = Parse(string.Empty, options: new CSharpParseOptions().WithPreprocessorSymbols(new[] { "1" })); 430var syntaxTree2 = Parse(string.Empty, options: new CSharpParseOptions().WithPreprocessorSymbols(new[] { "2" })); 431var syntaxTree3 = Parse(string.Empty, options: new CSharpParseOptions().WithPreprocessorSymbols(new[] { "3" })); 458var syntaxTree1 = Parse(string.Empty, options: parseOptions1); 459var syntaxTree2 = Parse(string.Empty, options: parseOptions2); 460var syntaxTree3 = Parse(string.Empty, options: parseOptions2); 482var tree1 = Parse(string.Empty, options: parseOptions); 483var tree2 = Parse("ref struct X {}", options: parseOptions); 670var tree = compilation.SyntaxTrees.First(); 723var tree = compilation.SyntaxTrees.First(); 741var tree = compilation.SyntaxTrees.First(); 778var syntaxTree = compilation.SyntaxTrees[0]; 835var syntaxTree = compilation.SyntaxTrees[0]; 1057var syntaxTree = compilation.SyntaxTrees[0]; 1121var tree1 = compilation.SyntaxTrees[0]; 1122var tree2 = compilation.SyntaxTrees[1]; 1514var tree1 = compilation.SyntaxTrees[0]; 1515var tree2 = compilation.SyntaxTrees[1]; 1527var analyzedTree = Assert.Single(analyzer.AnalyzedTrees); 1567var expectedSemanticModelTreeCallbacks = new HashSet<SyntaxTree>(); 1696var tree = compilation.SyntaxTrees[0];

1273var tree = comp.SyntaxTrees.Single(); 1331var tree = comp.SyntaxTrees.Single(); 9471static (object, string, string)[] getInitializerValues(CSharpCompilation comp, SyntaxTree tree) 10488var tree = comp.SyntaxTrees.Single(); 10492var modifiedTree = SyntaxFactory.ParseSyntaxTree(source.Replace("return null;", "return field;"), parseOptions); 10522var tree = comp.SyntaxTrees.Single(); 10526var modifiedTree = SyntaxFactory.ParseSyntaxTree(source.Replace("return null;", "return field;"), parseOptions);

2820var tree = comp.SyntaxTrees.Single(); 2853var tree = comp.SyntaxTrees.Single(); 4998var tree = comp.SyntaxTrees.Single();

120var tree = comp.SyntaxTrees[0]; 141var tree = comp.SyntaxTrees[0]; 173var tree = comp.SyntaxTrees[0]; 194var tree = comp.SyntaxTrees[0]; 215protected T GetFirstNode<T>(SyntaxTree tree, int offset) 221protected 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]; 14119var tree = comp.CommonSyntaxTrees[0]; 14142var tree = comp.CommonSyntaxTrees[0];

442var tree = comp.SyntaxTrees[0]; 698var tree = comp3.SyntaxTrees[0]; 758var tree = comp3.SyntaxTrees[0]; 806var tree = comp3.SyntaxTrees[0]; 977var tree = comp.SyntaxTrees[0]; 2219var tree = comp.SyntaxTrees[0]; 2317var tree = comp.SyntaxTrees[0]; 2489var tree = comp.SyntaxTrees[0];

1523var tree = comp.SyntaxTrees[0]; 7100var tree = comp.SyntaxTrees.Single(); 7128var tree = comp.SyntaxTrees.Single();

6627var tree = comp.SyntaxTrees.Single(); 6764var tree = comp.SyntaxTrees.Single(); 6880var tree = comp.SyntaxTrees.Single(); 7012var tree = comp.SyntaxTrees.Single(); 7141var tree = comp.SyntaxTrees.Single(); 7471var tree = comp.SyntaxTrees.Single(); 7661var tree = comp.SyntaxTrees.Single(); 7880var tree = comp.SyntaxTrees.Single(); 8074var tree = comp.SyntaxTrees.Single(); 8267var tree = comp.SyntaxTrees.Single(); 8440var tree = comp.SyntaxTrees.Single(); 8546var tree = comp.SyntaxTrees.Single(); 8930var tree = comp.SyntaxTrees.Single(); 9134var tree = comp.SyntaxTrees.Single(); 9330var tree = comp.SyntaxTrees.Single(); 9498var tree = comp.SyntaxTrees.Single(); 9713var tree = comp.SyntaxTrees.Single(); 9934var tree = comp.SyntaxTrees.Single(); 10149var tree = comp.SyntaxTrees.Single(); 10346var tree = comp.SyntaxTrees.Single(); 10441var tree = comp.SyntaxTrees.Single(); 10541var tree = comp.SyntaxTrees.Single(); 10738var tree = comp.SyntaxTrees.Single(); 10978var tree = comp.SyntaxTrees.Single(); 11197var tree = comp.SyntaxTrees.Single(); 11421var tree = comp.SyntaxTrees.Single(); 11604var tree = comp.SyntaxTrees.Single(); 11699var tree = comp.SyntaxTrees.Single(); 12147var tree = comp1.SyntaxTrees.Single(); 12415var tree = comp1.SyntaxTrees.Single(); 12660var tree = comp1.SyntaxTrees.Single(); 12923var tree = comp1.SyntaxTrees.Single(); 13190var tree = comp1.SyntaxTrees.Single(); 13452var tree = comp1.SyntaxTrees.Single(); 14150var tree = comp.SyntaxTrees.Single(); 14491var tree = comp.SyntaxTrees.Single(); 14853var tree = comp.SyntaxTrees.Single(); 15204var tree = comp.SyntaxTrees.Single(); 15552var tree = comp.SyntaxTrees.Single(); 15731var tree = comp.SyntaxTrees.Single(); 15986var tree = comp.SyntaxTrees.Single(); 16757var tree = comp.SyntaxTrees.Single(); 16822var tree = comp.SyntaxTrees.Single(); 16887var tree = comp.SyntaxTrees.Single(); 16971var tree = comp.SyntaxTrees.Single(); 17059var tree = comp.SyntaxTrees.Single(); 17152var tree = comp.SyntaxTrees.Single(); 17249var tree = comp.SyntaxTrees.Single(); 17333var tree = comp.SyntaxTrees.Single(); 17654var tree = comp.SyntaxTrees.Single(); 17851var tree = comp.SyntaxTrees.Single(); 18074var tree = comp.SyntaxTrees.Single(); 18274var tree = comp.SyntaxTrees.Single(); 18475var tree = comp.SyntaxTrees.Single(); 18651var tree = comp.SyntaxTrees.Single(); 18759var tree = comp.SyntaxTrees.Single(); 19127var tree = comp.SyntaxTrees.Single(); 19298var tree = comp.SyntaxTrees.Single(); 19471var tree = comp.SyntaxTrees.Single(); 19623var tree = comp.SyntaxTrees.Single(); 19861var tree = comp.SyntaxTrees.Single(); 19965var tree = comp.SyntaxTrees.Single(); 21235var tree = comp2.SyntaxTrees.Single(); 21303var tree = comp.SyntaxTrees.Single(); 21705var tree = comp.SyntaxTrees.Single();

199var tree = comp.SyntaxTrees[0]; 234var tree = comp.SyntaxTrees[0]; 4769var tree = comp.SyntaxTrees.First(); 7533var tree = comp.SyntaxTrees[0]; 8256var tree = comp.SyntaxTrees[0]; 8327var tree = comp.SyntaxTrees[0]; 8411var tree = comp.SyntaxTrees[0]; 8496var tree = comp.SyntaxTrees[0]; 14232var tree = comp.SyntaxTrees.First(); 14308var tree = comp.SyntaxTrees.First(); 14381var tree = comp.SyntaxTrees.First(); 14443var tree = comp.SyntaxTrees.First(); 14567var tree = comp.SyntaxTrees.First(); 14650var tree = comp.SyntaxTrees.First(); 14739var tree = comp.SyntaxTrees.First(); 15078var tree = comp.SyntaxTrees[0]; 26012var tree = comp.SyntaxTrees[0]; 26138var tree = comp.SyntaxTrees[0]; 26252var tree = comp.SyntaxTrees[0]; 26310var tree = comp.SyntaxTrees[0]; 26381var tree = comp.SyntaxTrees[0]; 26463var tree = comp.SyntaxTrees[0]; 26529var tree = comp.SyntaxTrees[0]; 26590var tree = comp.SyntaxTrees[0]; 26660var tree = comp.SyntaxTrees[0]; 26835var tree = comp.SyntaxTrees[0]; 26900var tree = comp.SyntaxTrees[0]; 26956var tree = comp.SyntaxTrees[0]; 28618var tree = comp.SyntaxTrees.First(); 28662var tree = comp.SyntaxTrees.First(); 28708var tree = comp.SyntaxTrees.First(); 28752var tree = comp.SyntaxTrees.First(); 28795var tree = comp.SyntaxTrees.First(); 28838var tree = comp.SyntaxTrees.First(); 28877var tree = comp.SyntaxTrees.First(); 28910var tree = comp.SyntaxTrees.First(); 28944var tree = comp.SyntaxTrees.First(); 28997var tree = comp.SyntaxTrees.First(); 29063var tree = comp.SyntaxTrees.First(); 29124var tree = comp.SyntaxTrees.First(); 29200var tree = comp.SyntaxTrees.First(); 29243var tree = comp.SyntaxTrees.First(); 29290var tree = comp.SyntaxTrees.First(); 31479var tree = comp.SyntaxTrees.Single(); 31527var tree = comp.SyntaxTrees.Single(); 31585var tree = comp.SyntaxTrees.Single(); 31683var tree = comp.SyntaxTrees.Single(); 32297var tree = comp.SyntaxTrees.First(); 32333var tree = comp.SyntaxTrees.First(); 32365var tree = comp.SyntaxTrees.First(); 32393var tree = comp.SyntaxTrees.First(); 32435var tree = comp.SyntaxTrees.First(); 32480var tree = comp.SyntaxTrees.First(); 32544var tree = comp.SyntaxTrees.First(); 32640var tree = comp.SyntaxTrees.First(); 33035var tree = comp.SyntaxTrees.First(); 33463var tree = compilation.SyntaxTrees[0]; 33504var tree = compilation.SyntaxTrees[0];

2356var tree = comp.SyntaxTrees.First(); 2391var tree = comp.SyntaxTrees.First(); 2425var tree = comp.SyntaxTrees.First(); 2505var tree = comp.SyntaxTrees.First(); 6030var tree = comp.SyntaxTrees.First(); 6196var tree = comp.SyntaxTrees.First(); 8115var tree = comp.SyntaxTrees.First(); 8832var tree = comp.SyntaxTrees.First(); 9200var tree = comp.SyntaxTrees.First(); 10544var tree = comp.SyntaxTrees.First(); 11288var tree = comp.SyntaxTrees.First(); 15205var tree = comp.SyntaxTrees.First(); 16492var tree = comp.SyntaxTrees.First(); 18580var tree = comp.SyntaxTrees.First(); 18906var tree = comp.SyntaxTrees.First(); 19243var tree = comp.SyntaxTrees.First();

56var tree = compilation.SyntaxTrees.Single(); 100var tree = compilation.SyntaxTrees.Single(); 216var tree = compilation.SyntaxTrees.Single(); 269var tree = compilation.SyntaxTrees.Single(); 332var tree = compilation.SyntaxTrees.Single(); 819private static IdentifierNameSyntax GetReference(SyntaxTree tree, string name) 824private static IdentifierNameSyntax[] GetReferences(SyntaxTree tree, string name, int count) 831internal static IEnumerable<IdentifierNameSyntax> GetReferences(SyntaxTree tree, string name) 836private static IEnumerable<DeclarationExpressionSyntax> GetDeclarations(SyntaxTree tree, string name) 842private static DeclarationExpressionSyntax GetDeclaration(SyntaxTree tree, string name) 847internal static DeclarationExpressionSyntax GetOutVarDeclaration(SyntaxTree tree, string name) 852private static IEnumerable<DeclarationExpressionSyntax> GetOutVarDeclarations(SyntaxTree tree, string name) 858private static IEnumerable<DiscardDesignationSyntax> GetDiscardDesignations(SyntaxTree tree) 863private static IEnumerable<IdentifierNameSyntax> GetDiscardIdentifiers(SyntaxTree tree) 868private static IEnumerable<DeclarationExpressionSyntax> GetOutVarDeclarations(SyntaxTree tree) 907var tree = compilation.SyntaxTrees.Single(); 1404var tree = compilation.SyntaxTrees.Single(); 1462var tree = compilation.SyntaxTrees.Single(); 1496var tree = compilation.SyntaxTrees.Single(); 1531var tree = compilation.SyntaxTrees.Single(); 1565var tree = compilation.SyntaxTrees.Single(); 1599var tree = compilation.SyntaxTrees.Single(); 1639var tree = compilation.SyntaxTrees.Single(); 1677var tree = compilation.SyntaxTrees.Single(); 1714var tree = compilation.SyntaxTrees.Single(); 1750var tree = compilation.SyntaxTrees.Single(); 1883var tree = compilation.SyntaxTrees.Single(); 2004var tree = compilation.SyntaxTrees.Single(); 2114var tree = compilation.SyntaxTrees.Single(); 2225var tree = compilation.SyntaxTrees.Single(); 2335var tree = compilation.SyntaxTrees.Single(); 2470var tree = compilation.SyntaxTrees.Single(); 2637var tree = compilation.SyntaxTrees.Single(); 2854var tree = compilation.SyntaxTrees.Single(); 2949var tree = compilation.SyntaxTrees.Single(); 3201var tree = compilation.SyntaxTrees.Single(); 3303var tree = compilation.SyntaxTrees.Single(); 3375var tree = compilation.SyntaxTrees.Single(); 3427var tree = compilation.SyntaxTrees.Single(); 3461var tree = compilation.SyntaxTrees.Single(); 3502var tree = compilation.SyntaxTrees.Single(); 3643var tree = compilation.SyntaxTrees.Single(); 3864var tree = compilation.SyntaxTrees.Single(); 3961var tree = compilation.SyntaxTrees.Single(); 3997var tree = compilation.SyntaxTrees.Single(); 4052var tree = compilation.SyntaxTrees.Single(); 4096var tree = compilation.SyntaxTrees.Single(); 4147var tree = compilation.SyntaxTrees.Single(); 4207var tree = compilation.SyntaxTrees.Single(); 4273var tree = compilation.SyntaxTrees.Single(); 4496var tree = compilation.SyntaxTrees.Single(); 4675var tree = compilation.SyntaxTrees.Single(); 4916var tree = compilation.SyntaxTrees.Single(); 5018var tree = compilation.SyntaxTrees.Single(); 5065var tree = compilation.SyntaxTrees.Single(); 5103var tree = compilation.SyntaxTrees.Single(); 5180var tree = compilation.SyntaxTrees.Single(); 5283var tree = compilation.SyntaxTrees.Single(); 5410var tree = compilation.SyntaxTrees.Single(); 5512var tree = compilation.SyntaxTrees.Single(); 5576var tree = compilation.SyntaxTrees.Single(); 5708var tree = compilation.SyntaxTrees.Single(); 5748var tree = compilation.SyntaxTrees.Single(); 5909var tree = compilation.SyntaxTrees.Single(); 6050var tree = compilation.SyntaxTrees.Single(); 6327var tree = compilation.SyntaxTrees.Single(); 6562var tree = compilation.SyntaxTrees.Single(); 6818var tree = compilation.SyntaxTrees.Single(); 7064var tree = compilation.SyntaxTrees.Single(); 7302var tree = compilation.SyntaxTrees.Single(); 7624var tree = compilation.SyntaxTrees.Single(); 7773var tree = compilation.SyntaxTrees.Single(); 7833var tree = compilation.SyntaxTrees.Single(); 7895var tree = compilation.SyntaxTrees.Single(); 7961var tree = compilation.SyntaxTrees.Single(); 8025var tree = compilation.SyntaxTrees.Single(); 8092var tree = compilation.SyntaxTrees.Single(); 8154var tree = compilation.SyntaxTrees.Single(); 8209var tree = compilation.SyntaxTrees.Single(); 8387var tree = compilation.SyntaxTrees.Single(); 8487var tree = compilation.SyntaxTrees.Single(); 8659var tree = compilation.SyntaxTrees.Single(); 8761var tree = compilation.SyntaxTrees.Single(); 8797var tree = compilation.SyntaxTrees.Single(); 8869var tree = compilation.SyntaxTrees.Single(); 8919var tree = compilation.SyntaxTrees.Single(); 9161var tree = compilation.SyntaxTrees.Single(); 9263var tree = compilation.SyntaxTrees.Single(); 9334var tree = compilation.SyntaxTrees.Single(); 9427var tree = compilation.SyntaxTrees.Single(); 9507var tree = compilation.SyntaxTrees.Single(); 9583var tree = compilation.SyntaxTrees.Single(); 9636var tree = compilation.SyntaxTrees.Single(); 9693var tree = compilation.SyntaxTrees.Single(); 9758var tree = compilation.SyntaxTrees.Single(); 9815var tree = compilation.SyntaxTrees.Single(); 9890var tree = compilation.SyntaxTrees.Single(); 9985var tree = compilation.SyntaxTrees.Single(); 10067var tree = compilation.SyntaxTrees.Single(); 10148var tree = compilation.SyntaxTrees.Single(); 10204var tree = compilation.SyntaxTrees.Single(); 10260var tree = compilation.SyntaxTrees.Single(); 10327var tree = compilation.SyntaxTrees.Single(); 10386var tree = compilation.SyntaxTrees.Single(); 10458var tree = compilation.SyntaxTrees.Single(); 10542var tree = compilation.SyntaxTrees.Single(); 10720var tree = compilation.SyntaxTrees.Single(); 10817var tree = compilation.SyntaxTrees.Single(); 10853var tree = compilation.SyntaxTrees.Single(); 10908var tree = compilation.SyntaxTrees.Single(); 10958var tree = compilation.SyntaxTrees.Single(); 11046var tree = compilation.SyntaxTrees.Single(); 11183var tree = compilation.SyntaxTrees.Single(); 11265var tree = compilation.SyntaxTrees.Single(); 11334var tree = compilation.SyntaxTrees.Single(); 11427var tree = compilation.SyntaxTrees.Single(); 11467var tree = compilation.SyntaxTrees.Single(); 11715var tree = compilation.SyntaxTrees.Single(); 11972var tree = compilation.SyntaxTrees.Single(); 12124var tree = compilation.SyntaxTrees.Single(); 12274var tree = compilation.SyntaxTrees.Single(); 12351var tree = compilation.SyntaxTrees.Single(); 12420var tree = compilation.SyntaxTrees.Single(); 12496var tree = compilation.SyntaxTrees.Single(); 12658var tree = compilation.SyntaxTrees.Single(); 12778var tree = compilation.SyntaxTrees.Single(); 12865var tree = compilation.SyntaxTrees.Single(); 12920var tree = compilation.SyntaxTrees.Single(); 12962var tree = compilation.SyntaxTrees.Single(); 13017var tree = compilation.SyntaxTrees.Single(); 13201var tree = compilation.SyntaxTrees.Single(); 13295var tree = compilation.SyntaxTrees.Single(); 13333var tree = compilation.SyntaxTrees.Single(); 13385var tree = compilation.SyntaxTrees.Single(); 13439var tree = compilation.SyntaxTrees.Single(); 13605var tree = compilation.SyntaxTrees.Single(); 13696var tree = compilation.SyntaxTrees.Single(); 13732var tree = compilation.SyntaxTrees.Single(); 13796var tree = compilation.SyntaxTrees.Single(); 13846var tree = compilation.SyntaxTrees.Single(); 14127var tree = compilation.SyntaxTrees.Single(); 14256var tree = compilation.SyntaxTrees.Single(); 14303var tree = compilation.SyntaxTrees.Single(); 14352var tree = compilation.SyntaxTrees.Single(); 14394var tree = compilation.SyntaxTrees.Single(); 14436var tree = compilation.SyntaxTrees.Single(); 14481var tree = compilation.SyntaxTrees.Single(); 14523var tree = compilation.SyntaxTrees.Single(); 14568var tree = compilation.SyntaxTrees.Single(); 14617var tree = compilation.SyntaxTrees.Single(); 14671var tree = compilation.SyntaxTrees.Single(); 14730var tree = compilation.SyntaxTrees.Single(); 14777var tree = compilation.SyntaxTrees.Single(); 14827var tree = compilation.SyntaxTrees.Single(); 14942var tree = compilation.SyntaxTrees.Single(); 15122var tree = compilation.SyntaxTrees.Single(); 15215var tree = compilation.SyntaxTrees.Single(); 15253var tree = compilation.SyntaxTrees.Single(); 15311var tree = compilation.SyntaxTrees.Single(); 15369var tree = compilation.SyntaxTrees.Single(); 15530var tree = compilation.SyntaxTrees.Single(); 15743var tree = compilation.SyntaxTrees.Single(); 15956var tree = compilation.SyntaxTrees.Single(); 16071var tree = compilation.SyntaxTrees.Single(); 16158var tree = compilation.SyntaxTrees.Single(); 16399var tree = compilation.SyntaxTrees.Single(); 16495var tree = compilation.SyntaxTrees.Single(); 16531var tree = compilation.SyntaxTrees.Single(); 16588var tree = compilation.SyntaxTrees.Single(); 16642var tree = compilation.SyntaxTrees.Single(); 16702var tree = compilation.SyntaxTrees.Single(); 16762var tree = compilation.SyntaxTrees.Single(); 16825var tree = compilation.SyntaxTrees.Single(); 16959var tree = compilation.SyntaxTrees.Single(); 17051var tree = compilation.SyntaxTrees.Single(); 17090var tree = compilation.SyntaxTrees.Single(); 17148var tree = compilation.SyntaxTrees.Single(); 17202var tree = compilation.SyntaxTrees.Single(); 17386var tree = compilation.SyntaxTrees.Single(); 17488var tree = compilation.SyntaxTrees.Single(); 17526var tree = compilation.SyntaxTrees.Single(); 17589var tree = compilation.SyntaxTrees.Single(); 17642var tree = compilation.SyntaxTrees.Single(); 17677var tree = compilation.SyntaxTrees.Single(); 17710var tree = compilation.SyntaxTrees.Single(); 17743var tree = compilation.SyntaxTrees.Single(); 17782var tree = compilation.SyntaxTrees.Single(); 17829var tree = compilation.SyntaxTrees.Single(); 17859var tree = compilation.SyntaxTrees.Single(); 17890var tree = compilation.SyntaxTrees.Single(); 17919var tree = compilation.SyntaxTrees.Single(); 17951var tree = compilation.SyntaxTrees.Single(); 17993var tree = compilation.SyntaxTrees.Single(); 18030var tree = compilation.SyntaxTrees.Single(); 18067var tree = compilation.SyntaxTrees.Single(); 18102var tree = compilation.SyntaxTrees.Single(); 18141var tree = compilation.SyntaxTrees.Single(); 18182var tree = compilation.SyntaxTrees.Single(); 18225var tree = compilation.SyntaxTrees.Single(); 18268var tree = compilation.SyntaxTrees.Single(); 18307var tree = compilation.SyntaxTrees.Single(); 18348var tree = compilation.SyntaxTrees.Single(); 18383var tree = compilation.SyntaxTrees.Single(); 18429var tree = compilation.SyntaxTrees.Single(); 18493var tree = compilation.SyntaxTrees.Single(); 18542var tree = compilation.SyntaxTrees.Single(); 18587var tree = compilation.SyntaxTrees.Single(); 18639var tree = compilation.SyntaxTrees.Single(); 18683var tree = compilation.SyntaxTrees.Single(); 18725var tree = compilation.SyntaxTrees.Single(); 18779var tree = compilation.SyntaxTrees.Single(); 18812var tree = context.Node.SyntaxTree; 18872var tree = compilation.SyntaxTrees.Single(); 18916var tree = compilation.SyntaxTrees.Single(); 18958var tree = compilation.SyntaxTrees.Single(); 19011var tree = compilation.SyntaxTrees.Single(); 19056var tree = compilation.SyntaxTrees.Single(); 19099var tree = compilation.SyntaxTrees.Single(); 19153var tree = compilation.SyntaxTrees.Single(); 19202var tree = compilation.SyntaxTrees.Single(); 19249var tree = compilation.SyntaxTrees.Single(); 19287var tree = compilation.SyntaxTrees.Single(); 19328var tree = compilation.SyntaxTrees.Single(); 19362var tree = compilation.SyntaxTrees.Single(); 19423var tree = compilation.SyntaxTrees.Single(); 19468var tree = compilation.SyntaxTrees.Single(); 19506var tree = compilation.SyntaxTrees.Single(); 19545var tree = compilation.SyntaxTrees.Single(); 19589var tree = compilation.SyntaxTrees.Single(); 19658var tree = compilation.SyntaxTrees.Single(); 19686var tree = compilation.SyntaxTrees.Single(); 19729var tree = compilation.SyntaxTrees.Single(); 19767var tree = compilation.SyntaxTrees.Single(); 19840var tree = compilation.SyntaxTrees.Single(); 19873var tree = compilation.SyntaxTrees.Single(); 19906var tree = compilation.SyntaxTrees.Single(); 19941var tree = compilation.SyntaxTrees.Single(); 19976var tree = compilation.SyntaxTrees.Single(); 20014var tree = compilation.SyntaxTrees.Single(); 20046var tree = compilation.SyntaxTrees.Single(); 20220var tree = compilation.SyntaxTrees.Single(); 20248var tree = compilation.SyntaxTrees.Single(); 20356var tree = compilation.SyntaxTrees[0]; 20613var tree = compilation.SyntaxTrees.Single(); 20656var tree = compilation.SyntaxTrees.Single(); 20773var tree = compilation.SyntaxTrees.Single(); 20826var tree = compilation.SyntaxTrees.Single(); 20917var tree = compilation.SyntaxTrees.Single(); 21036var tree = compilation.SyntaxTrees.Single(); 21131var tree = compilation.SyntaxTrees.Single(); 21235var tree = compilation.SyntaxTrees.Single(); 21292var tree = compilation.SyntaxTrees.Single(); 21360var tree = compilation.SyntaxTrees.Single(); 21410var tree = compilation.SyntaxTrees.Single(); 21644var tree = compilation.SyntaxTrees.Single(); 21817var tree = compilation.SyntaxTrees.Single(); 22011var tree = compilation.SyntaxTrees.Single(); 22138var tree = compilation.SyntaxTrees.Single(); 22236var tree = compilation.SyntaxTrees.Single(); 22424var tree = compilation.SyntaxTrees.Single(); 22579var tree = compilation.SyntaxTrees.Single(); 22658var tree = compilation.SyntaxTrees.Single(); 22781var tree = compilation.SyntaxTrees.Single(); 22863var tree = compilation.SyntaxTrees.Single(); 22947var tree = compilation.SyntaxTrees.Single(); 23014var tree = compilation.SyntaxTrees.Single(); 23053var tree = compilation.SyntaxTrees.Single(); 23209var tree = compilation.SyntaxTrees.Single(); 23303var tree = compilation.SyntaxTrees.Single(); 23393var tree = compilation.SyntaxTrees.Single(); 23441var tree = compilation.SyntaxTrees.Single(); 23474var tree = compilation.SyntaxTrees.Single(); 23525var tree = compilation.SyntaxTrees.Single(); 23669var tree = compilation.SyntaxTrees.Single(); 23767var tree = compilation.SyntaxTrees.Single(); 23865var tree = compilation.SyntaxTrees.Single(); 24007var tree = compilation.SyntaxTrees.Single(); 24111var tree = compilation.SyntaxTrees.Single(); 24206var tree = compilation.SyntaxTrees.Single(); 24294var tree = compilation.SyntaxTrees.Single(); 24400var tree = compilation.SyntaxTrees.Single(); 24493var tree = compilation.SyntaxTrees.Single(); 24524var tree = compilation.SyntaxTrees.Single(); 24726var tree = compilation.SyntaxTrees.Single(); 24985var tree = compilation.SyntaxTrees.Single(); 25176var tree = compilation.SyntaxTrees.Single(); 25289var tree = compilation.SyntaxTrees.Single(); 25388var tree = compilation.SyntaxTrees.Single(); 25567var tree = compilation.SyntaxTrees.Single(); 25611var tree = compilation.SyntaxTrees.Single(); 25692var tree = compilation.SyntaxTrees.Single(); 25736var tree = compilation.SyntaxTrees.Single(); 25791var tree = compilation.SyntaxTrees.Single(); 25872var tree = compilation.SyntaxTrees.Single(); 25932var tree = compilation.SyntaxTrees.Single(); 26029var tree = compilation.SyntaxTrees.Single(); 26086var tree = compilation.SyntaxTrees.Single(); 26153var tree = compilation.SyntaxTrees.Single(); 26201var tree = compilation.SyntaxTrees.Single(); 26282var tree = compilation.SyntaxTrees.Single(); 26329var tree = compilation.SyntaxTrees.Single(); 26424var tree = compilation.SyntaxTrees.Single(); 26472var tree = compilation.SyntaxTrees.Single(); 26556var tree = compilation.SyntaxTrees.Single(); 26616var tree = compilation.SyntaxTrees.Single(); 26700var tree = compilation.SyntaxTrees.Single(); 26760var tree = compilation.SyntaxTrees.Single(); 26821var tree = compilation.SyntaxTrees.Single(); 26891var tree = compilation.SyntaxTrees.Single(); 26935var tree = compilation.SyntaxTrees.Single(); 27021var tree = compilation.SyntaxTrees.Single(); 27066var tree = compilation.SyntaxTrees.Single(); 27158var tree = compilation.SyntaxTrees.Single(); 27212var tree = compilation.SyntaxTrees.Single(); 27311var tree = compilation.SyntaxTrees.Single(); 27365var tree = compilation.SyntaxTrees.Single(); 27434var tree = compilation.SyntaxTrees.Single(); 27511var tree = compilation.SyntaxTrees.Single(); 27584var tree = compilation.SyntaxTrees.Single(); 27688var tree = compilation.SyntaxTrees.Single(); 27761var tree = compilation.SyntaxTrees.Single(); 27824var tree = compilation.SyntaxTrees.Single(); 27901var tree = compilation.SyntaxTrees.Single(); 27974var tree = compilation.SyntaxTrees.Single(); 28079var tree = compilation.SyntaxTrees.Single(); 28152var tree = compilation.SyntaxTrees.Single(); 28225var tree = compilation.SyntaxTrees.Single(); 28300var tree = compilation.SyntaxTrees.Single(); 28354var tree = compilation.SyntaxTrees.Single(); 28451var tree = compilation.SyntaxTrees.Single(); 28505var tree = compilation.SyntaxTrees.Single(); 28572var tree = compilation.SyntaxTrees.Single(); 28620var tree = compilation.SyntaxTrees.Single(); 28704var tree = compilation.SyntaxTrees.Single(); 28765var tree = compilation.SyntaxTrees.Single(); 28872var tree = compilation.SyntaxTrees.Single(); 28928var tree = compilation.SyntaxTrees.Single(); 29023var tree = compilation.SyntaxTrees.Single(); 29079var tree = compilation.SyntaxTrees.Single(); 29144var tree = compilation.SyntaxTrees.Single(); 29230var tree = compilation.SyntaxTrees.Single(); 29297var tree = compilation.SyntaxTrees.Single(); 29406var tree = compilation.SyntaxTrees.Single(); 29473var tree = compilation.SyntaxTrees.Single(); 29546var tree = compilation.SyntaxTrees.Single(); 29595var tree = compilation.SyntaxTrees.Single(); 29693var tree = compilation.SyntaxTrees.Single(); 29769var tree = compilation.SyntaxTrees.Single(); 29894var tree = compilation.SyntaxTrees.Single(); 29970var tree = compilation.SyntaxTrees.Single(); 30048var tree = compilation.SyntaxTrees.Single(); 30134var tree = compilation.SyntaxTrees.Single(); 30195var tree = compilation.SyntaxTrees.Single(); 30306var tree = compilation.SyntaxTrees.Single(); 30367var tree = compilation.SyntaxTrees.Single(); 30431var tree = compilation.SyntaxTrees.Single(); 30486var tree = compilation.SyntaxTrees.Single(); 30530var tree = compilation.SyntaxTrees.Single(); 30574var tree = compilation.SyntaxTrees.Single(); 30615var tree = compilation.SyntaxTrees.Single(); 30695var tree = compilation.SyntaxTrees.Single(); 30764var tree = compilation.SyntaxTrees.Single(); 30866var tree = compilation.SyntaxTrees.Single(); 30935var tree = compilation.SyntaxTrees.Single(); 30999var tree = compilation.SyntaxTrees.Single(); 31054var tree = compilation.SyntaxTrees.Single(); 31098var tree = compilation.SyntaxTrees.Single(); 31142var tree = compilation.SyntaxTrees.Single(); 31226var tree = compilation.SyntaxTrees.Single(); 31285var tree = compilation.SyntaxTrees.Single(); 31399var tree = compilation.SyntaxTrees.Single(); 31458var tree = compilation.SyntaxTrees.Single(); 31527var tree = compilation.SyntaxTrees.Single(); 31582var tree = compilation.SyntaxTrees.Single(); 31626var tree = compilation.SyntaxTrees.Single(); 31670var tree = compilation.SyntaxTrees.Single(); 31711var tree = compilation.SyntaxTrees.Single(); 31765var tree = compilation.SyntaxTrees.Single(); 31799var tree = compilation.SyntaxTrees.Single(); 31852var tree = compilation.SyntaxTrees.Single(); 31892var tree = compilation.SyntaxTrees.Single(); 31942var tree = compilation.SyntaxTrees.Single(); 31976var tree = compilation.SyntaxTrees.Single(); 32032var tree = compilation.SyntaxTrees.Single(); 32072var tree = compilation.SyntaxTrees.Single(); 32117var tree = compilation.SyntaxTrees.Single(); 32161var tree = compilation.SyntaxTrees.Single(); 32195var tree = compilation.SyntaxTrees.Single(); 32229var tree = compilation.SyntaxTrees.Single(); 32269var tree = compilation.SyntaxTrees.Single(); 32309var tree = compilation.SyntaxTrees.Single(); 32364var tree = compilation.SyntaxTrees.Single(); 32433var tree = compilation.SyntaxTrees.Single(); 32480var tree = compilation.SyntaxTrees.Single(); 32511var tree = node1.SyntaxTree; 32546var tree = compilation.SyntaxTrees.Single(); 32574var tree = compilation.SyntaxTrees.Single(); 32602var tree = compilation.SyntaxTrees.Single(); 32628var tree = compilation.SyntaxTrees.Single(); 32666var tree = compilation.SyntaxTrees.Single(); 32702var tree = compilation.SyntaxTrees.Single(); 32946var tree = compilation.SyntaxTrees.Single(); 32975var tree = comp.Compilation.SyntaxTrees.Single(); 33060var tree = comp.SyntaxTrees.Single(); 33129var tree = comp.SyntaxTrees.Single(); 33174var tree = comp.SyntaxTrees.Single(); 33238var tree = comp.SyntaxTrees.Single(); 33504var tree = comp.SyntaxTrees[0]; 33545var tree = comp.SyntaxTrees[0]; 33608var tree = compilation.SyntaxTrees[0]; 33691var tree = compilation.SyntaxTrees[0]; 33779var tree = compilation.SyntaxTrees.Single(); 33877var tree = compilation.SyntaxTrees.Single(); 33976var tree = compilation.SyntaxTrees.Single(); 34074var tree = compilation.SyntaxTrees.Single(); 34147var tree = compilation.SyntaxTrees.Single(); 34203var tree = compilation.SyntaxTrees.Single(); 34269var tree = compilation.SyntaxTrees.Single(); 34326var syntaxTree = Parse(source, filename: "file.cs"); 34396var tree = compilation.SyntaxTrees.Single(); 34487var tree = compilation.SyntaxTrees.Single(); 34540var syntaxTree = Parse(source, filename: "file.cs"); 34594var tree = compilation.SyntaxTrees.Single(); 34715var tree = compilation.SyntaxTrees.Single(); 34755var tree = compilation.SyntaxTrees[0]; 34831var tree = compilation.SyntaxTrees[0]; 34886var tree = compilation.SyntaxTrees[0]; 34940var tree = compilation.SyntaxTrees[0]; 34998var tree = compilation.SyntaxTrees[0]; 35048var tree = compilation.SyntaxTrees[0]; 35102var tree = compilation.SyntaxTrees[0]; 35142var tree = compilation.SyntaxTrees[0]; 35176var tree = compilation.SyntaxTrees.First(); 35215var tree = compilation.SyntaxTrees.First(); 35259var tree = compilation.SyntaxTrees.First(); 35290var tree = compilation.SyntaxTrees.First(); 35329var tree = compilation.SyntaxTrees.First(); 35361var tree = compilation.SyntaxTrees.First(); 35397var tree = compilation.SyntaxTrees.First(); 35436var tree = compilation.SyntaxTrees.First(); 35466var tree = compilation.SyntaxTrees.First(); 35503var tree = compilation.SyntaxTrees.First(); 35555var tree = compilation.SyntaxTrees.Single(); 35660var tree = comp.SyntaxTrees.Single(); 35695var tree = comp.SyntaxTrees.Single(); 35774var tree = compilation.SyntaxTrees.Single(); 35816var tree = compilation.SyntaxTrees.Single(); 35845var tree = compilation.SyntaxTrees.Single(); 35891var tree = compilation.SyntaxTrees.Single(); 35979var tree = compilation.SyntaxTrees.Single(); 36119var tree = compilation.SyntaxTrees.Single(); 36227var tree = compilation.SyntaxTrees.Single(); 36320var tree = compilation.SyntaxTrees.Single(); 36359var tree = comp.SyntaxTrees.Single(); 36362var tree2 = CSharpSyntaxTree.ParseText(source); 36405var tree = comp.SyntaxTrees.Single(); 36408var tree2 = CSharpSyntaxTree.ParseText(source); 36445var tree = comp.SyntaxTrees.Single(); 36448var tree2 = CSharpSyntaxTree.ParseText(source); 36487var tree = comp.SyntaxTrees.Single(); 36490var tree2 = CSharpSyntaxTree.ParseText(source); 36522var tree = comp.SyntaxTrees.Single(); 36525var tree2 = CSharpSyntaxTree.ParseText(source); 36560var tree = comp.SyntaxTrees.Single(); 36563var tree2 = CSharpSyntaxTree.ParseText(source);