Span

1233 references to Span

Aspire.Hosting.Integration.Analyzers (2)

AspireExportAnalyzer.cs (2)

404if (localFunction.Span.Contains(invocation.Span))

ConfigurationSchemaGenerator (1)

RuntimeSource\Configuration.Binder\Specs\InterceptorInfo.cs (1)

180TextSpan memberNameSpan = memberAccessExprSyntax.Name.Span;

GenerateDocumentationAndConfigFiles (47)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (5)

196=> node.Span.Length; 301var fullSpan = nodes.First().Span; 306Math.Max(fullSpan.End, node.Span.End)); 313=> node.OverlapsHiddenPosition(node.Span, cancellationToken); 320var start = startNode.Span.End;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Context\FormattingContext.InitialContextFinder.cs (2)

78node.DescendantNodesAndSelf(n => n != previous && n.Span.IntersectsWith(span) && !span.Contains(n.Span))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\FormattingExtensions.cs (2)

28if (node.Parent.Span != node.Span)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Rules\BaseIndentationFormattingRule.cs (1)

41else if (node.Span.Contains(_span))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Helpers\RemoveUnnecessaryImports\AbstractUnnecessaryImportsProvider.cs (3)

47=> x?.Span == y?.Span; 50=> obj.Span.GetHashCode();

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\HeaderFacts\AbstractHeaderFacts.cs (4)

63if (holes.Any(static (h, position) => h.Span.Contains(position) && position > h.Span.Start, position)) 102var endOfAttributeLists = attributeList.Last().Span.End; 105return Math.Min(afterAttributesToken.Span.Start, node.Span.End);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\RefactoringHelpers\AbstractRefactoringHelpers.cs (4)

29if (!allowEmptyNodes && node.Span.IsEmpty) 306if (leftNode.GetLastToken().Span.End != location && leftNode.Span.End != location) 352if (rightNode.Span.Start != location) 551var argumentStartLine = sourceText.Lines.GetLineFromPosition(typedAncestor.Span.Start).LineNumber;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SelectedMembers\AbstractSelectedMembers.cs (1)

110if (textSpan.Contains(member.Span))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\AbstractDocumentationCommentService.cs (1)

74var sb = new StringBuilder(summaryElement.Span.Length);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\ISyntaxFactsExtensions.cs (6)

164var span = TextSpan.FromBounds(firstNode.Span.Start, lastNode.Span.End); 179=> ContainsInterleavedDirective(syntaxFacts, node.Span, node, cancellationToken); 455var endOfAttributeLists = attributeList.Last().Span.End; 458var endOfNode = node.Span.End; 464return node.Span;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)

773!forEachExpression.Span.Contains(OriginalExpression.SpanStart))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\CommonFormattingHelpers.cs (1)

365var endPosition = endToken.RawKind == 0 ? root.Span.End : endToken.Span.End;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\LightweightOverloadResolution.cs (1)

252=> expression.Span.IsEmpty;

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

222var beforeMember = declarationList.FirstOrDefault(m => m.Span.End >= info.Context.BeforeThisLocation.SourceSpan.End);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeRefactorings\CodeRefactoringHelpers.cs (6)

48if (selection.IsEmpty || node.Span.IsEmpty) 54if (selection.Contains(node.Span)) 81var beginningNode = node.FindToken(node.Span.Start).Parent; 82var endNode = node.FindToken(node.Span.End - 1).Parent; 93return beginningNode.Span.End <= selection.Start || endNode.Span.Start >= selection.End;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.State.cs (1)

172var affectedSpan = TextSpan.FromBounds(previousToken.SpanStart, FirstStatementAffectedInInnermostBlock.Span.End);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\RemoveUnnecessaryImports\AbstractRemoveUnnecessaryImportsService.cs (3)

44=> x?.Span == y?.Span; 47=> obj.Span.GetHashCode();

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Simplification\Simplifiers\AbstractMemberAccessExpressionSimplifier.cs (1)

71return !semanticModel.SyntaxTree.OverlapsHiddenPosition(memberAccessExpression.Span, cancellationToken) &&

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\NullableHelpers.cs (3)

43semanticFacts, semanticModel, rootOperation, declaredSymbol, rootOperation.Syntax.Span, includeDeclaration: true, cancellationToken) == true; 67if (!span.IntersectsWith(operation.Syntax.Span)) 70if (span.Contains(operation.Syntax.Span) &&

Microsoft.Analyzers.Extra (1)

CallAnalysis\Fixers\LegacyLoggingFixer.cs (1)

326return (doc, (root!.FindNode(invocationExpression.Span) as ExpressionSyntax)!);

Microsoft.AspNetCore.App.Analyzers (1)

Infrastructure\VirtualChars\CSharpVirtualCharService.cs (1)

200var indentationLength = parentSourceText.Lines.GetLineFromPosition(parentExpression.Span.End).GetFirstNonWhitespaceOffset() ?? 0;

Microsoft.CodeAnalysis (13)

Diagnostic\SourceLocation.cs (1)

27: this(node.SyntaxTree, node.Span)

DiagnosticAnalyzer\AnalysisContextInfo.cs (3)

112var lineSpan = text?.Lines?.GetLinePositionSpan(_node.Span); 115sb.AppendLine($"{nameof(SyntaxNode)}: {GetFlattenedNodeText(_node)} [{_node.GetType().Name}]@{_node.Span} {(lineSpan.HasValue ? lineSpan.Value.ToString() : string.Empty)}"); 125var lastEnd = node.Span.Start;

DiagnosticAnalyzer\AnalyzerExecutor.cs (2)

1632_isGeneratedCodeLocation(node.SyntaxTree, node.Span, cancellationToken)) 1644_isGeneratedCodeLocation(operation.Syntax.SyntaxTree, operation.Syntax.Span, cancellationToken))

Operations\OperationExtensions.cs (1)

63return model.GetDiagnostics(operation.Syntax.Span, cancellationToken).Any(static d => d.DefaultSeverity == DiagnosticSeverity.Error);

