SyntaxTree

Syntax\TranslationSyntaxReference.cs (1)

29public sealed override SyntaxTree SyntaxTree

Syntax\SimpleSyntaxReference.cs (1)

22public override SyntaxTree SyntaxTree

DeclarationTests.cs (1)

898public override SyntaxTree SyntaxTree

Workspace\LanguageServices\CSharpSyntaxTreeFactoryService.NodeSyntaxReference.cs (1)

21public override SyntaxTree SyntaxTree

Syntax\SimpleSyntaxReference.vb (1)

23Public Overrides ReadOnly Property SyntaxTree As SyntaxTree

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\LanguageServices\VisualBasicSymbolDeclarationService.vb (1)

57Public Overrides ReadOnly Property SyntaxTree As SyntaxTree

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\LanguageServices\VisualBasicSymbolDeclarationService.vb (1)

57Public Overrides ReadOnly Property SyntaxTree As SyntaxTree

Workspace\LanguageServices\VisualBasicSyntaxTreeFactoryService.NodeSyntaxReference.vb (1)

18Public Overrides ReadOnly Property SyntaxTree As SyntaxTree

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\MetricsHelper.cs (2)

232attribute.ApplicationSyntaxReference.SyntaxTree == declaration.SyntaxTree)

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\MetricsHelper.cs (2)

232attribute.ApplicationSyntaxReference.SyntaxTree == declaration.SyntaxTree)

CompilationFeatureDetector.cs (1)

39var semanticModel = compilation.GetSemanticModel(syntaxReferences[j].SyntaxTree);

Compilation\Compilation.cs (1)

3567MarkImportDirectiveAsUsed(node.SyntaxTree, node.Span.Start);

Diagnostic\SourceLocation.cs (1)

49: this(syntaxRef.SyntaxTree, syntaxRef.Span)

DiagnosticAnalyzer\AnalysisScope.cs (2)

216return symbolEvent.Symbol.IsImplicitlyDeclared || symbolEvent.DeclaringSyntaxReferences.All(s => s.SyntaxTree == null); 254if (syntaxRef.SyntaxTree == filterTree)

DiagnosticAnalyzer\AnalyzerDriver.cs (5)

1887var model = compilation.GetSemanticModel(syntaxReference.SyntaxTree); 2287if (!IsGeneratedOrHiddenCodeLocation(declaringRef.SyntaxTree, declaringRef.Span, cancellationToken)) 2518if (analysisScope.FilterFileOpt != null && analysisScope.FilterFileOpt?.SourceTree != decl.SyntaxTree) 2523var isInGeneratedCode = isGeneratedCodeSymbol || IsGeneratedOrHiddenCodeLocation(decl.SyntaxTree, decl.Span, cancellationToken); 2586GetOrCreateSemanticModel(decl.SyntaxTree, symbolEvent.Compilation);

DiagnosticAnalyzer\AnalyzerExecutor.cs (1)

1454if (syntaxRef.SyntaxTree == diagnostic.Location.SourceTree)

SourceGeneration\Nodes\SyntaxValueProvider_ForAttributeWithMetadataName.cs (1)

163if (attribute.ApplicationSyntaxReference?.SyntaxTree == targetSyntaxTree &&

Syntax\SyntaxReference.cs (1)

52return this.SyntaxTree.GetLocation(this.Span);

Syntax\TranslationSyntaxReference.cs (2)

31get { return _reference.SyntaxTree; } 37Debug.Assert(node.SyntaxTree == _reference.SyntaxTree);

MetaAnalyzers\CompilerExtensionStrictApiAnalyzer.cs (1)

153context.ReportDiagnostic(Diagnostic.Create(descriptor, Location.Create(applicationSyntaxReference.SyntaxTree, applicationSyntaxReference.Span)));

MetaAnalyzers\CompilerExtensionTargetFrameworkAnalyzer.cs (1)

104Location.Create(applicationSyntaxReference.SyntaxTree, applicationSyntaxReference.Span),

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\MetricsHelper.cs (2)

232attribute.ApplicationSyntaxReference.SyntaxTree == declaration.SyntaxTree)

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\MetricsHelper.cs (2)

