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

CompilationFeatureDetector.cs (1)

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

Compilation\Compilation.cs (1)

3505MarkImportDirectiveAsUsed(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)

1408if (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);

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

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

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

146if (!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)

107if (reference.SyntaxTree == syntaxTree)

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

23? symbol.DeclaringSyntaxReferences[0].SyntaxTree.FilePath 182type.DeclaringSyntaxReferences[0].SyntaxTree.FilePath != filePath)

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

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

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\AbstractCodeGenerationService_FindDeclaration.cs (1)

190declaration = await SelectFirstOrDefaultAsync(declarations.Where(r => r.SyntaxTree == location.SourceTree), node => true, cancellationToken).ConfigureAwait(false);

Binder\Binder_Initializers.cs (3)

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

Binder\BinderFactory.BinderFactoryVisitor.cs (1)

1254if (primaryConstructor.SyntaxRef.SyntaxTree == memberSyntax.SyntaxTree &&

Binder\WithExternAndUsingAliasesBinder.cs (1)

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

Compilation\CSharpCompilation.cs (3)

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

Compilation\CSharpSemanticModel.cs (1)

5232&& primaryConstructor.SyntaxRef.SyntaxTree == node.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)

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

Declarations\SingleTypeDeclaration.cs (2)

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

Symbols\LexicalSortKey.cs (1)

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

Symbols\Source\LocalFunctionSymbol.cs (1)

397var 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)

425get { return _syntaxRef.SyntaxTree; }

Symbols\Source\SourceFieldSymbol.cs (2)

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

Symbols\Source\SourceMemberContainerSymbol.cs (9)

1024if (syntaxRef.SyntaxTree == tree && 1102if (tree == syntaxRef.SyntaxTree) 1174group[0].Syntax.SyntaxTree == tree && 1877var tree = declaration.Declarations[0].SyntaxReference.SyntaxTree; 2752(primaryConstructor.SyntaxRef.SyntaxTree != whereFoundField.SyntaxTree || primaryConstructor.SyntaxRef.Span != whereFoundField.Span)) 3050declaredMembers.DeclarationWithParameters.SyntaxTree == declaredMembers.InstanceInitializers[insertAt][0].Syntax.SyntaxTree && 3058Debug.Assert(insertedInitializers[insertedInitializers.Count - 1].Syntax.SyntaxTree == declaredInitializers[0].Syntax.SyntaxTree); 3072Debug.Assert(!declaredMembers.InstanceInitializers.Any(g => declaredMembers.DeclarationWithParameters.SyntaxTree == g[0].Syntax.SyntaxTree &&

Symbols\Source\SourceMethodSymbolWithAttributes.cs (1)

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

Symbols\Source\SourceNamedTypeSymbol.cs (3)

153var syntaxTree = syntaxRef.SyntaxTree; 334var binderFactory = this.DeclaringCompilation.GetBinderFactory(syntaxRef.SyntaxTree); 415var binderFactory = this.DeclaringCompilation.GetBinderFactory(syntaxRef.SyntaxTree);

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

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)

469if (declarationSyntaxRef.SyntaxTree != tree)

Symbols\Source\SourceNamespaceSymbol_Completion.cs (1)

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

Symbols\Source\SourcePropertySymbolBase.cs (1)

684return _syntaxRef.SyntaxTree;

Symbols\Symbol.cs (1)

954=> 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)

102var fieldSyntaxTree = fieldSyntaxReference.SyntaxTree;

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

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

Semantics\PrimaryConstructorTests.cs (9)

Semantics\RecordTests.cs (5)

26242Assert.Same(literal.SyntaxTree, context.ContainingSymbol!.DeclaringSyntaxReferences.Single().SyntaxTree); 26268Assert.Same(equalsValue.SyntaxTree, context.ContainingSymbol!.DeclaringSyntaxReferences.Single().SyntaxTree); 26286Assert.Same(initializer.SyntaxTree, context.ContainingSymbol!.DeclaringSyntaxReferences.Single().SyntaxTree); 26317Assert.Same(baseType.SyntaxTree, context.ContainingSymbol!.DeclaringSyntaxReferences.Single().SyntaxTree); 26340Assert.Same(record.SyntaxTree, context.ContainingSymbol!.DeclaringSyntaxReferences.Single().SyntaxTree);