Syntax\SyntaxList`1.cs (2)

186return TextSpan.FromBounds(this[0].Span.Start, this[this.Count - 1].Span.End);

Syntax\SyntaxNode.cs (2)

114/// Same as accessing <see cref="TextSpan.Start"/> on <see cref="Span"/>. 676return this.SyntaxTree.GetLocation(this.Span);

Syntax\SyntaxNodeOrToken.cs (1)

238return _nodeOrParent.Span;

Syntax\SyntaxNodeOrTokenList.cs (1)

173public TextSpan Span => _node?.Span ?? default(TextSpan);

Microsoft.CodeAnalysis.Analyzers (47)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (5)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Context\FormattingContext.InitialContextFinder.cs (2)

78node.DescendantNodesAndSelf(n => n != previous && n.Span.IntersectsWith(span) && !span.Contains(n.Span))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\FormattingExtensions.cs (2)

28if (node.Parent.Span != node.Span)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Rules\BaseIndentationFormattingRule.cs (1)

41else if (node.Span.Contains(_span))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Helpers\RemoveUnnecessaryImports\AbstractUnnecessaryImportsProvider.cs (3)

47=> x?.Span == y?.Span; 50=> obj.Span.GetHashCode();

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\HeaderFacts\AbstractHeaderFacts.cs (4)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\RefactoringHelpers\AbstractRefactoringHelpers.cs (4)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SelectedMembers\AbstractSelectedMembers.cs (1)

110if (textSpan.Contains(member.Span))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\AbstractDocumentationCommentService.cs (1)

74var sb = new StringBuilder(summaryElement.Span.Length);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\ISyntaxFactsExtensions.cs (6)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)

773!forEachExpression.Span.Contains(OriginalExpression.SpanStart))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\CommonFormattingHelpers.cs (1)

365var endPosition = endToken.RawKind == 0 ? root.Span.End : endToken.Span.End;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\LightweightOverloadResolution.cs (1)

252=> expression.Span.IsEmpty;

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

222var beforeMember = declarationList.FirstOrDefault(m => m.Span.End >= info.Context.BeforeThisLocation.SourceSpan.End);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeRefactorings\CodeRefactoringHelpers.cs (6)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.State.cs (1)

172var affectedSpan = TextSpan.FromBounds(previousToken.SpanStart, FirstStatementAffectedInInnermostBlock.Span.End);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\RemoveUnnecessaryImports\AbstractRemoveUnnecessaryImportsService.cs (3)

44=> x?.Span == y?.Span; 47=> obj.Span.GetHashCode();

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Simplification\Simplifiers\AbstractMemberAccessExpressionSimplifier.cs (1)

71return !semanticModel.SyntaxTree.OverlapsHiddenPosition(memberAccessExpression.Span, cancellationToken) &&

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\NullableHelpers.cs (3)

Microsoft.CodeAnalysis.AnalyzerUtilities (32)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (5)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Context\FormattingContext.InitialContextFinder.cs (2)

78node.DescendantNodesAndSelf(n => n != previous && n.Span.IntersectsWith(span) && !span.Contains(n.Span))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\FormattingExtensions.cs (2)

28if (node.Parent.Span != node.Span)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Rules\BaseIndentationFormattingRule.cs (1)

41else if (node.Span.Contains(_span))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Helpers\RemoveUnnecessaryImports\AbstractUnnecessaryImportsProvider.cs (3)

47=> x?.Span == y?.Span; 50=> obj.Span.GetHashCode();

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\HeaderFacts\AbstractHeaderFacts.cs (4)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\RefactoringHelpers\AbstractRefactoringHelpers.cs (4)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SelectedMembers\AbstractSelectedMembers.cs (1)

110if (textSpan.Contains(member.Span))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\AbstractDocumentationCommentService.cs (1)

74var sb = new StringBuilder(summaryElement.Span.Length);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\ISyntaxFactsExtensions.cs (6)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)

773!forEachExpression.Span.Contains(OriginalExpression.SpanStart))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\CommonFormattingHelpers.cs (1)

365var endPosition = endToken.RawKind == 0 ? root.Span.End : endToken.Span.End;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\LightweightOverloadResolution.cs (1)

252=> expression.Span.IsEmpty;

Microsoft.CodeAnalysis.CodeStyle (49)

src\roslyn\src\Analyzers\Core\Analyzers\PopulateSwitch\AbstractPopulateSwitchDiagnosticAnalyzer.cs (1)

66if (switchBlock.SyntaxTree.OverlapsHiddenPosition(switchBlock.Span, context.CancellationToken))

src\roslyn\src\Analyzers\Core\Analyzers\RemoveUnnecessaryCast\AbstractRemoveUnnecessaryCastDiagnosticAnalyzer.cs (1)

65if (tree.OverlapsHiddenPosition(node.Span, cancellationToken))

src\roslyn\src\Analyzers\Core\Analyzers\RemoveUnnecessaryImports\AbstractRemoveUnnecessaryImportsDiagnosticAnalyzer.cs (3)

158textSpan = TextSpan.FromBounds(node.Span.Start, nodeEnd); 172textSpan = TextSpan.FromBounds(node.Span.Start, nodeEnd); 186var end = node.Span.End;

src\roslyn\src\Analyzers\Core\Analyzers\RemoveUnusedParametersAndValues\AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.BlockAnalyzer.cs (1)

129if (memberDecl != null && !context.ShouldAnalyzeSpan(memberDecl.Span))

src\roslyn\src\Analyzers\Core\Analyzers\SimplifyInterpolation\AbstractSimplifyInterpolationHelpers.cs (4)

150unnecessarySpans.AddRange(invocation.Syntax.Span 165unnecessarySpans.AddRange(invocation.Syntax.Span 178unnecessarySpans.AddRange(invocation.Syntax.Span 295unnecessarySpans.AddRange(invocation.Syntax.Span

src\roslyn\src\Analyzers\Core\Analyzers\SimplifyLinqExpression\AbstractSimplifyLinqExpressionDiagnosticAnalyzer.cs (1)

186TextSpan.FromBounds(memberName.SpanStart, nextInvocationNode.Span.End)));

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

205if (node is TPropertyDeclaration or TFieldDeclaration && context.ShouldAnalyzeSpan(node.Span, node.SyntaxTree))

src\roslyn\src\Analyzers\Core\Analyzers\UseCollectionInitializer\UseCollectionInitializerHelpers.cs (2)

37syntaxTree.GetLocation(TextSpan.FromBounds(arguments.Last().FullSpan.End, match.Span.End))); 49syntaxTree.GetLocation(TextSpan.FromBounds(expression.FullSpan.End, match.Span.End)));

src\roslyn\src\Analyzers\Core\Analyzers\UseObjectInitializer\AbstractUseObjectInitializerDiagnosticAnalyzer.cs (3)

162: syntaxFacts.GetExpressionOfMemberAccessExpression(match.MemberAccessExpression)!.Span.End; 168if (match.Statement.Span.End > match.Initializer.FullSpan.End) 170locations.Add(syntaxTree.GetLocation(TextSpan.FromBounds(match.Initializer.FullSpan.End, match.Statement.Span.End)));

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (5)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Context\FormattingContext.InitialContextFinder.cs (2)

78node.DescendantNodesAndSelf(n => n != previous && n.Span.IntersectsWith(span) && !span.Contains(n.Span))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\FormattingExtensions.cs (2)

28if (node.Parent.Span != node.Span)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Rules\BaseIndentationFormattingRule.cs (1)

41else if (node.Span.Contains(_span))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Helpers\RemoveUnnecessaryImports\AbstractUnnecessaryImportsProvider.cs (3)

47=> x?.Span == y?.Span; 50=> obj.Span.GetHashCode();

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\HeaderFacts\AbstractHeaderFacts.cs (4)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\RefactoringHelpers\AbstractRefactoringHelpers.cs (4)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SelectedMembers\AbstractSelectedMembers.cs (1)

110if (textSpan.Contains(member.Span))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\AbstractDocumentationCommentService.cs (1)

74var sb = new StringBuilder(summaryElement.Span.Length);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\ISyntaxFactsExtensions.cs (6)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)

773!forEachExpression.Span.Contains(OriginalExpression.SpanStart))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\CommonFormattingHelpers.cs (1)

365var endPosition = endToken.RawKind == 0 ? root.Span.End : endToken.Span.End;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\LightweightOverloadResolution.cs (1)

252=> expression.Span.IsEmpty;

Microsoft.CodeAnalysis.CodeStyle.Fixes (25)

src\roslyn\src\Analyzers\Core\CodeFixes\AddAnonymousTypeMemberName\AbstractAddAnonymousTypeMemberNameCodeFixProvider.cs (1)

58if (node?.Span != span)

src\roslyn\src\Analyzers\Core\CodeFixes\AddExplicitCast\Fixer.cs (1)

211if (newRoot.FindNode(targetNode.Span).GetAncestorOrThis<TArgumentListSyntax>() is TArgumentListSyntax newArgumentList)

src\roslyn\src\Analyzers\Core\CodeFixes\ConvertToAsync\AbstractConvertToAsyncCodeFixProvider.cs (1)

47node = ancestors.FirstOrDefault(n => n.Span.Contains(span) && n != root);

src\roslyn\src\Analyzers\Core\CodeFixes\Iterator\AbstractIteratorCodeFixProvider.cs (1)

44node = ancestors.FirstOrDefault(n => n.Span.Contains(span) && n != root);

src\roslyn\src\Analyzers\Core\CodeFixes\RemoveUnusedParametersAndValues\AbstractRemoveUnusedValuesCodeFixProvider.cs (1)

845var spansToFormat = originalDeclStatementsToMoveOrRemove.Select(s => s.Span);

src\roslyn\src\Analyzers\Core\CodeFixes\UseAutoProperty\AbstractUseAutoPropertyCodeFixProvider.cs (2)

495.Select(d => (d.SyntaxTree.FilePath, d.Span)) 576if (constructorSpans.Contains((node.SyntaxTree.FilePath, node.Span)))

src\roslyn\src\Analyzers\Core\CodeFixes\UseConditionalExpression\AbstractUseConditionalExpressionCodeFixProvider.cs (3)

166if (condition.Span.Length + trueSyntax.Span.Length + falseSyntax.Span.Length > formattingOptions.ConditionalExpressionWrappingLength)

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

222var beforeMember = declarationList.FirstOrDefault(m => m.Span.End >= info.Context.BeforeThisLocation.SourceSpan.End);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeRefactorings\CodeRefactoringHelpers.cs (6)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.State.cs (1)

172var affectedSpan = TextSpan.FromBounds(previousToken.SpanStart, FirstStatementAffectedInInnermostBlock.Span.End);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\RemoveUnnecessaryImports\AbstractRemoveUnnecessaryImportsService.cs (3)

44=> x?.Span == y?.Span; 47=> obj.Span.GetHashCode();

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Simplification\Simplifiers\AbstractMemberAccessExpressionSimplifier.cs (1)

71return !semanticModel.SyntaxTree.OverlapsHiddenPosition(memberAccessExpression.Span, cancellationToken) &&

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\NullableHelpers.cs (3)

Microsoft.CodeAnalysis.CSharp (100)

Binder\Binder_Expressions.cs (1)

5532var end = analyzedArguments.Arguments[analyzedArguments.Arguments.Count - 1].Syntax.Span.End;

Binder\Binder_Query.cs (1)

737SourceLocation errorLocation = new SourceLocation(let.SyntaxTree, new TextSpan(let.Identifier.SpanStart, let.Expression.Span.End - let.Identifier.SpanStart));

Binder\Binder_QueryErrors.cs (4)

141if (join.LeftExpression.Span.Contains(node.Span) && join.Identifier.ValueText == node.Identifier.ValueText) return true; 157if (join.RightExpression.Span.Contains(node.Span)) return true;

Binder\Binder_Statements.cs (1)

3477anonymousMethodSyntax.ParameterList?.Span.End ?? anonymousMethodSyntax.DelegateKeyword.Span.End));

Binder\BinderFactory.BinderFactoryVisitor.cs (4)

540return (SourcePropertySymbol)GetMemberSymbol(propertyName, basePropertyDeclarationSyntax.Span, container, SymbolKind.Property); 557return (SourceEventSymbol)GetMemberSymbol(eventName, eventDeclarationSyntax.Span, container, SymbolKind.Event); 1065TextSpan containingSpan = containingNode.Span; 1120if (parent.Type.Span.Contains(_position))

Binder\ExpressionVariableFinder.cs (2)

718designation.Identifier.ValueText, designation, designation.Span, 745locationSpan: designation.Span,

CodeGen\CodeGenerator.cs (1)

514EmitSequencePoint(syntax.SyntaxTree, syntax.Span);

CodeGen\EmitStatement.cs (1)

1098spSpan = TextSpan.FromBounds(syntax.SpanStart, syntax.Declaration.Span.End);

Compilation\CSharpCompilation.cs (5)

276return IsNullableAnalysisEnabledIn((CSharpSyntaxTree)syntax.SyntaxTree, syntax.Span); 2880TryAdd(new ImportInfo(syntax.SyntaxTree, syntax.Kind(), syntax.Span), default); 2886_lazyImportInfos.TryUpdate(new ImportInfo(syntax.SyntaxTree, syntax.Kind(), syntax.Span), dependencies, default); 4786return loc1.Span.Start - loc2.Span.Start;

Compilation\CSharpSemanticModel.cs (3)

1338if (betterPosition < node.Span.End) 2219var binder = this.GetEnclosingBinder(boundExpr.Syntax.Span.Start); 3247if (location.SourceTree == this.SyntaxTree && parameter.Span.Contains(location.SourceSpan))

Compilation\SpeculativeSemanticModelWithMemberModel.cs (3)

155!Root.Span.Contains(attributeOrParameter.Span)) 189if (defaultValueSyntax != null && defaultValueSyntax.FullSpan.Contains(node.Span))

Compilation\SyntaxTreeSemanticModel.cs (12)

773return ((CSharpSyntaxTree)speculativeSyntax.SyntaxTree).IsNullableAnalysisEnabled(speculativeSyntax.Span) ?? 848var span = node.Span; 1338var symbol = GetDeclaredNamespace(container, declarationSyntax.Span, declarationSyntax.Name); 1399var declarationSpan = extensionDeclaration.Span; 1428return GetDeclaredMember(container, declarationSyntax.Span, isKnownToBeANamespace: false, name) as NamedTypeSymbol; 1617return (this.GetDeclaredMember(container, declarationSyntax.Span, isKnownToBeANamespace: false) as MethodSymbol).GetPublicSymbol(); 1640return (this.GetDeclaredMember(container, declarationSyntax.Span, isKnownToBeANamespace: false) as MethodSymbol).GetPublicSymbol(); 1865var result = this.GetDeclaredMember(container, declarationSyntax.Span, isKnownToBeANamespace: false, declarationSyntax.Identifier.ValueText); 1958if (alias.Alias.GetFirstLocation().SourceSpan == declarationSyntax.Alias.Name.Span) 2050if (location.SourceTree == this.SyntaxTree && parameter.Span.Contains(location.SourceSpan)) 2234if (location.SourceTree == this.SyntaxTree && parameter.Span.Contains(location.SourceSpan)) 2405return this.GetDeclaredMember(container, declarationSyntax.Span, isKnownToBeANamespace: false, name);

Compiler\UnprocessedDocumentationCommentFinder.cs (1)

56if (node.Span.Length > 0)

FlowAnalysis\AbstractFlowPass.cs (1)

202int endLocation = lastInRegion.Syntax.Span.End;

FlowAnalysis\AlwaysAssignedWalker.cs (3)

85if (IsInside && pending.Branch != null && !RegionContains(pending.Branch.Syntax.Span)) 107if (node.Syntax != null && RegionContains(node.Syntax.Span)) _labelsInside.Add(label); 137if (branch.Branch != null && RegionContains(branch.Branch.Syntax.Span) && !_labelsInside.Contains(branch.Label))

FlowAnalysis\ControlFlowPass.cs (1)

265statement.Syntax.Span.Length != 0)

FlowAnalysis\DataFlowsInWalker.cs (4)

85if (!gotoStmt.WasCompilerGenerated && !targetStmt.WasCompilerGenerated && !RegionContains(gotoStmt.Syntax.Span) && RegionContains(targetStmt.Syntax.Span)) 106if (RegionContains(node.Span)) 121if (node != null && node is ReturnStatementSyntax && RegionContains(node.Span))

FlowAnalysis\DefiniteAssignment.cs (1)

1170(symbol.TryGetFirstLocation() is var location && (location is null || node.Span.End < location.SourceSpan.Start)))

FlowAnalysis\EntryPointsWalker.cs (2)

62if (!gotoStmt.WasCompilerGenerated && !targetStmt.WasCompilerGenerated && RegionContains(targetStmt.Syntax.Span) && !RegionContains(gotoStmt.Syntax.Span))

FlowAnalysis\ExitPointsWalker.cs (1)

124if (pending.Branch == null || !RegionContains(pending.Branch.Syntax.Span)) continue;

FlowAnalysis\ReadWriteWalker.cs (10)

147if (!IsInside && node.Span.Contains(RegionSpan) && (expr.Kind == BoundKind.FieldAccess)) 191if (RegionContains(receiverSyntax.Span)) 197if (RegionContains(receiverSyntax.Span)) 203if (RegionContains(receiverSyntax.Span)) 209if (RegionContains(receiverSyntax.Span)) 215if (RegionContains(receiverSyntax.Span)) 221if (receiver.Type.IsStructType() && receiverSyntax.Span.OverlapsWith(RegionSpan)) 227if (receiverSyntax.Span.OverlapsWith(RegionSpan)) 259if (!IsInside && node.Syntax != null && node.Syntax.Span.Contains(RegionSpan)) 269if (!IsInside && node.Syntax != null && node.Syntax.Span.Contains(RegionSpan))

FlowAnalysis\RegionAnalysisContext.cs (1)

45firstInRegion.Syntax.SpanStart > lastInRegion.Syntax.Span.End;

Lowering\Instrumentation\CodeCoverageInstrumenter.cs (3)

620return syntax.Span; 627var originalSpan = syntax.Span; 630var startSpan = modifiers.Node != null ? modifiers.Span : (keyword.Node != null ? keyword.Span : type!.Span);

Lowering\Instrumentation\DebugInfoInjector.cs (6)

98return new BoundSequencePointWithSpan(typeDecl, rewritten, TextSpan.FromBounds(typeDecl.Identifier.SpanStart, typeDecl.ParameterList.Span.End)); 103return new BoundSequencePointWithSpan(baseInit, rewritten, baseInit.Span); 279return new BoundSequencePointWithSpan(forEachSyntax, base.InstrumentForEachStatementDeconstructionVariablesDeclaration(original, iterationVarDecl), forEachSyntax.Variable.Span); 325iterationVarDeclSpan = forEachSyntax.Variable.Span; 428(switchSyntax.CloseParenToken != default) ? switchSyntax.CloseParenToken.Span.End : switchSyntax.Expression.Span.End); 445span: whenClause.Span);

Lowering\Instrumentation\DebugInfoInjector_SequencePoints.cs (5)

32int end = declarationSyntax.Initializer.Span.End; 42int start = usingSyntax.Span.Start; 125part = TextSpan.FromBounds(declarationSyntax.SpanStart, declaratorSyntax.Span.End); 158end = declarationSyntax.Parent.Span.End; 164end = declaratorSyntax.Span.End;

Lowering\LocalRewriter\LocalRewriter_SwitchExpression.cs (1)

77var spanEnd = syntax.Span.End;

src\roslyn\src\Compilers\CSharp\CSharpAnalyzerDriver\CSharpDeclarationComputer.cs (1)

27(node, level) => !node.Span.OverlapsWith(span) || InvalidLevel(level),

SymbolDisplay\SymbolDisplayVisitor_Minimal.cs (1)

257queryBody.SelectOrGroup.Span.End - 1, identifierName, SpeculativeBindingOption.BindAsExpression).Type;

Symbols\NamespaceOrTypeSymbol.cs (1)

228if (loc.IsInSource && loc.SourceTree == syntax.SyntaxTree && syntax.Span.Contains(loc.SourceSpan))

Symbols\Source\SourceConstructorSymbol.cs (4)

261if (ctorSyntax.Body?.Span.Contains(position) == true) 263offset = position - ctorSyntax.Body.Span.Start; 266else if (ctorSyntax.ExpressionBody?.Span.Contains(position) == true) 268offset = position - ctorSyntax.ExpressionBody.Span.Start;

Symbols\Source\SourceConstructorSymbolBase.cs (1)

207span = ctorInitializer.Span;

Symbols\Source\SourceMemberContainerSymbol.cs (3)

3478Debug.Assert(declaredMembers.DeclarationWithParameters.Span.Contains(InstanceInitializersForPositionalMembers[0].Syntax.Span.Start)); 3504declaredMembers.DeclarationWithParameters.Span.Contains(declaredMembers.InstanceInitializers[insertAt][0].Syntax.Span.Start)) 3526declaredMembers.DeclarationWithParameters.Span.Contains(g[0].Syntax.Span.Start)));

Symbols\Source\SourceMemberFieldSymbol.cs (1)

651return fieldDeclaration.SyntaxTree.HasCompilationUnitRoot && fieldDeclaration.Span.IntersectsWith(definedWithinSpan.Value);

Symbols\Source\SourceMemberMethodSymbol.cs (2)

1116if (blockBody?.Span.Contains(localPosition) == true) 1120else if (expressionBody?.Span.Contains(localPosition) == true)

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

72TextSpan.FromBounds(recordDeclaration.Identifier.Span.Start, recordDeclaration.TypeParameterList.Span.End)));

Symbols\Synthesized\SynthesizedSimpleProgramEntryPointSymbol.cs (1)

285if (global.Span.IntersectsWith(span))

Syntax\LookupPosition.cs (1)

285return section.Span.Contains(position);

Syntax\SimpleSyntaxReference.cs (1)

34return _node.Span;

Syntax\SyntaxNodeRemover.cs (3)

306this.AddDirectives(node, GetRemovedSpan(node.Span, node.FullSpan)); 344var span = TextSpan.FromBounds(token.Span.Start, node.Span.End); 378var span = TextSpan.FromBounds(node.Span.Start, token.Span.End);

Syntax\SyntaxReplacer.cs (1)

427: base(originalNode.Span, editKind, false, originalNode.IsPartOfStructuredTrivia())

Microsoft.CodeAnalysis.CSharp.CodeStyle (59)

src\roslyn\src\Analyzers\CSharp\Analyzers\AddAccessibilityModifiers\CSharpAddAccessibilityModifiersDiagnosticAnalyzer.cs (1)

41if (!context.ShouldAnalyzeSpan(member.Span))

src\roslyn\src\Analyzers\CSharp\Analyzers\AddBraces\CSharpAddBracesDiagnosticAnalyzer.cs (2)

132var ifStatementSpanWithoutElse = TextSpan.FromBounds(statement.Span.Start, embeddedStatement.Span.End);

src\roslyn\src\Analyzers\CSharp\Analyzers\ConvertNamespace\ConvertToFileScopedNamespaceDiagnosticAnalyzer.cs (1)

57: declaration.SyntaxTree.GetLocation(TextSpan.FromBounds(declaration.SpanStart, declaration.Name.Span.End));

src\roslyn\src\Analyzers\CSharp\Analyzers\InlineDeclaration\CSharpInlineDeclarationDiagnosticAnalyzer.cs (4)

151if (!context.ShouldAnalyzeSpan(localDeclaration.Span)) 335var localStatementStart = localStatement.Span.Start; 336var argumentNodeStart = argumentNode.Span.Start; 344var descendentStart = descendentNode.Span.Start;

src\roslyn\src\Analyzers\CSharp\Analyzers\InvokeDelegateWithConditionalAccess\InvokeDelegateWithConditionalAccessAnalyzer.cs (4)

136[Location.Create(tree, ifStatement.Span), Location.Create(tree, expressionStatement.Span)], 202if (nextToken.Span.Start < ifStatement.Span.End) 204fadeLocation = Location.Create(tree, TextSpan.FromBounds(nextToken.Span.Start, ifStatement.Span.End));

src\roslyn\src\Analyzers\CSharp\Analyzers\RemoveUnnecessaryCast\CSharpRemoveUnnecessaryCastDiagnosticAnalyzer.cs (1)

32BinaryExpressionSyntax binary => TextSpan.FromBounds(binary.OperatorToken.SpanStart, node.Span.End),

src\roslyn\src\Analyzers\CSharp\Analyzers\RemoveUnnecessaryLambdaExpression\CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs (2)

230var endReportSpan = TextSpan.FromBounds(invokedExpression.Span.End, anonymousFunction.Span.End);

src\roslyn\src\Analyzers\CSharp\Analyzers\RemoveUnnecessaryNullableDirective\CSharpRemoveUnnecessaryNullableDirectiveDiagnosticAnalyzer.cs (6)

119|| !possibleNullableImpactIntervalTree.HasIntervalThatOverlapsWith(currentOptionsDirective.Span.End, nullableDirectiveTrivia.SpanStart - currentOptionsDirective.Span.End)) 140possibleNullableImpactIntervalTree.AddIntervalInPlace(directive.Span); 151|| !possibleNullableImpactIntervalTree.HasIntervalThatOverlapsWith(currentOptionsDirective.Span.End, root.Span.End - currentOptionsDirective.Span.End))

src\roslyn\src\Analyzers\CSharp\Analyzers\RemoveUnnecessaryNullableDirective\NullableImpactingSpanWalker.cs (4)

47if (node.Span.End < _positionOfFirstReducingNullableDirective) 52if (_ignoredSpans.HasIntervalThatContains(node.SpanStart, node.Span.Length)) 139SpansBuilder.Add(predefinedType.Span); 157SpansBuilder.Add(node.Span);

src\roslyn\src\Analyzers\CSharp\Analyzers\RemoveUnnecessarySuppressions\UnnecessaryNullableWarningSuppressionsUtilities.cs (5)

38var semanticDiagnostics = semanticModel.GetDiagnostics(postfixUnary.Span, cancellationToken); 139var span = TextSpan.FromBounds(globalStatements.First().SpanStart, globalStatements.Last().Span.End); 154var typeDeclarationDiagnostics = updatedSemanticModel.GetDiagnostics(typeDeclaration.Span, cancellationToken); 161CheckDiagnostics(remainder, n => updatedSemanticModel.GetDiagnostics(n.Span, cancellationToken)); 172var intersectingDiagnostics = diagnostics.Where(d => d.Location.SourceSpan.IntersectsWith(rewrittenAncestor.Span));

src\roslyn\src\Analyzers\CSharp\Analyzers\RemoveUnnecessaryUnsafeModifier\UnnecessaryUnsafeModifierUtilities.cs (2)

30var semanticDiagnostics = semanticModel.GetDiagnostics(declaration.Span, cancellationToken); 114var updatedDiagnostics = updatedSemanticModel.GetDiagnostics(newNode.Span, cancellationToken);

src\roslyn\src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForArrayDiagnosticAnalyzer.cs (1)

221? arrayCreationExpression.Type.Span.End

src\roslyn\src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForFluentDiagnosticAnalyzer.cs (1)

302text.Lines.GetLineFromPosition(expression.SpanStart).LineNumber + 1 == text.Lines.GetLineFromPosition(expression.Span.End).LineNumber &&

src\roslyn\src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForStackAllocDiagnosticAnalyzer.cs (1)

112expression.Type.Span.End)));

src\roslyn\src\Analyzers\CSharp\Analyzers\UseImplicitOrExplicitType\CSharpTypeStyleDiagnosticAnalyzerBase.cs (1)

70declarationStatement.SyntaxTree.GetLocation(declaredType.StripRefIfNeeded().Span),

src\roslyn\src\Analyzers\CSharp\Analyzers\UseIndexOrRangeOperator\CSharpUseRangeOperatorDiagnosticAnalyzer.cs (1)

319TextSpan.FromBounds(arguments.First().SpanStart, arguments.Last().Span.End));

src\roslyn\src\Analyzers\CSharp\Analyzers\UseLocalFunction\CSharpUseLocalFunctionDiagnosticAnalyzer.cs (3)

185if (context.ShouldAnalyzeSpan(localDeclaration.Span)) 189&& context.ShouldAnalyzeSpan(anonymousFunctionStatement!.Span)) 252var descendentStart = descendentNode.Span.Start;

src\roslyn\src\Analyzers\CSharp\Analyzers\UsePatternMatching\CSharpAsAndNullCheckDiagnosticAnalyzer.Analyzer.cs (6)

160if (forStatement.Condition is null || !forStatement.Condition.Span.Contains(_comparison.Span)) 256if (node.SpanStart < _localStatement.Span.End) 260if (node.Span.End >= _comparison.SpanStart) 354var scopeSpan = scope.Span; 368if (descendentNodeSpanStart >= comparisonSpanStart && scopeSpan.Contains(descendentNode.Span))

src\roslyn\src\Analyzers\CSharp\Analyzers\UsePatternMatching\CSharpAsAndNullCheckDiagnosticAnalyzer.cs (3)

117if (!syntaxContext.ShouldAnalyzeSpan(localStatement.Span)) 217descendentNode.Span.IntersectsWith(comparisonEnclosingBlock.Span) &&

src\roslyn\src\Analyzers\CSharp\Analyzers\UsePatternMatching\CSharpIsAndCastCheckDiagnosticAnalyzer.cs (1)

83if (!syntaxContext.ShouldAnalyzeSpan(localDeclarationStatement.Span))

src\roslyn\src\Analyzers\CSharp\Analyzers\UseUtf8StringLiteral\UseUtf8StringLiteralDiagnosticAnalyzer.cs (1)

123var span = TextSpan.FromBounds(elements[0].Syntax.SpanStart, elements[^1].Syntax.Span.End);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\EmbeddedLanguages\VirtualChars\CSharpVirtualCharService.cs (1)

187var indentationLength = parentSourceText.Lines.GetLineFromPosition(parentExpression.Span.End).GetFirstNonWhitespaceOffset() ?? 0;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\BlockSyntaxExtensions.cs (3)

86conditionalDirectives.Last().Span.End >= block.CloseBraceToken.Span.End) 92if (conditionalDirectives.Last().Span.End <= statement.Span.Start)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\SyntaxNodeExtensions.cs (1)

561var matchSpan = match.Span;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Formatting\Engine\Trivia\CSharpTriviaFormatter.DocumentationCommentExteriorCommentRewriter.cs (1)

75trivia.Span.End == currentParent.Span.End)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Services\SyntaxFacts\CSharpSyntaxFacts.cs (2)

722if (useFullSpan || node.Span.Contains(position)) 936if (node.Span.IsEmpty)

Microsoft.CodeAnalysis.CSharp.CodeStyle.Fixes (17)

src\roslyn\src\Analyzers\CSharp\CodeFixes\AddInheritdoc\AddInheritdocCodeFixProvider.cs (1)

97var indentation = sourceText.GetLeadingWhitespaceOfLineAtPosition(node.Span.Start);

src\roslyn\src\Analyzers\CSharp\CodeFixes\AssignOutParameters\AbstractAssignOutParametersCodeFixProvider.cs (1)

140foreach (var container in unassignedParameters.Keys.OrderByDescending(n => n.Span.Start))

src\roslyn\src\Analyzers\CSharp\CodeFixes\ConvertNamespace\ConvertNamespaceTransform.cs (1)

165lastRawStringLiteralData = (stringNode, ComputeCommonIndentationLength(text.Lines.GetLineFromPosition(stringNode.Span.End)));

src\roslyn\src\Analyzers\CSharp\CodeFixes\Iterator\CSharpAddYieldCodeFixProvider.cs (2)

107var symbol = model.GetEnclosingSymbol(node.Span.Start, cancellationToken); 220node = ancestors.FirstOrDefault(n => n.Span.Contains(span) && n != root && n.IsKind(SyntaxKind.ReturnStatement));

src\roslyn\src\Analyzers\CSharp\CodeFixes\RemoveUnnecessarySuppressions\CSharpRemoveUnnecessaryNullableWarningSuppressionsCodeFixProvider.cs (2)

56linkedSpansArray.Add([.. unnecessaryNodes.Select(n => n.Span)]); 71if (!linkedSpans.Contains(expr.Span))

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpCollectionExpressionRewriter.cs (2)

802totalLength += expression.Span.Length; 831totalLength += component.Span.Length;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\CompilationUnitSyntaxExtensions.cs (3)

43var end = usings.Last().Span.End; 52var end = rootUsings.Last().Span.End; 60: root.Span.End;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\ContextQuery\CSharpSyntaxContext.cs (1)

504lockStatement.Statement.Span.Contains(position))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\ContextQuery\SyntaxTreeExtensions.cs (1)

690return declaration?.Name.Span.IntersectsWith(position) == true;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\TypeDeclarationSyntaxExtensions.cs (1)

46start = members.Last().Span.End;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\CSharpRemoveUnnecessaryImportsService.cs (1)

67spansToFormat.Add(TextSpan.FromBounds(baseNamespace.Name.Span.End, firstMemberB.SpanStart));

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\CSharpTypeInferenceService.TypeInferrer.cs (1)

2295if (descendant.SpanStart <= afterNode.Span.End)

Microsoft.CodeAnalysis.CSharp.Features (261)

ChangeSignature\CSharpChangeSignatureService.cs (2)

142if (!matchingNode.Span.IntersectsWith(position)) 176var argument = argumentList?.Arguments.FirstOrDefault(a => a.Span.Contains(position));

CodeRefactorings\ConvertLocalFunctionToMethod\CSharpConvertLocalFunctionToMethodCodeRefactoringProvider.cs (1)

60localFunction.Span);

CodeRefactorings\EnableNullable\EnableNullableCodeRefactoringProvider.cs (1)

248if (firstSemanticToken.IsKind(SyntaxKind.None) || firstSemanticToken.SpanStart > nullableDirective.Span.End)

CodeRefactorings\InlineTemporary\InlineTemporaryCodeRefactoringProvider.cs (4)

89if (references.Any(static (r, variableDeclarator) => variableDeclarator.Initializer.Span.Contains(r.Span), variableDeclarator)) 97variableDeclarator.Span); 443if (!text.AreOnSameLine(expression.SpanStart, expression.Span.End))

CodeRefactorings\SyncNamespace\CSharpChangeNamespaceService.cs (2)

59containerSpan = container.Span; 365if (!compilationUnit.Span.Contains(span))

CodeRefactorings\SyncNamespace\CSharpSyncNamespaceCodeRefactoringProvider.cs (1)

40if (namespaceDeclaration.Name.Span.IntersectsWith(position))

CodeRefactorings\UseExplicitOrImplicitType\AbstractUseTypeCodeRefactoringProvider.cs (1)

68declaredType.Span);

CodeRefactorings\UseRecursivePatterns\UseRecursivePatternsCodeRefactoringProvider.cs (1)

605if (!fixAllSpans.Any(fixAllSpan => fixAllSpan.Contains(originalNode.Span)))

Completion\CompletionProviders\AttributeNamedParameterCompletionProvider.cs (2)

207argumentList.Arguments.Where(a => a.Span.End <= position) 211argumentList.Arguments.Where(a => a.Span.End <= position)

Completion\CompletionProviders\AwaitCompletionProvider.cs (3)

76return new TextChange(existingReturnType.Span, newTypeName); 176return node.Span.Contains(position); 178return node.Span.IntersectsWith(position);

Completion\CompletionProviders\CompletionUtilities.cs (8)

194return methodDeclaration.ExpressionBody.Expression.Span; 199return methodDeclaration.Body.Statements.Last().Span; 203return methodDeclaration.Span; 213return new TextSpan(caretTarget.Span.End, 0); 224return lastStatement.Span; 227return expression.Span; 232return expression.Span; 236return new TextSpan(propertyDeclaration.Span.End, 0);

Completion\CompletionProviders\DeclarationName\DeclarationNameInfo.cs (1)

194if (type.Span.Length != subSpan.Length)

Completion\CompletionProviders\ExplicitInterfaceTypeCompletionProvider.cs (1)

81if (typeNode.Parent is TypeSyntax parentType && parentType.Span.End < position)

Completion\CompletionProviders\NamedParameterCompletionProvider.cs (1)

129.Where(a => a.Span.End <= position && a.NameColon != null)

Completion\KeywordRecommenders\InKeywordRecommender.cs (1)

69if (statement != null && token.Span.End == statement.Variable.Span.End)

ConvertLinq\CSharpConvertLinqQueryToForEachProvider.cs (1)

93!_semanticModel.GetDiagnostics(_source.Span, _cancellationToken).Any(static diagnostic => diagnostic.DefaultSeverity == DiagnosticSeverity.Error))

ConvertNamespace\ConvertNamespaceCodeRefactoringProvider.cs (1)

82return position <= namespaceDeclaration.Name.Span.End;

ConvertToRawString\ConvertInterpolatedStringToRawStringCodeRefactoringProvider.cs (2)

355var interpolation = stringExpression.Contents.OfType<InterpolationSyntax>().Single(i => i.Span.Contains(start)); 503var descendantSpan = descendant.Span;

Copilot\CSharpCopilotCodeFixProvider.cs (1)

80if (containingMethod?.Span.IntersectsWith(context.Span) is true)

Debugging\DataTipInfoGetter.cs (6)

42return new DebugDataTipInfo(typeSyntax.Span, text); 54: new DebugDataTipInfo(expression.Span, type.ToNameDisplayString()); 67? expression.GetRequiredParent().Span 68: TextSpan.FromBounds(current.SpanStart, expression.Span.End); 78return new DebugDataTipInfo(expression.Span, fullExpressionSpan ?? expression.Span, Text: null, kind);

EditAndContinue\BreakpointSpans.cs (11)

179return (methodDeclaration.Body != null) ? CreateSpanForBlock(methodDeclaration.Body, position) : methodDeclaration.ExpressionBody?.Expression.Span; 343return property.ExpressionBody.Expression.Span; 349return property.Initializer.Value.Span; 364return indexer.ExpressionBody.Expression.Span; 445return constructorSyntax.ExpressionBody.Expression.Span; 458return constructorSyntax.ExpressionBody.Expression.Span; 487return TextSpan.FromBounds(typeDeclaration.Identifier.SpanStart, typeDeclaration.ParameterList.Span.End); 507=> baseTypeSyntax.Span; 546=> accessor.Span; 616if (position < doStatement.Statement.Span.Start) 682return ((ForEachVariableStatementSyntax)statement).Variable.Span;

EditAndContinue\CSharpEditAndContinueAnalyzer.cs (39)

EditAndContinue\DeclarationBody\OrdinaryInstanceConstructorWithExplicitInitializerDeclarationBody.cs (1)

41=> TextSpan.FromBounds(InitializerActiveStatementSpan.Start, Body.Span.End);

EditAndContinue\DeclarationBody\OrdinaryInstanceConstructorWithImplicitInitializerDeclarationBody.cs (1)

35=> TextSpan.FromBounds(InitializerActiveStatementSpan.Start, Body.Span.End);

EditAndContinue\DeclarationBody\PropertyOrIndexerAccessorDeclarationBody.cs (1)

66=> ExplicitBody?.Span ?? HeaderActiveStatementSpan;

EditAndContinue\DeclarationBody\TopLevelCodeDeclarationBody.cs (1)

35=> TextSpan.FromBounds(unit.Members[0].SpanStart, GlobalStatements.Last().Span.End);

EncapsulateField\CSharpEncapsulateFieldService.cs (3)

129.DescendantNodes(d => d.Span.IntersectsWith(span)) 131.Where(n => n.Span.IntersectsWith(span)); 144declarators = declarations.SelectMany(d => d.Variables.Where(v => v.Span.IntersectsWith(span)));

ExtractMethod\CSharpMethodExtractor.cs (4)

70if (!OriginalSelectionResult.FinalSpan.Contains(anonymousFunction.Span)) 85if (!OriginalSelectionResult.FinalSpan.Contains(localFunction.Span)) 138if (OriginalSelectionResult.FinalSpan.Contains(memberNode.Span)) 159return node.Span.Contains(OriginalSelectionResult.FinalSpan);

ExtractMethod\CSharpSelectionValidator.cs (4)

223if (variable.Initializer != null && variable.Initializer.Span.Contains(span)) 263var expressionBodiedMemberBody = TextSpan.FromBounds(expressionBodiedMember.Expression.SpanStart, expressionBodiedMember.Expression.Span.End); 372if (expression != null && firstStatement.Span.Contains(expression.Span))

ExtractMethod\Extensions.cs (5)

78return constructorInitializer.ContainsInArgument(node.Span); 92return initializer.ArgumentList.Arguments.Any(a => a.Span.Contains(textSpan)); 140return equal.Value != null && equal.Value.Span.Contains(node.Span); 158if (catchClause == null || !textSpan.Contains(catchClause.Span))

GenerateMember\GenerateVariable\CSharpGenerateVariableService.cs (2)

161var startIndex = identifierName.Span.Start - localRoot.Span.Start;

GenerateType\CSharpGenerateTypeService.cs (1)

563? semanticModel.SyntaxTree.GetLocation(new TextSpan(lastMember.Span.End, 0))

InlineHints\CSharpInlineParameterNameHintsService.cs (2)

55buffer.Add((argument.Span.Start, argument, parameter, GetKind(argument.Expression))); 82buffer.Add((argument.Span.Start, argument, parameter, GetKind(argument.Expression)));

IntroduceVariable\CSharpIntroduceVariableService_IntroduceLocal.cs (3)

449var localFunctions = innermostCommonBlock.DescendantNodes().Where(node => node.IsKind(SyntaxKind.LocalFunctionStatement) && matches.Any(match => match.Span.OverlapsWith(node.Span))); 476var earliestLocalFunctionCallIndex = statementsInBlock.IndexOf(s => s.Span.Contains(earliestLocalFunctionCall));

LanguageServices\CSharpSymbolDisplayService.SymbolDescriptionBuilder.cs (1)

339LanguageServices, semanticModel, equalsValue.Value.Span,

NavigationBar\CSharpNavigationBarItemService.cs (3)

274var spanEnd = declaringNode.Span.End; 285spanEnd = fieldDeclaration.Span.End; 312return declaringNode.Span;

QuickInfo\CSharpDiagnosticAnalyzerQuickInfoProvider.cs (2)

79document, errorCode, errorCodeNode.Span, cancellationToken).ConfigureAwait(false); 118document, errorCode, suppressMessageCheckIdArgument.Span, cancellationToken).ConfigureAwait(false);

QuickInfo\CSharpSemanticQuickInfoProvider.cs (1)

126if (nameSyntax is null || !nameSyntax.Span.Contains(token.Span))

QuickInfo\CSharpSyntacticQuickInfoProvider.cs (2)

138return QuickInfoItem.Create(token.Span, relatedSpans: [regionStart.Span]); 145.SelectAsArray(d => d.Span);

RawStringLiteral\CSharpRawStringLiteralOnAutoInsertService.cs (1)

175return new TextChange(new TextSpan(token.GetRequiredParent().Span.End, 0), "\"");

SignatureHelp\AttributeSignatureHelpProvider.cs (1)

68expression.ArgumentList.Span.Contains(token.SpanStart) &&

SignatureHelp\ConstructorInitializerSignatureHelpProvider.cs (1)

55expression.ArgumentList.Span.Contains(token.SpanStart) &&

SignatureHelp\ElementAccessExpressionSignatureHelpProvider.cs (4)

118return TextSpan.FromBounds(conditional.Span.Start, openBracket.FullSpan.End); 288return expression.ArgumentList.Span.Contains(token.SpanStart) && 337return TextSpan.FromBounds(expression.SpanStart, openBracket.Parent.Span.End); 373return expression.ArgumentList.Span.Contains(token.SpanStart) &&

SignatureHelp\GenericNameFullyWrittenSignatureHelpProvider.cs (1)

54node.TypeArgumentList.Span.Contains(token.SpanStart) &&

SignatureHelp\InitializerExpressionSignatureHelpProvider.cs (1)

53=> expression.Span.Contains(token.SpanStart) && token != expression.CloseBraceToken;

SignatureHelp\InvocationExpressionSignatureHelpProvider.cs (1)

50return expression.ArgumentList.Span.Contains(token.SpanStart) &&

SignatureHelp\ObjectCreationExpressionSignatureHelpProvider.cs (1)

48expression.ArgumentList.Span.Contains(token.SpanStart) &&

SignatureHelp\PrimaryConstructorBaseTypeSignatureHelpProvider.cs (1)

61expression.ArgumentList.Span.Contains(token.SpanStart) &&

SignatureHelp\TupleConstructionSignatureHelpProvider.cs (3)

71if (!currentSpan.Contains(expression.Span)) 90if (!currentSpan.Contains(expression.Span)) 161return CreateSignatureHelpItems(items, targetExpression.Span, state, selectedItemIndex: null, parameterIndexOverride: -1);

SignatureHelp\WithElementSignatureHelpProvider.cs (1)

47expression.ArgumentList.Span.Contains(token.SpanStart) &&

Snippets\CSharpSnippetFunctionService.cs (1)

34var expressionNode = token.GetAncestor(n => n.Span == switchExpressionSpan);

SolutionCrawler\CSharpDocumentDifferenceService.cs (4)

25(constructor.Initializer != null && constructor.Initializer.Span.Contains(span)); 29return property.AccessorList != null && property.AccessorList.Span.Contains(span); 31return @enum.EqualsValue != null && @enum.EqualsValue.Span.Contains(span); 33return field.Declaration != null && field.Declaration.Span.Contains(span);

SplitStringLiteral\InterpolatedStringSplitter.cs (3)

45if (content.Span.End <= CursorPosition) 50else if (content.Span.Start >= CursorPosition) 59afterSplitContents.Insert(0, CreateInterpolatedStringText(CursorPosition, content.Span.End));

SplitStringLiteral\StringSplitter.cs (2)

89if (CursorPosition <= nodeToReplace.SpanStart || CursorPosition >= nodeToReplace.Span.End) 119return (newRoot2, rightExpression.Span.Start + indentString.Length + StringOpenQuoteLength());

src\roslyn\src\Analyzers\CSharp\Analyzers\AddAccessibilityModifiers\CSharpAddAccessibilityModifiersDiagnosticAnalyzer.cs (1)

41if (!context.ShouldAnalyzeSpan(member.Span))

src\roslyn\src\Analyzers\CSharp\Analyzers\AddBraces\CSharpAddBracesDiagnosticAnalyzer.cs (2)

132var ifStatementSpanWithoutElse = TextSpan.FromBounds(statement.Span.Start, embeddedStatement.Span.End);

src\roslyn\src\Analyzers\CSharp\Analyzers\ConvertNamespace\ConvertToFileScopedNamespaceDiagnosticAnalyzer.cs (1)

57: declaration.SyntaxTree.GetLocation(TextSpan.FromBounds(declaration.SpanStart, declaration.Name.Span.End));

src\roslyn\src\Analyzers\CSharp\Analyzers\InlineDeclaration\CSharpInlineDeclarationDiagnosticAnalyzer.cs (4)

src\roslyn\src\Analyzers\CSharp\Analyzers\InvokeDelegateWithConditionalAccess\InvokeDelegateWithConditionalAccessAnalyzer.cs (4)

src\roslyn\src\Analyzers\CSharp\Analyzers\RemoveUnnecessaryCast\CSharpRemoveUnnecessaryCastDiagnosticAnalyzer.cs (1)

32BinaryExpressionSyntax binary => TextSpan.FromBounds(binary.OperatorToken.SpanStart, node.Span.End),

src\roslyn\src\Analyzers\CSharp\Analyzers\RemoveUnnecessaryLambdaExpression\CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs (2)

230var endReportSpan = TextSpan.FromBounds(invokedExpression.Span.End, anonymousFunction.Span.End);

src\roslyn\src\Analyzers\CSharp\Analyzers\RemoveUnnecessaryNullableDirective\CSharpRemoveUnnecessaryNullableDirectiveDiagnosticAnalyzer.cs (6)

src\roslyn\src\Analyzers\CSharp\Analyzers\RemoveUnnecessaryNullableDirective\NullableImpactingSpanWalker.cs (4)

src\roslyn\src\Analyzers\CSharp\Analyzers\RemoveUnnecessarySuppressions\UnnecessaryNullableWarningSuppressionsUtilities.cs (5)

src\roslyn\src\Analyzers\CSharp\Analyzers\RemoveUnnecessaryUnsafeModifier\UnnecessaryUnsafeModifierUtilities.cs (2)

30var semanticDiagnostics = semanticModel.GetDiagnostics(declaration.Span, cancellationToken); 114var updatedDiagnostics = updatedSemanticModel.GetDiagnostics(newNode.Span, cancellationToken);

src\roslyn\src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForArrayDiagnosticAnalyzer.cs (1)

221? arrayCreationExpression.Type.Span.End

src\roslyn\src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForFluentDiagnosticAnalyzer.cs (1)

302text.Lines.GetLineFromPosition(expression.SpanStart).LineNumber + 1 == text.Lines.GetLineFromPosition(expression.Span.End).LineNumber &&

src\roslyn\src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForStackAllocDiagnosticAnalyzer.cs (1)

112expression.Type.Span.End)));

src\roslyn\src\Analyzers\CSharp\Analyzers\UseImplicitOrExplicitType\CSharpTypeStyleDiagnosticAnalyzerBase.cs (1)

70declarationStatement.SyntaxTree.GetLocation(declaredType.StripRefIfNeeded().Span),

src\roslyn\src\Analyzers\CSharp\Analyzers\UseIndexOrRangeOperator\CSharpUseRangeOperatorDiagnosticAnalyzer.cs (1)

319TextSpan.FromBounds(arguments.First().SpanStart, arguments.Last().Span.End));

src\roslyn\src\Analyzers\CSharp\Analyzers\UseLocalFunction\CSharpUseLocalFunctionDiagnosticAnalyzer.cs (3)

185if (context.ShouldAnalyzeSpan(localDeclaration.Span)) 189&& context.ShouldAnalyzeSpan(anonymousFunctionStatement!.Span)) 252var descendentStart = descendentNode.Span.Start;

src\roslyn\src\Analyzers\CSharp\Analyzers\UsePatternMatching\CSharpAsAndNullCheckDiagnosticAnalyzer.Analyzer.cs (6)

src\roslyn\src\Analyzers\CSharp\Analyzers\UsePatternMatching\CSharpAsAndNullCheckDiagnosticAnalyzer.cs (3)

117if (!syntaxContext.ShouldAnalyzeSpan(localStatement.Span)) 217descendentNode.Span.IntersectsWith(comparisonEnclosingBlock.Span) &&

src\roslyn\src\Analyzers\CSharp\Analyzers\UsePatternMatching\CSharpIsAndCastCheckDiagnosticAnalyzer.cs (1)

83if (!syntaxContext.ShouldAnalyzeSpan(localDeclarationStatement.Span))

src\roslyn\src\Analyzers\CSharp\Analyzers\UseUtf8StringLiteral\UseUtf8StringLiteralDiagnosticAnalyzer.cs (1)

123var span = TextSpan.FromBounds(elements[0].Syntax.SpanStart, elements[^1].Syntax.Span.End);

src\roslyn\src\Analyzers\CSharp\CodeFixes\AddInheritdoc\AddInheritdocCodeFixProvider.cs (1)

97var indentation = sourceText.GetLeadingWhitespaceOfLineAtPosition(node.Span.Start);

src\roslyn\src\Analyzers\CSharp\CodeFixes\AssignOutParameters\AbstractAssignOutParametersCodeFixProvider.cs (1)

140foreach (var container in unassignedParameters.Keys.OrderByDescending(n => n.Span.Start))

src\roslyn\src\Analyzers\CSharp\CodeFixes\ConvertNamespace\ConvertNamespaceTransform.cs (1)

165lastRawStringLiteralData = (stringNode, ComputeCommonIndentationLength(text.Lines.GetLineFromPosition(stringNode.Span.End)));

src\roslyn\src\Analyzers\CSharp\CodeFixes\Iterator\CSharpAddYieldCodeFixProvider.cs (2)

src\roslyn\src\Analyzers\CSharp\CodeFixes\RemoveUnnecessarySuppressions\CSharpRemoveUnnecessaryNullableWarningSuppressionsCodeFixProvider.cs (2)

56linkedSpansArray.Add([.. unnecessaryNodes.Select(n => n.Span)]); 71if (!linkedSpans.Contains(expr.Span))

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpCollectionExpressionRewriter.cs (2)

802totalLength += expression.Span.Length; 831totalLength += component.Span.Length;

src\roslyn\src\Compilers\CSharp\CSharpAnalyzerDriver\CSharpDeclarationComputer.cs (1)

27(node, level) => !node.Span.OverlapsWith(span) || InvalidLevel(level),

StringIndentation\CSharpStringIndentationService.cs (4)

119builder.Add(interpolation.Span); 130if (content is InterpolationSyntax && content.Span.Contains(sourceSpan)) 144var holeEndLine = text.Lines.GetLineFromPosition(interpolation.Span.End).LineNumber; 163var lastLine = text.Lines.GetLineFromPosition(expression.Span.End);

Structure\CSharpStructureHelpers.cs (1)

327node.Span,

Structure\Providers\AnonymousObjectCreationExpressionStructureProvider.cs (2)

38textSpan: TextSpan.FromBounds(node.NewKeyword.Span.End, node.Span.End), 39hintSpan: node.Span,

Structure\Providers\ArgumentListStructureProvider.cs (1)

24node.Span));

Structure\Providers\ArrowExpressionClauseStructureProvider.cs (6)

30hintSpan: TextSpan.FromBounds(parent.Span.Start, end), 55matchingDirectives[0].Span.Start >= parent.Span.Start && 56matchingDirectives.All(d => d.Span.End <= nextToken.Span.Start)) 59return lastDirective.Span.End; 65return parent.Span.End;

Structure\Providers\BlockSyntaxStructureProvider.cs (6)

141textSpan: node.Span, 142hintSpan: node.Span, 162var start = parent.Span.Start; 172return node.Span; 193return node.Span.End; 199return node.GetRequiredParent().Span.End;

Structure\Providers\CollectionExpressionStructureProvider.cs (2)

40: node.Span.End; 61var textSpan = TextSpan.FromBounds(previousToken.Span.End, node.Span.End);

Structure\Providers\InitializerExpressionStructureProvider.cs (4)

42: node.Span.End; 64? containingStatement.Span 65: node.Parent.Span; 69textSpan: TextSpan.FromBounds(node.SpanStart, node.Span.End),

Structure\Providers\InterpolatedStringExpressionStructureProvider.cs (2)

29textSpan: node.Span, 30hintSpan: node.Span,

Structure\Providers\ParameterListStructureProvider.cs (1)

24node.Span));

Structure\Providers\RegionDirectiveStructureProvider.cs (2)

19var prefixLength = kw.Span.End - simpleDirective.Span.Start; 54textSpan: TextSpan.FromBounds(regionDirective.SpanStart, match.Span.End),

Structure\Providers\StringLiteralExpressionStructureProvider.cs (3)

29textSpan: node.Span, 30hintSpan: node.Span, 48var span = node.Span;

Structure\Providers\SwitchExpressionStructureProvider.cs (1)

25hintSpan: node.Span,

Structure\Providers\SwitchStatementStructureProvider.cs (4)

24textSpan: TextSpan.FromBounds(node.CloseParenToken != default ? node.CloseParenToken.Span.End : node.Expression.Span.End, node.CloseBraceToken.Span.End), 25hintSpan: node.Span, 33var end = section.Statements.Last().Span.End; 38hintSpan: section.Span,

UseExpressionBody\UseExpressionBodyCodeRefactoringProvider.cs (2)

130declaration.Span); 143declaration.Span);

UsePatternMatching\CSharpIsAndCastCheckWithoutNameDiagnosticAnalyzer.cs (3)

171if (node.Span.End >= type.Span.End) 205var diagnostics = updatedSemanticModel.GetDiagnostics(currentNode.Span, cancellationToken);

Wrapping\SeparatedSyntaxList\CSharpCollectionExpressionWrapper.cs (1)

52return listSyntax.Span.Contains(position);

Wrapping\SeparatedSyntaxList\CSharpInitializerExpressionWrapper.cs (1)

52return listSyntax.Span.Contains(position);

Microsoft.CodeAnalysis.CSharp.NetAnalyzers (3)

Microsoft.NetCore.Analyzers\Performance\CSharpUseSearchValues.Fixer.cs (1)

155foreach (SyntaxTrivia trivia in node.DescendantTrivia(node.Span))

Microsoft.NetCore.Analyzers\Runtime\CSharpAvoidRedundantRegexIsMatchBeforeMatch.Fixer.cs (2)

316return core.Span.Equals(matchNode.Span);

Microsoft.CodeAnalysis.CSharp.Workspaces (61)

Classification\SyntaxClassification\DiscardSyntaxClassifier.cs (2)

30result.Add(new ClassifiedSpan(syntax.Span, ClassificationTypeNames.Keyword)); 51result.Add(new ClassifiedSpan(syntax.Span, ClassificationTypeNames.Keyword));

Classification\SyntaxClassification\NameSyntaxClassifier.cs (6)

145classifiedSpan = new ClassifiedSpan(name.Span, ClassificationTypeNames.NamespaceName); 153classifiedSpan = new ClassifiedSpan(name.Span, ClassificationTypeNames.Keyword); 160classifiedSpan = new ClassifiedSpan(name.Span, ClassificationTypeNames.Keyword); 168classifiedSpan = new ClassifiedSpan(name.Span, ClassificationTypeNames.Keyword); 175classifiedSpan = new ClassifiedSpan(name.Span, ClassificationTypeNames.Keyword); 328result.Add(new(name.Span, ClassificationTypeNames.Keyword));

Classification\SyntaxClassification\UsingDirectiveSyntaxClassifier.cs (2)

52result.Add(new ClassifiedSpan(token.Span, classification)); 57result.Add(new ClassifiedSpan(token.Span, ClassificationTypeNames.NamespaceName));

Classification\Worker.cs (1)

260if (!_textSpan.OverlapsWith(skippedTokens.Span))

Classification\Worker_DocumentationComments.cs (1)

16if (!_textSpan.OverlapsWith(documentationComment.Span))

Classification\Worker_Preprocesser.cs (1)

16if (!_textSpan.OverlapsWith(node.Span))

CodeGeneration\CSharpSyntaxGenerator.cs (8)

2879if (root.Span.Contains(declaration.Span)) 3018if (root.Span.Contains(declaration.Span)) 3057if (root.Span.Contains(declaration.Span)) 3127if (root.Span.Contains(node.Span))

Rename\CSharpRenameRewriterLanguageService.cs (4)

162if (_conflictLocations.Any(cf => cf.Contains(lambda.Span))) 195_conflictLocations.Contains(node.Span) && 294var oldSpan = originalNode.Span; 309var newSpan = newNode.Span;

Simplification\Reducers\CSharpNullableAnnotationReducer.cs (1)

37var context = semanticModel.GetNullableContext(node.Span.End);

Simplification\Simplifiers\ExpressionSimplifier.cs (7)

50issueSpan = memberAccessExpression.Expression.Span; 108issueSpan = memberAccess.Span; 163issueSpan = memberAccess.Span; 169issueSpan = memberAccess.Expression.Span; 189issueSpan = memberAccess.Span; // we want to show the whole expression as unnecessary 215issueSpan = memberAccess.Expression.Span; 440issueSpan = left.Span;

Simplification\Simplifiers\NameSimplifier.cs (9)

92issueSpan = genericName.TypeArgumentList.Span; 108issueSpan = name.Span; 166issueSpan = name.Span; 176issueSpan = qualifiedName3.Left.Span; 296issueSpan = name.Span; 322issueSpan = ((AliasQualifiedNameSyntax)name).Alias.Span; 328issueSpan = ((QualifiedNameSyntax)name).Left.Span; 455return !name.Span.Contains(argumentDecl.Span); 472issueSpan = name.Span; // we want to show the whole name expression as unnecessary

Simplification\Simplifiers\QualifiedCrefSimplifier.cs (2)

58issueSpan = crefSyntax.Span; 96issueSpan = crefSyntax.Container.Span;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\EmbeddedLanguages\VirtualChars\CSharpVirtualCharService.cs (1)

187var indentationLength = parentSourceText.Lines.GetLineFromPosition(parentExpression.Span.End).GetFirstNonWhitespaceOffset() ?? 0;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\BlockSyntaxExtensions.cs (3)

86conditionalDirectives.Last().Span.End >= block.CloseBraceToken.Span.End) 92if (conditionalDirectives.Last().Span.End <= statement.Span.Start)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\SyntaxNodeExtensions.cs (1)

561var matchSpan = match.Span;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Formatting\Engine\Trivia\CSharpTriviaFormatter.DocumentationCommentExteriorCommentRewriter.cs (1)

75trivia.Span.End == currentParent.Span.End)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Services\SyntaxFacts\CSharpSyntaxFacts.cs (2)

722if (useFullSpan || node.Span.Contains(position)) 936if (node.Span.IsEmpty)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\CompilationUnitSyntaxExtensions.cs (3)

43var end = usings.Last().Span.End; 52var end = rootUsings.Last().Span.End; 60: root.Span.End;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\ContextQuery\CSharpSyntaxContext.cs (1)

504lockStatement.Statement.Span.Contains(position))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\ContextQuery\SyntaxTreeExtensions.cs (1)

690return declaration?.Name.Span.IntersectsWith(position) == true;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\TypeDeclarationSyntaxExtensions.cs (1)

46start = members.Last().Span.End;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\CSharpRemoveUnnecessaryImportsService.cs (1)

67spansToFormat.Add(TextSpan.FromBounds(baseNamespace.Name.Span.End, firstMemberB.SpanStart));

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\CSharpTypeInferenceService.TypeInferrer.cs (1)

2295if (descendant.SpanStart <= afterNode.Span.End)

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

25=> _node.Span;

Microsoft.CodeAnalysis.Features (131)

AddImport\AbstractAddImportCodeRefactoringProvider.cs (1)

115qualifiedTypeReference.Span);

AddImport\AbstractAddImportFeatureService.cs (1)

96.GetAncestor(n => n.Span.Contains(span) && n != root);

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.cs (2)

311var containedDecls = decls.Where(d => span.Contains(d.DeclaredNode.Span)); 324var declSpan = decl.DeclaredNode.Span;

CodeLens\CodeLensFindReferenceProgress.cs (2)

79where !(_queriedNode.Span == candidateSyntaxNode.Span &&

CodeRefactorings\AddAwait\AbstractAddAwaitCodeRefactoringProvider.cs (2)

57expression.Span); 65expression.Span);

CodeRefactorings\SyncNamespace\AbstractChangeNamespaceService.cs (3)

290spanForContainers.Add(container.Span); 910return x.Span.Start - y.Span.Start;

Completion\Providers\AbstractPartialTypeCompletionProvider.cs (1)

107.Any(node => !(node.SyntaxTree == context.SyntaxTree && node.Span.IntersectsWith(context.Position)));

ConvertAnonymousType\AbstractConvertAnonymousTypeToClassCodeRefactoringProvider.cs (2)

68anonymousObject.Span); 76anonymousObject.Span);

ConvertAutoPropertyToFullProperty\AbstractConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs (2)

54property.Span); 65property.Span);

ConvertCast\AbstractConvertCastCodeRefactoringProvider.cs (1)

64from.Span);

ConvertForEachToFor\AbstractConvertForEachToForCodeRefactoringProvider.cs (1)

82foreachStatement.Span);

ConvertForToForEach\AbstractConvertForToForEachCodeRefactoringProvider.cs (1)

141forStatement.Span);

ConvertIfToSwitch\AbstractConvertIfToSwitchCodeRefactoringProvider.cs (3)

57ifStatement.Span); 67ifStatement.Span); 241if (!fixAllSpans.Any(fixAllSpan => fixAllSpan.Contains(originalIfStatement.Span)))

ConvertIfToSwitch\AbstractConvertIfToSwitchCodeRefactoringProvider.Rewriting.cs (1)

38var ifSpan = ifStatement.Span;

ConvertLinq\AbstractConvertLinqQueryToForEachProvider.cs (1)

51queryExpression.Span);

ConvertLinq\ConvertForEachToLinqQuery\AbstractConvertForEachToLinqQueryProvider.cs (3)

93if (semanticModel.GetDiagnostics(forEachStatement.Span, cancellationToken) 118forEachStatement.Span); 141forEachStatement.Span);

ConvertToInterpolatedString\AbstractConvertConcatenationToInterpolatedStringRefactoringProvider.cs (1)

114top.Span);

ConvertToInterpolatedString\AbstractConvertPlaceholderToInterpolatedStringRefactoringProvider.cs (2)

151invocation.Span); 302if (normalizedSpans.IntersectsWith(childNode!.Span))

ConvertToInterpolatedString\ConvertRegularStringToInterpolatedStringRefactoringProvider.cs (1)

80literalExpression.Span);

ConvertTupleToStruct\AbstractConvertTupleToStructCodeRefactoringProvider.cs (2)

101tupleExprOrTypeNode.Span); 113tupleExprOrTypeNode.Span);

Debugging\AbstractDataTipInfoGetter.cs (1)

37return (DebugDataTipInfoKind.LinqExpression, invocation.Span);

Diagnostics\Analyzers\UnboundIdentifiersDiagnosticAnalyzerBase.cs (1)

68var typeNames = member.DescendantNodes().Where(n => IsQualifiedOrSimpleName(n) && !n.Span.IsEmpty);

EditAndContinue\AbstractEditAndContinueAnalyzer.cs (10)

261=> TryGetDiagnosticSpan(node, editKind) ?? node.Span; 270return node.Span; 1543if (!newEncompassingAncestor.Span.Contains(newStatementSyntaxSpan.Start)) 1819if (TryGetActiveSpan(statement, statementPart, minLength: statement.Span.Length, out var span)) 1830return node.Span; 1841return statement.Span; 2474triviaEdits.Add((segment.oldNode, segment.newNode, segment.newNode.Span)); 5275locationNode.Span : analyzer.GetDiagnosticSpan(GetDiagnosticNode(out var distance, cancellationToken), distance > 0 ? EditKind.Delete : EditKind.Update), 5503if (!TryFindMemberDeclaration(root: null, newNode, newNode.Span, out var newDeclarations)) 5539if (!TryFindMemberDeclaration(root: null, newNode, newNode.Span, out var newDeclarations))

EditAndContinue\AbstractSimpleMemberBody.cs (1)

26=> node.Span;

EncapsulateField\AbstractEncapsulateFieldService.cs (1)

313.Select(n => (solution.GetRequiredDocument(n.SyntaxTree).Id, n.Span))

ExtractMethod\MethodExtractor.Analyzer.cs (1)

434var analysisRange = TextSpan.FromBounds(SelectionResult.FinalSpan.Start, containingScope.Span.End);

ExtractMethod\SelectionInfo.cs (2)

106if (firstStatement.Span.Contains(lastStatement.Span))

ExtractMethod\SelectionResult.cs (1)

150if (childNode.Span.OverlapsWith(span))

ExtractMethod\SelectionValidator.cs (3)

84if (firstStatement != null && statement.Span.End <= textSpan.End && statement.Parent == firstStatement.Parent) 159if (statement.Span.End < textSpan.Start) 173if (textSpan.End <= statement.Span.End && spine.Any(s => AreStatementsInSameContainer(s, statement)))

FullyQualify\AbstractFullyQualifyService.cs (1)

68var node = root.FindToken(span.Start).GetAncestors<SyntaxNode>().First(n => n.Span.Contains(span));

GenerateConstructors\AbstractGenerateConstructorsCodeRefactoringProvider.cs (1)

262pickMemberOptions.ToImmutable()), typeDeclaration.Span);

GenerateOverrides\GenerateOverridesCodeRefactoringProvider.cs (1)

58typeDeclaration.Span);

GenerateType\AbstractGenerateTypeService.Editor.cs (1)

395new CodeGenerationContext(afterThisLocation: _semanticDocument.SyntaxTree.GetLocation(_state.SimpleName.Span))),

InitializeParameter\AbstractInitializeParameterCodeRefactoringProvider.cs (1)

122listOfPotentiallyValidParametersNodes.ToImmutable(), selectedParameter.Span, cancellationToken).ConfigureAwait(false);

InlineHints\AbstractInlineParameterNameHintsService.cs (1)

65foreach (var node in root.DescendantNodes(textSpan, n => n.Span.IntersectsWith(textSpan)))

InlineHints\AbstractInlineTypeHintsService.cs (1)

55foreach (var node in root.DescendantNodes(n => n.Span.IntersectsWith(textSpan)))

InlineMethod\AbstractInlineMethodRefactoringProvider.cs (1)

201calleeInvocationNode.Span);

IntroduceUsingStatement\AbstractIntroduceUsingStatementCodeRefactoringProvider.cs (2)

83localDeclaration.Span); 97expressionStatement.Span);

IntroduceVariable\AbstractIntroduceLocalForExpressionCodeRefactoringProvider.cs (2)

59expressionStatement.Span); 67expressionStatement.Span);

InvertConditional\AbstractInvertConditionalCodeRefactoringProvider.cs (1)

36conditional.Span);

InvertIf\AbstractInvertIfCodeRefactoringProvider.cs (2)

148ifDirective.Span); 209ifNode.Span);

InvertLogical\AbstractInvertLogicalCodeRefactoringProvider.cs (1)

79expression.Span);

MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceCodeRefactoringProvider.cs (1)

43declaration.Span);

NameTupleElement\AbstractNameTupleElementCodeRefactoringProvider.cs (1)

37argument.Span);

ReplaceConditionalWithStatements\AbstractReplaceConditionalWithStatementsCodeRefactoringProvider.cs (2)

137conditionalExpression.Span); 166conditionalExpression.Span);

ReplaceMethodWithProperty\ReplaceMethodWithPropertyCodeRefactoringProvider.cs (2)

73methodDeclaration.Span); 86methodDeclaration.Span);

ReplacePropertyWithMethods\ReplacePropertyWithMethodsCodeRefactoringProvider.cs (1)

68propertyDeclaration.Span);

SimplifyTypeNames\AbstractSimplifyTypeNamesCodeFixProvider.cs (1)

53if (node.Span.IntersectsWith(span) && CanSimplifyTypeNameExpression(model, node, options, span, out var diagnosticId, cancellationToken))

Snippets\SnippetFunctionService.cs (1)

146var nodeToReplace = syntaxRoot.DescendantNodes().FirstOrDefault(n => n.Span == fullyQualifiedTypeSpan);

Snippets\SnippetProviders\AbstractConsoleSnippetProvider.cs (1)

67return caretTarget.Span.End;

SolutionCrawler\AbstractDocumentDifferenceService.cs (4)

164if (oldMember.Span.IsEmpty) 170if (!oldMember.Span.Contains(range.Span)) 178return (oldMember.Span.Length + lengthDelta) == newMember.Span.Length ? newMember : null;

SpellCheck\AbstractSpellCheckCodeFixProvider.cs (1)

48if (node != null && node.Span == span)

SplitOrMergeIfStatements\AbstractMergeIfStatementsCodeRefactoringProvider.cs (5)

47RegisterRefactoring(MergeDirection.Up, upperIfOrElseIf.Span, ifOrElseIf.Span); 50RegisterRefactoring(MergeDirection.Down, ifOrElseIf.Span, lowerIfOrElseIf.Span); 83node => ifGenerator.IsIfOrElseIf(node) && node.Span == span);

SplitOrMergeIfStatements\AbstractSplitIfStatementCodeRefactoringProvider.cs (3)

53c => RefactorAsync(document, token.Span, ifOrElseIf.Span, c), 55ifOrElseIf.Span); 78node => ifGenerator.IsIfOrElseIf(node) && node.Span == span);

src\roslyn\src\Analyzers\Core\Analyzers\PopulateSwitch\AbstractPopulateSwitchDiagnosticAnalyzer.cs (1)

66if (switchBlock.SyntaxTree.OverlapsHiddenPosition(switchBlock.Span, context.CancellationToken))

src\roslyn\src\Analyzers\Core\Analyzers\RemoveUnnecessaryCast\AbstractRemoveUnnecessaryCastDiagnosticAnalyzer.cs (1)

65if (tree.OverlapsHiddenPosition(node.Span, cancellationToken))

src\roslyn\src\Analyzers\Core\Analyzers\RemoveUnnecessaryImports\AbstractRemoveUnnecessaryImportsDiagnosticAnalyzer.cs (3)

158textSpan = TextSpan.FromBounds(node.Span.Start, nodeEnd); 172textSpan = TextSpan.FromBounds(node.Span.Start, nodeEnd); 186var end = node.Span.End;

src\roslyn\src\Analyzers\Core\Analyzers\RemoveUnusedParametersAndValues\AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.BlockAnalyzer.cs (1)

129if (memberDecl != null && !context.ShouldAnalyzeSpan(memberDecl.Span))

src\roslyn\src\Analyzers\Core\Analyzers\SimplifyInterpolation\AbstractSimplifyInterpolationHelpers.cs (4)

src\roslyn\src\Analyzers\Core\Analyzers\SimplifyLinqExpression\AbstractSimplifyLinqExpressionDiagnosticAnalyzer.cs (1)

186TextSpan.FromBounds(memberName.SpanStart, nextInvocationNode.Span.End)));

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

205if (node is TPropertyDeclaration or TFieldDeclaration && context.ShouldAnalyzeSpan(node.Span, node.SyntaxTree))

src\roslyn\src\Analyzers\Core\Analyzers\UseCollectionInitializer\UseCollectionInitializerHelpers.cs (2)

37syntaxTree.GetLocation(TextSpan.FromBounds(arguments.Last().FullSpan.End, match.Span.End))); 49syntaxTree.GetLocation(TextSpan.FromBounds(expression.FullSpan.End, match.Span.End)));

src\roslyn\src\Analyzers\Core\Analyzers\UseObjectInitializer\AbstractUseObjectInitializerDiagnosticAnalyzer.cs (3)

src\roslyn\src\Analyzers\Core\CodeFixes\AddAnonymousTypeMemberName\AbstractAddAnonymousTypeMemberNameCodeFixProvider.cs (1)

58if (node?.Span != span)

src\roslyn\src\Analyzers\Core\CodeFixes\AddExplicitCast\Fixer.cs (1)

211if (newRoot.FindNode(targetNode.Span).GetAncestorOrThis<TArgumentListSyntax>() is TArgumentListSyntax newArgumentList)

src\roslyn\src\Analyzers\Core\CodeFixes\ConvertToAsync\AbstractConvertToAsyncCodeFixProvider.cs (1)

47node = ancestors.FirstOrDefault(n => n.Span.Contains(span) && n != root);

src\roslyn\src\Analyzers\Core\CodeFixes\Iterator\AbstractIteratorCodeFixProvider.cs (1)

44node = ancestors.FirstOrDefault(n => n.Span.Contains(span) && n != root);

src\roslyn\src\Analyzers\Core\CodeFixes\RemoveUnusedParametersAndValues\AbstractRemoveUnusedValuesCodeFixProvider.cs (1)

845var spansToFormat = originalDeclStatementsToMoveOrRemove.Select(s => s.Span);

src\roslyn\src\Analyzers\Core\CodeFixes\UseAutoProperty\AbstractUseAutoPropertyCodeFixProvider.cs (2)

495.Select(d => (d.SyntaxTree.FilePath, d.Span)) 576if (constructorSpans.Contains((node.SyntaxTree.FilePath, node.Span)))

src\roslyn\src\Analyzers\Core\CodeFixes\UseConditionalExpression\AbstractUseConditionalExpressionCodeFixProvider.cs (3)

166if (condition.Span.Length + trueSyntax.Span.Length + falseSyntax.Span.Length > formattingOptions.ConditionalExpressionWrappingLength)

Testing\AbstractTestMethodFinder.cs (3)

40var intersectingNodes = testNodes.WhereAsArray(node => node.Span.IntersectsWith(textSpan)); 47return testNodes.WhereAsArray(node => node.Parent?.Span.IntersectsWith(textSpan) == true); 110return node.Span.IntersectsWith(textSpan) && DescendIntoChildren(node);

UseNamedArguments\AbstractUseNamedArgumentsCodeRefactoringProvider.cs (3)

115argument.Span); 122argument.Span); 131argument.Span);

Wrapping\AbstractCodeActionComputer.cs (1)

268return (root, rewrittenRoot, trackedNode.Span);

Wrapping\BinaryExpression\BinaryExpressionCodeActionComputer.cs (1)

62OriginalSourceText.GetOffset(binaryExpression.Span.Start)

Wrapping\SeparatedSyntaxList\AbstractSeparatedSyntaxListWrapper.cs (1)

56if (listSyntax == null || listSyntax.Span.IsEmpty)

Wrapping\SeparatedSyntaxList\SeparatedSyntaxListCodeActionComputer.cs (2)

314currentOffset += item.Span.Length; 331currentOffset = indentationTrivia.FullWidth() + item.Span.Length;

Microsoft.CodeAnalysis.ResxSourceGenerator (32)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (5)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Context\FormattingContext.InitialContextFinder.cs (2)

78node.DescendantNodesAndSelf(n => n != previous && n.Span.IntersectsWith(span) && !span.Contains(n.Span))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\FormattingExtensions.cs (2)

28if (node.Parent.Span != node.Span)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Rules\BaseIndentationFormattingRule.cs (1)

41else if (node.Span.Contains(_span))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Helpers\RemoveUnnecessaryImports\AbstractUnnecessaryImportsProvider.cs (3)

47=> x?.Span == y?.Span; 50=> obj.Span.GetHashCode();

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\HeaderFacts\AbstractHeaderFacts.cs (4)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\RefactoringHelpers\AbstractRefactoringHelpers.cs (4)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SelectedMembers\AbstractSelectedMembers.cs (1)

110if (textSpan.Contains(member.Span))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\AbstractDocumentationCommentService.cs (1)

74var sb = new StringBuilder(summaryElement.Span.Length);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\ISyntaxFactsExtensions.cs (6)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)

773!forEachExpression.Span.Contains(OriginalExpression.SpanStart))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\CommonFormattingHelpers.cs (1)

365var endPosition = endToken.RawKind == 0 ? root.Span.End : endToken.Span.End;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\LightweightOverloadResolution.cs (1)

252=> expression.Span.IsEmpty;

Microsoft.CodeAnalysis.VisualBasic (41)

Analysis\FlowAnalysis\AlwaysAssignedWalker.vb (3)

76If IsInsideRegion(branch.Branch.Syntax.Span) AndAlso Not _labelsInside.Contains(branch.Label) Then 85If node.Syntax IsNot Nothing AndAlso IsInsideRegion(node.Syntax.Span) Then 93If IsInside AndAlso pending.Branch IsNot Nothing AndAlso Not IsInsideRegion(pending.Branch.Syntax.Span) Then

Analysis\FlowAnalysis\DataFlowsInWalker.vb (3)

68If stmt.Syntax IsNot Nothing AndAlso labelStmt.Syntax IsNot Nothing AndAlso Not IsInsideRegion(stmt.Syntax.Span) AndAlso IsInsideRegion(labelStmt.Syntax.Span) Then 115If IsInsideRegion(node.Span) Then

Analysis\FlowAnalysis\EntryPointsWalker.vb (2)

48If stmt.Syntax IsNot Nothing AndAlso labelStmt.Syntax IsNot Nothing AndAlso IsInsideRegion(labelStmt.Syntax.Span) AndAlso Not IsInsideRegion(stmt.Syntax.Span) Then

Analysis\FlowAnalysis\ExitPointsWalker.vb (1)

103If IsInsideRegion(pending.Branch.Syntax.Span) Then

Analysis\FlowAnalysis\ReadWriteWalker.vb (7)

110If (Me._regionPlace <> RegionPlace.Inside AndAlso fieldAccess.Syntax.Span.Contains(_region)) Then NoteReceiverRead(fieldAccess) 135If _region.Contains(receiverSyntax.Span) Then readOrWritten.Add(CType(receiver, BoundLocal).LocalSymbol) 137If _region.Contains(receiverSyntax.Span) Then readOrWritten.Add(Me.MeParameter) 139If _region.Contains(receiverSyntax.Span) Then readOrWritten.Add(Me.MeParameter) 141If _region.Contains(receiverSyntax.Span) Then readOrWritten.Add(CType(receiver, BoundParameter).ParameterSymbol) 143If _region.Contains(receiverSyntax.Span) Then readOrWritten.Add(CType(receiver, BoundRangeVariable).RangeVariable) 145If receiver.Type.IsStructureType AndAlso receiverSyntax.Span.OverlapsWith(_region) Then NoteReceiverReadOrWritten(CType(receiver, BoundFieldAccess), readOrWritten)

Analysis\FlowAnalysis\VariablesDeclaredWalker.vb (1)

84If IsInsideRegion(catchBlock.Syntax.Span) Then

Binding\Binder_Invocation.vb (5)

1300If node.SyntaxTree Is groupOpt.Syntax.SyntaxTree AndAlso node.Span.Contains(groupOpt.Syntax.Span) Then 1949If argument.Syntax.Span.Contains(diagnostic.Location.SourceSpan) Then 3152callerInfoValue = ConstantValue.Create(callerInfoOpt.SyntaxTree.GetDisplayPath(callerInfoOpt.Span, Me.Compilation.Options.SourceReferenceResolver)) 3289Return syntax.Span

Binding\Binder_Query.vb (4)

624source.Syntax.Span, 4354source.Syntax.Span, additionalDiagnostics) 4372source.Syntax.Span, additionalDiagnostics) 4395source.Syntax.Span, additionalDiagnostics)

CodeGen\CodeGenerator.vb (1)

295EmitSequencePoint(syntax.SyntaxTree, syntax.Span)

Compilation\SyntaxTreeSemanticModel.vb (1)

868If location.SourceTree Is Me.SyntaxTree AndAlso nodeToCheck.Span.Contains(location.SourceSpan) Then

Lowering\Instrumentation\CodeCoverageInstrumenter.vb (2)

543Return syntax.Span 547Dim originalSpan As Text.TextSpan = syntax.Span

Lowering\Instrumentation\DebugInfoInjector.vb (1)

138sequencePointSpan = TextSpan.FromBounds(original.Syntax.SpanStart, original.Syntax.Span.End)

Symbols\LexicalSortKey.vb (2)

214Return first.Span.Start - second.Span.Start

Syntax\SimpleSyntaxReference.vb (1)

31Return _node.Span

Syntax\SyntaxFacts.vb (1)

202Dim span = node.Span

Syntax\SyntaxNodeRemover.vb (3)

214Me.AddDirectives(node, GetRemovedSpan(node.Span, node.FullSpan)) 240Dim span = TextSpan.FromBounds(token.Span.Start, node.Span.End) 264Dim span = TextSpan.FromBounds(node.Span.Start, token.Span.End)

Syntax\VisualBasicSyntaxNode.vb (3)

142''' Same as accessing <see cref="TextSpan.Start"/> on <see cref="Span"/>. 441Return New EmbeddedTreeLocation(tree.GetEmbeddedKind, Me.Span) 443Return New MyTemplateLocation(tree, Me.Span)

Microsoft.CodeAnalysis.VisualBasic.CodeStyle (8)

src\roslyn\src\Analyzers\VisualBasic\Analyzers\AddAccessibilityModifiers\VisualBasicAddAccessibilityModifiersDiagnosticAnalyzer.vb (1)

43If Not context.ShouldAnalyzeSpan(member.Span) Then

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Extensions\ParenthesizedExpressionSyntaxExtensions.vb (1)

142node.OpenParenToken.Span.End = expression.Span.Start Then

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Extensions\SyntaxNodeExtensions.vb (5)

410Dim parentSpan = trivia.GetStructure().Span 415Dim matchSpan = match.Span 866If declaration.Initializer IsNot Nothing AndAlso declaration.Initializer.Span.Contains(span) Then 873If [property] IsNot Nothing AndAlso [property].Initializer IsNot Nothing AndAlso [property].Initializer.Span.Contains(span) Then 886Dim blockSpan = TextSpan.FromBounds(block.BlockStatement.Span.End, block.EndBlockStatement.SpanStart)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Services\SyntaxFacts\VisualBasicSyntaxFacts.vb (1)

777If useFullSpan OrElse node.Span.Contains(position) Then

Microsoft.CodeAnalysis.VisualBasic.CodeStyle.Fixes (10)

src\roslyn\src\Analyzers\VisualBasic\CodeFixes\GenerateParameterizedMember\GenerateParameterizedMemberCodeFixProvider.vb (2)

62If node.Span.Start = diagnosticSpan.Start AndAlso node.Span.End < diagnosticSpan.End Then

src\roslyn\src\Analyzers\VisualBasic\CodeFixes\GenerateParameterizedMember\VisualBasicGenerateConversionService.vb (5)

33Return node.AncestorsAndSelf.Where(AddressOf IsCastExpression).Where(Function(n) n.Span.Contains(node.Span)).Any 44Return node.AncestorsAndSelf.Where(Function(n) n.IsKind(SyntaxKind.ImplementsClause)).Where(Function(n) n.Span.Contains(node.Span)).Any 48Return node.AncestorsAndSelf.Where(Function(n) n.IsKind(SyntaxKind.SimpleMemberAccessExpression)).Where(Function(n) n.Span.Contains(node.Span)).Any 84Dim castExpression = TryCast(expression.AncestorsAndSelf.Where(AddressOf IsCastExpression).Where(Function(n) n.Span.Contains(expression.Span)).FirstOrDefault, CastExpressionSyntax) 95expression = TryCast(expression.AncestorsAndSelf.Where(Function(n) TypeOf n Is ExpressionSyntax And n.Span.Contains(expression.Span)).FirstOrDefault, ExpressionSyntax)

src\roslyn\src\Analyzers\VisualBasic\CodeFixes\Iterator\VisualBasicConvertToIteratorCodeFixProvider.vb (1)

62Dim symbol = model.GetEnclosingSymbol(node.Span.Start, cancellationToken)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\CodeGeneration\VisualBasicCodeGenerationService.vb (1)

85TextSpan.FromBounds(destination.Members.Last.Span.End, destination.EndOfFileToken.SpanStart), cancellationToken))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\Extensions\TypeBlockSyntaxExtensions.vb (1)

19Dim start = destination.BlockStatement.Span.End

Microsoft.CodeAnalysis.VisualBasic.Features (102)

ChangeSignature\VisualBasicChangeSignatureService.vb (1)

110If Not matchingNode.Span.IntersectsWith(position) Then

CodeFixes\CorrectNextControlVariable\CorrectNextControlVariableCodeFixProvider.vb (1)

51Dim indexOfControlVariable = nextStatement.ControlVariables.IndexOf(Function(n) n.Span.Contains(context.Span))

CodeFixes\GenerateEndConstruct\GenerateEndConstructCodeFixProvider.vb (2)

124Return begin.Span.Contains(node.Span)

CodeFixes\MoveToTopOfFile\MoveToTopOfFileCodeFixProvider.vb (1)

98node.Span.End > m.SpanStart)

CodeFixes\OverloadBase\OverloadBaseCodeFixProvider.AddKeywordAction.vb (1)

74newNode = Await cleanupService.CleanupAsync(newNode, ImmutableArray.Create(newNode.Span), options, services, cleanupService.GetDefaultProviders(), cancellationToken).ConfigureAwait(False)

CodeRefactorings\InlineTemporary\VisualBasicInlineTemporaryCodeRefactoringProvider.vb (1)

65variableDeclarator.Span)

Debugging\DataTipInfoGetter.vb (1)

60Dim span = expression.Span

EditAndContinue\BreakpointSpans.vb (8)

92Return TextSpan.FromBounds(node.SpanStart, node.Span.End) 100Return TextSpan.FromBounds(list.First.SpanStart, list.Last.Span.End) 237Return TextSpan.FromBounds(methodBase.DeclarationKeyword.SpanStart, methodBase.Span.End) 240Return TextSpan.FromBounds(methodBase.Modifiers.First().SpanStart, methodBase.Span.End) 250Return TextSpan.FromBounds(node.Identifier.Span.Start, node.Initializer.Span.End) 254Return TextSpan.FromBounds(node.Identifier.Span.Start, node.AsClause.Span.End) 417Return TextSpan.FromBounds(clause.Keys.First.SpanStart, clause.Span.End) 429Return clause.Variables(GetItemIndexByPosition(clause.Variables, position)).Expression.Span

EditAndContinue\DeclarationBody\FieldOrPropertyDeclarationBody.vb (1)

123Return InitializerActiveStatement.Span

EditAndContinue\DeclarationBody\FieldWithMultipleAsNewClauseDeclarationBody.vb (4)

42Return TextSpan.FromBounds(_modifedIdentifier.Span.Start, NewExpression.Span.End) 48Return TextSpan.FromBounds(_modifedIdentifier.Span.End, NewExpression.Span.Start).Contains(span)

EditAndContinue\DeclarationBody\PropertyWithInitializerDeclarationBody.vb (1)

36Return TextSpan.FromBounds(PropertyStatement.Identifier.Span.Start, PropertyStatement.Initializer.Span.End)

EditAndContinue\DeclarationBody\PropertyWithNewClauseDeclarationBody.vb (1)

42Return TextSpan.FromBounds(PropertyStatement.Identifier.Span.Start, PropertyStatement.AsClause.Span.End)

EditAndContinue\VisualBasicEditAndContinueAnalyzer.vb (27)

EncapsulateField\VisualBasicEncapsulateFieldService.vb (1)

75Dim fields = root.DescendantNodes(Function(n) n.Span.IntersectsWith(span)) _

ExtractMethod\Extensions.vb (9)

74Dim firstContainingSpan = initialNode.Span 85Loop While node IsNot Nothing AndAlso node.Span.Equals(firstContainingSpan) 113Return equal.Value IsNot Nothing AndAlso equal.Value.Span.Contains(node.Span) 121If argument Is Nothing OrElse node.Span <> argument.Span Then 189If Not textSpan.Contains(directive.Span) Then 273If range.UpperBound.Span.Contains(token.Span) AndAlso 283Dim span = TextSpan.FromBounds(asNewClause.NewExpression.NewKeyword.Span.End, asNewClause.NewExpression.Span.End) 320Dim blockSpan = TextSpan.FromBounds(block.BlockStatement.Span.End, block.EndBlockStatement.SpanStart)

GenerateType\VisualBasicGenerateTypeService.vb (2)

392simpleName.Span.End <= t.Members.Last().Span.End) 445semanticModel.SyntaxTree.GetLocation(New TextSpan(lastMember.Span.End, 0)))

Highlighting\KeywordHighlighters\MultiLineIfBlockHighlighter.vb (1)

51highlights.Add(ifBlock.EndIfStatement.Span)

Highlighting\KeywordHighlighters\TryBlockHighlighter.vb (1)

59highlights.Add(node.Span)

Highlighting\KeywordHighlightingHelpers.vb (2)

22highlights.Add(.Span) 28highlights.Add(.Span)

InlineHints\VisualBasicInlineParameterNameHintsService.vb (1)

55buffer.Add((argument.Span.Start, argument, parameter, GetKind(argument.Expression)))

LanguageServices\VisualBasicSymbolDisplayService.SymbolDescriptionBuilder.vb (1)

160LanguageServices, semanticModel, equalsValue.Value.Span, Options.ClassificationOptions, CancellationToken).ConfigureAwait(False)

SignatureHelp\AttributeSignatureHelpProvider.vb (1)

47node.ArgumentList.Span.Contains(token.SpanStart) AndAlso

SignatureHelp\CastExpressionSignatureHelpProvider.vb (1)

47Return node.Span.Contains(token.SpanStart) AndAlso

SignatureHelp\CollectionInitializerSignatureHelpProvider.vb (1)

42Return expression.Span.Contains(token.SpanStart) AndAlso token <> expression.CloseBraceToken

SignatureHelp\ConditionalExpressionSignatureHelpProvider.vb (1)

33Return node.Span.Contains(token.SpanStart) AndAlso

SignatureHelp\GenericNameSignatureHelpProvider.vb (1)

56Return node.TypeArgumentList.Span.Contains(token.SpanStart) AndAlso

SignatureHelp\InvocationExpressionSignatureHelpProvider.vb (1)

58node.ArgumentList.Span.Contains(token.SpanStart) AndAlso

SignatureHelp\MidAssignmentSignatureHelpProvider.vb (1)

40DirectCast(node.Left, MidExpressionSyntax).ArgumentList.Span.Contains(token.SpanStart) AndAlso

SignatureHelp\ObjectCreationExpressionSignatureHelpProvider.vb (1)

57node.ArgumentList.Span.Contains(token.SpanStart) AndAlso

SignatureHelp\RaiseEventStatementSignatureHelpProvider.vb (1)

56statement.ArgumentList.Span.Contains(token.SpanStart) AndAlso

SolutionCrawler\VisualBasicDocumentDifferenceService.vb (4)

44Return [enum].Initializer IsNot Nothing AndAlso ContainsExclusively([enum].Initializer.Span, span) 49Return propStatement.Initializer IsNot Nothing AndAlso ContainsExclusively(propStatement.Initializer.Span, span) 65Return TextSpan.FromBounds(list.First.SpanStart, list.Last.Span.End) 70Return TextSpan.FromBounds(list.First.SpanStart, list.Last.Span.End)

src\roslyn\src\Analyzers\VisualBasic\Analyzers\AddAccessibilityModifiers\VisualBasicAddAccessibilityModifiersDiagnosticAnalyzer.vb (1)

43If Not context.ShouldAnalyzeSpan(member.Span) Then

src\roslyn\src\Analyzers\VisualBasic\CodeFixes\GenerateParameterizedMember\GenerateParameterizedMemberCodeFixProvider.vb (2)

62If node.Span.Start = diagnosticSpan.Start AndAlso node.Span.End < diagnosticSpan.End Then

src\roslyn\src\Analyzers\VisualBasic\CodeFixes\GenerateParameterizedMember\VisualBasicGenerateConversionService.vb (5)

src\roslyn\src\Analyzers\VisualBasic\CodeFixes\Iterator\VisualBasicConvertToIteratorCodeFixProvider.vb (1)

62Dim symbol = model.GetEnclosingSymbol(node.Span.Start, cancellationToken)

Structure\Providers\CollectionInitializerStructureProvider.vb (1)

40node.Span.End)

Structure\Providers\CompilationUnitStructureProvider.vb (1)

24Dim endPos = compilationUnit.Imports.Last().Span.End

Structure\Providers\InterpolatedStringExpressionStructureProvider.vb (1)

27textSpan:=node.Span,

Structure\Providers\ObjectCreationInitializerStructureProvider.vb (2)

34textSpan:=TextSpan.FromBounds(previousToken.Span.End, node.Span.End), 35hintSpan:=node.Parent.Span,

Structure\Providers\StringLiteralExpressionStructureProvider.vb (1)

24textSpan:=node.Span,

Structure\Providers\XmlExpressionStructureProvider.vb (1)

24Dim span = xmlExpression.Span

Structure\VisualBasicStructureHelpers.vb (4)

191blockNode.Span, GetHintSpan(blockNode), 203blockNode.Span, GetHintSpan(blockNode), 218Return TextSpan.FromBounds(child.SpanStart, blockNode.Span.End) 223Return blockNode.Span

Wrapping\SeparatedSyntaxList\VisualBasicCollectionCreationExpressionWrapper.vb (1)

66Return listSyntax.Span.Contains(position)

Microsoft.CodeAnalysis.VisualBasic.Workspaces (52)

Classification\Worker.DocumentationCommentClassifier.vb (1)

19If Not _worker._textSpan.OverlapsWith(documentationComment.Span) Then

Classification\Worker.vb (1)

171If Not _textSpan.OverlapsWith(skippedTokens.Span) Then

CodeCleanup\Providers\AddMissingTokensCodeCleanupProvider.vb (2)

333Dim span = originalNode.Span 568Return node IsNot Nothing AndAlso node.Span.Length > 0

CodeCleanup\Providers\NormalizeModifiersOrOperatorsCodeCleanupProvider.vb (3)

202Dim span = node.Span 242Dim span = node.Span 454Dim span = originalNode.Span

CodeGeneration\VisualBasicSyntaxGenerator.vb (8)

3331If root.Span.Contains(declaration.Span) Then 3411If root.Span.Contains(declaration.Span) Then 3437If root.Span.Contains(declaration.Span) Then 3551If root.Span.Contains(declaration.Span) Then

Rename\VisualBasicRenameRewriterLanguageService.vb (6)

169_conflictLocations.Contains(node.Span) AndAlso 179If Me._complexifiedSpans.Contains(originalNode.Span) Then 182Me._complexifiedSpans.Add(originalNode.Span) 200Dim oldSpan = originalNode.Span 233Dim newSpan = expandedNewNode.Span 249If Me._conflictLocations.Contains(node.Span) Then

Simplification\Reducers\VisualBasicVariableDeclaratorReducer.vb (2)

106issueSpan = variableDeclarator.Span 134issueSpan = variableDeclarator.Span

Simplification\Simplifiers\AbstractVisualBasicSimplifier.vb (1)

171boundSymbols = semanticModel.LookupNamespacesAndTypes(node.Span.Start, name:=aliasName + "Attribute")

Simplification\Simplifiers\ExpressionSimplifier.vb (8)

39issueSpan = memberAccessExpression.Expression.Span 92issueSpan = memberAccess.Span 119issueSpan = memberAccess.Span 124issueSpan = memberAccess.Expression.Span 143issueSpan = memberAccess.Span 158issueSpan = memberAccess.Expression.Span 261issueSpan = left.Span 281issueSpan = memberAccess.Name.Span

Simplification\Simplifiers\NameSimplifier.vb (10)

49issueSpan = genericName.TypeArgumentList.Span 66issueSpan = name.Span 103issueSpan = name.Span 111issueSpan = qualifiedName.Left.Span 181issueSpan = name.Span 209issueSpan = name.Span 231issueSpan = qualifiedName.Left.Span 336issueSpan = name.Right.Span 375issueSpan = New TextSpan(name.Span.End - 9, 9) 456Return Not name.Span.Contains(argumentDecl.Span)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Extensions\ParenthesizedExpressionSyntaxExtensions.vb (1)

142node.OpenParenToken.Span.End = expression.Span.Start Then

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Extensions\SyntaxNodeExtensions.vb (5)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Services\SyntaxFacts\VisualBasicSyntaxFacts.vb (1)

777If useFullSpan OrElse node.Span.Contains(position) Then

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\CodeGeneration\VisualBasicCodeGenerationService.vb (1)

85TextSpan.FromBounds(destination.Members.Last.Span.End, destination.EndOfFileToken.SpanStart), cancellationToken))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\Extensions\TypeBlockSyntaxExtensions.vb (1)

19Dim start = destination.BlockStatement.Span.End

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

26Return _node.Span

Microsoft.CodeAnalysis.Workspaces (59)

CodeCleanup\AbstractCodeCleanerService.cs (2)

205return TryCreateTextSpan(GetPreviousTokenStartPosition(previousTokenMarker.Type, previousToken), node.Span.End, out span); 226span = TextSpan.FromBounds(GetPreviousTokenStartPosition(previousTokenMarker.Type, previousToken), node.Span.End);

Differencing\AbstractSyntaxComparer.cs (1)

49=> node.Span;

FindSymbols\FindReferences\Finders\ImplicitConstructorInitializerSymbolReferenceFinder.cs (1)

75constructor.Locations.First(loc => loc.SourceTree == constructorNode.SyntaxTree && constructorNode.Span.IntersectsWith(loc.SourceSpan)),

LanguageServices\DeclaredSymbolFactoryService\AbstractDeclaredSymbolInfoFactoryService.cs (1)

333nameSyntax.Span,

ObsoleteSymbol\AbstractObsoleteSymbolService.cs (1)

72if (current.Span.IntersectsWith(span))

ReassignedVariable\AbstractReassignedVariableService.cs (3)

77if (current.Span.IntersectsWith(span)) 131result.Add(identifier.Span); 285localDeclaration.Span,

Recommendations\AbstractRecommendationServiceRunner.cs (1)

353declarationSyntax.Span.IntersectsWith(candidateLocation.SourceSpan)), declarationSyntax);

Rename\ConflictEngine\ConflictResolver.Session.cs (1)

430ComplexifiedTargetSpan: complexifiedTarget != null ? complexifiedTarget.Span : default));

Rename\ConflictEngine\RenamedSpansTracker.cs (1)

204AddComplexifiedSpan(documentId, oldSpan, node.Span, modifiedSubSpans);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (5)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Context\FormattingContext.InitialContextFinder.cs (2)

78node.DescendantNodesAndSelf(n => n != previous && n.Span.IntersectsWith(span) && !span.Contains(n.Span))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\FormattingExtensions.cs (2)

28if (node.Parent.Span != node.Span)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Rules\BaseIndentationFormattingRule.cs (1)

41else if (node.Span.Contains(_span))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Helpers\RemoveUnnecessaryImports\AbstractUnnecessaryImportsProvider.cs (3)

47=> x?.Span == y?.Span; 50=> obj.Span.GetHashCode();

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\HeaderFacts\AbstractHeaderFacts.cs (4)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\RefactoringHelpers\AbstractRefactoringHelpers.cs (4)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SelectedMembers\AbstractSelectedMembers.cs (1)

110if (textSpan.Contains(member.Span))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\AbstractDocumentationCommentService.cs (1)

74var sb = new StringBuilder(summaryElement.Span.Length);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\ISyntaxFactsExtensions.cs (6)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)

773!forEachExpression.Span.Contains(OriginalExpression.SpanStart))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\CommonFormattingHelpers.cs (1)

365var endPosition = endToken.RawKind == 0 ? root.Span.End : endToken.Span.End;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\LightweightOverloadResolution.cs (1)

252=> expression.Span.IsEmpty;

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

222var beforeMember = declarationList.FirstOrDefault(m => m.Span.End >= info.Context.BeforeThisLocation.SourceSpan.End);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeRefactorings\CodeRefactoringHelpers.cs (6)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.State.cs (1)

172var affectedSpan = TextSpan.FromBounds(previousToken.SpanStart, FirstStatementAffectedInInnermostBlock.Span.End);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\RemoveUnnecessaryImports\AbstractRemoveUnnecessaryImportsService.cs (3)

44=> x?.Span == y?.Span; 47=> obj.Span.GetHashCode();

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Simplification\Simplifiers\AbstractMemberAccessExpressionSimplifier.cs (1)

71return !semanticModel.SyntaxTree.OverlapsHiddenPosition(memberAccessExpression.Span, cancellationToken) &&

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\NullableHelpers.cs (3)

Microsoft.Maui.Controls.BindingSourceGen (1)

BindingSourceGenerator.cs (1)

161 NullableContext nullableContext = context.SemanticModel.GetNullableContext(context.Node.Span.Start);

Microsoft.ML.InternalCodeAnalyzer (2)

ContractsCheckNameofFixProvider.cs (2)

92if (candidate.Span.Length < shortestSymbol) 95shortestSymbol = candidate.Span.Length;

Roslyn.Diagnostics.Analyzers (49)

AbstractApplyTraitToClass`1.cs (2)