232attribute.ApplicationSyntaxReference.SyntaxTree == declaration.SyntaxTree)

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\MetricsHelper.cs (2)

232attribute.ApplicationSyntaxReference.SyntaxTree == declaration.SyntaxTree)

src\Analyzers\Core\Analyzers\RemoveUnusedMembers\AbstractRemoveUnusedMembersDiagnosticAnalyzer.cs (1)

599r => r.SyntaxTree == diagnosticLocation.SourceTree && r.Span.Contains(diagnosticLocation.SourceSpan));

src\Analyzers\Core\Analyzers\UseAutoProperty\AbstractUseAutoPropertyAnalyzer.cs (1)

187if (!namedType.DeclaringSyntaxReferences.Select(d => d.SyntaxTree).Distinct().Any(tree =>

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.AliasSymbolKey.cs (1)

22visitor.WriteString(symbol.DeclaringSyntaxReferences.FirstOrDefault()?.SyntaxTree.FilePath ?? "");

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.BodyLevelSymbolKey.cs (1)

106if (reference.SyntaxTree == syntaxTree)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.NamedTypeSymbolKey.cs (2)

23visitor.WriteString(symbol.IsFileLocal ? symbol.DeclaringSyntaxReferences[0].SyntaxTree.FilePath : null); 179type.DeclaringSyntaxReferences[0].SyntaxTree.FilePath != filePath)

src\Analyzers\Core\CodeFixes\UnsealClass\AbstractUnsealClassCodeFixProvider.cs (1)

61declarationReferences.GroupBy(reference => solution.GetDocumentId(reference.SyntaxTree)!))

Binder\Binder_Initializers.cs (3)

104binderFactory = compilation.GetBinderFactory(syntaxRef.SyntaxTree); 126binderFactory = compilation.GetBinderFactory(syntaxRef.SyntaxTree); 194var syntaxTree = syntaxRef.SyntaxTree;

Binder\WithExternAndUsingAliasesBinder.cs (1)

180if (declaration.HasGlobalUsings && compilationUnit.SyntaxTree != declaration.SyntaxReference.SyntaxTree)

Compilation\CSharpCompilation.cs (3)

3101if (singleDeclaration.SyntaxReference.SyntaxTree == tree) 4580var comparison = CompareSyntaxTreeOrdering(loc1.SyntaxTree, loc2.SyntaxTree);

Compiler\ClsComplianceChecker.cs (2)

663else if (_filterTree == null || (syntaxRef != null && syntaxRef.SyntaxTree == _filterTree)) 665System.Diagnostics.Debug.Assert(syntaxRef.SyntaxTree.HasCompilationUnitRoot);

Compiler\DocumentationCommentCompiler.cs (1)

691DocumentationMode currDocumentationMode = reference.SyntaxTree.Options.DocumentationMode;

Declarations\SingleTypeDeclaration.cs (2)