InitializeParameter\CSharpInitializeMemberFromPrimaryConstructorParameterCodeRefactoringProvider.cs (1)

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

InitializeParameter\CSharpInitializeMemberFromPrimaryConstructorParameterCodeRefactoringProvider_Update.cs (1)

171.Select(r => solution.GetRequiredDocument(r.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)

102var fieldSyntaxTree = fieldSyntaxReference.SyntaxTree;

Semantics\RecordStructTests.cs (4)

5990Assert.Same(literal.SyntaxTree, context.ContainingSymbol!.DeclaringSyntaxReferences.Single().SyntaxTree); 6008Assert.Same(equalsValue.SyntaxTree, context.ContainingSymbol!.DeclaringSyntaxReferences.Single().SyntaxTree); 6026Assert.Same(initializer.SyntaxTree, context.ContainingSymbol!.DeclaringSyntaxReferences.Single().SyntaxTree); 6055Assert.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)

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

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

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

EncapsulateField\AbstractEncapsulateFieldService.cs (2)

180document = 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)

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

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

146if (!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);

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)

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

Symbols\Source\SourceComplexParameterSymbol.vb (1)

159_syntaxRef.SyntaxTree,

Symbols\Source\SourceEventSymbol.vb (2)

724Dim syntaxTree = _syntaxRef.SyntaxTree 740Dim binder = BinderBuilder.CreateBinderForType(ContainingSourceModule, _syntaxRef.SyntaxTree, _containingType)

Symbols\Source\SourceFieldSymbol.vb (2)

72Return _syntaxRef.SyntaxTree 853Dim syntaxTree = syntaxRef.SyntaxTree

Symbols\Source\SourceMemberContainerTypeSymbol.vb (2)

258Dim refKind = ref.SyntaxTree.GetEmbeddedKind() 3227If 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)

1180If syntaxRef.SyntaxTree.IsMyTemplate Then

Symbols\Source\SourceNamedTypeSymbol.vb (8)

177Dim binder As Binder = BinderBuilder.CreateBinderForType(ContainingSourceModule, syntaxRef.SyntaxTree, Me) 219CheckDeclarationPart(syntaxRef.SyntaxTree, syntaxRef.GetVisualBasicSyntax(), firstNode, foundPartial, diagnostics) 796Dim tree = syntaxRef.SyntaxTree 919Dim tree = syntaxRef.SyntaxTree 1280MakeDeclaredBaseInPart(syntaxRef.SyntaxTree, syntaxRef.GetVisualBasicSyntax(), baseType, basesBeingResolved, diagnostics) 1300MakeDeclaredInterfacesInPart(syntaxRef.SyntaxTree, syntaxRef.GetVisualBasicSyntax(), interfaces, basesBeingResolved, diagnostics) 1318Dim binder As Binder = CreateLocationSpecificBinderForType(part.SyntaxTree, BindingLocation.BaseTypes) 1758Dim 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 (2)

1018Dim binder = BinderBuilder.CreateBinderForType(DirectCast(ContainingModule, SourceModuleSymbol), _syntaxRef.SyntaxTree, _containingType) 1176Return _syntaxRef.SyntaxTree

Symbols\Source\SourceTypeParameterSymbol.vb (1)

162Dim 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 908If 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)

256var originalDocument = solution.GetDocument(location.SyntaxTree); 266var 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)

107if (reference.SyntaxTree == syntaxTree)

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

23? symbol.DeclaringSyntaxReferences[0].SyntaxTree.FilePath 182type.DeclaringSyntaxReferences[0].SyntaxTree.FilePath != filePath)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\AbstractCodeGenerationService_FindDeclaration.cs (1)

190declaration = await SelectFirstOrDefaultAsync(declarations.Where(r => r.SyntaxTree == location.SourceTree), node => true, cancellationToken).ConfigureAwait(false);

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)

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

CallHierarchy\Finders\OverridingMemberFinder.cs (1)

40var 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)

66var 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;

Helpers\RoslynExtensions.cs (1)

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