86.Single(attributeData => attributeData.ApplicationSyntaxReference is not null && attribute.Span.Contains(attributeData.ApplicationSyntaxReference.Span)); 106.Single(attributeData => attributeData.ApplicationSyntaxReference is not null && attribute.Span.Contains(attributeData.ApplicationSyntaxReference.Span));

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (5)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Context\FormattingContext.InitialContextFinder.cs (2)

78node.DescendantNodesAndSelf(n => n != previous && n.Span.IntersectsWith(span) && !span.Contains(n.Span))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\FormattingExtensions.cs (2)

28if (node.Parent.Span != node.Span)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\Rules\BaseIndentationFormattingRule.cs (1)

41else if (node.Span.Contains(_span))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Helpers\RemoveUnnecessaryImports\AbstractUnnecessaryImportsProvider.cs (3)

47=> x?.Span == y?.Span; 50=> obj.Span.GetHashCode();

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\HeaderFacts\AbstractHeaderFacts.cs (4)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\RefactoringHelpers\AbstractRefactoringHelpers.cs (4)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SelectedMembers\AbstractSelectedMembers.cs (1)

110if (textSpan.Contains(member.Span))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\AbstractDocumentationCommentService.cs (1)

74var sb = new StringBuilder(summaryElement.Span.Length);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\ISyntaxFactsExtensions.cs (6)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (1)