268if ((object)thisDecl.SyntaxReference.SyntaxTree != otherDecl.SyntaxReference.SyntaxTree

Symbols\LexicalSortKey.cs (1)

68: this(syntaxRef.SyntaxTree, syntaxRef.Span.Start, compilation)

Symbols\Source\LocalFunctionSymbol.cs (1)

403var diagnosticInfo = MessageID.IDS_FeatureLocalFunctionAttributes.GetFeatureAvailabilityDiagnosticInfo((CSharpParseOptions)syntaxReferenceOpt.SyntaxTree.Options);

Symbols\Source\SourceDestructorSymbol.cs (1)

84var bodyBinder = this.DeclaringCompilation.GetBinderFactory(syntaxReferenceOpt.SyntaxTree).GetBinder(syntax, syntax, this);

Symbols\Source\SourceEventSymbol.cs (1)

477get { return _syntaxRef.SyntaxTree; }

Symbols\Source\SourceFieldSymbol.cs (2)

193return _syntaxReference.SyntaxTree; 217=> _syntaxReference.SyntaxTree.GetLocation(_locationSpan);

Symbols\Source\SourceMemberContainerSymbol.cs (5)

1033if (syntaxRef.SyntaxTree == tree && 1111if (tree == syntaxRef.SyntaxTree) 1183group[0].Syntax.SyntaxTree == tree && 1900var tree = declaration.Declarations[0].SyntaxReference.SyntaxTree; 3042(primaryConstructor.SyntaxRef.SyntaxTree != whereFoundField.SyntaxTree || primaryConstructor.SyntaxRef.Span != whereFoundField.Span))

Symbols\Source\SourceMethodSymbolWithAttributes.cs (1)

97return this.syntaxReferenceOpt == null ? null : this.syntaxReferenceOpt.SyntaxTree;

Symbols\Source\SourceNamedTypeSymbol.cs (3)

155var syntaxTree = syntaxRef.SyntaxTree; 337var binderFactory = this.DeclaringCompilation.GetBinderFactory(syntaxRef.SyntaxTree); 418var binderFactory = this.DeclaringCompilation.GetBinderFactory(syntaxRef.SyntaxTree);

Symbols\Source\SourceNamespaceSymbol.AliasesAndUsings.cs (5)

74if (declarationSyntaxRef.SyntaxTree != declarationSyntax.SyntaxTree) 879uniqueUsings.AddAll(globalUsingNamespacesOrTypes.Where(n => n.UsingDirectiveReference?.SyntaxTree != tree).Select(n => n.NamespaceOrType)); 977if (alias.UsingDirectiveReference!.SyntaxTree != declarationSyntax.SyntaxTree) 1003if (@using.UsingDirectiveReference!.SyntaxTree != declarationSyntax.SyntaxTree)

Symbols\Source\SourceNamespaceSymbol.cs (1)

472if (declarationSyntaxRef.SyntaxTree != tree)

Symbols\Source\SourceNamespaceSymbol_Completion.cs (1)

40if (locationOpt == null || locationOpt.SourceTree == declaration.SyntaxReference.SyntaxTree)

Symbols\Source\SourcePropertySymbolBase.cs (1)

866return _syntaxRef.SyntaxTree;

Symbols\Symbol.cs (1)

955=> syntaxRef.SyntaxTree == tree &&

Symbols\SymbolDistinguisher.cs (1)

168var tree = syntaxReferences[0].SyntaxTree;

Symbols\Synthesized\Records\SynthesizedPrimaryConstructor.cs (1)

172if (attributeDeclarationSyntax.SyntaxTree == SyntaxRef.SyntaxTree &&

Symbols\Synthesized\SynthesizedSimpleProgramEntryPointSymbol.cs (1)

256if (_declaration.SyntaxReference.SyntaxTree == tree)

src\Analyzers\CSharp\Analyzers\UsePrimaryConstructor\CSharpUsePrimaryConstructorDiagnosticAnalyzer.cs (2)

266var styleOption = options.GetCSharpAnalyzerOptions(reference.SyntaxTree).PreferPrimaryConstructors; 268|| diagnosticAnalyzer.ShouldSkipAnalysis(reference.SyntaxTree, context.Options, context.Compilation.Options, styleOption.Notification, cancellationToken))

src\Analyzers\CSharp\Analyzers\UseSystemThreadingLock\CSharpUseSystemThreadingLockDiagnosticAnalyzer.cs (1)

100var fieldSyntaxTree = fieldSyntaxReference.SyntaxTree;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Services\SemanticFacts\CSharpSemanticFacts.cs (1)

376var semanticModel = compilation.GetSemanticModel(syntaxReference.SyntaxTree);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\InitializeParameter\InitializeParameterHelpers.cs (1)

104.Select(r => solution.GetRequiredDocument(r.SyntaxTree))

Semantics\PrimaryConstructorTests.cs (9)

Semantics\RecordTests.cs (5)

26347Assert.Same(literal.SyntaxTree, context.ContainingSymbol!.DeclaringSyntaxReferences.Single().SyntaxTree); 26373Assert.Same(equalsValue.SyntaxTree, context.ContainingSymbol!.DeclaringSyntaxReferences.Single().SyntaxTree); 26391Assert.Same(initializer.SyntaxTree, context.ContainingSymbol!.DeclaringSyntaxReferences.Single().SyntaxTree); 26422Assert.Same(baseType.SyntaxTree, context.ContainingSymbol!.DeclaringSyntaxReferences.Single().SyntaxTree); 26445Assert.Same(record.SyntaxTree, context.ContainingSymbol!.DeclaringSyntaxReferences.Single().SyntaxTree);

InitializeParameter\CSharpInitializeMemberFromPrimaryConstructorParameterCodeRefactoringProvider.cs (1)

275foreach (var group in parameter.ContainingType.DeclaringSyntaxReferences.GroupBy(r => r.SyntaxTree))

QuickInfo\OnTheFlyDocsUtilities.cs (1)

40var syntaxReferenceDocument = solution.GetDocument(typeSyntaxReference.SyntaxTree);

src\Analyzers\CSharp\Analyzers\UsePrimaryConstructor\CSharpUsePrimaryConstructorDiagnosticAnalyzer.cs (2)

266var styleOption = options.GetCSharpAnalyzerOptions(reference.SyntaxTree).PreferPrimaryConstructors; 268|| diagnosticAnalyzer.ShouldSkipAnalysis(reference.SyntaxTree, context.Options, context.Compilation.Options, styleOption.Notification, cancellationToken))

