Span

InheritanceMargin\BenchmarksHelpers.cs (1)

30document, root.Span, includeGlobalImports: true, frozenPartialSemantics: true, cancellationToken).ConfigureAwait(false);

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)

1429_isGeneratedCodeLocation(node.SyntaxTree, node.Span)) 1441_isGeneratedCodeLocation(operation.Syntax.SyntaxTree, operation.Syntax.Span))

Operations\OperationExtensions.cs (1)

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

Syntax\SyntaxList`1.cs (2)

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

Syntax\SyntaxNode.cs (2)

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

Syntax\SyntaxNodeOrToken.cs (1)

237return _nodeOrParent.Span;

Syntax\SyntaxNodeOrTokenList.cs (1)

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

AbstractDocumentationCommentService.cs (1)

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

AbstractHeaderFacts.cs (4)

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

AbstractPopulateSwitchDiagnosticAnalyzer.cs (1)

57!tree.OverlapsHiddenPosition(switchBlock.Span, context.CancellationToken))

AbstractRemoveUnnecessaryCastDiagnosticAnalyzer.cs (1)

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

AbstractRemoveUnnecessaryImportsDiagnosticAnalyzer.cs (3)

102textSpan = TextSpan.FromBounds(node.Span.Start, nodeEnd); 116textSpan = TextSpan.FromBounds(node.Span.Start, nodeEnd); 130var end = node.Span.End;

AbstractSelectedMembers.cs (1)

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

AbstractSimplifyInterpolationHelpers.cs (3)

97unnecessarySpans.AddRange(invocation.Syntax.Span 112unnecessarySpans.AddRange(invocation.Syntax.Span 220unnecessarySpans.AddRange(invocation.Syntax.Span

AbstractSpeculationAnalyzer.cs (1)

727!forEachExpression.Span.Contains(_expression.SpanStart))

AbstractUnnecessaryImportsProvider.cs (3)

25=> x?.Span == y?.Span; 28=> obj.Span.GetHashCode();

AbstractUseCollectionInitializerDiagnosticAnalyzer.cs (1)

150syntaxTree.GetLocation(TextSpan.FromBounds(arguments.Last().FullSpan.End, match.Span.End)));

AbstractUseObjectInitializerDiagnosticAnalyzer.cs (3)

133: syntaxFacts.GetExpressionOfMemberAccessExpression(match.MemberAccessExpression)!.Span.End; 138if (match.Statement.Span.End > match.Initializer.FullSpan.End) 146syntaxTree.GetLocation(TextSpan.FromBounds(match.Initializer.FullSpan.End, match.Statement.Span.End)))));

BaseIndentationFormattingRule.cs (1)

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

CommonFormattingHelpers.cs (1)

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

FormattingContext.InitialContextFinder.cs (2)

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

FormattingExtensions.cs (2)

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

ISyntaxFactsExtensions.cs (6)

166var span = TextSpan.FromBounds(nodes.First().Span.Start, nodes.Last().Span.End); 181=> ContainsInterleavedDirective(syntaxFacts, node.Span, node, cancellationToken); 457var endOfAttributeLists = attributeList.Last().Span.End; 460var endOfNode = node.Span.End; 466return node.Span;

SyntaxNodeExtensions.cs (5)

185=> node.Span.Length; 318var fullSpan = nodes.First().Span; 323Math.Max(fullSpan.End, node.Span.End)); 330=> node.OverlapsHiddenPosition(node.Span, cancellationToken); 337var start = startNode.Span.End;

AbstractAddAnonymousTypeMemberNameCodeFixProvider.cs (1)

59if (node?.Span != span)

AbstractConvertToAsyncCodeFixProvider.cs (1)

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

AbstractIteratorCodeFixProvider.cs (1)

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

AbstractMoveDeclarationNearReferenceService.State.cs (1)

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

AbstractRemoveUnnecessaryImportsService.cs (3)

48=> x?.Span == y?.Span; 51=> obj.Span.GetHashCode();

AbstractRemoveUnusedValuesCodeFixProvider.cs (1)

840rootWithTrackedNodes = FormatterHelper.Format(rootWithTrackedNodes, originalDeclStatementsToMoveOrRemove.Select(s => s.Span), provider, options, rules: null, cancellationToken);

AbstractUseConditionalExpressionCodeFixProvider.cs (3)

158if (condition.Span.Length + trueSyntax.Span.Length + falseSyntax.Span.Length > wrappingLength)

CodeGenerationHelpers.cs (1)

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

Fixer.cs (1)

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

Binder\Binder_Expressions.cs (1)

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

Binder\Binder_Query.cs (1)

731SourceLocation 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)

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

Binder\BinderFactory.BinderFactoryVisitor.cs (4)

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

CodeGen\CodeGenerator.cs (1)

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

CodeGen\EmitStatement.cs (1)

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

Compilation\CSharpCompilation.cs (5)

224return IsNullableAnalysisEnabledIn((CSharpSyntaxTree)syntax.SyntaxTree, syntax.Span); 2513TryAdd(new ImportInfo(syntax.SyntaxTree, syntax.Kind(), syntax.Span), default); 2519_lazyImportInfos.TryUpdate(new ImportInfo(syntax.SyntaxTree, syntax.Kind(), syntax.Span), dependencies, default); 4260return loc1.Span.Start - loc2.Span.Start;

Compilation\CSharpSemanticModel.cs (3)

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

Compilation\SpeculativeSemanticModelWithMemberModel.cs (3)

151!Root.Span.Contains(attributeOrParameter.Span)) 185if (defaultValueSyntax != null && defaultValueSyntax.FullSpan.Contains(node.Span))

Compilation\SyntaxTreeSemanticModel.cs (10)

769return ((CSharpSyntaxTree)speculativeSyntax.SyntaxTree).IsNullableAnalysisEnabled(speculativeSyntax.Span) ?? 844var span = node.Span; 1344var symbol = (NamespaceSymbol)GetDeclaredMember(container, declarationSyntax.Span, declarationSyntax.Name); 1407return GetDeclaredMember(container, declarationSyntax.Span, name) as NamedTypeSymbol; 1596return (this.GetDeclaredMember(container, declarationSyntax.Span) as MethodSymbol).GetPublicSymbol(); 1619return (this.GetDeclaredMember(container, declarationSyntax.Span) as MethodSymbol).GetPublicSymbol(); 1830var result = this.GetDeclaredMember(container, declarationSyntax.Span, declarationSyntax.Identifier.ValueText); 1923if (alias.Alias.Locations[0].SourceSpan == declarationSyntax.Alias.Name.Span) 2175if (location.SourceTree == this.SyntaxTree && parameter.Span.Contains(location.SourceSpan)) 2346return this.GetDeclaredMember(container, declarationSyntax.Span, name);

Compiler\UnprocessedDocumentationCommentFinder.cs (1)

56if (node.Span.Length > 0)

CSharpDeclarationComputer.cs (1)

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

FlowAnalysis\AbstractFlowPass.cs (1)

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

FlowAnalysis\AlwaysAssignedWalker.cs (3)

84if (IsInside && pending.Branch != null && !RegionContains(pending.Branch.Syntax.Span)) 106if (node.Syntax != null && RegionContains(node.Syntax.Span)) _labelsInside.Add(label); 136if (branch.Branch != null && RegionContains(branch.Branch.Syntax.Span) && !_labelsInside.Contains(branch.Label))

FlowAnalysis\ControlFlowPass.cs (1)

266statement.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)

1173(symbol.Locations.Length == 0 || node.Span.End < symbol.Locations.FirstOrNone().SourceSpan.Start))

FlowAnalysis\EntryPointsWalker.cs (2)

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

142if (!IsInside && node.Span.Contains(RegionSpan) && (expr.Kind == BoundKind.FieldAccess)) 176if (RegionContains(receiverSyntax.Span)) 182if (RegionContains(receiverSyntax.Span)) 188if (RegionContains(receiverSyntax.Span)) 194if (RegionContains(receiverSyntax.Span)) 200if (RegionContains(receiverSyntax.Span)) 206if (receiver.Type.IsStructType() && receiverSyntax.Span.OverlapsWith(RegionSpan)) 237if (!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 (4)

234return new BoundSequencePointWithSpan(forEachSyntax, base.InstrumentForEachStatementDeconstructionVariablesDeclaration(original, iterationVarDecl), forEachSyntax.Variable.Span); 280iterationVarDeclSpan = forEachSyntax.Variable.Span; 375(switchSyntax.CloseParenToken != default) ? switchSyntax.CloseParenToken.Span.End : switchSyntax.Expression.Span.End); 392span: whenClause.Span);

Lowering\Instrumentation\DebugInfoInjector_SequencePoints.cs (5)

32int end = declarationSyntax.Initializer.Span.End; 42int start = usingSyntax.Span.Start; 144part = TextSpan.FromBounds(declarationSyntax.SpanStart, declaratorSyntax.Span.End); 177end = declarationSyntax.Parent.Span.End; 183end = declaratorSyntax.Span.End;

Lowering\LocalRewriter\LocalRewriter_SwitchExpression.cs (1)

77var spanEnd = syntax.Span.End;

SymbolDisplay\SymbolDisplayVisitor_Minimal.cs (1)

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

Symbols\NamespaceOrTypeSymbol.cs (1)

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

Symbols\Source\SourceConstructorSymbol.cs (4)

192if (ctorSyntax.Body?.Span.Contains(position) == true) 194offset = position - ctorSyntax.Body.Span.Start; 197else if (ctorSyntax.ExpressionBody?.Span.Contains(position) == true) 199offset = position - ctorSyntax.ExpressionBody.Span.Start;

Symbols\Source\SourceConstructorSymbolBase.cs (1)

220span = ctorInitializer.Span;

Symbols\Source\SourceMemberContainerSymbol.cs (3)

2917Debug.Assert(declaredMembers.DeclarationWithParameters.Span.Contains(InstanceInitializersForPositionalMembers[0].Syntax.Span.Start)); 2943declaredMembers.DeclarationWithParameters.Span.Contains(declaredMembers.InstanceInitializers[insertAt][0].Syntax.Span.Start)) 2965declaredMembers.DeclarationWithParameters.Span.Contains(g[0].Syntax.Span.Start)));

Symbols\Source\SourceMemberFieldSymbol.cs (1)

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

Symbols\Source\SourceMemberMethodSymbol.cs (2)

1024if (blockBody?.Span.Contains(localPosition) == true) 1028else if (expressionBody?.Span.Contains(localPosition) == true)

Symbols\Synthesized\SynthesizedSimpleProgramEntryPointSymbol.cs (1)

271if (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)

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

ConvertToFileScopedNamespaceDiagnosticAnalyzer.cs (1)

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

CSharpAddBracesDiagnosticAnalyzer.cs (2)

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

CSharpAsAndNullCheckDiagnosticAnalyzer.Analyzer.cs (4)

150if (forStatement.Condition is null || !forStatement.Condition.Span.Contains(_comparison.Span)) 314var scopeSpan = scope.Span; 328if (descendentNodeSpanStart >= comparisonSpanStart && scopeSpan.Contains(descendentNode.Span))

CSharpAsAndNullCheckDiagnosticAnalyzer.cs (2)

217descendentNode.Span.IntersectsWith(comparisonEnclosingBlock.Span) &&

CSharpInlineDeclarationDiagnosticAnalyzer.cs (3)

329var localStatementStart = localStatement.Span.Start; 330var argumentNodeStart = argumentNode.Span.Start; 338var descendentStart = descendentNode.Span.Start;

CSharpRemoveUnnecessaryCastDiagnosticAnalyzer.cs (1)

31node is BinaryExpressionSyntax binary ? TextSpan.FromBounds(binary.OperatorToken.SpanStart, node.Span.End) : throw ExceptionUtilities.Unreachable();

CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs (2)

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

CSharpRemoveUnnecessaryNullableDirectiveDiagnosticAnalyzer.cs (6)

128|| !possibleNullableImpactIntervalTree.HasIntervalThatOverlapsWith(currentOptionsDirective.Span.End, nullableDirectiveTrivia.SpanStart - currentOptionsDirective.Span.End)) 149possibleNullableImpactIntervalTree.AddIntervalInPlace(directive.Span); 160|| !possibleNullableImpactIntervalTree.HasIntervalThatOverlapsWith(currentOptionsDirective.Span.End, root.Span.End - currentOptionsDirective.Span.End))

CSharpSyntaxFacts.cs (6)

709if (useFullSpan || node.Span.Contains(position)) 934if (node.Span.IsEmpty) 965(constructor.Initializer != null && constructor.Initializer.Span.Contains(span)); 969return property.AccessorList != null && property.AccessorList.Span.Contains(span); 971return @enum.EqualsValue != null && @enum.EqualsValue.Span.Contains(span); 973return field.Declaration != null && field.Declaration.Span.Contains(span);

CSharpTriviaFormatter.DocumentationCommentExteriorCommentRewriter.cs (1)

76trivia.Span.End == currentParent.Span.End)

CSharpTypeStyleDiagnosticAnalyzerBase.cs (1)

73context.ReportDiagnostic(CreateDiagnostic(descriptor, declarationStatement, declaredType.StripRefIfNeeded().Span, typeStyle.Severity));

CSharpUseLocalFunctionDiagnosticAnalyzer.cs (1)

212var descendentStart = descendentNode.Span.Start;

CSharpUseRangeOperatorDiagnosticAnalyzer.cs (1)

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

CSharpVirtualCharService.cs (1)

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

InvokeDelegateWithConditionalAccessAnalyzer.cs (7)

134Location.Create(tree, ifStatement.Span), 135Location.Create(tree, expressionStatement.Span)); 200if (nextToken.Span.Start < ifStatement.Span.End) 202fadeLocation = Location.Create(tree, TextSpan.FromBounds(nextToken.Span.Start, ifStatement.Span.End)); 321Location.Create(tree, localDeclarationStatement.Span), 322Location.Create(tree, ifStatement.Span), 323Location.Create(tree, expressionStatement.Span));

NullableImpactingSpanWalker.cs (4)

56if (node.Span.End < _positionOfFirstReducingNullableDirective) 61if (_ignoredSpans.HasIntervalThatContains(node.SpanStart, node.Span.Length)) 144SpansBuilder.Add(predefinedType.Span); 162SpansBuilder.Add(node.Span);

SyntaxNodeExtensions.cs (4)

640var matchSpan = match.Span; 902if (variable.Initializer != null && variable.Initializer.Span.Contains(span)) 927return initializer.ArgumentList.Arguments.Any(a => a.Span.Contains(textSpan)); 948var expressionBodiedMemberBody = TextSpan.FromBounds(expressionBodiedMember.Expression.SpanStart, expressionBodiedMember.Expression.Span.End);

UseUtf8StringLiteralDiagnosticAnalyzer.cs (1)

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

AbstractAssignOutParametersCodeFixProvider.cs (1)

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

CompilationUnitSyntaxExtensions.cs (3)

54var end = usings.Last().Span.End; 63var end = rootUsings.Last().Span.End; 71: root.Span.End;

CSharpAddYieldCodeFixProvider.cs (2)

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

CSharpRemoveUnnecessaryImportsService.cs (1)

113=> list.Count > 0 ? list[0].SpanStart : container.Span.End;

CSharpSyntaxContext.cs (1)

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

CSharpTypeInferenceService.TypeInferrer.cs (1)

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

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

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

TypeDeclarationSyntaxExtensions.cs (1)

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

AutomaticCompletion\AutomaticLineEnderCommandHandler.cs (2)

247if (embeddedStatement == null || embeddedStatement.Span.IsEmpty) 621IndexerDeclarationSyntax indexerNode => indexerNode.ParameterList.Span.End,

AutomaticCompletion\AutomaticLineEnderCommandHandler_Helpers.cs (12)

CompleteStatement\CompleteStatementCommandHandler.cs (9)

212var newCaretPosition = currentNode.Span.End; 290return (caret >= condition.Span.Start && caret <= condition.Span.End); 367forStatementCaret = GetCaretAtPosition(condition.Span.End); 371forStatementCaret = GetCaretAtPosition(declaration.Span.End); 397return caretPosition > condition.SpanStart && caretPosition <= condition.Span.End; 406return caretPosition > declaration.Span.Start && caretPosition <= declaration.Span.End; 416=> currentNode.Kind() is SyntaxKind.InterpolatedStringExpression or SyntaxKind.StringLiteralExpression or SyntaxKind.CharacterLiteralExpression && caret.Position < currentNode.Span.End

EventHookup\EventHookupCommandHandler_TabKeyCommand.cs (1)

310editSpan = memberAccessExpression.Name.Span;

Interactive\CSharpSendToInteractiveSubmissionProvider.cs (5)

40? new TextSpan[] { expandedNode.Span } 73if (startNode.Span.Contains(endNode.Span)) 77else if (endNode.Span.Contains(startNode.Span))

RawStringLiteral\RawStringLiteralCommandHandler_TypeChar.cs (1)

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

StringCopyPaste\KnownSourcePasteProcessor.cs (4)

201edits.Add(new TextChange(new TextSpan(StringExpressionBeforePaste.Span.Start, 0), dollarSignsToAdd)); 244if (beforeSelection && interpolation.Span.End > _selectionSpanBeforePaste.Start) 247if (!beforeSelection && interpolation.Span.Start < _selectionSpanBeforePaste.End) 348if (line == TextBeforePaste.Lines.GetLineFromPosition(StringExpressionBeforePaste.Span.End).LineNumber)

StringCopyPaste\StringCopyPasteCommandHandler.cs (4)

261var lastLine = textBeforePaste.Lines.GetLineFromPosition(stringExpressionBeforePaste.Span.End); 293var spanAfterPaste = MapSpan(stringExpressionBeforePaste.Span, snapshotBeforePaste, snapshotAfterPaste); 294return spanAfterPaste == stringExpressionAfterPaste.Span; 314var spanAfterPaste = MapSpan(stringExpressionBeforePaste.Span, snapshotBeforePaste, snapshotAfterPaste);

StringCopyPaste\StringCopyPasteData.cs (2)

159if (interpolatedContent.Span.OverlapsWith(selectionSpan)) 165if (!selectionSpan.Contains(interpolation.Span))

StringCopyPaste\StringInfo.cs (8)

102var end = SkipU8Suffix(text, literal.Span.End); 116endDelimiterSpan: TextSpan.FromBounds(end, literal.Span.End), 157TextSpan.FromBounds(rawEnd, literal.Span.End), 178var end = SkipU8Suffix(text, literal.Span.End); 187endDelimiterSpan: TextSpan.FromBounds(end, literal.Span.End), 208var end = SkipU8Suffix(text, interpolatedString.Span.End); 221currentPosition = content.Span.End; 231endDelimiterSpan: TextSpan.FromBounds(interpolatedString.StringEndToken.SpanStart, interpolatedString.Span.End),

StringCopyPaste\UnknownSourcePasteProcessor.cs (3)

133edits.Add(new TextChange(new TextSpan(StringExpressionBeforePaste.Span.Start, 0), dollarSignsToAdd)); 238var endLine = TextBeforePaste.Lines.GetLineFromPosition(StringExpressionBeforePaste.Span.End); 329if (line == TextBeforePaste.Lines.GetLineFromPosition(StringExpressionBeforePaste.Span.End).LineNumber)

CodeActions\Preview\PreviewExceptionTests.cs (1)

114var span = document.GetSyntaxRootAsync().Result.Span;

CodeActions\Preview\PreviewTests.cs (1)

99var span = document.GetSyntaxRootAsync().Result.Span;

EditAndContinue\BreakpointSpansTests.cs (1)

94var endPosition = root.Span.End;

ExtractMethod\ExtractMethodBase.cs (1)

199var validator = new CSharpSelectionValidator(semanticDocument, node.Span, ExtractMethodOptions.Default, localFunction: false);

TypeInferrer\TypeInferrerTests.cs (2)

40inferredType = typeInference.InferType(await document.ReuseExistingSpeculativeModelAsync(node?.Span ?? textSpan, CancellationToken.None), node, objectAsDefault: true, cancellationToken: CancellationToken.None); 74if (currentNode is ExpressionSyntax result && result.Span == textSpan)

Diagnostics\GetDiagnosticsTests.cs (3)

722var span = localDecl.Span; 1001var span = localDecl.Span; 1165var result = await compilationWithAnalyzers.GetAnalysisResultAsync(model1, filterSpan: localDecl.Span, CancellationToken.None);

FlowAnalysis\FlowTestBase.cs (6)

117if (expr.SpanStart >= start && expr.Span.End <= end) 138if (expr.SpanStart >= start && expr.Span.End <= end) 159if (expr.SpanStart >= start && expr.Span.End <= end) 185if (firstStatement != null && stmt.Span.End <= end && stmt.Parent == firstStatement.Parent) 197return GetSyntaxNodeList(tree).OfType<T>().Where(n => n.Span.Contains(offset)).FirstOrDefault(); 203return GetSyntaxNodeList(tree).OfType<T>().Where(n => n.Span.Contains(offset)).Last();

FlowAnalysis\RegionAnalysisTests.cs (1)

7910Assert.Equal(0, stmt.Span.Length);

AbstractAssignOutParametersCodeFixProvider.cs (1)

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

ChangeSignature\CSharpChangeSignatureService.cs (2)

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

CodeRefactorings\ConvertLocalFunctionToMethod\CSharpConvertLocalFunctionToMethodCodeRefactoringProvider.cs (1)

73localFunction.Span);

CodeRefactorings\EnableNullable\EnableNullableCodeRefactoringProvider.cs (1)

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

CodeRefactorings\InlineTemporary\InlineTemporaryCodeRefactoringProvider.cs (4)

90if (references.Any(static (r, variableDeclarator) => variableDeclarator.Initializer.Span.Contains(r.Span), variableDeclarator)) 98variableDeclarator.Span); 380if (!text.AreOnSameLine(expression.SpanStart, expression.Span.End))

CodeRefactorings\SyncNamespace\CSharpChangeNamespaceService.cs (2)

50containerSpan = container.Span; 356if (!compilationUnit.Span.Contains(span))

CodeRefactorings\SyncNamespace\CSharpSyncNamespaceCodeRefactoringProvider.cs (1)

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

CodeRefactorings\UseExplicitOrImplicitType\AbstractUseTypeCodeRefactoringProvider.cs (1)

73declaredType.Span);

CodeRefactorings\UseRecursivePatterns\UseRecursivePatternsCodeRefactoringProvider.cs (1)

546if (!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\ExplicitInterfaceTypeCompletionProvider.cs (1)

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

Completion\CompletionProviders\NamedParameterCompletionProvider.cs (1)

145var existingArguments = argumentList.Arguments.Where(a => a.Span.End <= position && a.NameColon != null)

Completion\KeywordRecommenders\InKeywordRecommender.cs (1)

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

ConvertLinq\CSharpConvertLinqQueryToForEachProvider.cs (1)

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

ConvertNamespace\ConvertNamespaceCodeRefactoringProvider.cs (1)

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

ConvertToFileScopedNamespaceDiagnosticAnalyzer.cs (1)

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

CSharpAddBracesDiagnosticAnalyzer.cs (2)

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

CSharpAddYieldCodeFixProvider.cs (2)

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

CSharpAsAndNullCheckDiagnosticAnalyzer.Analyzer.cs (4)

150if (forStatement.Condition is null || !forStatement.Condition.Span.Contains(_comparison.Span)) 314var scopeSpan = scope.Span; 328if (descendentNodeSpanStart >= comparisonSpanStart && scopeSpan.Contains(descendentNode.Span))

CSharpAsAndNullCheckDiagnosticAnalyzer.cs (2)

217descendentNode.Span.IntersectsWith(comparisonEnclosingBlock.Span) &&

CSharpDeclarationComputer.cs (1)

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

CSharpInlineDeclarationDiagnosticAnalyzer.cs (3)

329var localStatementStart = localStatement.Span.Start; 330var argumentNodeStart = argumentNode.Span.Start; 338var descendentStart = descendentNode.Span.Start;

CSharpRemoveUnnecessaryCastDiagnosticAnalyzer.cs (1)

31node is BinaryExpressionSyntax binary ? TextSpan.FromBounds(binary.OperatorToken.SpanStart, node.Span.End) : throw ExceptionUtilities.Unreachable();

CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs (2)

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

CSharpRemoveUnnecessaryNullableDirectiveDiagnosticAnalyzer.cs (6)

128|| !possibleNullableImpactIntervalTree.HasIntervalThatOverlapsWith(currentOptionsDirective.Span.End, nullableDirectiveTrivia.SpanStart - currentOptionsDirective.Span.End)) 149possibleNullableImpactIntervalTree.AddIntervalInPlace(directive.Span); 160|| !possibleNullableImpactIntervalTree.HasIntervalThatOverlapsWith(currentOptionsDirective.Span.End, root.Span.End - currentOptionsDirective.Span.End))

CSharpTypeStyleDiagnosticAnalyzerBase.cs (1)

73context.ReportDiagnostic(CreateDiagnostic(descriptor, declarationStatement, declaredType.StripRefIfNeeded().Span, typeStyle.Severity));

CSharpUseLocalFunctionDiagnosticAnalyzer.cs (1)

212var descendentStart = descendentNode.Span.Start;

CSharpUseRangeOperatorDiagnosticAnalyzer.cs (1)

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

Debugging\DataTipInfoGetter.cs (4)

51: new DebugDataTipInfo(expression.Span, type.ToNameDisplayString()); 60return new DebugDataTipInfo(expression.Parent.Span, text: null); 65return new DebugDataTipInfo(TextSpan.FromBounds(curr.SpanStart, expression.Span.End), text: null); 88return new DebugDataTipInfo(expression.Span, textOpt);

EditAndContinue\BreakpointSpans.cs (11)

151return (methodDeclaration.Body != null) ? CreateSpanForBlock(methodDeclaration.Body, position) : methodDeclaration.ExpressionBody?.Expression.Span; 236return property.ExpressionBody.Expression.Span; 242return property.Initializer.Value.Span; 257return indexer.ExpressionBody.Expression.Span; 338return constructorSyntax.ExpressionBody.Expression.Span; 351return constructorSyntax.ExpressionBody.Expression.Span; 434if (position < doStatement.Statement.Span.Start) 500return ((ForEachVariableStatementSyntax)statement).Variable.Span; 816return TextSpan.FromBounds(firstSpan.Value.Start, constructorBody.Span.End); 821return TextSpan.FromBounds(unit.Members[0].SpanStart, unit.Members.OfType<GlobalStatementSyntax>().Last().Span.End); 830return body.Span;

EditAndContinue\CSharpEditAndContinueAnalyzer.cs (34)

EncapsulateField\CSharpEncapsulateFieldService.cs (3)

133var fields = root.DescendantNodes(d => d.Span.IntersectsWith(span)) 135.Where(n => n.Span.IntersectsWith(span)); 148declarators = declarations.SelectMany(d => d.Variables.Where(v => v.Span.IntersectsWith(span)));

ExtractInterface\CSharpExtractInterfaceService.cs (1)

48var spanEnd = typeDeclaration.TypeParameterList != null ? typeDeclaration.TypeParameterList.Span.End : typeDeclaration.Identifier.Span.End;

ExtractMethod\CSharpMethodExtractor.Analyzer.cs (2)

115first.Span.Contains(last.Span))

ExtractMethod\CSharpMethodExtractor.cs (4)

62if (!OriginalSelectionResult.OriginalSpan.Contains(anonymousFunction.Span)) 80if (!OriginalSelectionResult.OriginalSpan.Contains(localFunction.Span)) 115if (OriginalSelectionResult.FinalSpan.Contains(memberNode.Span)) 140return node.Span.Contains(OriginalSelectionResult.OriginalSpan);

ExtractMethod\CSharpMethodExtractor.CSharpCodeGenerator.SingleStatementCodeGenerator.cs (2)

42return firstStatement == lastStatement || firstStatement.Span.Contains(lastStatement.Span);

ExtractMethod\CSharpSelectionValidator.cs (2)

382if (expression != null && statement1.Span.Contains(expression.Span))

ExtractMethod\Extensions.cs (4)

91return constructorInitializer.ContainsInArgument(node.Span); 146return equal.Value != null && equal.Value.Span.Contains(node.Span); 164if (catchClause == null || !textSpan.Contains(catchClause.Span))

GenerateMember\GenerateVariable\CSharpGenerateVariableService.cs (2)

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

GenerateType\CSharpGenerateTypeService.cs (1)

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

InlineHints\CSharpInlineParameterNameHintsService.cs (2)

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

IntroduceVariable\CSharpIntroduceVariableService_IntroduceLocal.cs (3)

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

InvokeDelegateWithConditionalAccessAnalyzer.cs (7)

134Location.Create(tree, ifStatement.Span), 135Location.Create(tree, expressionStatement.Span)); 200if (nextToken.Span.Start < ifStatement.Span.End) 202fadeLocation = Location.Create(tree, TextSpan.FromBounds(nextToken.Span.Start, ifStatement.Span.End)); 321Location.Create(tree, localDeclarationStatement.Span), 322Location.Create(tree, ifStatement.Span), 323Location.Create(tree, expressionStatement.Span));

LanguageServices\CSharpSymbolDisplayService.SymbolDescriptionBuilder.cs (1)

197Services, semanticModel, equalsValue.Value.Span,

NavigationBar\CSharpNavigationBarItemService.cs (3)

223var spanEnd = declaringNode.Span.End; 234spanEnd = fieldDeclaration.Span.End; 261return declaringNode.Span;

NullableImpactingSpanWalker.cs (4)

56if (node.Span.End < _positionOfFirstReducingNullableDirective) 61if (_ignoredSpans.HasIntervalThatContains(node.SpanStart, node.Span.Length)) 144SpansBuilder.Add(predefinedType.Span); 162SpansBuilder.Add(node.Span);

QuickInfo\CSharpDiagnosticAnalyzerQuickInfoProvider.cs (2)

93return GetQuickInfoFromSupportedDiagnosticsOfProjectAnalyzers(document, errorCode, errorCodeNode.Span); 131return GetQuickInfoFromSupportedDiagnosticsOfProjectAnalyzers(document, errorCode, suppressMessageCheckIdArgument.Span);

QuickInfo\CSharpSyntacticQuickInfoProvider.cs (2)

152return QuickInfoItem.Create(token.Span, relatedSpans: ImmutableArray.Create(regionStart.Span)); 159.Select(d => d.Span)

SignatureHelp\AbstractCSharpSignatureHelpProvider.LightweightOverloadResolution.cs (1)

272=> expression.Span.IsEmpty;

SignatureHelp\AttributeSignatureHelpProvider.cs (1)

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

SignatureHelp\ConstructorInitializerSignatureHelpProvider.cs (1)

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

SignatureHelp\ElementAccessExpressionSignatureHelpProvider.cs (4)

120return TextSpan.FromBounds(conditional.Span.Start, openBracket.FullSpan.End); 297return expression.ArgumentList.Span.Contains(token.SpanStart) && 346return TextSpan.FromBounds(expression.SpanStart, openBracket.Parent.Span.End); 382return expression.ArgumentList.Span.Contains(token.SpanStart) &&

SignatureHelp\GenericNameSignatureHelpProvider.cs (1)

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

SignatureHelp\InitializerExpressionSignatureHelpProvider.cs (1)

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

SignatureHelp\InvocationExpressionSignatureHelpProvider.cs (1)

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

SignatureHelp\ObjectCreationExpressionSignatureHelpProvider.cs (1)

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

SignatureHelp\PrimaryConstructorBaseTypeSignatureHelpProvider.cs (1)

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

SignatureHelp\TupleConstructionSignatureHelpProvider.cs (3)

70if (!currentSpan.Contains(expression.Span)) 89if (!currentSpan.Contains(expression.Span)) 162return CreateSignatureHelpItems(items, targetExpression.Span, state, selectedItemIndex: null, parameterIndexOverride: -1);

Snippets\CSharpSnippetFunctionService.cs (1)

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

SplitStringLiteral\InterpolatedStringSplitter.cs (3)

49if (content.Span.End <= CursorPosition) 54else if (content.Span.Start >= CursorPosition) 63afterSplitContents.Insert(0, CreateInterpolatedStringText(CursorPosition, content.Span.End));

SplitStringLiteral\StringSplitter.cs (2)

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

StringIndentation\CSharpStringIndentationService.cs (5)

59if (!node.Span.IntersectsWith(textSpan)) 126builder.Add(interpolation.Span); 137if (content is InterpolationSyntax && content.Span.Contains(sourceSpan)) 151var holeEndLine = text.Lines.GetLineFromPosition(interpolation.Span.End).LineNumber; 170var lastLine = text.Lines.GetLineFromPosition(expression.Span.End);

Structure\CSharpStructureHelpers.cs (1)

346node.Span,

Structure\Providers\ArrowExpressionClauseStructureProvider.cs (2)

27textSpan: TextSpan.FromBounds(previousToken.Span.End, node.Parent.Span.End), 28hintSpan: node.Parent.Span,

Structure\Providers\BlockSyntaxStructureProvider.cs (6)

73textSpan: node.Span, 74hintSpan: node.Span, 90var start = parent.Span.Start; 100return node.Span; 121return node.Span.End; 127return node.Parent.Span.End;

Structure\Providers\InitializerExpressionStructureProvider.cs (3)

42: node.Span.End; 64textSpan: TextSpan.FromBounds(previousToken.Span.End, node.Span.End), 65hintSpan: node.Parent.Span,

Structure\Providers\InterpolatedStringExpressionStructureProvider.cs (2)

29textSpan: node.Span, 30hintSpan: node.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 (2)

26textSpan: node.Span, 27hintSpan: 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)

134declaration.Span); 147declaration.Span);

UsePatternMatching\CSharpIsAndCastCheckWithoutNameDiagnosticAnalyzer.cs (3)

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

UseUtf8StringLiteralDiagnosticAnalyzer.cs (1)

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

Wrapping\SeparatedSyntaxList\CSharpInitializerExpressionWrapper.cs (1)

53return listSyntax.Span.Contains(position);

Semantics\FieldInitializerBindingTests.cs (1)

282var initValueLineNumber = syntaxTree.GetLineSpan(initValueSyntax.Span).StartLinePosition.Line;

Semantics\GlobalUsingDirectiveTests.cs (4)

4979Assert.Equal("alias1=C1", model.GetSpeculativeAliasInfo(tree.GetRoot().Span.End, alias1, SpeculativeBindingOption.BindAsExpression).ToTestDisplayString()); 4980Assert.Equal("alias1=C1", model.GetSpeculativeAliasInfo(tree.GetRoot().Span.End, alias1, SpeculativeBindingOption.BindAsTypeOrNamespace).ToTestDisplayString()); 4984Assert.Equal("alias1=C1", model.GetSpeculativeAliasInfo(tree.GetRoot().Span.End, alias1, SpeculativeBindingOption.BindAsExpression).ToTestDisplayString()); 4985Assert.Equal("alias1=C1", model.GetSpeculativeAliasInfo(tree.GetRoot().Span.End, alias1, SpeculativeBindingOption.BindAsTypeOrNamespace).ToTestDisplayString());

Semantics\NullableContextTests.cs (1)

735bool actualAnalysis = tree.IsNullableAnalysisEnabled(methodDeclaration.Span).Value;

Semantics\OutVarTests.cs (10)

1079if (typeofExpression?.Type?.FullSpan.Contains(decl.Span) == true) 1210if (dataFlowParent.Span.Contains(reference.Span) && reference.SpanStart > decl.SpanStart) 1261if (!dataFlowParent.Span.Contains(reference.Span)) 1298if (!dataFlowParent.Span.Contains(reference.Span) && 1299(containingReturnOrThrow == null || containingReturnOrThrow.Span.Contains(reference.SpanStart)) && 1319if (!dataFlowParent.Span.Contains(reference.Span))

Semantics\QueryTests.cs (3)

3424bool success = model.TryGetSpeculativeSemanticModel(methodM.Body.Statements[1].Span.End, queryStatement, out speculativeModel); 3468bool success = model.TryGetSpeculativeSemanticModel(methodM.Body.Statements[1].Span.End, queryStatement, out speculativeModel); 3554bool success = model.TryGetSpeculativeSemanticModel(methodM.Body.Statements[0].Span.End, queryStatement, out speculativeModel);

Semantics\TopLevelStatementsTests.cs (7)

2913model1.GetDiagnostics(nameRef.Ancestors().OfType<StatementSyntax>().First().Span).Verify( 2935model2.GetDiagnostics(nameRef.Ancestors().OfType<StatementSyntax>().First().Span).Verify( 8641for (int i = id.SpanStart; i <= id.Span.End; i++) 8663for (int i = id.SpanStart; i <= id.Span.End; i++) 8685for (int i = id.SpanStart; i <= id.Span.End; i++) 9695model.TryGetSpeculativeSemanticModel(root.DescendantNodes().Single(n => n is ExpressionStatementSyntax { Parent: GlobalStatementSyntax }).Span.End, nodeToSpeculate, out var speculativeModelInTopLevel); 9700model.TryGetSpeculativeSemanticModel(root.DescendantNodes().Single(n => n is ExpressionStatementSyntax { Parent: BlockSyntax }).Span.End, nodeToSpeculate, out var speculativeModelOutsideTopLevel);

Compilation\SemanticModelAPITests.cs (5)

1394var info = model.GetSpeculativeSymbolInfo(oldSyntax.ParameterList.Span.End, newSyntax); 1920bool success = model.TryGetSpeculativeSemanticModel(methodDecl.Body.Statements[0].Span.End, switchStatement, out statModel); 1958bool success = model.TryGetSpeculativeSemanticModel(methodDecl.Body.Statements[0].Span.End, speculatedStatement, out speculativeModel); 2264var success = model.TryGetSpeculativeSemanticModel(methodDecl.Body.Statements[0].Span.End, unsafeStatement, out speculativeModel); 2679var success = model.TryGetSpeculativeSemanticModelForMethodBody(methodDecl.Body.Statements[0].Span.End, speculatedMethod, out speculativeModel);

DeclarationTests.cs (2)

398if (node.Span == nodeInUnderlying.Span && node.RawKind == nodeInUnderlying.RawKind)

Symbols\AnonymousTypesSemanticsTests.cs (6)

1494var pos = data.Nodes[0].Span.End; 1513pos = data.Nodes[3].Span.End; 1923while (current.Span == identifier.Span && !current.IsKind(SyntaxKind.IdentifierName)) 1930var span = node.Span; 1972if (span.Contains(node.Span))

Symbols\AnonymousTypesSymbolTests.cs (2)

1702Assert.True(statement1.Span.Contains(typeA3.Locations[0].SourceSpan)); 1703Assert.True(statement2.Span.Contains(typeA4.Locations[0].SourceSpan));

Symbols\Source\NullablePublicAPITests.cs (1)

4121var position = localFunction.DescendantNodes().OfType<VariableDeclarationSyntax>().Single().Span.End;

Diagnostics\LineSpanDirectiveTests.cs (1)

489var mappedLineAndPositionSpan = unmappedText.GetMappedLineSpanAndVisibility(syntax.Span, out _);

Syntax\LambdaUtilitiesTests.cs (1)

49bool expected = enclosingMethod.MethodKind == MethodKind.LambdaMethod && enclosingSyntax.Span.Contains(span.Value);

Syntax\SyntaxAnnotationTests.cs (2)

624Assert.Equal(oldNode.Span, annotatedNode.Span);

Syntax\SyntaxNodeTests.cs (9)

704Assert.Equal(root, root.FindNode(root.Span, findInsideTrivia: false)); 705Assert.Equal(root, root.FindNode(root.Span, findInsideTrivia: true)); 711var position = identifier.Span.Start + 1; 713Assert.Equal(classDecl, root.FindNode(identifier.Span, findInsideTrivia: false)); 714Assert.Equal(identifier, root.FindNode(identifier.Span, findInsideTrivia: true)); 1756Assert.Equal(rootNode.Span.Length, rootNode.ToString().Length); 1774Assert.Equal(rootNode.Span.Length, rootNode.ToString().Length); 1789Assert.Equal(namespaceNode.Span, nodeOrToken.Span); 2046Assert.Equal(method.Span, nodeLocation.SourceSpan);

Syntax\SyntaxTests.cs (1)

160var span = section.Span;

Classification\SyntaxClassification\DiscardSyntaxClassifier.cs (2)

31result.Add(new ClassifiedSpan(syntax.Span, ClassificationTypeNames.Keyword)); 52result.Add(new ClassifiedSpan(syntax.Span, ClassificationTypeNames.Keyword));

Classification\SyntaxClassification\NameSyntaxClassifier.cs (6)

158classifiedSpan = new ClassifiedSpan(name.Span, ClassificationTypeNames.NamespaceName); 173classifiedSpan = new ClassifiedSpan(name.Span, ClassificationTypeNames.Keyword); 182classifiedSpan = new ClassifiedSpan(name.Span, ClassificationTypeNames.Keyword); 190classifiedSpan = new ClassifiedSpan(name.Span, ClassificationTypeNames.Keyword); 206classifiedSpan = new ClassifiedSpan(name.Span, ClassificationTypeNames.Keyword); 374result.Add(new(name.Span, ClassificationTypeNames.Keyword));

Classification\SyntaxClassification\UsingDirectiveSyntaxClassifier.cs (2)

50result.Add(new ClassifiedSpan(token.Span, classification)); 55result.Add(new ClassifiedSpan(token.Span, ClassificationTypeNames.NamespaceName));

Classification\Worker.cs (1)

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

Classification\Worker_DocumentationComments.cs (1)

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

Classification\Worker_Preprocesser.cs (1)

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

CodeGeneration\CSharpSyntaxGenerator.cs (8)

2748if (root.Span.Contains(declaration.Span)) 2887if (root.Span.Contains(declaration.Span)) 2926if (root.Span.Contains(declaration.Span)) 2994if (root.Span.Contains(node.Span))

CSharpRemoveUnnecessaryImportsService.cs (1)

113=> list.Count > 0 ? list[0].SpanStart : container.Span.End;

CSharpSyntaxContext.cs (1)

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

CSharpSyntaxFacts.cs (6)

709if (useFullSpan || node.Span.Contains(position)) 934if (node.Span.IsEmpty) 965(constructor.Initializer != null && constructor.Initializer.Span.Contains(span)); 969return property.AccessorList != null && property.AccessorList.Span.Contains(span); 971return @enum.EqualsValue != null && @enum.EqualsValue.Span.Contains(span); 973return field.Declaration != null && field.Declaration.Span.Contains(span);

CSharpTriviaFormatter.DocumentationCommentExteriorCommentRewriter.cs (1)

76trivia.Span.End == currentParent.Span.End)

CSharpTypeInferenceService.TypeInferrer.cs (1)

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

CSharpVirtualCharService.cs (1)

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

J\s\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\SyntaxNodeExtensions.cs\SyntaxNodeExtensions.cs (4)

640var matchSpan = match.Span; 902if (variable.Initializer != null && variable.Initializer.Span.Contains(span)) 927return initializer.ArgumentList.Arguments.Any(a => a.Span.Contains(textSpan)); 948var expressionBodiedMemberBody = TextSpan.FromBounds(expressionBodiedMember.Expression.SpanStart, expressionBodiedMember.Expression.Span.End);

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

54var end = usings.Last().Span.End; 63var end = rootUsings.Last().Span.End; 71: root.Span.End;

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

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

Rename\CSharpRenameRewriterLanguageService.cs (4)

166if (_conflictLocations.Any(cf => cf.Contains(lambda.Span))) 200_conflictLocations.Contains(node.Span) && 300var oldSpan = originalNode.Span; 315var newSpan = newNode.Span;

Simplification\Reducers\CSharpNullableAnnotationReducer.cs (1)

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

Simplification\Simplifiers\ExpressionSimplifier.cs (7)

53issueSpan = memberAccessExpression.Expression.Span; 111issueSpan = memberAccess.Span; 166issueSpan = memberAccess.Span; 172issueSpan = memberAccess.Expression.Span; 192issueSpan = memberAccess.Span; // we want to show the whole expression as unnecessary 218issueSpan = memberAccess.Expression.Span; 463issueSpan = left.Span;

Simplification\Simplifiers\NameSimplifier.cs (9)

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

Simplification\Simplifiers\QualifiedCrefSimplifier.cs (2)

60issueSpan = crefSyntax.Span; 98issueSpan = crefSyntax.Container.Span;

TypeDeclarationSyntaxExtensions.cs (1)

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

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

26=> _node.Span;

TextStructureNavigation\AbstractTextStructureNavigatorProvider.TextStructureNavigator.cs (1)

345while (node.Parent != null && node.Parent.Span == node.Span)

Snippets\CSharpSnippets\SnippetFunctions\SnippetFunctionGenerateSwitchCases.cs (2)

63var expressionNode = token.GetAncestor(n => n.Span == expressionSpan); 89var nodeToReplace = syntaxRoot.DescendantNodes().FirstOrDefault(n => n.Span == typeSpanToAnnotate);

Snippets\CSharpSnippets\SnippetFunctions\SnippetFunctionSimpleTypeName.cs (1)

30var nodeToReplace = syntaxRoot.DescendantNodes().FirstOrDefault(n => n.Span == updatedTextSpan);

EditAndContinue\EditAndContinueTestHelpers.cs (2)

359while (result.Span != span) 464.ThenByDescending(partners => partners.Key.Span.Length)

RefactoringHelpers\RefactoringHelpersTestBase.cs (2)

39Assert.Equal(result, resultNode!.Span); 57Assert.Equal(result, resultNode!.Span);

Structure\AbstractSyntaxNodeStructureProviderTests.cs (2)

33(position == node.Span.End && position == node.Parent.Span.End))

CodeGeneration\CodeGenerationTests.cs (1)

934return token.Parent.AncestorsAndSelf().OfType<T>().FirstOrDefault(t => !fullSpanCoverage || t.Span.End >= destSpan.End);

InheritanceMargin\InheritanceMarginTests.cs (1)

100var searchingSpan = root.Span;

Peek\PeekHelpers.cs (1)

70return identifierLocation.SourceTree.GetLocation(node.Span).GetMappedLineSpan().Span;

Diagnostics\DiagnosticServiceTests.vb (2)

2221Dim span = localDecl.Span 2311Dim span = localDecl.Span

Expansion\AbstractExpansionTest.vb (1)

60If node.Span.End = spanEnd Then

Simplification\AbstractSimplificationTests.vb (1)

136If node.Span.End = spanEnd Then

AbstractAddAnonymousTypeMemberNameCodeFixProvider.cs (1)

59if (node?.Span != span)

AbstractConvertToAsyncCodeFixProvider.cs (1)

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

AbstractIteratorCodeFixProvider.cs (1)

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

AbstractPopulateSwitchDiagnosticAnalyzer.cs (1)

57!tree.OverlapsHiddenPosition(switchBlock.Span, context.CancellationToken))

AbstractRemoveUnnecessaryCastDiagnosticAnalyzer.cs (1)

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

AbstractRemoveUnnecessaryImportsDiagnosticAnalyzer.cs (3)

102textSpan = TextSpan.FromBounds(node.Span.Start, nodeEnd); 116textSpan = TextSpan.FromBounds(node.Span.Start, nodeEnd); 130var end = node.Span.End;

AbstractRemoveUnusedValuesCodeFixProvider.cs (1)

843rootWithTrackedNodes = Formatter.Format(rootWithTrackedNodes, originalDeclStatementsToMoveOrRemove.Select(s => s.Span), provider, options, rules: null, cancellationToken);

AbstractSimplifyInterpolationHelpers.cs (3)

97unnecessarySpans.AddRange(invocation.Syntax.Span 112unnecessarySpans.AddRange(invocation.Syntax.Span 220unnecessarySpans.AddRange(invocation.Syntax.Span

AbstractUseCollectionInitializerDiagnosticAnalyzer.cs (1)

150syntaxTree.GetLocation(TextSpan.FromBounds(arguments.Last().FullSpan.End, match.Span.End)));

AbstractUseConditionalExpressionCodeFixProvider.cs (3)

158if (condition.Span.Length + trueSyntax.Span.Length + falseSyntax.Span.Length > wrappingLength)

AbstractUseObjectInitializerDiagnosticAnalyzer.cs (3)

133: syntaxFacts.GetExpressionOfMemberAccessExpression(match.MemberAccessExpression)!.Span.End; 138if (match.Statement.Span.End > match.Initializer.FullSpan.End) 146syntaxTree.GetLocation(TextSpan.FromBounds(match.Initializer.FullSpan.End, match.Statement.Span.End)))));

AddImport\AbstractAddImportFeatureService.cs (1)

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

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.cs (2)

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

CodeLens\CodeLensFindReferenceProgress.cs (2)

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

CodeRefactoringHelpers.cs (6)

53if (selection.IsEmpty || node.Span.IsEmpty) 59if (selection.Contains(node.Span)) 86var beginningNode = node.FindToken(node.Span.Start).Parent; 87var endNode = node.FindToken(node.Span.End - 1).Parent; 98return beginningNode.Span.End <= selection.Start || endNode.Span.Start >= selection.End;

CodeRefactorings\AbstractRefactoringHelpersService.cs (4)

40if (node.Span.Length > 0) 293if (leftNode.GetLastToken().Span.End != location && leftNode.Span.End != location) 335if (rightNode.Span.Start != location) 535var argumentStartLine = sourceText.Lines.GetLineFromPosition(correctTypeNode.Span.Start).LineNumber;

CodeRefactorings\AddAwait\AbstractAddAwaitCodeRefactoringProvider.cs (2)

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

CodeRefactorings\SyncNamespace\AbstractChangeNamespaceService.cs (3)

289spanForContainers.Add(container.Span); 875return x.Span.Start - y.Span.Start;

Completion\Providers\AbstractPartialTypeCompletionProvider.cs (1)

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

ConvertAnonymousType\AbstractConvertAnonymousTypeToClassCodeRefactoringProvider.cs (2)

70anonymousObject.Span); 78anonymousObject.Span);

ConvertAutoPropertyToFullProperty\AbstractConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs (1)

54property.Span);

ConvertCast\AbstractConvertCastCodeRefactoringProvider.cs (1)

64from.Span);

ConvertForEachToFor\AbstractConvertForEachToForCodeRefactoringProvider.cs (1)

82foreachStatement.Span);

ConvertForToForEach\AbstractConvertForToForEachCodeRefactoringProvider.cs (1)

141forStatement.Span);

ConvertIfToSwitch\AbstractConvertIfToSwitchCodeRefactoringProvider.cs (3)

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

ConvertIfToSwitch\AbstractConvertIfToSwitchCodeRefactoringProvider.Rewriting.cs (1)

39var ifSpan = ifStatement.Span;

ConvertLinq\AbstractConvertLinqQueryToForEachProvider.cs (1)

52queryExpression.Span);

ConvertLinq\ConvertForEachToLinqQuery\AbstractConvertForEachToLinqQueryProvider.cs (3)

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

ConvertToInterpolatedString\AbstractConvertConcatenationToInterpolatedStringRefactoringProvider.cs (1)

113top.Span);

ConvertToInterpolatedString\AbstractConvertPlaceholderToInterpolatedStringRefactoringProvider.cs (1)

111invocation.Span);

ConvertToInterpolatedString\ConvertRegularStringToInterpolatedStringRefactoringProvider.cs (1)

81literalExpression.Span);

ConvertTupleToStruct\AbstractConvertTupleToStructCodeRefactoringProvider.cs (2)

102tupleExprOrTypeNode.Span); 114tupleExprOrTypeNode.Span);

Diagnostics\Analyzers\UnboundIdentifiersDiagnosticAnalyzerBase.cs (1)

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

EditAndContinue\AbstractEditAndContinueAnalyzer.cs (15)

163Debug.Assert(root.Span.Contains(bodyOrMatchRoot.Span)); 300=> TryGetDiagnosticSpan(node, editKind) ?? node.Span; 309return node.Span; 1325if (!bodyMatch.NewRoot.Span.Contains(newStatementSyntaxSpan.Start)) 1493ReportMemberBodyUpdateRudeEdits(diagnostics, match.NewRoot, match.NewRoot.Span); 1630if (TryGetActiveSpan(statement, statementPart, minLength: statement.Span.Length, out var span)) 1641return node.Span; 1652return statement.Span; 2214triviaEdits.Add((segment.oldNode, segment.newNode, segment.newNode.Span)); 4715syntax.Span, 4970(accumulate, node) => (node.SpanStart < accumulate.min) ? (node.SpanStart, node.Span) : accumulate).span; 5279diagnostics.Add(new RudeEditDiagnostic(rudeEdit, useSite.Span, null, arguments)); 5454errorSpan = GetVariableUseSites(GetLambdaBodyExpressionsAndStatements(lambdaBody), captures[i], model, cancellationToken).First().Span; 5813newCaptureNode.Span,

EncapsulateField\AbstractEncapsulateFieldService.cs (2)

187if (linkedFieldNode.Span != fieldDeclaration.Span) 340=> GetConstructorNodes(containingType).Select(n => (solution.GetRequiredDocument(n.SyntaxTree).Id, n.Span)).ToSet();

ExtractMethod\MethodExtractor.CodeGenerator.cs (1)

163methodDefinition.SyntaxTree.IsHiddenPosition(methodDefinition.AsNode().Span.End, cancellationToken))

ExtractMethod\SelectionResult.cs (1)

151if (!node.Span.OverlapsWith(span))

ExtractMethod\SelectionValidator.cs (3)

123if (stmt.Span.End < textSpan.Start) 141if (textSpan.End <= stmt.Span.End && spine.Any(s => CanMergeExistingSpineWithCurrent(syntaxFacts, s, stmt))) 184if (firstStatement != null && stmt.Span.End <= textSpan.End && stmt.Parent == firstStatement.Parent)

Fixer.cs (1)

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

FullyQualify\AbstractFullyQualifyService.cs (1)

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

GenerateConstructorFromMembers\AbstractGenerateConstructorFromMembersCodeRefactoringProvider.cs (1)

245pickMemberOptions.ToImmutable(), fallbackOptions), typeDeclaration.Span);

GenerateOverrides\GenerateOverridesCodeRefactoringProvider.cs (1)

64typeDeclaration.Span);

GenerateType\AbstractGenerateTypeService.Editor.cs (1)

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

InitializeParameter\AbstractInitializeParameterCodeRefactoringProvider.cs (1)

129listOfPotentiallyValidParametersNodes.ToImmutable(), selectedParameter.Span, context.Options, cancellationToken).ConfigureAwait(false);

InlineHints\AbstractInlineParameterNameHintsService.cs (1)

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

InlineHints\AbstractInlineTypeHintsService.cs (1)

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

InlineMethod\AbstractInlineMethodRefactoringProvider.cs (1)

243context.RegisterRefactoring(nestedCodeAction, calleeInvocationNode.Span);

IntroduceUsingStatement\AbstractIntroduceUsingStatementCodeRefactoringProvider.cs (1)

58declarationSyntax.Span);

IntroduceVariable\AbstractIntroduceLocalForExpressionCodeRefactoringProvider.cs (2)

60expressionStatement.Span); 68expressionStatement.Span);

InvertConditional\AbstractInvertConditionalCodeRefactoringProvider.cs (1)

36conditional.Span);

InvertIf\AbstractInvertIfCodeRefactoringProvider.cs (1)

101ifNode.Span);

InvertLogical\AbstractInvertLogicalCodeRefactoringProvider.cs (1)

80expression.Span);

MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceCodeRefactoringProvider.cs (1)

51declaration.Span);

NameTupleElement\AbstractNameTupleElementCodeRefactoringProvider.cs (1)

38argument.Span);

ReplaceConditionalWithStatements\AbstractReplaceConditionalWithStatementsCodeRefactoringProvider.cs (2)

155conditionalExpression.Span); 184conditionalExpression.Span);

ReplaceMethodWithProperty\ReplaceMethodWithPropertyCodeRefactoringProvider.cs (2)

80methodDeclaration.Span); 93methodDeclaration.Span);

ReplacePropertyWithMethods\ReplacePropertyWithMethodsCodeRefactoringProvider.cs (1)

72propertyDeclaration.Span);

SimplifyTypeNames\AbstractSimplifyTypeNamesCodeFixProvider.cs (1)

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

Snippets\SnippetFunctionService.cs (1)

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

Snippets\SnippetProviders\AbstractConsoleSnippetProvider.cs (2)

89return caretTarget.Span.End; 95return caretTarget.Span.End;

SolutionCrawler\AbstractDocumentDifferenceService.cs (4)

163if (oldMember.Span.IsEmpty) 169if (!oldMember.Span.Contains(range.Span)) 177return (oldMember.Span.Length + lengthDelta) == newMember.Span.Length ? newMember : null;

SpellCheck\AbstractSpellCheckCodeFixProvider.cs (1)

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

SplitOrMergeIfStatements\AbstractMergeIfStatementsCodeRefactoringProvider.cs (5)

48RegisterRefactoring(MergeDirection.Up, upperIfOrElseIf.Span, ifOrElseIf.Span); 51RegisterRefactoring(MergeDirection.Down, ifOrElseIf.Span, lowerIfOrElseIf.Span); 84node => ifGenerator.IsIfOrElseIf(node) && node.Span == span);

SplitOrMergeIfStatements\AbstractSplitIfStatementCodeRefactoringProvider.cs (2)

54c => RefactorAsync(document, token.Span, ifOrElseIf.Span, c), 56ifOrElseIf.Span);

UseAutoProperty\AbstractUseAutoPropertyCodeFixProvider.cs (2)

300.Select(d => (d.SyntaxTree.FilePath, d.Span)) 333if (constructorSpans.Contains((node.SyntaxTree.FilePath, node.Span)))

UseNamedArguments\AbstractUseNamedArgumentsCodeRefactoringProvider.cs (3)

118argument.Span); 125argument.Span); 134argument.Span);

Wrapping\AbstractCodeActionComputer.cs (1)

267return (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)

287currentOffset += item.Span.Length; 304currentOffset = indentationTrivia.FullWidth() + item.Span.Length;

Compilation\ControlFlowGraphVerifier.cs (1)

350if (model.GetDiagnostics(graph.OriginalOperation.Syntax.Span).

Analysis\FlowAnalysis\AlwaysAssignedWalker.vb (3)

75If IsInsideRegion(branch.Branch.Syntax.Span) AndAlso Not _labelsInside.Contains(branch.Label) Then 84If node.Syntax IsNot Nothing AndAlso IsInsideRegion(node.Syntax.Span) Then 92If IsInside AndAlso pending.Branch IsNot Nothing AndAlso Not IsInsideRegion(pending.Branch.Syntax.Span) Then

Analysis\FlowAnalysis\DataFlowsInWalker.vb (4)

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

Analysis\FlowAnalysis\EntryPointsWalker.vb (2)

47If 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)

102If 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)

83If IsInsideRegion(catchBlock.Syntax.Span) Then

Binding\Binder_Invocation.vb (6)

1302If node.SyntaxTree Is groupOpt.Syntax.SyntaxTree AndAlso node.Span.Contains(groupOpt.Syntax.Span) Then 1951If argument.Syntax.Span.Contains(diagnostic.Location.SourceSpan) Then 3158callerInfoValue = ConstantValue.Create(callerInfoOpt.SyntaxTree.GetDisplayPath(callerInfoOpt.Span, Me.Compilation.Options.SourceReferenceResolver)) 3291Return DirectCast(syntax, MemberAccessExpressionSyntax).Name.Span 3295Return syntax.Span

Binding\Binder_Query.vb (5)

625source.Syntax.Span, 4296syntax.AsClause.Span, 4355source.Syntax.Span, additionalDiagnostics) 4373source.Syntax.Span, additionalDiagnostics) 4396source.Syntax.Span, additionalDiagnostics)

Binding\MemberSemanticModel.vb (1)

530If parameter.Span.Contains(location.SourceSpan) Then

CodeGen\CodeGenerator.vb (1)

295EmitSequencePoint(syntax.SyntaxTree, syntax.Span)

CommandLine\VisualBasicCommandLineParser.vb (1)

1961Dim parsedEnd As Integer = offset + expression.Span.End

Compilation\SyntaxTreeSemanticModel.vb (5)

868If location.SourceTree Is Me.SyntaxTree AndAlso nodeToCheck.Span.Contains(location.SourceSpan) Then 1144If location.IsInSource AndAlso location.SourceTree Is _syntaxTree AndAlso parameter.Span.Contains(location.SourceSpan) Then 1330If location.IsInSource AndAlso location.SourceTree Is _syntaxTree AndAlso declarationSyntax.Span.Contains(location.SourceSpan) Then 1891Dim region As TextSpan = expression.Span 1907Dim region As TextSpan = TextSpan.FromBounds(firstStatement.SpanStart, lastStatement.Span.End)

Compilation\VisualBasicCompilation.vb (2)

1833Me.StatementSpan = syntax.Span 1838builder.Add(clause.Span)

Declarations\DeclarationTreeBuilder.vb (4)

345nameLocation:=_syntaxTree.GetLocation(dotted.Right.Span), 360nameLocation:=_syntaxTree.GetLocation(name.Span), 368nameLocation:=_syntaxTree.GetLocation(name.Span), 376nameLocation:=_syntaxTree.GetLocation(name.Span),

Lowering\AsyncRewriter\AsyncRewriter.AsyncMethodToClassRewriter.vb (1)

201bodyBuilder.Add(Me.F.SequencePointWithSpan(block, block.EndBlockStatement.Span, stateDone))

Lowering\Instrumentation\CodeCoverageInstrumenter.vb (2)

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

Lowering\Instrumentation\DebugInfoInjector.vb (4)

118sequencePointSpan = aggregateClause.Span 126aggregateClause.Variables.Last.Span.End) 129aggregateClause.AdditionalQueryOperators.Last.Span.End) 138sequencePointSpan = TextSpan.FromBounds(original.Syntax.SpanStart, original.Syntax.Span.End)

Lowering\Instrumentation\DebugInfoInjector_SequencePoints.vb (3)

105Dim statementSpanWithoutAttributes = TextSpan.FromBounds(firstModifierOrKeyword.SpanStart, methodStatement.Span.End) 125If(propertyStatement.Initializer Is Nothing, propertyStatement.AsClause.Span.End, propertyStatement.Initializer.Span.End))

Semantics\OverloadResolution.vb (1)

3419Return DirectCast(parent, AttributeSyntax).Name.Span.Contains(syntax.Position)

Symbols\LexicalSortKey.vb (2)

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

Symbols\MethodSymbolExtensions.vb (1)

51If location.IsInSource AndAlso location.SourceTree Is syntaxTree AndAlso parameter.Span.Contains(location.SourceSpan) Then

Symbols\Source\SourceMethodSymbol.vb (1)

866Return DirectCast(node, LambdaExpressionSyntax).SubOrFunctionHeader.Span

Symbols\Source\SourceNamespaceSymbol.vb (1)

633Return nsBlock IsNot Nothing AndAlso nsBlock.SyntaxTree Is tree AndAlso nsBlock.Span.Contains(location)

Symbols\Source\SourcePropertySymbol.vb (1)

1136Return syntaxTree.GetLocation(block.BlockStatement.Span)

Syntax\SimpleSyntaxReference.vb (1)

31Return _node.Span

Syntax\SyntaxFacts.vb (4)

202Dim span = node.Span 250afterBegin = (position >= singleLineLambda.SubOrFunctionHeader.Span.End) 255beforeEnd = (position <= singleLineLambda.Body.Span.End) 264afterBegin = (position >= multiLineLambda.SubOrFunctionHeader.Span.End)

Syntax\SyntaxNodeRemover.vb (3)

219Me.AddDirectives(node, GetRemovedSpan(node.Span, node.FullSpan)) 245Dim span = TextSpan.FromBounds(token.Span.Start, node.Span.End) 269Dim span = TextSpan.FromBounds(node.Span.Start, token.Span.End)

Syntax\VisualBasicSyntaxNode.vb (3)

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

VisualBasicDeclarationComputer.vb (1)

21Function(node, level) Not node.Span.OverlapsWith(span) OrElse InvalidLevel(level),

ParenthesizedExpressionSyntaxExtensions.vb (1)

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

SyntaxNodeExtensions.vb (5)

409Dim parentSpan = trivia.GetStructure().Span 414Dim matchSpan = match.Span 894If declaration.Initializer IsNot Nothing AndAlso declaration.Initializer.Span.Contains(span) Then 901If [property] IsNot Nothing AndAlso [property].Initializer IsNot Nothing AndAlso [property].Initializer.Span.Contains(span) Then 914Dim blockSpan = TextSpan.FromBounds(block.BlockStatement.Span.End, block.EndBlockStatement.SpanStart)

VisualBasicSyntaxFacts.vb (5)

720If useFullSpan OrElse node.Span.Contains(position) Then 846Return [enum].Initializer IsNot Nothing AndAlso ContainsExclusively([enum].Initializer.Span, span) 851Return propStatement.Initializer IsNot Nothing AndAlso ContainsExclusively(propStatement.Initializer.Span, span) 867Return TextSpan.FromBounds(list.First.SpanStart, list.Last.Span.End) 872Return TextSpan.FromBounds(list.First.SpanStart, list.Last.Span.End)

CompilationUnitSyntaxExtensions.vb (2)

30Dim [end] = root.Imports.Last.Span.End 37root.Span.End)

ExpressionSyntaxExtensions.vb (1)

229Dim descendentExpressions = expression.DescendantNodesAndSelf().OfType(Of ExpressionSyntax).Where(Function(e) span.Contains(e.Span)).ToSet()

SyntaxTreeExtensions.vb (1)

78Return statement IsNot Nothing AndAlso (statement.Name.Span.IntersectsWith(position) OrElse statement.NamespaceKeyword = token)

TypeBlockSyntaxExtensions.vb (1)

19Dim start = destination.BlockStatement.Span.End

VisualBasicConvertToIteratorCodeFixProvider.vb (1)

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

VisualBasicSyntaxContextExtensions.vb (1)

139Not accessors.Any(Function(a) a.Span.Contains(context.Position))

EndConstructGeneration\EndConstructStatementVisitor_IfStatement.vb (1)

48Dim position = If(ifBlock.Statements.Any(), ifBlock.Statements(0).SpanStart, ifBlock.IfStatement.Span.End + _state.NewLineCharacter.Length)

EndConstructGeneration\VisualBasicEndConstructGenerationService.vb (2)

204If element.StartTag IsNot Nothing AndAlso element.StartTag.Span.End = state.CaretPosition AndAlso 306Dim aligningWhitespace = subjectBuffer.CurrentSnapshot.GetAligningWhitespace(state.TokenToLeft.Parent.Span.Start)

LineCommit\CommitBufferManager.vb (1)

206finalSpanEnd = Math.Max(finalSpanEnd, endingStatementInfo.MatchingBlockConstruct.Span.End)

LineCommit\ContainingStatementInfo.vb (5)

17Me.New(node, node.Span) 178Dim containingAttribute = attributes.FirstOrDefault(Function(a) a.Span.Contains(position) OrElse a.Span.End = position) 186Return New ContainingStatementInfo(node, TextSpan.FromBounds(attributes.Last.Span.End, node.Span.End))

Utilities\CommandHandlers\AbstractImplementAbstractClassOrInterfaceCommandHandler.vb (1)

144If statement.Span.End <> token.Span.End Then

Utilities\NavigationPointHelpers.vb (2)

17line = text.Lines.GetLineFromPosition(eventBlock.EventStatement.Span.End).LineNumber + 1 28line = text.Lines.GetLineFromPosition(methodBlock.BlockStatement.Span.End).LineNumber + 1

CodeActions\Preview\PreviewTests.vb (1)

74Dim span = document.GetSyntaxRootAsync().Result.Span

Diagnostics\Suppression\SuppressionAllCodeTests.vb (1)

42Dim member = VisualBasicSyntaxFacts.Instance.GetContainingMemberDeclaration(n, n.Span.Start)

EditAndContinue\BreakpointSpansTests.vb (1)

85Dim endPosition = root.Span.End

ExtractMethod\ExtractMethodTests.vb (1)

176Dim validator = New VisualBasicSelectionValidator(sdocument, node.Span, ExtractMethodOptions.Default)

TypeInferrer\TypeInferrerTests.vb (2)

26typeInference.InferType(Await document.ReuseExistingSpeculativeModelAsync(node.Span, CancellationToken.None), node, objectAsDefault:=True, cancellationToken:=CancellationToken.None)) 53If result IsNot Nothing AndAlso result.Span = textSpan Then

ChangeSignature\VisualBasicChangeSignatureService.vb (2)

110If Not matchingNode.Span.IntersectsWith(position) Then 143Dim argument = invocation?.ArgumentList?.Arguments.FirstOrDefault(Function(a) a.Span.Contains(position))

CodeFixes\CorrectNextControlVariable\CorrectNextControlVariableCodeFixProvider.vb (1)

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

CodeFixes\GenerateEndConstruct\GenerateEndConstructCodeFixProvider.vb (3)

73.FirstOrDefault(Function(c) c.Span.IntersectsWith(context.Span) AndAlso IsCandidate(c)) 124Return begin.Span.Contains(node.Span)

CodeFixes\GenerateEvent\GenerateEventCodeFixProvider.vb (1)

53For Each node In token.GetAncestors(Of SyntaxNode).Where(Function(c) c.Span.IntersectsWith(context.Span) AndAlso IsCandidate(c))

CodeFixes\GenerateParameterizedMember\GenerateParameterizedMemberCodeFixProvider.vb (2)

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

CodeFixes\IncorrectExitContinue\IncorrectExitContinueCodeFixProvider.vb (1)

71Return c.Span.IntersectsWith(span) AndAlso (

CodeFixes\IncorrectFunctionReturnType\IncorrectFunctionReturnTypeCodeFixProvider.vb (1)

75.FirstOrDefault(Function(c) c.Span.IntersectsWith(span))

CodeFixes\MoveToTopOfFile\MoveToTopOfFileCodeFixProvider.vb (2)

56.FirstOrDefault(Function(c) c.Span.IntersectsWith(span)) 97node.Span.End > m.SpanStart)

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

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

CodeRefactorings\InlineTemporary\VisualBasicInlineTemporaryCodeRefactoringProvider.vb (1)

66variableDeclarator.Span)

CodeRefactorings\VisualBasicRefactoringHelpersService.vb (4)

31Dim start = If(typeDecl.Implements.LastOrDefault()?.Span.End, 32If(typeDecl.Inherits.LastOrDefault()?.Span.End, 33typeDecl.BlockStatement.Span.End)) 36position <= typeDecl.EndBlockStatement.Span.Start Then

Completion\CompletionProviders\NamedParameterCompletionProvider.vb (1)

123Where(Function(n) n.IsNamed AndAlso Not n.NameColonEquals.ColonEqualsToken.IsMissing AndAlso n.NameColonEquals.Span.End <= position).

Completion\KeywordRecommenders\Declarations\GenericConstraintsKeywordRecommender.vb (1)

34Dim previousConstraints = multipleConstraint.Constraints.Where(Function(c) c.Span.End < context.Position).ToList()

Completion\KeywordRecommenders\PreprocessorDirectives\EndRegionDirectiveKeywordRecommender.vb (1)

39If directive.Kind = SyntaxKind.RegionDirectiveTrivia AndAlso directive.Span.End <= context.Position Then

Debugging\DataTipInfoGetter.vb (1)

50Dim 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\VisualBasicEditAndContinueAnalyzer.vb (38)

EncapsulateField\VisualBasicEncapsulateFieldService.vb (3)

76Dim fields = root.DescendantNodes(Function(n) n.Span.IntersectsWith(span)) _ 78.Where(Function(n) n.Span.IntersectsWith(span) AndAlso CanEncapsulate(n)) 86names = fields.SelectMany(Function(f) f.Declarators.SelectMany(Function(d) d.Names.Where(Function(n) n.Span.IntersectsWith(span))))

ExtractInterface\VisualBasicExtractInterfaceService.vb (1)

43Dim spanEnd = If(typeDeclaration.BlockStatement.TypeParameterList IsNot Nothing, typeDeclaration.BlockStatement.TypeParameterList.Span.End, typeDeclaration.BlockStatement.Identifier.Span.End)

ExtractMethod\Extensions.vb (13)

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 170If catchBlock Is Nothing OrElse Not textSpan.Contains(catchBlock.Span) Then 189If Not textSpan.Contains(directive.Span) Then 252Dim withBlockSpan = TextSpan.FromBounds(withBlock.WithStatement.Span.End, withBlock.EndWithStatement.SpanStart) 263Dim initializerSpan = TextSpan.FromBounds(initializer.WithKeyword.Span.End, initializer.Span.End) 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)

ExtractMethod\VisualBasicMethodExtractor.Analyzer.vb (2)

89firstStatement.Span.Contains(lastStatement.Span) Then

ExtractMethod\VisualBasicMethodExtractor.VisualBasicCodeGenerator.SingleStatementCodeGenerator.vb (2)

27Return firstStatement Is lastStatement OrElse firstStatement.Span.Contains(lastStatement.Span)

ExtractMethod\VisualBasicSelectionValidator.vb (4)

308.SelectionInSingleStatement = forBlock.Span.Contains(nextStatement.Span) 403If expression IsNot Nothing AndAlso statement1.Span.Contains(expression.Span) Then

GenerateMember\GenerateParameterizedMember\VisualBasicGenerateConversionService.vb (10)

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)

GenerateType\VisualBasicGenerateTypeService.vb (3)

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

Highlighting\KeywordHighlighters\AccessorDeclarationHighlighter.vb (1)

55highlights.Add(.EndBlockStatement.Span)

Highlighting\KeywordHighlighters\ConstructorDeclarationHighlighter.vb (1)

39highlights.Add(.EndBlockStatement.Span)

Highlighting\KeywordHighlighters\EnumBlockHighlighter.vb (1)

41highlights.Add(.EndEnumStatement.Span)

Highlighting\KeywordHighlighters\EventBlockHighlighter.vb (1)

39highlights.Add(.EndEventStatement.Span)

Highlighting\KeywordHighlighters\MethodDeclarationHighlighter.vb (1)

61highlights.Add(.EndBlockStatement.Span)

Highlighting\KeywordHighlighters\MultiLineIfBlockHighlighter.vb (1)

51highlights.Add(ifBlock.EndIfStatement.Span)

Highlighting\KeywordHighlighters\MultiLineLambdaExpressionHighlighter.vb (1)

53highlights.Add(.EndSubOrFunctionStatement.Span)

Highlighting\KeywordHighlighters\NamespaceBlockHighlighter.vb (1)

30highlights.Add(.EndNamespaceStatement.Span)

Highlighting\KeywordHighlighters\OperatorDeclarationHighlighter.vb (1)

39highlights.Add(.EndBlockStatement.Span)

Highlighting\KeywordHighlighters\PropertyBlockHighlighter.vb (1)

38highlights.Add(.EndPropertyStatement.Span)

Highlighting\KeywordHighlighters\SelectBlockHighlighter.vb (1)

55highlights.Add(.EndSelectStatement.Span)

Highlighting\KeywordHighlighters\SyncLockBlockHighlighter.vb (1)

30highlights.Add(.EndSyncLockStatement.Span)

Highlighting\KeywordHighlighters\TryBlockHighlighter.vb (2)

53highlights.Add(.EndTryStatement.Span) 59highlights.Add(node.Span)

Highlighting\KeywordHighlighters\TypeBlockHighlighter.vb (1)

44highlights.Add(.EndBlockStatement.Span)

Highlighting\KeywordHighlighters\UsingBlockHighlighter.vb (1)

30highlights.Add(.EndUsingStatement.Span)

Highlighting\KeywordHighlighters\WhileBlockHighlighter.vb (1)

43highlights.Add(.EndWhileStatement.Span)

Highlighting\KeywordHighlighters\WithBlockHighlighter.vb (1)

30highlights.Add(.EndWithStatement.Span)

Highlighting\KeywordHighlighters\XmlElementHighlighter.vb (3)

31highlights.Add(.Span) 33highlights.Add(TextSpan.FromBounds(.LessThanToken.SpanStart, .Name.Span.End)) 38highlights.Add(.EndTag.Span)

Highlighting\KeywordHighlightingHelpers.vb (2)

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

ImplementInterface\VisualBasicImplementInterfaceCodeFixProvider.vb (3)

50.FirstOrDefault(Function(c) c.Span.IntersectsWith(span)) 55Dim typeNode = implementsNode.Types.Where(Function(c) c.Span.IntersectsWith(span)) _ 56.FirstOrDefault(Function(c) c.Span.IntersectsWith(span))

InlineHints\VisualBasicInlineParameterNameHintsService.vb (1)

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

LanguageServices\VisualBasicSymbolDisplayService.SymbolDescriptionBuilder.vb (1)

162Services, semanticModel, equalsValue.Value.Span, Options.ClassificationOptions, CancellationToken).ConfigureAwait(False)

SignatureHelp\AttributeSignatureHelpProvider.vb (1)

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

SignatureHelp\CastExpressionSignatureHelpProvider.vb (1)

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

SignatureHelp\CollectionInitializerSignatureHelpProvider.vb (1)

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

SignatureHelp\ConditionalExpressionSignatureHelpProvider.vb (1)

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

SignatureHelp\FunctionAggregationSignatureHelpProvider.vb (1)

51Function(n, t) n.CloseParenToken <> t AndAlso n.Span.Contains(t.SpanStart) AndAlso n.OpenParenToken.SpanStart <= t.SpanStart,

SignatureHelp\GenericNameSignatureHelpProvider.vb (1)

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

SignatureHelp\InvocationExpressionSignatureHelpProvider.vb (1)

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

SignatureHelp\MidAssignmentSignatureHelpProvider.vb (1)

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

SignatureHelp\ObjectCreationExpressionSignatureHelpProvider.vb (1)

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

SignatureHelp\RaiseEventStatementSignatureHelpProvider.vb (1)

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

Snippets\VisualBasicSnippetFunctionService.vb (1)

32Dim expressionNode = token.FirstAncestorOrSelf(Function(n) n.Span = switchExpressionSpan)

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\RegionDirectiveStructureProvider.vb (1)

42Dim span = TextSpan.FromBounds(regionDirective.SpanStart, matchingDirective.Span.End)

Structure\Providers\StringLiteralExpressionStructureProvider.vb (1)

24textSpan:=node.Span,

Structure\Providers\XmlExpressionStructureProvider.vb (1)

24Dim span = xmlExpression.Span

Structure\VisualBasicStructureHelpers.vb (4)

195blockNode.Span, GetHintSpan(blockNode), 207blockNode.Span, GetHintSpan(blockNode), 222Return TextSpan.FromBounds(child.SpanStart, blockNode.Span.End) 227Return blockNode.Span

VisualBasicConvertToIteratorCodeFixProvider.vb (1)

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

VisualBasicDeclarationComputer.vb (1)

21Function(node, level) Not node.Span.OverlapsWith(span) OrElse InvalidLevel(level),

Wrapping\SeparatedSyntaxList\VisualBasicCollectionCreationExpressionWrapper.vb (1)

66Return listSyntax.Span.Contains(position)

Compilation\SemanticModelAPITests.vb (5)

936Dim position1 = originalStatement.Span.End 971Dim position1 = originalStatement.Span.End 1661Dim position1 = originalStatement.Span.End 1697Dim position1 = originalStatement.Span.End 2913Dim conv2 = model.ClassifyConversion(castNode.Span.Start, expr, castType)

Compilation\SemanticModelGetDeclaredSymbolAPITests.vb (7)

1013Assert.Equal(treeA.GetLineSpan(syntax.Span).StartLinePosition.Line, 1019Assert.Equal(treeA.GetLineSpan(syntax.Span).StartLinePosition.Line, 1025Assert.Equal(treeA.GetLineSpan(syntax.Span).StartLinePosition.Line, 1031Assert.Equal(treeA.GetLineSpan(syntax.Span).StartLinePosition.Line, 1037Assert.Equal(treeB.GetLineSpan(syntax.Span).StartLinePosition.Line, 1043Assert.Equal(treeB.GetLineSpan(syntax.Span).StartLinePosition.Line, 1052Assert.Equal(treeB.GetLineSpan(syntax.Span).StartLinePosition.Line,

FlowAnalysis\FlowTestBase.vb (3)

199If endPosition >= endNode.Span.End Then endPosition = endNode.Span.End 200While endNode IsNot Nothing AndAlso endNode.Span.End = endPosition

Semantics\FieldInitializerBindingTests.vb (1)

1548Dim initValueLineNumber = syntaxTree.GetLineSpan(initValueSyntax.Span).StartLinePosition.Line

Semantics\OptionApis.vb (9)

85For i As Integer = 0 To root.Span.End 117For i As Integer = 0 To root.Span.End 144For i As Integer = 0 To root.Span.End 171For i As Integer = 0 To root.Span.End 198For i As Integer = 0 To root.Span.End 230For i As Integer = 0 To root.Span.End 262For i As Integer = 0 To root.Span.End 294For i As Integer = 0 To root.Span.End 327For i As Integer = 0 To root.Span.End

SymbolDisplay\SymbolDisplayTests.vb (1)

6009semanticModel.TryGetSpeculativeSemanticModelForMethodBody(member.BlockStatement.Span.End, member, speculativeModel)

SymbolsTests\AnonymousTypes\AnonymousTypesSemanticsTests.vb (6)

1618Dim pos As Integer = nodes(0).Span.End 1661Dim pos As Integer = nodes(0).Span.End 1873Assert.True(statement1.Span.Contains(typeA3.Locations(0).SourceSpan)) 1874Assert.True(statement2.Span.Contains(typeA4.Locations(0).SourceSpan)) 1926Dim span As TextSpan = node.Span 1987If span.Contains(node.Span) Then

SymbolsTests\MyBaseMyClassSemanticsTests.vb (2)

86Dim span As TextSpan = node.Span 136If span.Contains(node.Span) Then

SymbolsTests\WithStatementSymbolsTests.vb (1)

289If span.Contains(node.Span) Then

Syntax\SyntaxAnnotationTests.vb (2)

566Assert.Equal(oldNode.Span, annotatedNode.Span)

TestSyntaxNodes.vb (23)

ParserTestUtilities.vb (9)

378Assert.False(node.IsMissing, "Unexpected missing node: " & node.Kind.ToString & node.Span.ToString) 388Assert.True(0 <> node.Span.Length OrElse node.Kind = SyntaxKind.CompilationUnit, "Unexpected 0 width node: " & node.Kind.ToString & node.Span.ToString) 453node.Span.End <= node.Parent.Span.End, "Span of child (" & 454node.Kind.ToString & node.Span.ToString & 456node.Parent.Kind.ToString & node.Parent.Span.ToString & ")") 858node.Span.End <= node.Parent.Span.End, "Span of child (" & 861node.Parent.Kind.ToString & node.Parent.Span.ToString & ")")

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 (3)

154node, newNode, Function(n) n.Expression.Span.Length > 0, Function(n) n.ArgumentList, Function(n) n.WithArgumentList(SyntaxFactory.ArgumentList()), semanticChecker) 332Dim span = originalNode.Span 567Return 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\VisualBasicCodeGenerationService.vb (1)

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

CodeGeneration\VisualBasicSyntaxGenerator.vb (8)

3650If root.Span.Contains(declaration.Span) Then 3730If root.Span.Contains(declaration.Span) Then 3756If root.Span.Contains(declaration.Span) Then 3870If root.Span.Contains(declaration.Span) Then

CompilationUnitSyntaxExtensions.vb (2)

30Dim [end] = root.Imports.Last.Span.End 37root.Span.End)

J\s\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\Extensions\ContextQuery\SyntaxTreeExtensions.vb\SyntaxTreeExtensions.vb (1)

78Return statement IsNot Nothing AndAlso (statement.Name.Span.IntersectsWith(position) OrElse statement.NamespaceKeyword = token)

J\s\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\Extensions\ExpressionSyntaxExtensions.vb\ExpressionSyntaxExtensions.vb (1)

229Dim descendentExpressions = expression.DescendantNodesAndSelf().OfType(Of ExpressionSyntax).Where(Function(e) span.Contains(e.Span)).ToSet()

ParenthesizedExpressionSyntaxExtensions.vb (1)

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

Rename\VisualBasicRenameRewriterLanguageService.vb (7)

142Return cf.Contains(lambda.Span) 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)

107issueSpan = variableDeclarator.Span 135issueSpan = variableDeclarator.Span

Simplification\Simplifiers\AbstractVisualBasicSimplifier.vb (1)

172boundSymbols = 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)

50issueSpan = genericName.TypeArgumentList.Span 67issueSpan = name.Span 104issueSpan = name.Span 112issueSpan = qualifiedName.Left.Span 182issueSpan = name.Span 210issueSpan = name.Span 232issueSpan = qualifiedName.Left.Span 337issueSpan = name.Right.Span 376issueSpan = New TextSpan(name.Span.End - 9, 9) 457Return Not name.Span.Contains(argumentDecl.Span)

SyntaxNodeExtensions.vb (5)

409Dim parentSpan = trivia.GetStructure().Span 414Dim matchSpan = match.Span 894If declaration.Initializer IsNot Nothing AndAlso declaration.Initializer.Span.Contains(span) Then 901If [property] IsNot Nothing AndAlso [property].Initializer IsNot Nothing AndAlso [property].Initializer.Span.Contains(span) Then 914Dim blockSpan = TextSpan.FromBounds(block.BlockStatement.Span.End, block.EndBlockStatement.SpanStart)

TypeBlockSyntaxExtensions.vb (1)

19Dim start = destination.BlockStatement.Span.End

VisualBasicSyntaxContextExtensions.vb (1)

139Not accessors.Any(Function(a) a.Span.Contains(context.Position))

VisualBasicSyntaxFacts.vb (5)

720If useFullSpan OrElse node.Span.Contains(position) Then 846Return [enum].Initializer IsNot Nothing AndAlso ContainsExclusively([enum].Initializer.Span, span) 851Return propStatement.Initializer IsNot Nothing AndAlso ContainsExclusively(propStatement.Initializer.Span, span) 867Return TextSpan.FromBounds(list.First.SpanStart, list.Last.Span.End) 872Return TextSpan.FromBounds(list.First.SpanStart, list.Last.Span.End)

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

26Return _node.Span

AbstractDocumentationCommentService.cs (1)

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

AbstractHeaderFacts.cs (4)

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

AbstractMoveDeclarationNearReferenceService.State.cs (1)

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

AbstractRemoveUnnecessaryImportsService.cs (3)

48=> x?.Span == y?.Span; 51=> obj.Span.GetHashCode();

AbstractSelectedMembers.cs (1)

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

AbstractSpeculationAnalyzer.cs (1)

727!forEachExpression.Span.Contains(_expression.SpanStart))

AbstractUnnecessaryImportsProvider.cs (3)

25=> x?.Span == y?.Span; 28=> obj.Span.GetHashCode();

BaseIndentationFormattingRule.cs (1)

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

CodeCleanup\AbstractCodeCleanerService.cs (2)

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

CodeGenerationHelpers.cs (1)

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

CommonFormattingHelpers.cs (1)

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

Differencing\AbstractSyntaxComparer.cs (1)

51=> node.Span;

FormattingContext.InitialContextFinder.cs (2)

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

FormattingExtensions.cs (2)

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

ISyntaxFactsExtensions.cs (6)

166var span = TextSpan.FromBounds(nodes.First().Span.Start, nodes.Last().Span.End); 181=> ContainsInterleavedDirective(syntaxFacts, node.Span, node, cancellationToken); 457var endOfAttributeLists = attributeList.Last().Span.End; 460var endOfNode = node.Span.End; 466return node.Span;

LanguageServices\DeclaredSymbolFactoryService\AbstractDeclaredSymbolInfoFactoryService.cs (1)

317nameSyntax.Span,

ReassignedVariable\AbstractReassignedVariableService.cs (3)

64if (current.Span.IntersectsWith(span)) 107result.Add(identifier.Span); 224localDeclaration.Span,

Recommendations\AbstractRecommendationServiceRunner.cs (1)

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

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

426complexifiedTargetSpan: complexifiedTarget != null ? complexifiedTarget.Span : default));

Rename\ConflictEngine\RenamedSpansTracker.cs (1)

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

Simplification\Simplifiers\AbstractMemberAccessExpressionSimplifier.cs (1)

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

SyntaxNodeExtensions.cs (5)

185=> node.Span.Length; 318var fullSpan = nodes.First().Span; 323Math.Max(fullSpan.End, node.Span.End)); 330=> node.OverlapsHiddenPosition(node.Span, cancellationToken); 337var start = startNode.Span.End;

SyntaxReferenceTests.cs (1)

192Assert.Equal(0, node.Span.Length);

CodeLens\RemoteCodeLensReferencesService.cs (4)

58(service, solutionInfo, cancellationToken) => service.GetReferenceCountAsync(solutionInfo, documentId, syntaxNode.Span, maxSearchResults, cancellationToken), 104(service, solutionInfo, cancellationToken) => service.FindReferenceMethodsAsync(solutionInfo, documentId, syntaxNode.Span, cancellationToken), 129(service, solutionInfo, cancellationToken) => service.GetFullyQualifiedNameAsync(solutionInfo, documentId, syntaxNode.Span, cancellationToken), 267(service, solutionInfo, cancellationToken) => service.FindReferenceLocationsAsync(solutionInfo, documentId, syntaxNode.Span, cancellationToken),

LanguageService\AbstractLanguageService`2.IVsLanguageBlock.cs (1)

93return (description, node.Span);

Venus\ContainedDocument.cs (2)

838if (current.Span.Start == visibleTextSpan.Start) 848if (current.Span.Start < visibleSpan.Start)

CodeModel\CSharpCodeModelService.NodeLocator.cs (19)

CodeModel\AbstractCodeModelService.cs (1)

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

CodeModel\VisualBasicCodeModelService.NodeLocator.vb (35)

CodeModel\VisualBasicCodeModelService.vb (3)

4075position = methodStatement.HandlesClause.Span.End 4127text = text.Replace(methodStatement.HandlesClause.Span, String.Empty) 4135text = text.Replace(TextSpan.FromBounds(methodStatement.HandlesClause.Events.GetSeparator(index - 1).SpanStart, clauseItemToRemove.Span.End), String.Empty)

Help\VisualBasicHelpContextService.Visitor.vb (1)

808Dim bestName = node.Names.FirstOrDefault(Function(n) n.Span.IntersectsWith(_span))

LanguageService\VisualBasicDebuggerIntelliSenseContext.vb (2)

71Return containingNode.Span.End 82Return containingNode.Span.End