773!forEachExpression.Span.Contains(OriginalExpression.SpanStart))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\CommonFormattingHelpers.cs (1)

365var endPosition = endToken.RawKind == 0 ? root.Span.End : endToken.Span.End;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\LightweightOverloadResolution.cs (1)

252=> expression.Span.IsEmpty;

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

222var beforeMember = declarationList.FirstOrDefault(m => m.Span.End >= info.Context.BeforeThisLocation.SourceSpan.End);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeRefactorings\CodeRefactoringHelpers.cs (6)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.State.cs (1)

172var affectedSpan = TextSpan.FromBounds(previousToken.SpanStart, FirstStatementAffectedInInnermostBlock.Span.End);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\RemoveUnnecessaryImports\AbstractRemoveUnnecessaryImportsService.cs (3)

44=> x?.Span == y?.Span; 47=> obj.Span.GetHashCode();

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Simplification\Simplifiers\AbstractMemberAccessExpressionSimplifier.cs (1)

71return !semanticModel.SyntaxTree.OverlapsHiddenPosition(memberAccessExpression.Span, cancellationToken) &&

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\NullableHelpers.cs (3)

Roslyn.Diagnostics.CSharp.Analyzers (16)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\EmbeddedLanguages\VirtualChars\CSharpVirtualCharService.cs (1)