src\Analyzers\CSharp\Analyzers\UseSystemThreadingLock\CSharpUseSystemThreadingLockDiagnosticAnalyzer.cs (1)

100var fieldSyntaxTree = fieldSyntaxReference.SyntaxTree;

Semantics\RecordStructTests.cs (4)

6062Assert.Same(literal.SyntaxTree, context.ContainingSymbol!.DeclaringSyntaxReferences.Single().SyntaxTree); 6080Assert.Same(equalsValue.SyntaxTree, context.ContainingSymbol!.DeclaringSyntaxReferences.Single().SyntaxTree); 6098Assert.Same(initializer.SyntaxTree, context.ContainingSymbol!.DeclaringSyntaxReferences.Single().SyntaxTree); 6127Assert.Same(record.SyntaxTree, context.ContainingSymbol!.DeclaringSyntaxReferences.Single().SyntaxTree);

Semantics\TopLevelStatementsTests.cs (2)

6455Assert.Same(globalStatement.SyntaxTree, context.ContainingSymbol.DeclaringSyntaxReferences.Single().SyntaxTree); 6721Assert.Same(context.ContainingSymbol.DeclaringSyntaxReferences.Single().SyntaxTree, context.Operation.Syntax.SyntaxTree);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Services\SemanticFacts\CSharpSemanticFacts.cs (1)

376var semanticModel = compilation.GetSemanticModel(syntaxReference.SyntaxTree);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\InitializeParameter\InitializeParameterHelpers.cs (1)

104.Select(r => solution.GetRequiredDocument(r.SyntaxTree))

Navigation\AbstractDefinitionLocationService.cs (1)

133if (symbol.DeclaringSyntaxReferences is not [{ SyntaxTree: { } definitionTree, Span: var definitionSpan }])

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.RemoveSuppressionCodeAction_Attribute.cs (1)

50public override SyntaxTree SyntaxTreeToModify => _attribute.ApplicationSyntaxReference.SyntaxTree;

EncapsulateField\AbstractEncapsulateFieldService.cs (2)

178document = document.WithSyntaxRoot(fieldDeclaration.SyntaxTree.GetRoot(cancellationToken).ReplaceNode(fieldDeclaration.GetSyntax(cancellationToken), 329contextLocation: fieldDeclaration.SyntaxTree.GetLocation(fieldDeclaration.Span)));

MoveStaticMembers\MoveStaticMembersOptions.cs (2)

42RoslynDebug.AssertNotNull(sourceLocation.SyntaxTree); 45FileName = sourceLocation.SyntaxTree.FilePath;

NavigationBar\AbstractNavigationBarItemService.cs (1)

80Location.Create(allReferences.First().SyntaxTree, allReferences.First().Span);

src\Analyzers\Core\Analyzers\RemoveUnusedMembers\AbstractRemoveUnusedMembersDiagnosticAnalyzer.cs (1)

599r => r.SyntaxTree == diagnosticLocation.SourceTree && r.Span.Contains(diagnosticLocation.SourceSpan));

src\Analyzers\Core\Analyzers\UseAutoProperty\AbstractUseAutoPropertyAnalyzer.cs (1)

187if (!namedType.DeclaringSyntaxReferences.Select(d => d.SyntaxTree).Distinct().Any(tree =>

src\Analyzers\Core\CodeFixes\UnsealClass\AbstractUnsealClassCodeFixProvider.cs (1)

61declarationReferences.GroupBy(reference => solution.GetDocumentId(reference.SyntaxTree)!))

ValueTracking\ValueTracker.cs (1)

48var location = Location.Create(syntaxRef.SyntaxTree, syntaxRef.Span);

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\MetricsHelper.cs (2)

232attribute.ApplicationSyntaxReference.SyntaxTree == declaration.SyntaxTree)

Diagnostics\CommonDiagnosticAnalyzers.cs (3)

2778ReportDiagnostics("RegisterOperationBlockAction", operationBlockContext.OwningSymbol.DeclaringSyntaxReferences[0].SyntaxTree, operationBlockContext.OwningSymbol, operationBlockContext.ReportDiagnostic)); 2789ReportDiagnostics("RegisterOperationBlockEndAction", operationBlockEndContext.OwningSymbol.DeclaringSyntaxReferences[0].SyntaxTree, operationBlockEndContext.OwningSymbol, operationBlockEndContext.ReportDiagnostic)); 2824var trees = symbol.DeclaringSyntaxReferences.Select(syntaxRef => syntaxRef.SyntaxTree).Distinct();

Compilation\ClsComplianceChecker.vb (2)

401ElseIf _filterTree Is Nothing OrElse (syntaxRef IsNot Nothing AndAlso syntaxRef.SyntaxTree Is _filterTree) Then 402Debug.Assert(syntaxRef.SyntaxTree.HasCompilationUnitRoot)

Declarations\SingleTypeDeclaration.vb (1)

110Return SyntaxReference.SyntaxTree.GetEmbeddedKind()

Symbols\ConstantValueUtils.vb (1)

33Dim binder As Binder = BinderBuilder.CreateBinderForType(containingModule, equalsValueOrAsNewNodeRef.SyntaxTree, field.ContainingSourceType)

Symbols\LexicalSortKey.vb (4)

101Me.New(syntaxRef.SyntaxTree, syntaxRef.Span.Start, compilation) 200If first.SyntaxTree IsNot Nothing AndAlso first.SyntaxTree Is second.SyntaxTree Then

Symbols\Source\ImplicitNamedTypeSymbol.vb (1)

185Dim binder As Binder = BinderBuilder.CreateBinderForType(ContainingSourceModule, syntaxRef.SyntaxTree, Me)

Symbols\Source\SourceComplexParameterSymbol.vb (1)

159_syntaxRef.SyntaxTree,

Symbols\Source\SourceEventSymbol.vb (3)

154Dim binder = BinderBuilder.CreateBinderForType(ContainingSourceModule, _syntaxRef.SyntaxTree, _containingType) 726Dim syntaxTree = _syntaxRef.SyntaxTree 742Dim binder = BinderBuilder.CreateBinderForType(ContainingSourceModule, _syntaxRef.SyntaxTree, _containingType)

Symbols\Source\SourceFieldSymbol.vb (2)

85Return _syntaxRef.SyntaxTree 866Dim syntaxTree = syntaxRef.SyntaxTree

Symbols\Source\SourceMemberContainerTypeSymbol.vb (2)

259Dim refKind = ref.SyntaxTree.GetEmbeddedKind() 3248If tree Is syntaxRef.SyntaxTree Then

Symbols\Source\SourceMethodSymbol.vb (3)