187var indentationLength = parentSourceText.Lines.GetLineFromPosition(parentExpression.Span.End).GetFirstNonWhitespaceOffset() ?? 0;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\BlockSyntaxExtensions.cs (3)

86conditionalDirectives.Last().Span.End >= block.CloseBraceToken.Span.End) 92if (conditionalDirectives.Last().Span.End <= statement.Span.Start)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\SyntaxNodeExtensions.cs (1)

561var matchSpan = match.Span;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Formatting\Engine\Trivia\CSharpTriviaFormatter.DocumentationCommentExteriorCommentRewriter.cs (1)

75trivia.Span.End == currentParent.Span.End)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Services\SyntaxFacts\CSharpSyntaxFacts.cs (2)

722if (useFullSpan || node.Span.Contains(position)) 936if (node.Span.IsEmpty)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\CompilationUnitSyntaxExtensions.cs (3)

43var end = usings.Last().Span.End; 52var end = rootUsings.Last().Span.End; 60: root.Span.End;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\ContextQuery\CSharpSyntaxContext.cs (1)

504lockStatement.Statement.Span.Contains(position))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\ContextQuery\SyntaxTreeExtensions.cs (1)

690return declaration?.Name.Span.IntersectsWith(position) == true;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\TypeDeclarationSyntaxExtensions.cs (1)