778Return m_syntaxReferenceOpt.SyntaxTree 853Dim syntaxTree = syntaxRef.SyntaxTree 1160syntaxTree = m_syntaxReferenceOpt.SyntaxTree

Symbols\Source\SourceModuleSymbol.vb (1)

1182If syntaxRef.SyntaxTree.IsMyTemplate Then

Symbols\Source\SourceNamedTypeSymbol.vb (8)

180Dim binder As Binder = BinderBuilder.CreateBinderForType(ContainingSourceModule, syntaxRef.SyntaxTree, Me) 222CheckDeclarationPart(syntaxRef.SyntaxTree, syntaxRef.GetVisualBasicSyntax(), firstNode, foundPartial, diagnostics) 799Dim tree = syntaxRef.SyntaxTree 922Dim tree = syntaxRef.SyntaxTree 1283MakeDeclaredBaseInPart(syntaxRef.SyntaxTree, syntaxRef.GetVisualBasicSyntax(), baseType, basesBeingResolved, diagnostics) 1303MakeDeclaredInterfacesInPart(syntaxRef.SyntaxTree, syntaxRef.GetVisualBasicSyntax(), interfaces, basesBeingResolved, diagnostics) 1321Dim binder As Binder = CreateLocationSpecificBinderForType(part.SyntaxTree, BindingLocation.BaseTypes) 1801Dim tree = blockRef.SyntaxTree

Symbols\Source\SourceNamedTypeSymbol_GroupClass.vb (1)

323Dim binder As Binder = BinderBuilder.CreateBinderForType(ContainingSourceModule, syntaxRef.SyntaxTree, Me)

Symbols\Source\SourceNamespaceSymbol.vb (8)

171Dim refKind = ref.SyntaxTree.GetEmbeddedKind() 302If reference IsNot Nothing AndAlso Not reference.SyntaxTree.IsEmbeddedOrMyTemplateTree() Then 319If reference IsNot Nothing AndAlso reference.SyntaxTree Is tree Then 320If Not reference.SyntaxTree.IsEmbeddedOrMyTemplateTree() Then 375If tree IsNot Nothing AndAlso syntaxRef.SyntaxTree IsNot tree Then 379Dim currentTree = syntaxRef.SyntaxTree 470declaration.SyntaxReference.SyntaxTree.FilePath IsNot Nothing Then 472Dim otherPath = declaration.SyntaxReference.SyntaxTree.FilePath

Symbols\Source\SourcePropertySymbol.vb (3)

340Dim binder = BinderBuilder.CreateBinderForType(DirectCast(ContainingModule, SourceModuleSymbol), _syntaxRef.SyntaxTree, _containingType) 1066Dim binder = BinderBuilder.CreateBinderForType(DirectCast(ContainingModule, SourceModuleSymbol), _syntaxRef.SyntaxTree, _containingType) 1224Return _syntaxRef.SyntaxTree

Symbols\Source\SourceTypeParameterSymbol.vb (1)

168Dim syntaxTree = syntaxRef.SyntaxTree

Symbols\Source\SynthesizedMyGroupCollectionPropertyAccessorSymbol.vb (1)

101Dim typeBinder As Binder = BinderBuilder.CreateBinderForType(containingType.ContainingSourceModule, PropertyOrEvent.AttributeSyntax.SyntaxTree, containingType)

Symbols\Symbol.vb (3)

417Dim tree = reference.SyntaxTree 428Dim tree = reference.SyntaxTree 909If syntaxRef.SyntaxTree Is tree AndAlso

Symbols\SynthesizedSymbols\SynthesizedEventDelegateSymbol.vb (1)

57Dim binder As Binder = BinderBuilder.CreateBinderForType(sourceModule, _syntaxRef.SyntaxTree, Me.ContainingType)

VisualBasicExtensions.vb (2)

224Dim tree = TryCast(syntaxReference.SyntaxTree, VisualBasicSyntaxTree) 225If syntaxReference.SyntaxTree IsNot Nothing Then

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\LanguageServices\VisualBasicSymbolDeclarationService.vb (1)

59Return _reference.SyntaxTree

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\LanguageServices\VisualBasicSymbolDeclarationService.vb (1)

59Return _reference.SyntaxTree

FindSymbols\SymbolFinder.cs (2)

196var originalDocument = solution.GetDocument(location.SyntaxTree); 206var originalRoot = await location.SyntaxTree.GetRootAsync(cancellationToken).ConfigureAwait(false);

LanguageServices\FixAllSpanMappingService\AbstractFixAllSpanMappingService.cs (2)

52var documentForLocation = document.Project.GetDocument(syntaxRef.SyntaxTree); 54var root = await syntaxRef.SyntaxTree.GetRootAsync(cancellationToken).ConfigureAwait(false);

ReassignedVariable\AbstractReassignedVariableService.cs (1)

198foreach (var group in containingType.DeclaringSyntaxReferences.GroupBy(r => r.SyntaxTree))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.AliasSymbolKey.cs (1)

22visitor.WriteString(symbol.DeclaringSyntaxReferences.FirstOrDefault()?.SyntaxTree.FilePath ?? "");

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.BodyLevelSymbolKey.cs (1)

106if (reference.SyntaxTree == syntaxTree)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.NamedTypeSymbolKey.cs (2)

23visitor.WriteString(symbol.IsFileLocal ? symbol.DeclaringSyntaxReferences[0].SyntaxTree.FilePath : null); 179type.DeclaringSyntaxReferences[0].SyntaxTree.FilePath != filePath)

Analyzers\CustomMarshallerAttributeFixer.cs (1)

183attr.ApplicationSyntaxReference.SyntaxTree == locationInAttribute.SourceTree

DiagnosticExtensions.cs (4)

36? syntaxReference.SyntaxTree.GetLocation(syntaxReference.Span) 50? syntaxReference.SyntaxTree.GetLocation(syntaxReference.Span) 140? syntaxReference.SyntaxTree.GetLocation(syntaxReference.Span) 154? syntaxReference.SyntaxTree.GetLocation(syntaxReference.Span)

TypePositionInfo.cs (2)

130outAttributeLocation = attr.ApplicationSyntaxReference.SyntaxTree.GetLocation(attr.ApplicationSyntaxReference.Span); 135inAttributeLocation = attr.ApplicationSyntaxReference.SyntaxTree.GetLocation(attr.ApplicationSyntaxReference.Span);

CallHierarchy\Finders\ImplementerFinder.cs (1)

42var sourceLocations = implementation.DeclaringSyntaxReferences.Select(d => project.Solution.GetDocument(d.SyntaxTree)).WhereNotNull();

CallHierarchy\Finders\OverridingMemberFinder.cs (1)

38var sourceLocations = @override.DeclaringSyntaxReferences.Select(d => project.Solution.GetDocument(d.SyntaxTree)).WhereNotNull();

Progression\GraphQueries\CallsGraphQuery.cs (1)

48var semanticModel = await solution.GetDocument(reference.SyntaxTree).GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);

Venus\ContainedLanguageCodeSupport.cs (1)

65var typeNode = type.DeclaringSyntaxReferences.Where(r => r.SyntaxTree == tree).Select(r => r.GetSyntax(cancellationToken)).First();

ActualApiResponseMetadataFactoryTest.cs (4)

74var syntaxTree = returnType.DeclaringSyntaxReferences[0].SyntaxTree; 373var syntaxTree = method.DeclaringSyntaxReferences[0].SyntaxTree; 391var syntaxTree = controllerType.DeclaringSyntaxReferences[0].SyntaxTree; 410var syntaxTree = returnType.DeclaringSyntaxReferences[0].SyntaxTree;

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\MetricsHelper.cs (2)

232attribute.ApplicationSyntaxReference.SyntaxTree == declaration.SyntaxTree)

Helpers\RoslynExtensions.cs (1)

34return reference?.SyntaxTree.GetLocation(reference.Span);

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\MetricsHelper.cs (2)

232attribute.ApplicationSyntaxReference.SyntaxTree == declaration.SyntaxTree)