46start = members.Last().Span.End;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\CSharpRemoveUnnecessaryImportsService.cs (1)

67spansToFormat.Add(TextSpan.FromBounds(baseNamespace.Name.Span.End, firstMemberB.SpanStart));

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\CSharpTypeInferenceService.TypeInferrer.cs (1)

2295if (descendant.SpanStart <= afterNode.Span.End)

Roslyn.Diagnostics.VisualBasic.Analyzers (9)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Extensions\ParenthesizedExpressionSyntaxExtensions.vb (1)

142node.OpenParenToken.Span.End = expression.Span.Start Then

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Extensions\SyntaxNodeExtensions.vb (5)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Services\SyntaxFacts\VisualBasicSyntaxFacts.vb (1)

777If useFullSpan OrElse node.Span.Contains(position) Then

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\CodeGeneration\VisualBasicCodeGenerationService.vb (1)

85TextSpan.FromBounds(destination.Members.Last.Span.End, destination.EndOfFileToken.SpanStart), cancellationToken))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\Extensions\TypeBlockSyntaxExtensions.vb (1)

19Dim start = destination.BlockStatement.Span.End

SuperFileCheck (2)

Program.cs (2)

191throw new SuperFileCheckException($"Unable to find enclosing type declaration on: {node.Span}"); 290return !x.Token.Parent.Ancestors().Any(p => p.IsKind(SyntaxKind.MethodDeclaration) && p.Span.Contains(x.Span));