SpanStart

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

305Math.Min(fullSpan.Start, node.SpanStart), 321var end = endNode.SpanStart; 846=> x?.SpanStart == y?.SpanStart; 849=> obj.SpanStart; 926condDirectivesBuilder.Sort(static (n1, n2) => n1.SpanStart.CompareTo(n2.SpanStart));

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

108return node.SpanStart;

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

85var spanStart = documentationComment.SpanStart;

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

774!forEachExpression.Span.Contains(OriginalExpression.SpanStart)) 869newSymbol = this.OriginalSemanticModel.GetSpeculativeSymbolInfo(type.SpanStart, newType, bindingOption).Symbol;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.cs (1)

603return declarationSyntax != null && position < declarationSyntax.SpanStart;

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

205var afterMember = declarationList.LastOrDefault(m => m.SpanStart <= info.Context.AfterThisLocation.SourceSpan.Start);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Editing\ImportAdderService.cs (1)

259var containedNamespace = model.GetEnclosingNamespace(node.SpanStart, cancellationToken);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\SemanticsFactsService\AbstractSemanticFactsService.cs (1)

93=> semanticModel.LookupSymbols(location.SpanStart).Concat(semanticModel.GetAllDeclaredSymbols(container, cancellationToken));

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\SemanticModelReuse\AbstractSemanticModelReuseLanguageService.cs (2)

84if (previousBodyNode?.SpanStart != currentBodyNode.SpanStart)

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

305Math.Min(fullSpan.Start, node.SpanStart), 321var end = endNode.SpanStart; 846=> x?.SpanStart == y?.SpanStart; 849=> obj.SpanStart; 926condDirectivesBuilder.Sort(static (n1, n2) => n1.SpanStart.CompareTo(n2.SpanStart));

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

108return node.SpanStart;

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

85var spanStart = documentationComment.SpanStart;

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

774!forEachExpression.Span.Contains(OriginalExpression.SpanStart)) 869newSymbol = this.OriginalSemanticModel.GetSpeculativeSymbolInfo(type.SpanStart, newType, bindingOption).Symbol;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.cs (1)

603return declarationSyntax != null && position < declarationSyntax.SpanStart;

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

305Math.Min(fullSpan.Start, node.SpanStart), 321var end = endNode.SpanStart; 846=> x?.SpanStart == y?.SpanStart; 849=> obj.SpanStart; 926condDirectivesBuilder.Sort(static (n1, n2) => n1.SpanStart.CompareTo(n2.SpanStart));

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

108return node.SpanStart;

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

85var spanStart = documentationComment.SpanStart;

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

774!forEachExpression.Span.Contains(OriginalExpression.SpanStart)) 869newSymbol = this.OriginalSemanticModel.GetSpeculativeSymbolInfo(type.SpanStart, newType, bindingOption).Symbol;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.cs (1)

603return declarationSyntax != null && position < declarationSyntax.SpanStart;

Syntax\SyntaxNodeOrToken.cs (1)

263return _nodeOrParent.SpanStart;

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

305Math.Min(fullSpan.Start, node.SpanStart), 321var end = endNode.SpanStart; 846=> x?.SpanStart == y?.SpanStart; 849=> obj.SpanStart; 926condDirectivesBuilder.Sort(static (n1, n2) => n1.SpanStart.CompareTo(n2.SpanStart));

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

108return node.SpanStart;

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

85var spanStart = documentationComment.SpanStart;

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

774!forEachExpression.Span.Contains(OriginalExpression.SpanStart)) 869newSymbol = this.OriginalSemanticModel.GetSpeculativeSymbolInfo(type.SpanStart, newType, bindingOption).Symbol;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.cs (1)

603return declarationSyntax != null && position < declarationSyntax.SpanStart;

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

205var afterMember = declarationList.LastOrDefault(m => m.SpanStart <= info.Context.AfterThisLocation.SourceSpan.Start);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Editing\ImportAdderService.cs (1)

259var containedNamespace = model.GetEnclosingNamespace(node.SpanStart, cancellationToken);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\SemanticsFactsService\AbstractSemanticFactsService.cs (1)

93=> semanticModel.LookupSymbols(location.SpanStart).Concat(semanticModel.GetAllDeclaredSymbols(container, cancellationToken));

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\SemanticModelReuse\AbstractSemanticModelReuseLanguageService.cs (2)

84if (previousBodyNode?.SpanStart != currentBodyNode.SpanStart)

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\ParameterValidationAnalysis\ParameterValidationAnalysis.ParameterValidationDataFlowOperationVisitor.cs (2)

197syntaxNode.SpanStart < currentSyntaxNode.SpanStart)

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

305Math.Min(fullSpan.Start, node.SpanStart), 321var end = endNode.SpanStart; 846=> x?.SpanStart == y?.SpanStart; 849=> obj.SpanStart; 926condDirectivesBuilder.Sort(static (n1, n2) => n1.SpanStart.CompareTo(n2.SpanStart));

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

108return node.SpanStart;

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

85var spanStart = documentationComment.SpanStart;

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

774!forEachExpression.Span.Contains(OriginalExpression.SpanStart)) 869newSymbol = this.OriginalSemanticModel.GetSpeculativeSymbolInfo(type.SpanStart, newType, bindingOption).Symbol;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.cs (1)

603return declarationSyntax != null && position < declarationSyntax.SpanStart;

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

305Math.Min(fullSpan.Start, node.SpanStart), 321var end = endNode.SpanStart; 846=> x?.SpanStart == y?.SpanStart; 849=> obj.SpanStart; 926condDirectivesBuilder.Sort(static (n1, n2) => n1.SpanStart.CompareTo(n2.SpanStart));

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

108return node.SpanStart;

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

85var spanStart = documentationComment.SpanStart;

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

774!forEachExpression.Span.Contains(OriginalExpression.SpanStart)) 869newSymbol = this.OriginalSemanticModel.GetSpeculativeSymbolInfo(type.SpanStart, newType, bindingOption).Symbol;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.cs (1)

603return declarationSyntax != null && position < declarationSyntax.SpanStart;

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

205var afterMember = declarationList.LastOrDefault(m => m.SpanStart <= info.Context.AfterThisLocation.SourceSpan.Start);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Editing\ImportAdderService.cs (1)

259var containedNamespace = model.GetEnclosingNamespace(node.SpanStart, cancellationToken);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\SemanticsFactsService\AbstractSemanticFactsService.cs (1)

93=> semanticModel.LookupSymbols(location.SpanStart).Concat(semanticModel.GetAllDeclaredSymbols(container, cancellationToken));

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\SemanticModelReuse\AbstractSemanticModelReuseLanguageService.cs (2)

84if (previousBodyNode?.SpanStart != currentBodyNode.SpanStart)

src\Analyzers\Core\Analyzers\RemoveUnnecessaryImports\AbstractRemoveUnnecessaryImportsDiagnosticAnalyzer.cs (1)

147foreach (var node in nodes.OrderBy(n => n.SpanStart))

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

127var spanStart = firstBlock.Syntax.SpanStart;

src\Analyzers\Core\Analyzers\UseCollectionInitializer\AbstractUseCollectionInitializerAnalyzer.cs (1)

210_objectCreationExpression.SpanStart,

src\Analyzers\Core\Analyzers\UseCollectionInitializer\UseCollectionInitializerHelpers.cs (4)

36syntaxTree.GetLocation(TextSpan.FromBounds(match.SpanStart, arguments[0].SpanStart)), 48syntaxTree.GetLocation(TextSpan.FromBounds(match.SpanStart, expression.SpanStart)),

src\Analyzers\Core\Analyzers\UseObjectInitializer\AbstractUseObjectInitializerDiagnosticAnalyzer.cs (1)

153match.MemberAccessExpression.SpanStart, end));

src\Analyzers\Core\Analyzers\UseObjectInitializer\UseNamedMemberInitializerAnalyzer.cs (2)

215if (expression != null && expression.SpanStart < _objectCreationExpression.SpanStart)

src\Analyzers\Core\Analyzers\ValidateFormatString\AbstractValidateFormatStringDiagnosticAnalyzer.cs (1)

155formatString, formatStringLiteralExpressionSyntax.SpanStart);

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

305Math.Min(fullSpan.Start, node.SpanStart), 321var end = endNode.SpanStart; 846=> x?.SpanStart == y?.SpanStart; 849=> obj.SpanStart; 926condDirectivesBuilder.Sort(static (n1, n2) => n1.SpanStart.CompareTo(n2.SpanStart));

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

108return node.SpanStart;

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

85var spanStart = documentationComment.SpanStart;

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

774!forEachExpression.Span.Contains(OriginalExpression.SpanStart)) 869newSymbol = this.OriginalSemanticModel.GetSpeculativeSymbolInfo(type.SpanStart, newType, bindingOption).Symbol;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.cs (1)

603return declarationSyntax != null && position < declarationSyntax.SpanStart;

src\Analyzers\Core\CodeFixes\AddExplicitCast\AbstractAddExplicitCastCodeFixProvider.cs (1)

95var title = GetSubItemName(semanticModel, targetNode.SpanStart, conversionType);

src\Analyzers\Core\CodeFixes\AddObsoleteAttribute\AbstractAddObsoleteAttributeCodeFixProvider.cs (2)

66return _syntaxFacts.GetContainingMemberDeclaration(root, node.SpanStart) ?? 67_syntaxFacts.GetContainingTypeDeclaration(root, node.SpanStart);

src\Analyzers\Core\CodeFixes\AddParameter\AbstractAddParameterCodeFixProvider.cs (1)

88if (semanticModel.GetEnclosingSymbol(node.SpanStart, cancellationToken) is IMethodSymbol methodWithDiagnostic)

src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateConversionService.State.cs (2)

67ContainingType = document.SemanticModel.GetEnclosingNamedType(node.SpanStart, cancellationToken); 91ContainingType = document.SemanticModel.GetEnclosingNamedType(node.SpanStart, cancellationToken);

src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateDeconstructMethodService.State.cs (1)

59ContainingType = semanticModel.GetEnclosingNamedType(targetVariables.SpanStart, cancellationToken);

src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateMethodService.State.cs (2)

103ContainingType = semanticModel.GetEnclosingNamedType(methodDeclaration.SpanStart, cancellationToken); 152ContainingType = semanticModel.GetEnclosingNamedType(SimpleNameOpt.SpanStart, cancellationToken);

src\Analyzers\Core\CodeFixes\GenerateVariable\AbstractGenerateVariableService.State.cs (1)

476var enclosingMethodSymbol = _document.SemanticModel.GetEnclosingSymbol<IMethodSymbol>(SimpleNameOrMemberAccessExpressionOpt.SpanStart, cancellationToken);

src\Analyzers\Core\CodeFixes\ImplementInterface\ImplementInterfaceGenerator_DisposePattern.cs (1)

94.OrderByDescending(n => n.SpanStart)

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

887memberDeclaration = syntaxFacts.GetContainingMemberDeclaration(root, memberDeclaration.SpanStart) ?? root;

src\Analyzers\Core\CodeFixes\UseConditionalExpression\ForReturn\AbstractUseConditionalExpressionForReturnCodeFixProvider.cs (1)

56var containingSymbol = semanticModel.GetRequiredEnclosingSymbol(ifStatement.SpanStart, cancellationToken);

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

205var afterMember = declarationList.LastOrDefault(m => m.SpanStart <= info.Context.AfterThisLocation.SourceSpan.Start);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Editing\ImportAdderService.cs (1)

259var containedNamespace = model.GetEnclosingNamespace(node.SpanStart, cancellationToken);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\SemanticsFactsService\AbstractSemanticFactsService.cs (1)

93=> semanticModel.LookupSymbols(location.SpanStart).Concat(semanticModel.GetAllDeclaredSymbols(container, cancellationToken));

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\SemanticModelReuse\AbstractSemanticModelReuseLanguageService.cs (2)

84if (previousBodyNode?.SpanStart != currentBodyNode.SpanStart)

Binder\Binder_Expressions.cs (2)

2258if (node.SpanStart >= declarator.SpanStart) 9525location = expr.Syntax.SyntaxTree.GetLocation(TextSpan.FromBounds(expr.Syntax.SpanStart, conditional.OperatorToken.Span.End));

Binder\BinderFactory.cs (2)

111int position = node.SpanStart; 192Binder result = visitor.VisitNamespaceDeclaration((BaseNamespaceDeclarationSyntax)unit, unit.SpanStart, inBody: true, inUsing: false);

Compilation\CSharpSemanticModel.cs (2)

445if (position == node.SpanStart) 1318var position = node.SpanStart;

Compilation\MemberSemanticModel.cs (1)

1651CSharpSyntaxNode enclosingLambdaOrQuery = GetInnermostLambdaOrQuery(lambdaOrQuery, lambdaOrQuery.SpanStart, allowStarting: false);

FlowAnalysis\AbstractFlowPass.cs (1)

201int startLocation = firstInRegion.Syntax.SpanStart;

FlowAnalysis\NullableWalker.cs (2)

9978conversionOpt.Syntax.SpanStart != convertedNode.Syntax.SpanStart)

FlowAnalysis\NullableWalker.SnapshotManager.cs (2)

111int nodePosition = node.Syntax.SpanStart; 217_incrementalSnapshots[node.Syntax.SpanStart] = new Snapshot(currentState.CreateSnapshot(), _currentWalkerSlot);

FlowAnalysis\RegionAnalysisContext.cs (1)

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

Lowering\StateMachineRewriter\MethodToStateMachineRewriter.cs (1)

228int syntaxOffset = CurrentMethod.CalculateLocalSyntaxOffset(node.SpanStart, node.SyntaxTree);

Operations\CSharpOperationFactory.cs (1)

2077legacyMode ? null : new SynthesizedLocal((_semanticModel.GetEnclosingSymbol(boundLockStatement.Syntax.SpanStart) as IMethodSymbol).GetSymbol(),

Symbols\LexicalSortKey.cs (1)

83: this(node.SyntaxTree, node.SpanStart, compilation)

Symbols\Source\SourceConstructorSymbolBase.cs (1)

192if (position == ctorSyntax.SpanStart)

Symbols\Source\SourceMemberContainerSymbol.cs (1)

4569Debug.Assert(node.SpanStart > initializers.Last().Syntax.Span.Start);

Symbols\Source\SourceMemberMethodSymbol.cs (1)

1113return localPosition - bodySyntax.SpanStart;

Syntax\LambdaUtilities.cs (1)

483return (node is SwitchExpressionSyntax switchExpression) ? switchExpression.SwitchKeyword.SpanStart : node.SpanStart;

Syntax\LookupPosition.cs (1)

90return IsBeforeToken(position, firstExcluded) && position >= node.SpanStart;

src\Analyzers\CSharp\Analyzers\ConvertNamespace\ConvertToBlockScopedNamespaceDiagnosticAnalyzer.cs (1)

54: declaration.SyntaxTree.GetLocation(TextSpan.FromBounds(declaration.SpanStart, declaration.SemicolonToken.Span.End));

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

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

src\Analyzers\CSharp\Analyzers\InlineDeclaration\CSharpInlineDeclarationDiagnosticAnalyzer.cs (2)

154if (localDeclarator.SpanStart >= argumentNode.SpanStart)

src\Analyzers\CSharp\Analyzers\InvokeDelegateWithConditionalAccess\InvokeDelegateWithConditionalAccessAnalyzer.cs (1)

183var fadeLocation = Location.Create(tree, TextSpan.FromBounds(firstStatement.SpanStart, previousToken.Span.End));

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

230var startReportSpan = TextSpan.FromBounds(anonymousFunction.SpanStart, invokedExpression.SpanStart);

src\Analyzers\CSharp\Analyzers\RemoveUnnecessaryNullableDirective\CSharpRemoveUnnecessaryNullableDirectiveDiagnosticAnalyzer.cs (2)

127|| !possibleNullableImpactIntervalTree.HasIntervalThatOverlapsWith(currentOptionsDirective.Span.End, nullableDirectiveTrivia.SpanStart - currentOptionsDirective.Span.End)) 205positionOfFirstReducingNullableDirective = directive.SpanStart;

src\Analyzers\CSharp\Analyzers\RemoveUnnecessaryNullableDirective\NullableImpactingSpanWalker.cs (1)

52if (_ignoredSpans.HasIntervalThatContains(node.SpanStart, node.Span.Length))

src\Analyzers\CSharp\Analyzers\RemoveUnreachableCode\CSharpRemoveUnreachableCodeDiagnosticAnalyzer.cs (2)

74return firstUnreachableStatement != null && firstUnreachableStatement.SpanStart == node.SpanStart

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

219expression.SpanStart,

src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForCreateDiagnosticAnalyzer.cs (1)

61invocationExpression.SpanStart,

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

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

src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForNewDiagnosticAnalyzer.cs (1)

103objectCreationExpression.SpanStart,

src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForStackAllocDiagnosticAnalyzer.cs (2)

71expression.SpanStart, 111expression.SpanStart,

src\Analyzers\CSharp\Analyzers\UseDeconstruction\CSharpUseDeconstructionDiagnosticAnalyzer.cs (1)

207var reservedNames = semanticModel.LookupSymbols(container.SpanStart)

src\Analyzers\CSharp\Analyzers\UseExpressionBodyForLambda\UseExpressionBodyForLambdaDiagnosticAnalyzer.cs (1)

105TextSpan.FromBounds(declaration.SpanStart, declaration.ArrowToken.Span.End));

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

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

src\Analyzers\CSharp\Analyzers\UseInferredMemberName\CSharpUseInferredMemberNameDiagnosticAnalyzer.cs (2)

50var fadeSpan = TextSpan.FromBounds(nameColon.Name.SpanStart, nameColon.ColonToken.Span.End); 76var fadeSpan = TextSpan.FromBounds(nameEquals.Name.SpanStart, nameEquals.EqualsToken.Span.End);

src\Analyzers\CSharp\Analyzers\UseLocalFunction\CSharpUseLocalFunctionDiagnosticAnalyzer.cs (2)

244var anonymousFunctionStart = anonymousFunction.SpanStart; 401var localEnclosingSymbol = semanticModel.GetEnclosingSymbol(localDeclaration.SpanStart, cancellationToken);

src\Analyzers\CSharp\Analyzers\UseNameofInNullableAttribute\CSharpUseNameofInNullableAttributeDiagnosticAnalyzer.cs (2)

88var position = argument.Expression.SpanStart; 96var symbols = semanticModel.LookupSymbols(argument.Expression.SpanStart, name: stringValue);

src\Analyzers\CSharp\Analyzers\UsePatternCombinators\AnalyzedPattern.cs (1)

62if (operation.SemanticModel.TryGetSpeculativeSemanticModel(typeSyntax.SpanStart, dummyStatement, out var speculativeModel))

src\Analyzers\CSharp\Analyzers\UsePatternMatching\CSharpAsAndNullCheckDiagnosticAnalyzer.Analyzer.cs (5)

256if (node.SpanStart < _localStatement.Span.End) 260if (node.Span.End >= _comparison.SpanStart) 351var localStatementStart = _localStatement.SpanStart; 352var comparisonSpanStart = _comparison.SpanStart; 359var descendentNodeSpanStart = descendentNode.SpanStart;

src\Analyzers\CSharp\Analyzers\UsePatternMatching\CSharpAsAndNullCheckDiagnosticAnalyzer.cs (5)

166var localStatementStart = localStatement.SpanStart; 167var comparisonSpanStart = comparison.SpanStart; 171var descendentNodeSpanStart = descendentNode.SpanStart; 212var descendentNodeSpanStart = descendentNode.SpanStart; 233var descendentNodeSpanStart = descendentNode.SpanStart;

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

574var symbols = semanticModel.LookupSymbols(operation.Syntax.SpanStart, name: parameter.Name);

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

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

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

72if (conditionalDirectives.First().SpanStart <= block.OpenBraceToken.SpanStart ||

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

338var potentialType = semanticModel.GetSpeculativeTypeInfo(expression.SpanStart, expression, SpeculativeBindingOption.BindAsTypeOrNamespace).Type;

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

125return semanticModel.LookupSymbols(expr.SpanStart, container: symbol, name: name, includeReducedExtensionMethods: true);

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

575if (!textSpan.Contains(directives[0].SpanStart) || 576!textSpan.Contains(directives.Last().SpanStart))

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

74if (trivia.Span.End == currentParent.SpanStart ||

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

922var member = GetContainingMemberDeclaration(node, node.SpanStart);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Utilities\SpeculationAnalyzer.cs (1)

118var position = originalNode.SpanStart;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Utilities\TypeStyle\CSharpUseImplicitTypeHelper.cs (1)

106var conflict = semanticModel.GetSpeculativeSymbolInfo(typeName.SpanStart, candidateReplacementNode, SpeculativeBindingOption.BindAsTypeOrNamespace).Symbol;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Utilities\UsingsAndExternAliasesOrganizer.cs (1)

119.OrderBy(n => n.SpanStart).ToList();

src\Analyzers\CSharp\CodeFixes\AddExplicitCast\ArgumentFixer.cs (1)

32return semanticModel.GetSpeculativeSymbolInfo(newInvocation.SpanStart, newInvocation, SpeculativeBindingOption.BindAsExpression);

src\Analyzers\CSharp\CodeFixes\AddExplicitCast\AttributeArgumentFixer.cs (1)

32return semanticModel.GetSpeculativeSymbolInfo(newAttribute.SpanStart, newAttribute);

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

415var outerIndentation = document.Text.GetLeadingWhitespaceOfLineAtPosition(fileScopedNamespace.SpanStart);

src\Analyzers\CSharp\CodeFixes\GenerateConstructor\CSharpGenerateConstructorService.cs (1)

56var currentType = semanticModel.GetEnclosingNamedType(constructorInitializer.SpanStart, cancellationToken);

src\Analyzers\CSharp\CodeFixes\GenerateParameterizedMember\CSharpGenerateMethodService.cs (1)

150if (semanticModel.SyntaxTree.IsNameOfContext(expression.SpanStart, semanticModel, cancellationToken))

src\Analyzers\CSharp\CodeFixes\InlineDeclaration\CSharpInlineDeclarationCodeFixProvider.cs (1)

355topmostContainer.SpanStart, updatedTopmostContainer, out var speculativeModel))

src\Analyzers\CSharp\CodeFixes\Iterator\CSharpChangeToIEnumerableCodeFixProvider.cs (2)

104type.ToMinimalDisplayString(model, node.SpanStart), 105ienumerableGenericSymbol.ToMinimalDisplayString(model, node.SpanStart));

src\Analyzers\CSharp\CodeFixes\NewLines\ArrowExpressionClausePlacement\ArrowExpressionClausePlacementCodeFixProvider.cs (1)

93edits.Add(new TextChange(new TextSpan(nextExpression.SpanStart, 0), token.Text + " "));

src\Analyzers\CSharp\CodeFixes\NewLines\ConditionalExpressionPlacement\ConditionalExpressionPlacementCodeFixProvider.cs (1)

95edits.Add(new TextChange(new TextSpan(nextExpression.SpanStart, 0), token.Text + " "));

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

547var startLine = document.Text.Lines.GetLineFromPosition(GetAnchorNode(expression).SpanStart); 841var lineToConsider = text.Lines.GetLineFromPosition(expressionToReplace.SpanStart);

src\Analyzers\CSharp\CodeFixes\UseIndexOrRangeOperator\CSharpUseRangeOperatorCodeFixProvider.cs (1)

51.OrderByDescending(i => i.SpanStart)

src\Analyzers\CSharp\CodeFixes\UseLocalFunction\CSharpUseLocalFunctionCodeFixProvider.cs (1)

100foreach (var (localDeclaration, anonymousFunction, references) in nodesFromDiagnostics.OrderByDescending(nodes => nodes.function.SpanStart))

src\Analyzers\CSharp\CodeFixes\UseUtf8StringLiteral\UseUtf8StringLiteralCodeFixProvider.cs (1)

120.Where(a => a.Initializer?.ElementValues.FirstOrDefault()?.Syntax.SpanStart == diagnostic.Location.SourceSpan.Start)

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

42var start = usings.First().SpanStart; 51var start = rootUsings.First().SpanStart;

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

883if (firstConstructorConstraint == null || firstConstructorConstraint.SpanStart > token.Span.End) 1373return IsAtStartOfPattern(syntaxTree, parenthesizedExpression.GetFirstToken().GetPreviousToken(), parenthesizedExpression.SpanStart); 1565=> node.FindTokenOnLeftOfPosition(node.SpanStart); 2897var tokenBeforeName = syntaxTree.FindTokenOnLeftOfPosition(nameExpr.SpanStart, cancellationToken); 2903if (syntaxTree.IsExpressionContext(nameExpr.SpanStart, tokenBeforeName, attributes: false, cancellationToken))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\ExpressionSyntaxExtensions.cs (2)

177name.SpanStart, name, SpeculativeBindingOption.BindAsExpression); 180name.SpanStart, name, SpeculativeBindingOption.BindAsExpression).Type;

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

35var end = destination.Members.First().SpanStart;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Indentation\CSharpIndentationService.Indenter.cs (1)

410if (firstToken.SpanStart <= clause.SpanStart)

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

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

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

39var visibleSymbols = semanticModel.LookupSymbols(location.SpanStart);

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

261return InferTypes(expression.SpanStart); 1296=> InferTypes(implicitArray.SpanStart); 2217if (descendant.SpanStart <= afterNode.Span.End)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\SemanticModelReuse\CSharpSemanticModelReuseLanguageService.cs (2)

59previousSemanticModel.TryGetSpeculativeSemanticModelForMethodBody(previousBaseMethod.Body.SpanStart, currentBaseMethod, out var speculativeModel)) 67previousSemanticModel.TryGetSpeculativeSemanticModelForMethodBody(previousAccessorDeclaration.Body.SpanStart, currentAccessorDeclaration, out speculativeModel))

AutomaticCompletion\AutomaticLineEnderCommandHandler.cs (2)

615CatchClauseSyntax catchClauseNode => catchClauseNode.Block.SpanStart, 616FinallyClauseSyntax finallyClauseNode => finallyClauseNode.Block.SpanStart,

CompleteStatement\CompleteStatementCommandHandler.cs (3)

440return caretPosition > condition.SpanStart && caretPosition <= condition.Span.End; 490if (caret.Position <= currentNode.SpanStart + 1) 493else if (caret.Position <= currentNode.SpanStart)

StringCopyPaste\KnownSourcePasteProcessor.cs (1)

258if (line == TextBeforePaste.Lines.GetLineFromPosition(StringExpressionBeforePaste.SpanStart).LineNumber)

StringCopyPaste\StringCopyPasteCommandHandler.cs (1)

274var stringExpressionAfterPaste = FindContainingSupportedStringExpression(rootAfterPaste, stringExpressionBeforePaste.SpanStart);

StringCopyPaste\StringInfo.cs (10)

86var start = literal.SpanStart; 89var delimiterQuoteCount = start - literal.SpanStart; 104startDelimiterSpan: TextSpan.FromBounds(literal.SpanStart, start), 145TextSpan.FromBounds(literal.SpanStart, rawStart), 158var start = literal.SpanStart; 175startDelimiterSpan: TextSpan.FromBounds(literal.SpanStart, start), 187var start = interpolatedString.SpanStart; 190var delimiterDollarCount = start - interpolatedString.SpanStart; 209result.Add(TextSpan.FromBounds(currentPosition, content.SpanStart)); 219startDelimiterSpan: TextSpan.FromBounds(interpolatedString.SpanStart, interpolatedString.StringStartToken.Span.End),

StringCopyPaste\UnknownSourcePasteProcessor.cs (1)

271if (line == TextBeforePaste.Lines.GetLineFromPosition(StringExpressionBeforePaste.SpanStart).LineNumber)

CodeGeneration\SyntaxGeneratorTests.cs (1)

85statement.SpanStart, replacement,

TypeInferrer\TypeInferrerTests.cs (1)

35var position = node?.SpanStart ?? textSpan.Start;

CodeGen\CodeGenDeconstructTests.cs (8)

CodeGen\CodeGenTupleTest.cs (3)

12695var m1Tuple = model.LookupSymbols(node.SpanStart, name: "v1").OfType<ILocalSymbol>().Single().Type.GetSymbol<NamedTypeSymbol>(); 12696var m2Tuple = model.LookupSymbols(node.SpanStart, name: "v2").OfType<ILocalSymbol>().Single().Type.GetSymbol<NamedTypeSymbol>(); 12697var m6Tuple = model.LookupSymbols(node.SpanStart, name: "v6").OfType<ILocalSymbol>().Single().Type.GetSymbol<NamedTypeSymbol>();

FieldKeywordTests.cs (2)

10480Assert.True(model.TryGetSpeculativeSemanticModelForMethodBody(previousAccessor.Body.SpanStart, modifiedAccessor, out var speculativeModel)); 10514Assert.True(model.TryGetSpeculativeSemanticModelForMethodBody(previousAccessor.Body.SpanStart, modifiedAccessor, out var speculativeModel));

FirstClassSpanTests.cs (1)

5037var lookupResult = model.LookupSymbols(d1Access.Name.SpanStart, aSymbol.Type, "M", includeReducedExtensionMethods: true);

FlowAnalysis\FlowTestBase.cs (4)

147if (expr.SpanStart >= start && expr.Span.End <= end) 168if (expr.SpanStart >= start && expr.Span.End <= end) 200if (expr.SpanStart >= start && expr.Span.End <= end) 221if (firstStatement == null && stmt.SpanStart >= start)

Semantics\ExtensionTests.cs (2)

33018AssertEqualAndNoDuplicates(["void E.<>E__0<T>.M<U>(U u)"], model.LookupSymbols(position: expr.SpanStart, t, name: "M", includeReducedExtensionMethods: true).ToTestDisplayStrings()); 33061AssertEqualAndNoDuplicates(["void T.M<T>()"], model.LookupSymbols(position: expr.SpanStart, t, name: "M", includeReducedExtensionMethods: true).ToTestDisplayStrings());

Semantics\OutVarTests.cs (53)

Semantics\PatternMatchingTestBase.cs (25)

Semantics\PatternMatchingTests_Scope.cs (16)

Semantics\PatternMatchingTests4.cs (11)

Semantics\PrimaryConstructorTests.cs (82)

Semantics\RecordTests.cs (71)

ChangeSignature\CSharpChangeSignatureService.cs (7)

221matchingNode.SpanStart; 432originalNode.SpanStart, 454originalNode.SpanStart, 470originalNode.SpanStart, 486originalNode.SpanStart, 507originalNode.SpanStart, 523originalNode.SpanStart,

CodeRefactorings\InlineTemporary\InlineTemporaryCodeRefactoringProvider.cs (2)

103if (identifier.SpanStart < variableDeclarator.SpanStart)

Completion\CompletionProviders\AwaitCompletionProvider.cs (4)

40MethodDeclarationSyntax method => method.ReturnType.SpanStart, 41LocalFunctionStatementSyntax local => local.ReturnType.SpanStart, 46ParenthesizedLambdaExpressionSyntax parenthesizedLambda => (parenthesizedLambda.ReturnType as SyntaxNode ?? parenthesizedLambda.ParameterList).SpanStart, 47SimpleLambdaExpressionSyntax simpleLambda => simpleLambda.Parameter.SpanStart,

Completion\CompletionProviders\CSharpSuggestionModeCompletionProvider.cs (1)

138position = token.Parent.SpanStart;

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

147var type = typeInferenceService.InferType(semanticModel, argument.SpanStart, objectAsDefault: false, cancellationToken: cancellationToken);

Completion\CompletionProviders\ExplicitInterfaceMemberCompletionProvider.ItemGetter.cs (1)

123var namePosition = name.SpanStart;

Completion\CompletionProviders\OperatorsAndIndexer\UnnamedSymbolCompletionProvider.cs (1)

93return (dotToken, expression.SpanStart);

Completion\CompletionProviders\OperatorsAndIndexer\UnnamedSymbolCompletionProvider_Conversions.cs (1)

95builder.Add(new TextChange(new TextSpan(expression.SpanStart, 0), castText));

Completion\CompletionProviders\OverrideCompletionProvider.cs (1)

89if (token.SpanStart < parentMember.SpanStart)

ConvertLinq\ConvertForEachToLinqQuery\CSharpConvertForEachToLinqQueryProvider.cs (1)

290statement.SpanStart, cancellationToken), memberDeclarationSymbol)).Count();

ConvertLinq\CSharpConvertLinqQueryToForEachProvider.cs (1)

779declaredSymbol = _semanticModel.GetEnclosingSymbol(node.SpanStart, _cancellationToken);

ConvertNamespace\ConvertNamespaceCodeRefactoringProvider.cs (1)

75if (position < baseDeclaration.SpanStart)

ConvertPrimaryToRegularConstructor\ConvertPrimaryToRegularConstructorCodeRefactoringProvider.cs (1)

478foreach (var (fieldOrProperty, initializer) in initializedFieldsAndProperties.Where(i => ReferenceEquals(i.initializer.SyntaxTree, location.SourceTree)).OrderBy(i => i.initializer.SpanStart))

ConvertToRawString\ConvertInterpolatedStringToRawStringCodeRefactoringProvider.cs (4)

244var startLine = document.Text.Lines.GetLineFromPosition(GetAnchorNode(document, stringExpression).SpanStart); 358var interpolationLine = text.Lines.GetLineFromPosition(interpolation.SpanStart); 364interpolationLine.GetFirstNonWhitespacePosition() == interpolation.SpanStart) 367return GetIndentationStringForPosition(text, formattingOptions, interpolation.SpanStart);

EditAndContinue\BreakpointSpans.cs (3)

117=> TextSpan.FromBounds(node.SpanStart, token.Span.End); 214if (position <= typeDeclaration.ParameterList.SpanStart) 811position = variableDeclaration.SpanStart;

EditAndContinue\CSharpEditAndContinueAnalyzer.cs (12)

194position = body.SpanStart; 238Debug.Assert(position == ((PropertyDeclarationSyntax)node).Initializer!.SpanStart); 289Debug.Assert(position == ((SwitchExpressionArmSyntax)node).Expression.SpanStart); 321position < node.Expression.SpanStart ? ForEachPart.In : 328ForEachPart.VariableDeclaration => TextSpan.FromBounds(node.Type.SpanStart, node.Identifier.Span.End), 338ForEachPart.VariableDeclaration => TextSpan.FromBounds(node.Variable.SpanStart, node.Variable.Span.End), 620BreakpointSpans.TryGetClosestBreakpointSpan(node, propertyDeclaration.Initializer.SpanStart, minLength, out span)) 660return BreakpointSpans.TryGetClosestBreakpointSpan(node, node.SpanStart, minLength, out span); 1398return model.GetEnclosingSymbol(node.SpanStart, cancellationToken); 1403return model.GetEnclosingSymbol(primaryCtorBase.ArgumentList.SpanStart, cancellationToken); 1489return (IMethodSymbol)model.GetRequiredEnclosingSymbol(bodyExpression.SpanStart, cancellationToken); 2688tryStatement.Catches.First().SpanStart,

EditAndContinue\DeclarationBody\TopLevelCodeDeclarationBody.cs (1)

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

ExtractMethod\CSharpMethodExtractor.cs (2)

187!methodDefinition.FindTokenOnLeftOfPosition(methodDefinition.SpanStart).IsKind(SyntaxKind.OpenBraceToken)) 193if (!originalMethodDefinition.FindTokenOnLeftOfPosition(originalMethodDefinition.SpanStart).TrailingTrivia.Any(SyntaxKind.EndOfLineTrivia))

ExtractMethod\CSharpMethodExtractor.CSharpCodeGenerator.cs (2)

151var postProcessor = new PostProcessor(semanticModel, insertionPointNode.SpanStart); 786var postProcessor = new PostProcessor(semanticModel, insertionPointNode.SpanStart);

ExtractMethod\CSharpSelectionValidator.cs (1)

263var expressionBodiedMemberBody = TextSpan.FromBounds(expressionBodiedMember.Expression.SpanStart, expressionBodiedMember.Expression.Span.End);

GenerateType\CSharpGenerateTypeService.cs (3)

182var start = nameOrMemberAccessExpression.SpanStart; 509=> semanticModel.GetEnclosingNamedType(simpleName.SpanStart, cancellationToken); 745if (await IsWithinTheImportingNamespaceAsync(document, simpleName.SpanStart, includeUsingsOrImports, cancellationToken).ConfigureAwait(false))

GoToDefinition\CSharpGoToDefinitionSymbolService.cs (1)

84return target.DeclaringSyntaxReferences.FirstOrDefault()?.GetSyntax()?.SpanStart;

InlineHints\CSharpInlineTypeHintsService.cs (1)

123=> type.ToMinimalDisplayString(semanticModel, node.SpanStart, s_minimalTypeStyle);

IntroduceVariable\CSharpIntroduceVariableService_IntroduceField.cs (1)

37var typeDisplayString = oldType.ToMinimalDisplayString(document.SemanticModel, expression.SpanStart);

NavigationBar\CSharpNavigationBarItemService.cs (2)

273var spanStart = declaringNode.SpanStart; 304var start = enumMember.SpanStart;

QuickInfo\CSharpSemanticQuickInfoProvider.cs (1)

98var nullableContext = semanticModel.GetNullableContext(node.SpanStart);

QuickInfo\CSharpSyntacticQuickInfoProvider.cs (3)

74var spanStart = parent.SpanStart; 88spanStart = parent.Parent!.SpanStart; 152.TakeWhile(d => d.SpanStart < directiveTrivia.SpanStart)

SignatureHelp\AttributeSignatureHelpProvider.cs (2)

95.Sort(semanticModel, attribute.SpanStart); 135var position = attribute.SpanStart;

SignatureHelp\ElementAccessExpressionSignatureHelpProvider.cs (9)

100.Sort(semanticModel, expression.SpanStart); 143currentSpan.Start != expression.SpanStart) 160offset = expression.SpanStart - conditionalAccessExpression.SpanStart; 170offset = expression.SpanStart - elementAccessExpression.SpanStart; 337return TextSpan.FromBounds(expression.SpanStart, openBracket.Parent.Span.End); 384(c, elementBindingExpression) => c.SpanStart < elementBindingExpression.SpanStart, elementBindingExpression)!;

SignatureHelp\InvocationExpressionSignatureHelpProviderBase_DelegateAndFunctionPointerInvoke.cs (1)

41var position = invocationExpression.SpanStart;

SignatureHelp\InvocationExpressionSignatureHelpProviderBase_MethodGroup.cs (4)

30document, method, invocationExpression.SpanStart, semanticModel)); 61semanticModel.LookupSymbols(throughExpression.SpanStart, name: throughSymbol?.Name).Any(static s => s is not INamedTypeSymbol) || 62(throughSymbol is not INamespaceOrTypeSymbol && semanticModel.LookupSymbols(throughExpression.SpanStart, container: throughSymbol?.ContainingType).Any(static s => s is not INamedTypeSymbol)); 66semanticModel.LookupNamespacesAndTypes(throughExpression.SpanStart, name: throughSymbol?.Name).Any(static (t, throughType) => Equals(t.GetSymbolType(), throughType), throughType));

SignatureHelp\ObjectCreationExpressionSignatureHelpProvider_DelegateType.cs (1)

24objectCreationExpression.SpanStart,

SignatureHelp\ObjectCreationExpressionSignatureHelpProvider_NormalType.cs (1)

25var position = objectCreationExpression.SpanStart;

SignatureHelp\PrimaryConstructorBaseTypeSignatureHelpProvider.cs (1)

91.Sort(semanticModel, baseTypeSyntax.SpanStart);

SignatureHelp\SignatureHelpUtilities.cs (1)

95=> CommonSignatureHelpUtilities.GetSignatureHelpSpan(initializer, initializer.SpanStart, s_getInitializerExpressionCloseToken);

SignatureHelp\TupleConstructionSignatureHelpProvider.cs (4)

51if (currentSpan.Start == parenthesizedExpression.SpanStart) 77position = expression.SpanStart; 96position = expression.SpanStart; 134var inferredTypes = typeInferrer.InferTypes(semanticModel, targetExpression!.SpanStart, cancellationToken);

Snippets\AbstractCSharpAutoPropertySnippetProvider.cs (1)

85new SnippetPlaceholder(type.ToString(), type.SpanStart),

Snippets\AbstractCSharpForLoopSnippetProvider.cs (2)

103placeholderBuilder.Add(left.ToString(), left.SpanStart); 108placeholderBuilder.Add(operand.ToString(), operand.SpanStart);

Snippets\CSharpForEachLoopSnippetProvider.cs (1)

118arrayBuilder.Add(new SnippetPlaceholder(node.Expression.ToString(), node.Expression.SpanStart));

Snippets\CSharpForLoopSnippetProvider.cs (1)

38placeholderBuilder.Add(rightOfCondition.ToString(), rightOfCondition.SpanStart);

Snippets\CSharpLockSnippetProvider.cs (1)

31return [new SnippetPlaceholder(expression.ToString(), expression.SpanStart)];

Snippets\CSharpReversedForLoopSnippetProvider.cs (1)

44placeholderBuilder.Add(left.ToString(), left.SpanStart);

Snippets\CSharpSnippetHelpers.cs (1)

53var indentationString = GetBlockLikeIndentationString(document, block.SpanStart, syntaxFormattingOptions, cancellationToken);

Snippets\CSharpUsingSnippetProvider.cs (1)

31return [new SnippetPlaceholder(expression.ToString(), expression.SpanStart)];

SplitStringLiteral\InterpolatedStringSplitter.cs (1)

58beforeSplitContents.Add(CreateInterpolatedStringText(content.SpanStart, CursorPosition));

SplitStringLiteral\StringSplitter.cs (1)

89if (CursorPosition <= nodeToReplace.SpanStart || CursorPosition >= nodeToReplace.Span.End)

src\Analyzers\CSharp\Analyzers\ConvertNamespace\ConvertToBlockScopedNamespaceDiagnosticAnalyzer.cs (1)

54: declaration.SyntaxTree.GetLocation(TextSpan.FromBounds(declaration.SpanStart, declaration.SemicolonToken.Span.End));

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

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

src\Analyzers\CSharp\Analyzers\InlineDeclaration\CSharpInlineDeclarationDiagnosticAnalyzer.cs (2)

154if (localDeclarator.SpanStart >= argumentNode.SpanStart)

src\Analyzers\CSharp\Analyzers\InvokeDelegateWithConditionalAccess\InvokeDelegateWithConditionalAccessAnalyzer.cs (1)

183var fadeLocation = Location.Create(tree, TextSpan.FromBounds(firstStatement.SpanStart, previousToken.Span.End));

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

230var startReportSpan = TextSpan.FromBounds(anonymousFunction.SpanStart, invokedExpression.SpanStart);

src\Analyzers\CSharp\Analyzers\RemoveUnnecessaryNullableDirective\CSharpRemoveUnnecessaryNullableDirectiveDiagnosticAnalyzer.cs (2)

127|| !possibleNullableImpactIntervalTree.HasIntervalThatOverlapsWith(currentOptionsDirective.Span.End, nullableDirectiveTrivia.SpanStart - currentOptionsDirective.Span.End)) 205positionOfFirstReducingNullableDirective = directive.SpanStart;

src\Analyzers\CSharp\Analyzers\RemoveUnnecessaryNullableDirective\NullableImpactingSpanWalker.cs (1)

52if (_ignoredSpans.HasIntervalThatContains(node.SpanStart, node.Span.Length))

src\Analyzers\CSharp\Analyzers\RemoveUnreachableCode\CSharpRemoveUnreachableCodeDiagnosticAnalyzer.cs (2)

74return firstUnreachableStatement != null && firstUnreachableStatement.SpanStart == node.SpanStart

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

219expression.SpanStart,

src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForCreateDiagnosticAnalyzer.cs (1)

61invocationExpression.SpanStart,

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

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

src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForNewDiagnosticAnalyzer.cs (1)

103objectCreationExpression.SpanStart,

src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForStackAllocDiagnosticAnalyzer.cs (2)

71expression.SpanStart, 111expression.SpanStart,

src\Analyzers\CSharp\Analyzers\UseDeconstruction\CSharpUseDeconstructionDiagnosticAnalyzer.cs (1)

207var reservedNames = semanticModel.LookupSymbols(container.SpanStart)

src\Analyzers\CSharp\Analyzers\UseExpressionBodyForLambda\UseExpressionBodyForLambdaDiagnosticAnalyzer.cs (1)

105TextSpan.FromBounds(declaration.SpanStart, declaration.ArrowToken.Span.End));

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

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

src\Analyzers\CSharp\Analyzers\UseInferredMemberName\CSharpUseInferredMemberNameDiagnosticAnalyzer.cs (2)

50var fadeSpan = TextSpan.FromBounds(nameColon.Name.SpanStart, nameColon.ColonToken.Span.End); 76var fadeSpan = TextSpan.FromBounds(nameEquals.Name.SpanStart, nameEquals.EqualsToken.Span.End);

src\Analyzers\CSharp\Analyzers\UseLocalFunction\CSharpUseLocalFunctionDiagnosticAnalyzer.cs (2)

244var anonymousFunctionStart = anonymousFunction.SpanStart; 401var localEnclosingSymbol = semanticModel.GetEnclosingSymbol(localDeclaration.SpanStart, cancellationToken);

src\Analyzers\CSharp\Analyzers\UseNameofInNullableAttribute\CSharpUseNameofInNullableAttributeDiagnosticAnalyzer.cs (2)

88var position = argument.Expression.SpanStart; 96var symbols = semanticModel.LookupSymbols(argument.Expression.SpanStart, name: stringValue);

src\Analyzers\CSharp\Analyzers\UsePatternCombinators\AnalyzedPattern.cs (1)

62if (operation.SemanticModel.TryGetSpeculativeSemanticModel(typeSyntax.SpanStart, dummyStatement, out var speculativeModel))

src\Analyzers\CSharp\Analyzers\UsePatternMatching\CSharpAsAndNullCheckDiagnosticAnalyzer.Analyzer.cs (5)

256if (node.SpanStart < _localStatement.Span.End) 260if (node.Span.End >= _comparison.SpanStart) 351var localStatementStart = _localStatement.SpanStart; 352var comparisonSpanStart = _comparison.SpanStart; 359var descendentNodeSpanStart = descendentNode.SpanStart;

src\Analyzers\CSharp\Analyzers\UsePatternMatching\CSharpAsAndNullCheckDiagnosticAnalyzer.cs (5)

166var localStatementStart = localStatement.SpanStart; 167var comparisonSpanStart = comparison.SpanStart; 171var descendentNodeSpanStart = descendentNode.SpanStart; 212var descendentNodeSpanStart = descendentNode.SpanStart; 233var descendentNodeSpanStart = descendentNode.SpanStart;

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

574var symbols = semanticModel.LookupSymbols(operation.Syntax.SpanStart, name: parameter.Name);

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

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

src\Analyzers\CSharp\CodeFixes\AddExplicitCast\ArgumentFixer.cs (1)

32return semanticModel.GetSpeculativeSymbolInfo(newInvocation.SpanStart, newInvocation, SpeculativeBindingOption.BindAsExpression);

src\Analyzers\CSharp\CodeFixes\AddExplicitCast\AttributeArgumentFixer.cs (1)

32return semanticModel.GetSpeculativeSymbolInfo(newAttribute.SpanStart, newAttribute);

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

415var outerIndentation = document.Text.GetLeadingWhitespaceOfLineAtPosition(fileScopedNamespace.SpanStart);

src\Analyzers\CSharp\CodeFixes\GenerateConstructor\CSharpGenerateConstructorService.cs (1)

56var currentType = semanticModel.GetEnclosingNamedType(constructorInitializer.SpanStart, cancellationToken);

src\Analyzers\CSharp\CodeFixes\GenerateParameterizedMember\CSharpGenerateMethodService.cs (1)

150if (semanticModel.SyntaxTree.IsNameOfContext(expression.SpanStart, semanticModel, cancellationToken))

src\Analyzers\CSharp\CodeFixes\InlineDeclaration\CSharpInlineDeclarationCodeFixProvider.cs (1)

355topmostContainer.SpanStart, updatedTopmostContainer, out var speculativeModel))

src\Analyzers\CSharp\CodeFixes\Iterator\CSharpChangeToIEnumerableCodeFixProvider.cs (2)

104type.ToMinimalDisplayString(model, node.SpanStart), 105ienumerableGenericSymbol.ToMinimalDisplayString(model, node.SpanStart));

src\Analyzers\CSharp\CodeFixes\NewLines\ArrowExpressionClausePlacement\ArrowExpressionClausePlacementCodeFixProvider.cs (1)

93edits.Add(new TextChange(new TextSpan(nextExpression.SpanStart, 0), token.Text + " "));

src\Analyzers\CSharp\CodeFixes\NewLines\ConditionalExpressionPlacement\ConditionalExpressionPlacementCodeFixProvider.cs (1)

95edits.Add(new TextChange(new TextSpan(nextExpression.SpanStart, 0), token.Text + " "));

src\Analyzers\CSharp\CodeFixes\NewLines\EmbeddedStatementPlacement\EmbeddedStatementPlacementCodeFixProvider.cs (1)

82foreach (var badStatement in badStatements.OrderByDescending(s => s.SpanStart))

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

547var startLine = document.Text.Lines.GetLineFromPosition(GetAnchorNode(expression).SpanStart); 841var lineToConsider = text.Lines.GetLineFromPosition(expressionToReplace.SpanStart);

src\Analyzers\CSharp\CodeFixes\UseIndexOrRangeOperator\CSharpUseRangeOperatorCodeFixProvider.cs (1)

51.OrderByDescending(i => i.SpanStart)

src\Analyzers\CSharp\CodeFixes\UseLocalFunction\CSharpUseLocalFunctionCodeFixProvider.cs (1)

100foreach (var (localDeclaration, anonymousFunction, references) in nodesFromDiagnostics.OrderByDescending(nodes => nodes.function.SpanStart))

src\Analyzers\CSharp\CodeFixes\UseUtf8StringLiteral\UseUtf8StringLiteralCodeFixProvider.cs (1)

120.Where(a => a.Initializer?.ElementValues.FirstOrDefault()?.Syntax.SpanStart == diagnostic.Location.SourceSpan.Start)

src\Compilers\CSharp\Portable\Syntax\LambdaUtilities.cs (1)

483return (node is SwitchExpressionSyntax switchExpression) ? switchExpression.SwitchKeyword.SpanStart : node.SpanStart;

StringIndentation\CSharpStringIndentationService.cs (2)

143var holeStartLine = text.Lines.GetLineFromPosition(interpolation.SpanStart).LineNumber; 172var firstLine = text.Lines.GetLineFromPosition(expression.SpanStart);

Structure\CSharpStructureHelpers.cs (2)

382return TextSpan.FromBounds(node.SpanStart, endPos); 454var hintSpanStart = syntaxList.First().SpanStart;

Structure\Providers\CollectionExpressionStructureProvider.cs (1)

42var textSpan = TextSpan.FromBounds(node.SpanStart, end);

Structure\Providers\CompilationUnitStructureProvider.cs (2)

30externsAndUsings.Sort((node1, node2) => node1.SpanStart.CompareTo(node2.SpanStart));

Structure\Providers\DocumentationCommentStructureProvider.cs (1)

34var endPos = documentationComment.SpanStart + documentationComment.ToString().TrimEnd().Length;

Structure\Providers\IfDirectiveTriviaStructureProvider.cs (2)

42var startLineNumber = text.Lines.GetLineFromPosition(directive.SpanStart).LineNumber + 1; 43var endLineNumber = text.Lines.GetLineFromPosition(nextDirective.SpanStart).LineNumber - 1;

Structure\Providers\InitializerExpressionStructureProvider.cs (2)

46textSpan: TextSpan.FromBounds(node.SpanStart, end), 47hintSpan: TextSpan.FromBounds(node.SpanStart, end),

Structure\Providers\NamespaceDeclarationStructureProvider.cs (1)

39.OrderBy(node => node.SpanStart)

Structure\Providers\RegionDirectiveStructureProvider.cs (1)

54textSpan: TextSpan.FromBounds(regionDirective.SpanStart, match.Span.End),

UseExpressionBody\UseExpressionBodyCodeRefactoringProvider.cs (2)

98if (position < declaration.SpanStart) 104if (!text.AreOnSameLine(position, declaration.SpanStart))

UsePatternMatching\CSharpIsAndCastCheckWithoutNameDiagnosticAnalyzer.cs (1)

140.LookupSymbols(isExpression.SpanStart)

EditAndContinue\SyntaxUtilitiesTests.cs (2)

87var leftPosition = leftRoot.DescendantNodes().OfType<LiteralExpressionSyntax>().ElementAt(2).SpanStart; // 0 within Console.WriteLine(0) 134var leftPosition = leftRoot.DescendantNodes().OfType<LiteralExpressionSyntax>().ElementAt(5).SpanStart; // 3 within Console.WriteLine(3)

IOperation\IOperationTests.cs (1)

621bool success = model.TryGetSpeculativeSemanticModel(methodDecl.Body.Statements[0].SpanStart, speculatedBlock, out speculativeModel);

Semantics\BindingTests.cs (8)

3383var names = model.LookupNames(node1.SpanStart); 3391Assert.True(model.LookupSymbols(node1.SpanStart, name: "MathMin").IsEmpty); 3392Assert.Equal(1, model.LookupSymbols(node1.SpanStart, name: "MathMax").Length); 3393Assert.Equal(1, model.LookupSymbols(node1.SpanStart, name: "F1").Length); 3394Assert.True(model.LookupSymbols(node1.SpanStart, name: "F2").IsEmpty); 3395Assert.True(model.LookupSymbols(node1.SpanStart, name: "MathMax2").IsEmpty); 3396Assert.True(model.LookupSymbols(node1.SpanStart, name: "MathMax3").IsEmpty); 3398var symbols = model.LookupSymbols(node1.SpanStart);

Semantics\DelegateTypeTests.cs (1)

12209int position = syntax.SpanStart;

Semantics\ExpressionBodiedMemberTests.cs (1)

1027Assert.Equal($"System.Int32 y{i}", model.LookupSymbols(nodes[i].SpanStart, name: $"y{i}").Single().ToTestDisplayString());

Semantics\InitOnlyMemberTests.cs (1)

3147accessorDecl.Body.Statements[0].SpanStart, speculatedMethod, out speculativeModel);

Semantics\LambdaTests.cs (9)

944invocation.SpanStart, 1125.OrderByDescending(s => s.SpanStart); 3042var lambda = (IMethodSymbol)model.GetEnclosingSymbol(contentType.SpanStart); 3049lambda = (IMethodSymbol)model.GetEnclosingSymbol(b.SpanStart); 3054Assert.Equal("void Program.method1()", model.GetEnclosingSymbol(parameterSyntax.SpanStart).ToTestDisplayString()); 3987Assert.True(model.TryGetSpeculativeSemanticModelForMethodBody(m.Body.SpanStart, m, out model)); 8078Assert.True(model.TryGetSpeculativeSemanticModelForMethodBody(m2Syntax.Body.SpanStart, newMethod, out var speculativeModel)); 8158var methodBinder = getBinder<BlockBinder>(methodModel.GetEnclosingBinder(methodSyntax.Body.SpanStart)); 8159var defaultValueBinder = getBinder<BlockBinder>(defaultValueModel.GetEnclosingBinder(defaultValue.SpanStart));

Semantics\LocalFunctionTests.cs (9)

351Assert.True(model.TryGetSpeculativeSemanticModelForMethodBody(m.Body.SpanStart, m, out model)); 407Assert.True(model.TryGetSpeculativeSemanticModelForMethodBody(m.Body.SpanStart, m, out model)); 446Assert.True(model.TryGetSpeculativeSemanticModelForMethodBody(mMethod.Body.SpanStart, mMethod, out var newModel)); 1783Assert.Empty(model.LookupNamespacesAndTypes(a.SpanStart, name: "A")); 1807model.LookupNamespacesAndTypes(clsCompliant.SpanStart, name: "CLSCompliantAttribute").Single()); 1858Assert.Empty(model.LookupNamespacesAndTypes(a.SpanStart, name: "A")); 1882model.LookupNamespacesAndTypes(clsCompliant.SpanStart, name: "CLSCompliantAttribute").Single()); 7453return tree.GetRoot().DescendantNodes().OfType<IdentifierNameSyntax>().Where(i => i.Identifier.ValueText == identifier).Single().SpanStart; 8742Assert.True(model.TryGetSpeculativeSemanticModelForMethodBody(method.Body.SpanStart, method, out var speculativeModel));

Semantics\LookupTests.cs (1)

684var baseExprLocation = baseExprNode.SpanStart;

Semantics\NullableContextTests.cs (6)

67var classDeclPosition = syntaxTree.GetRoot().DescendantNodes().OfType<ClassDeclarationSyntax>().Single().SpanStart; 68var methodDeclPosition = syntaxTree.GetRoot().DescendantNodes().OfType<MethodDeclarationSyntax>().Single().SpanStart; 102var classDecl1 = syntaxTree1.GetRoot().DescendantNodes().OfType<ClassDeclarationSyntax>().Single().SpanStart; 103var classDecl2 = syntaxTree2.GetRoot().DescendantNodes().OfType<ClassDeclarationSyntax>().Single().SpanStart; 585var actualState = tree.GetNullableContextState(syntax.SpanStart); 2230Assert.True(model.TryGetSpeculativeSemanticModel(typeOf.Type.SpanStart, type, out model, SpeculativeBindingOption.BindAsTypeOrNamespace));

Semantics\NullableReferenceTypesTests.cs (15)

Semantics\OperatorTests.cs (2)

7332var binder = model.GetEnclosingBinder(methodBody.SpanStart); 8816var binder = model.GetEnclosingBinder(methodBody.SpanStart);

Semantics\QueryTests.cs (2)

3515bool success = model.TryGetSpeculativeSemanticModel(methodM.Body.SpanStart, queryStatement, out speculativeModel); 3602bool success = model.TryGetSpeculativeSemanticModel(methodM.Body.SpanStart, queryStatement, out speculativeModel);

Semantics\RecordStructTests.cs (13)

2673Assert.Equal("System.Int32 C.Z", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 2674Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 2675Assert.Contains("X", model.LookupNames(x.SpanStart)); 2708Assert.Equal("System.Int32 C.Z", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 2709Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 2710Assert.Contains("X", model.LookupNames(x.SpanStart)); 2742Assert.Equal("System.Int32 C.Z", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 2743Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 2744Assert.Contains("X", model.LookupNames(x.SpanStart)); 2777Assert.Equal("lambda expression", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 2778Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 2779Assert.Contains("X", model.LookupNames(x.SpanStart)); 10862Assert.False(model.TryGetSpeculativeSemanticModel(baseWithoutParens.SpanStart + 2, speculativeBase, out _));

Semantics\SemanticErrorTests.cs (1)

3332var callPosition = callExpr.SpanStart;

Semantics\SuppressAccessibilityChecksTests.cs (1)

222accessorDecl.Body.Statements[0].SpanStart, speculatedMethod, out speculativeModel);

Semantics\TopLevelStatementsTests.cs (162)

Semantics\UnsafeTests.cs (2)

5200var binder = ((CSharpSemanticModel)model).GetEnclosingBinder(methodBody.SpanStart); 7297model.GetSpeculativeTypeInfo(syntax.SpanStart, SyntaxFactory.ParseTypeName("S*"), SpeculativeBindingOption.BindAsTypeOrNamespace);

Semantics\UsingStatementTests.cs (2)

75var lookupSymbol = model.LookupSymbols(memberAccessExpression.SpanStart, name: declaredLocal.Name).Single(); 1896var actualSymbol = model.LookupSymbols(usingStatements[index - 1].SpanStart, name: symbol.Name).Single();

Compilation\GetSemanticInfoTests.cs (10)

1135Assert.NotEqual(0, root.SpanStart); 1712var lookupSymbols = model.LookupSymbols(exprSyntaxToBind.SpanStart, name: "x"); 1747var lookupSymbols = model.LookupSymbols(exprSyntaxToBind.SpanStart, name: "value"); 2229return model.LookupSymbols(exprSyntaxToBind.SpanStart, typeParameter, memberName); 4069var info2 = model.GetSpeculativeSymbolInfo(originalSyntax.SpanStart, speculativeSyntax, SpeculativeBindingOption.BindAsExpression); 4214var info = model.GetSpeculativeSymbolInfo(syntax.SpanStart, syntax, SpeculativeBindingOption.BindAsTypeOrNamespace); 4244var info = model.GetSpeculativeTypeInfo(syntax.SpanStart, syntax, SpeculativeBindingOption.BindAsTypeOrNamespace); 4274var info = model.GetSpeculativeTypeInfo(syntax.SpanStart, syntax, SpeculativeBindingOption.BindAsTypeOrNamespace); 4687int position = tree.GetRoot().DescendantNodes().OfType<InvocationExpressionSyntax>().First().SpanStart; 4732int position = tree.GetRoot().DescendantNodes().OfType<InvocationExpressionSyntax>().First().SpanStart;

Compilation\SemanticModelAPITests.cs (66)

Compilation\SemanticModelGetDeclaredSymbolAPITests.cs (26)

Compilation\SemanticModelGetSemanticInfoTests.cs (11)

DeclarationTests.cs (1)

918var token = _countedSyntaxTree.GetCompilationUnitRoot(cancellationToken).FindToken(nodeInUnderlying.SpanStart);

DocumentationComments\CrefTests.cs (8)

6050var members = model.LookupSymbols(typeParameterSyntax.SpanStart, (ITypeSymbol)typeParameterSymbol); 6074var members = model.LookupSymbols(methodNameSyntax.SpanStart, ((IMethodSymbol)methodSymbol).ReturnType); 6327var crefPosition = cref.SpanStart; 6328var crefReturnTypePosition = crefReturnType.SpanStart; 6329var crefParameterTypePosition = crefParameterType.SpanStart; 6434Assert.Equal(0, model.LookupSymbols(syntax.SpanStart, derivedInterface).Length); 6472Assert.Equal(0, model.LookupSymbols(syntax.SpanStart, symbol).Length); 6641Assert.Empty(model.LookupSymbols(name.SpanStart, typeParameter, "GetAwaiter"));

SymbolDisplay\SymbolDisplayTests.cs (10)

6178int position = methodDecl.Body.SpanStart; 6190position = methodDecl.Body.SpanStart; 6963declarator.SpanStart, 6996declarator.SpanStart, 7008declarator.SpanStart, 7041declarator.SpanStart, 7055declarator.SpanStart, 8028symbol.ToMinimalDisplayParts(model, variable.SpanStart), 8123symbol.ToMinimalDisplayParts(model, constructor.SpanStart, format), 8183symbol.ToMinimalDisplayParts(model, constructor.SpanStart, format),

Symbols\CheckedUserDefinedOperatorsTests.cs (16)

Symbols\DestructorTests.cs (1)

420var lookupSymbols = model.LookupSymbols(finalizeSyntax.SpanStart, name: WellKnownMemberNames.DestructorName);

Symbols\ExtensionMethodTests.cs (2)

2955memberAccess.SpanStart, 2963memberAccess.SpanStart,

Symbols\Source\BaseClassTests.cs (2)

274int positionInA = someMemberInA.SpanStart; 311int positionInA = someMemberInA.SpanStart;

Symbols\Source\NullablePublicAPITests.cs (42)

Symbols\Source\UsingAliasTests.cs (10)

312var symbolInfo = model.GetSpeculativeSymbolInfo(base2.SpanStart, base2, SpeculativeBindingOption.BindAsTypeOrNamespace); 318symbolInfo = model.GetSpeculativeSymbolInfo(base3.SpanStart, base3, SpeculativeBindingOption.BindAsTypeOrNamespace); 324symbolInfo = model.GetSpeculativeSymbolInfo(base4.SpanStart, base4, SpeculativeBindingOption.BindAsTypeOrNamespace); 358var symbolInfo = model.GetSpeculativeSymbolInfo(base2.SpanStart, base2, SpeculativeBindingOption.BindAsTypeOrNamespace); 364symbolInfo = model.GetSpeculativeSymbolInfo(base3.SpanStart, base3, SpeculativeBindingOption.BindAsTypeOrNamespace); 370symbolInfo = model.GetSpeculativeSymbolInfo(base4.SpanStart, base4, SpeculativeBindingOption.BindAsTypeOrNamespace); 448var names = model.LookupNames(root.Members[0].SpanStart); 467var names = model.LookupNames(root.Members[0].SpanStart); 486var symbols = model.LookupSymbols(root.Members[0].SpanStart, name: "O"); 507var symbols = model.LookupSymbols(root.Members[0].SpanStart, name: "O");

Symbols\StaticAbstractMembersInInterfacesTests.cs (45)

Syntax\LambdaUtilitiesTests.cs (2)

58Assert.Equal("C", model.GetEnclosingSymbol(methodDef.SpanStart).ToTestDisplayString()); 60Assert.Equal("void C.M()", model.GetEnclosingSymbol(methodDef.Body.SpanStart).ToTestDisplayString());

SemanticModelTestBase.cs (2)

23return GetSyntaxNodeForBinding(GetSyntaxNodeList(tree)).SpanStart; 103return model.GetSpeculativeSymbolInfo(constructorInitializer.SpanStart, constructorInitializer);

CodeGen\WinRTCollectionTests.cs (3)

7433Assert.True(model.LookupNames(add.SpanStart, jsonObjType).Contains("Add")); 7434Assert.True(model.LookupSymbols(add.SpanStart, jsonObjType, "Add").Contains(addMethod)); 7435Assert.True(model.LookupSymbols(add.SpanStart, jsonObjType).Contains(addMethod));

Recommendations\CSharpRecommendationServiceRunner.cs (9)

293alias.SpanStart, 532return parameterReference.Span.Start >= containingStaticFunction.SpanStart; 552return new RecommendedSymbols(_context.SemanticModel.LookupSymbols(position: name.SpanStart, container: symbol)); 558position: name.SpanStart, 598var reinterpretedBinding = semanticModel.GetSpeculativeSymbolInfo(identifier.SpanStart, identifier, SpeculativeBindingOption.BindAsTypeOrNamespace); 726reinterpretedBinding = semanticModel.GetSpeculativeSymbolInfo(identifier.SpanStart, identifier, SpeculativeBindingOption.BindAsExpression); 738reinterpretedBinding = semanticModel.GetSpeculativeSymbolInfo(identifier.SpanStart, identifier, SpeculativeBindingOption.BindAsTypeOrNamespace); 790!_context.SemanticModel.IsEventUsableAsField(originalExpression.SpanStart, ev)) 848var symbols = GetMemberSymbols(containerSymbol, position: originalExpression.SpanStart, excludeInstance, useBaseReferenceAccessibility, unwrapNullable, isForDereference);

Rename\CSharpRenameRewriterLanguageService.cs (1)

1243var position = nodeToSpeculate.SpanStart;

Simplification\CSharpSimplificationService.Expander.cs (4)

667_semanticModel.SyntaxTree.IsNameOfContext(originalSimpleName.SpanStart, _semanticModel, _cancellationToken)) 685if (!Equals(_semanticModel.GetEnclosingNamedType(originalSimpleName.SpanStart, _cancellationToken), symbol.ContainingType)) 1069var speculationPosition = originalNode.SpanStart; 1073var binding = _semanticModel.GetSpeculativeSymbolInfo(originalNode.SpanStart, expression, SpeculativeBindingOption.BindAsExpression);

Simplification\Reducers\CSharpExtensionMethodReducer.cs (1)

116node.SpanStart,

Simplification\Simplifiers\AbstractCSharpSimplifier.cs (6)

123var aliasTypeInfo = semanticModel.GetSpeculativeAliasInfo(node.SpanStart, aliasIdentifier, SpeculativeBindingOption.BindAsTypeOrNamespace); 226var scopes = model.GetImportScopes(firstMember.SpanStart, cancellationToken); 284var symbolInfo = semanticModel.GetSpeculativeSymbolInfo(node.SpanStart, aliasIdentifier, SpeculativeBindingOption.BindAsExpression); 289var typeInfo = semanticModel.GetSpeculativeTypeInfo(node.SpanStart, aliasIdentifier, SpeculativeBindingOption.BindAsExpression); 297var boundSymbols = semanticModel.LookupNamespacesAndTypes(node.SpanStart, name: aliasName); 408var symbols = semanticModel.LookupSymbols(expression.SpanStart, name: identifierName.Identifier.ValueText);

Simplification\Simplifiers\ExpressionSimplifier.cs (5)

232? semanticModel.LookupSymbols(memberAccess.SpanStart, name: memberAccess.Name.Identifier.ValueText) 235? semanticModel.LookupNamespacesAndTypes(memberAccess.SpanStart, name: memberAccess.Name.Identifier.ValueText) 347var enclosingNamedType = semanticModel.GetEnclosingNamedType(memberAccess.SpanStart, cancellationToken); 370if (ancestorInvocation?.SpanStart == memberAccess.SpanStart)

Simplification\Simplifiers\QualifiedCrefSimplifier.cs (1)

89var newSymbol = semanticModel.GetSpeculativeSymbolInfo(crefSyntax.SpanStart, replacement, speculativeBindingOption).Symbol;

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

72if (conditionalDirectives.First().SpanStart <= block.OpenBraceToken.SpanStart ||

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

338var potentialType = semanticModel.GetSpeculativeTypeInfo(expression.SpanStart, expression, SpeculativeBindingOption.BindAsTypeOrNamespace).Type;

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

125return semanticModel.LookupSymbols(expr.SpanStart, container: symbol, name: name, includeReducedExtensionMethods: true);

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

575if (!textSpan.Contains(directives[0].SpanStart) || 576!textSpan.Contains(directives.Last().SpanStart))

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

74if (trivia.Span.End == currentParent.SpanStart ||

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

922var member = GetContainingMemberDeclaration(node, node.SpanStart);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Utilities\SpeculationAnalyzer.cs (1)

118var position = originalNode.SpanStart;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Utilities\TypeStyle\CSharpUseImplicitTypeHelper.cs (1)

106var conflict = semanticModel.GetSpeculativeSymbolInfo(typeName.SpanStart, candidateReplacementNode, SpeculativeBindingOption.BindAsTypeOrNamespace).Symbol;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Utilities\UsingsAndExternAliasesOrganizer.cs (1)

119.OrderBy(n => n.SpanStart).ToList();

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

42var start = usings.First().SpanStart; 51var start = rootUsings.First().SpanStart;

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

360return syntaxTree.IsLocalFunctionDeclarationContext(token.Parent.SpanStart, validModifiers, cancellationToken); 883if (firstConstructorConstraint == null || firstConstructorConstraint.SpanStart > token.Span.End) 1373return IsAtStartOfPattern(syntaxTree, parenthesizedExpression.GetFirstToken().GetPreviousToken(), parenthesizedExpression.SpanStart); 1565=> node.FindTokenOnLeftOfPosition(node.SpanStart); 2897var tokenBeforeName = syntaxTree.FindTokenOnLeftOfPosition(nameExpr.SpanStart, cancellationToken); 2903if (syntaxTree.IsExpressionContext(nameExpr.SpanStart, tokenBeforeName, attributes: false, cancellationToken))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\ExpressionSyntaxExtensions.cs (2)

177name.SpanStart, name, SpeculativeBindingOption.BindAsExpression); 180name.SpanStart, name, SpeculativeBindingOption.BindAsExpression).Type;

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

35var end = destination.Members.First().SpanStart;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Indentation\CSharpIndentationService.Indenter.cs (1)

410if (firstToken.SpanStart <= clause.SpanStart)

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

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

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

39var visibleSymbols = semanticModel.LookupSymbols(location.SpanStart);

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

261return InferTypes(expression.SpanStart); 1296=> InferTypes(implicitArray.SpanStart); 2217if (descendant.SpanStart <= afterNode.Span.End)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\SemanticModelReuse\CSharpSemanticModelReuseLanguageService.cs (2)

59previousSemanticModel.TryGetSpeculativeSemanticModelForMethodBody(previousBaseMethod.Body.SpanStart, currentBaseMethod, out var speculativeModel)) 67previousSemanticModel.TryGetSpeculativeSemanticModelForMethodBody(previousAccessorDeclaration.Body.SpanStart, currentAccessorDeclaration, out speculativeModel))

Editor\GoToAdjacentMemberCommandHandler.cs (1)

142return node.SpanStart;

Structure\AbstractSyntaxNodeStructureProviderTests.cs (2)

32if ((position == node.SpanStart && position == node.Parent.SpanStart) ||

Expansion\AbstractExpansionTest.vb (2)

58While node IsNot Nothing And node.Parent IsNot Nothing And node.Parent.SpanStart = node.SpanStart

Simplification\AbstractSimplificationTests.vb (2)

132While node IsNot Nothing And node.Parent IsNot Nothing And node.Parent.SpanStart = node.SpanStart

Symbols\ISymbolExtensions.cs (1)

603return declarationSyntax != null && position < declarationSyntax.SpanStart;

AddImport\SymbolReferenceFinder.cs (1)

83for (var containingNamespace = _semanticModel.GetEnclosingNamespace(_node.SpanStart, cancellationToken);

ChangeSignature\AbstractChangeSignatureService.cs (1)

171positionForTypeBinding = syntax.SpanStart;

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.cs (1)

292var targetMemberNode = syntaxFacts.GetContainingMemberDeclaration(root, nodeWithTokens.SpanStart);

CodeRefactorings\AddAwait\AbstractAddAwaitCodeRefactoringProvider.cs (1)

105return type?.IsAwaitableNonDynamic(model, node.SpanStart) == true;

Completion\Providers\AbstractAwaitCompletionProvider.cs (2)

220builder.Add(new TextChange(new TextSpan(expr.SpanStart, 0), _awaitKeyword + " ")); 270document, syntaxContext.SemanticModel, potentialAwaitableExpression.SpanStart, cancellationToken);

DocumentationComments\AbstractDocumentationCommentSnippetService.cs (1)

235if (targetMember.SpanStart < documentationComment.SpanStart)

EditAndContinue\AbstractEditAndContinueAnalyzer.cs (4)

128/// In case there are multiple breakpoint spans starting at the <see cref="SyntaxNode.SpanStart"/> of the <paramref name="node"/>, 6589if (otherRootNode.FullSpan.Contains(otherNode.SpanStart)) 6601Debug.Assert(otherRoot.FullSpan.Contains(otherNode.SpanStart)); 6607var leftPosition = otherNode.SpanStart;

ExtractMethod\UniqueNameGenerator.cs (1)

25n => _semanticModel.LookupSymbols(contextNode.SpanStart, container: null, n).Length == 0);

FullyQualify\AbstractFullyQualifyService.cs (1)

198var containerName = container.ToMinimalDisplayString(semanticModel, simpleName.SpanStart);

GenerateConstructors\AbstractGenerateConstructorsCodeRefactoringProvider.GenerateConstructorWithDialogCodeAction.cs (1)

95constructorDocument.Id, constructorSyntax.SpanStart)];

GenerateEqualsAndGetHashCodeFromMembers\GenerateEqualsAndGetHashCodeAction.cs (1)

108&& semanticModel.GetNullableContext(_typeDeclaration.SpanStart).AnnotationsEnabled();

GenerateType\AbstractGenerateTypeService.cs (3)

139var containingNamespace = semanticDocument.SemanticModel.GetEnclosingNamespace(node.SpanStart, cancellationToken); 160var containingNamespace = document.SemanticModel.GetEnclosingNamespace(node.SpanStart, cancellationToken); 246var outerTypeSymbol = semanticModel.GetEnclosingNamedType(state.SimpleName.SpanStart, cancellationToken);

GenerateType\AbstractGenerateTypeService.Editor.cs (1)

388_state.SimpleName.SpanStart, _cancellationToken);

GenerateType\AbstractGenerateTypeService.State.cs (5)

129if (!semanticFacts.IsTypeContext(semanticModel, NameOrMemberAccessExpression.SpanStart, cancellationToken) && 130!semanticFacts.IsExpressionContext(semanticModel, NameOrMemberAccessExpression.SpanStart, cancellationToken) && 131!semanticFacts.IsStatementContext(semanticModel, NameOrMemberAccessExpression.SpanStart, cancellationToken) && 133!semanticFacts.IsNamespaceContext(semanticModel, NameOrMemberAccessExpression.SpanStart, cancellationToken)) 362var namespaceSymbol = semanticModel.GetEnclosingNamespace(SimpleName.SpanStart, cancellationToken);

InlineMethod\AbstractInlineMethodRefactoringProvider.cs (1)

386|| callerMethodSymbol.IsAwaitableNonDynamic(semanticModel, callerDeclarationNode.SpanStart)))

IntroduceVariable\AbstractIntroduceVariableService.cs (1)

270var declaringType = semanticModel.GetEnclosingNamedType(expression.SpanStart, cancellationToken);

InvertIf\AbstractInvertIfCodeRefactoringProvider.StatementRange.cs (2)

24Debug.Assert(firstStatement.SpanStart <= lastStatement.SpanStart);

RelatedDocuments\AbstractRelatedDocumentsService.cs (1)

97IteratePotentialTypeNodes(root).OrderBy(t => Math.Abs(t.expression.SpanStart - position)),

RemoveUnusedVariable\AbstractRemoveUnusedVariableCodeFixProvider.cs (1)

114actionsToPerform.Add((node.SpanStart, () => RemoveOrReplaceNode(syntaxEditor, node, blockFacts)));

SignatureHelp\CommonSignatureHelpUtilities.cs (1)

168var position = initializer.SpanStart;

Snippets\SnippetProviders\AbstractConditionalBlockSnippetProvider.cs (1)

29return [new SnippetPlaceholder(condition.ToString(), condition.SpanStart)];

Snippets\SnippetProviders\AbstractConsoleSnippetProvider.cs (1)

102if (nearestExpression.SpanStart != position)

Snippets\SnippetProviders\AbstractInlineStatementSnippetProvider.cs (2)

71return new TextChange(TextSpan.FromBounds(inlineExpressionInfo?.Node.SpanStart ?? position, position), statement.ToFullString()); 156var typeInfo = semanticModel.GetSpeculativeTypeInfo(expression.SpanStart, expression, SpeculativeBindingOption.BindAsExpression);

src\Analyzers\Core\Analyzers\RemoveUnnecessaryImports\AbstractRemoveUnnecessaryImportsDiagnosticAnalyzer.cs (1)

147foreach (var node in nodes.OrderBy(n => n.SpanStart))

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

127var spanStart = firstBlock.Syntax.SpanStart;

src\Analyzers\Core\Analyzers\UseCollectionInitializer\AbstractUseCollectionInitializerAnalyzer.cs (1)

210_objectCreationExpression.SpanStart,

src\Analyzers\Core\Analyzers\UseCollectionInitializer\UseCollectionInitializerHelpers.cs (3)

36syntaxTree.GetLocation(TextSpan.FromBounds(match.SpanStart, arguments[0].SpanStart)), 48syntaxTree.GetLocation(TextSpan.FromBounds(match.SpanStart, expression.SpanStart)),

src\Analyzers\Core\Analyzers\UseObjectInitializer\AbstractUseObjectInitializerDiagnosticAnalyzer.cs (1)

153match.MemberAccessExpression.SpanStart, end));

src\Analyzers\Core\Analyzers\UseObjectInitializer\UseNamedMemberInitializerAnalyzer.cs (2)

215if (expression != null && expression.SpanStart < _objectCreationExpression.SpanStart)

src\Analyzers\Core\Analyzers\ValidateFormatString\AbstractValidateFormatStringDiagnosticAnalyzer.cs (1)

155formatString, formatStringLiteralExpressionSyntax.SpanStart);

src\Analyzers\Core\CodeFixes\AddExplicitCast\AbstractAddExplicitCastCodeFixProvider.cs (1)

95var title = GetSubItemName(semanticModel, targetNode.SpanStart, conversionType);

src\Analyzers\Core\CodeFixes\AddObsoleteAttribute\AbstractAddObsoleteAttributeCodeFixProvider.cs (2)

66return _syntaxFacts.GetContainingMemberDeclaration(root, node.SpanStart) ?? 67_syntaxFacts.GetContainingTypeDeclaration(root, node.SpanStart);

src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateConversionService.State.cs (2)

67ContainingType = document.SemanticModel.GetEnclosingNamedType(node.SpanStart, cancellationToken); 91ContainingType = document.SemanticModel.GetEnclosingNamedType(node.SpanStart, cancellationToken);

src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateDeconstructMethodService.State.cs (1)

59ContainingType = semanticModel.GetEnclosingNamedType(targetVariables.SpanStart, cancellationToken);

src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateMethodService.State.cs (2)

103ContainingType = semanticModel.GetEnclosingNamedType(methodDeclaration.SpanStart, cancellationToken); 152ContainingType = semanticModel.GetEnclosingNamedType(SimpleNameOpt.SpanStart, cancellationToken);

src\Analyzers\Core\CodeFixes\GenerateVariable\AbstractGenerateVariableService.State.cs (1)

476var enclosingMethodSymbol = _document.SemanticModel.GetEnclosingSymbol<IMethodSymbol>(SimpleNameOrMemberAccessExpressionOpt.SpanStart, cancellationToken);

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

887memberDeclaration = syntaxFacts.GetContainingMemberDeclaration(root, memberDeclaration.SpanStart) ?? root;

src\Analyzers\Core\CodeFixes\UseConditionalExpression\ForReturn\AbstractUseConditionalExpressionForReturnCodeFixProvider.cs (1)

56var containingSymbol = semanticModel.GetRequiredEnclosingSymbol(ifStatement.SpanStart, cancellationToken);

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

305Math.Min(fullSpan.Start, node.SpanStart), 321var end = endNode.SpanStart; 846=> x?.SpanStart == y?.SpanStart; 849=> obj.SpanStart; 926condDirectivesBuilder.Sort(static (n1, n2) => n1.SpanStart.CompareTo(n2.SpanStart));

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

108return node.SpanStart;

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

85var spanStart = documentationComment.SpanStart;

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

774!forEachExpression.Span.Contains(OriginalExpression.SpanStart)) 869newSymbol = this.OriginalSemanticModel.GetSpeculativeSymbolInfo(type.SpanStart, newType, bindingOption).Symbol;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.cs (1)

603return declarationSyntax != null && position < declarationSyntax.SpanStart;

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

205var afterMember = declarationList.LastOrDefault(m => m.SpanStart <= info.Context.AfterThisLocation.SourceSpan.Start);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Editing\ImportAdderService.cs (1)

259var containedNamespace = model.GetEnclosingNamespace(node.SpanStart, cancellationToken);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\SemanticsFactsService\AbstractSemanticFactsService.cs (1)

93=> semanticModel.LookupSymbols(location.SpanStart).Concat(semanticModel.GetAllDeclaredSymbols(container, cancellationToken));

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\SemanticModelReuse\AbstractSemanticModelReuseLanguageService.cs (2)

84if (previousBodyNode?.SpanStart != currentBodyNode.SpanStart)

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

305Math.Min(fullSpan.Start, node.SpanStart), 321var end = endNode.SpanStart; 846=> x?.SpanStart == y?.SpanStart; 849=> obj.SpanStart; 926condDirectivesBuilder.Sort(static (n1, n2) => n1.SpanStart.CompareTo(n2.SpanStart));

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

108return node.SpanStart;

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

85var spanStart = documentationComment.SpanStart;

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

774!forEachExpression.Span.Contains(OriginalExpression.SpanStart)) 869newSymbol = this.OriginalSemanticModel.GetSpeculativeSymbolInfo(type.SpanStart, newType, bindingOption).Symbol;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.cs (1)

603return declarationSyntax != null && position < declarationSyntax.SpanStart;

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

305Math.Min(fullSpan.Start, node.SpanStart), 321var end = endNode.SpanStart; 846=> x?.SpanStart == y?.SpanStart; 849=> obj.SpanStart; 926condDirectivesBuilder.Sort(static (n1, n2) => n1.SpanStart.CompareTo(n2.SpanStart));

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

108return node.SpanStart;

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

85var spanStart = documentationComment.SpanStart;

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

774!forEachExpression.Span.Contains(OriginalExpression.SpanStart)) 869newSymbol = this.OriginalSemanticModel.GetSpeculativeSymbolInfo(type.SpanStart, newType, bindingOption).Symbol;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.cs (1)

603return declarationSyntax != null && position < declarationSyntax.SpanStart;

Compilation\ControlFlowGraphVerifier.cs (2)

698aggregate.AggregateKeyword.SpanStart < candidate.Syntax.SpanStart && 699aggregate.IntoKeyword.SpanStart > candidate.Syntax.SpanStart &&

Diagnostics\CommonDiagnosticAnalyzers.cs (1)

1258return _controlFlowGraphMapOpt.Values.OrderBy(flowGraphAndSymbol => flowGraphAndSymbol.Graph.OriginalOperation.Syntax.SpanStart).ToImmutableArray();

Analysis\FlowAnalysis\DataFlowPass.vb (1)

1194If isImplicitlyDeclared OrElse firstLocation Is Nothing OrElse firstLocation.SourceSpan.Start < node.SpanStart Then

Binding\MemberSemanticModel.vb (1)

96Dim binder = GetEnclosingBinderInternal(Me.RootBinder, Me.Root, node, node.SpanStart)

Compilation\SemanticModel.vb (6)

1120Dim binder As Binder = If(binderOpt, GetEnclosingBinder(boundNodes.LowestBoundNode.Syntax.SpanStart)) 1482Dim binder As Binder = If(binderOpt, GetEnclosingBinder(lowestBoundNode.Syntax.SpanStart)) 2998Dim binder = Me.GetEnclosingBinder(Root.SpanStart) ' should never return null. 3012Dim binder = Me.GetEnclosingBinder(Root.SpanStart) ' should never return null. 3026Dim binder = Me.GetEnclosingBinder(Root.SpanStart) ' should never return null. 3040Dim binder = Me.GetEnclosingBinder(Root.SpanStart) ' should never return null.

Compilation\SyntaxTreeSemanticModel.vb (1)

173Return GetMemberSemanticModel(node.SpanStart)

Emit\EditAndContinue\VisualBasicLambdaSyntaxFacts.vb (1)

25Return node.SpanStart

Lowering\Instrumentation\DebugInfoInjector.vb (1)

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

Lowering\LambdaRewriter\LambdaRewriter.vb (2)

1009Dim syntaxOffset As Integer = _topLevelMethod.CalculateLocalSyntaxOffset(syntax.SpanStart, syntax.SyntaxTree) 1058Dim syntaxOffset As Integer = _topLevelMethod.CalculateLocalSyntaxOffset(lambdaOrLambdaBodySyntax.SpanStart, lambdaOrLambdaBodySyntax.SyntaxTree)

Lowering\StateMachineRewriter\StateMachineRewriter.StateMachineMethodToClassRewriter.vb (1)

182Dim syntaxOffset = CurrentMethod.CalculateLocalSyntaxOffset(node.SpanStart, node.SyntaxTree)

Lowering\StateMachineRewriter\StateMachineRewriter.vb (1)

300Dim syntaxOffset As Integer = Me.Method.CalculateLocalSyntaxOffset(declaratorSyntax.SpanStart, declaratorSyntax.SyntaxTree)

Symbols\LexicalSortKey.vb (2)

217Dim firstKey = New LexicalSortKey(first.SyntaxTree, first.SpanStart, compilation) 218Dim secondKey = New LexicalSortKey(second.SyntaxTree, second.SpanStart, compilation)

Syntax\LambdaUtilities.vb (1)

393If lambdaBody.SpanStart < groupByClause.ByKeyword.SpanStart Then

Syntax\SyntaxFacts.vb (1)

194Return position < node.SpanStart OrElse InSpanOrEffectiveTrailingOfNode(node, position)

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

808Dim member = GetContainingMemberDeclaration(node, node.SpanStart)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Utilities\SpeculationAnalyzer.vb (1)

112Dim position = originalNode.SpanStart

src\Analyzers\VisualBasic\CodeFixes\AddExplicitCast\ArgumentFixer.vb (2)

39Return semanticModel.GetSpeculativeSymbolInfo(parent.SpanStart, DirectCast(parent, AttributeSyntax)) 41Return semanticModel.GetSpeculativeSymbolInfo(parent.SpanStart, parent, SpeculativeBindingOption.BindAsExpression)

AddImport\VisualBasicAddImportFeatureService.vb (1)

335leftExpressionType = semanticModel.GetEnclosingNamedType(expression.SpanStart, cancellationToken)

ChangeSignature\VisualBasicChangeSignatureService.vb (5)

180matchingNode.SpanStart) 348originalNode.SpanStart, 383originalNode.SpanStart, 408originalNode.SpanStart, 429originalNode.SpanStart,

CodeFixes\IncorrectExitContinue\IncorrectExitContinueCodeFixProvider.vb (2)

97Dim enclosingDeclaration = document.SemanticModel.GetEnclosingSymbol(node.SpanStart, cancellationToken) 129Dim enclosingDeclaration = document.SemanticModel.GetEnclosingSymbol(node.SpanStart, cancellationToken)

Completion\CompletionProviders\OverrideCompletionProvider.vb (1)

142Return overridesToken.Kind = SyntaxKind.OverridesKeyword AndAlso IsOnStartLine(overridesToken.Parent.SpanStart, text, startLine)

EditAndContinue\BreakpointSpans.vb (2)

92Return TextSpan.FromBounds(node.SpanStart, node.Span.End) 100Return TextSpan.FromBounds(list.First.SpanStart, list.Last.Span.End)

EditAndContinue\DeclarationBody\FieldOrPropertyDeclarationBody.vb (1)

89If span.Start = InitializerActiveStatement.SpanStart Then

EditAndContinue\SyntaxComparer.vb (1)

695nodeOpt.SpanStart < DirectCast(nodeOpt.Parent, GroupByClauseSyntax).ByKeyword.SpanStart Then

EditAndContinue\VisualBasicEditAndContinueAnalyzer.vb (3)

111position = body.SpanStart 128While node.Span.Length < span.Length AndAlso node.Parent.SpanStart = position 307Return BreakpointSpans.TryGetClosestBreakpointSpan(node, node.SpanStart, minLength, span)

ExtractMethod\VisualBasicMethodExtractor.VisualBasicCodeGenerator.vb (2)

121Dim postProcessor = New PostProcessor(semanticModel, insertionPointNode.SpanStart) 317Dim postProcessor = New PostProcessor(semanticModel, insertionPointNode.SpanStart)

QuickInfo\VisualBasicSemanticQuickInfoProvider.vb (1)

213Dim position = expression.SpanStart

SignatureHelp\AbstractIntrinsicOperatorSignatureHelpProvider.vb (3)

44Dim signatureHelpItem = GetSignatureHelpItemForIntrinsicOperator(document, semanticModel, node.SpanStart, documentation, cancellationToken) 48Dim textSpan = CommonSignatureHelpUtilities.GetSignatureHelpSpan(node, node.SpanStart, Function(n) n.ChildTokens.FirstOrDefault(Function(c) c.Kind = SyntaxKind.CloseParenToken)) 108currentSpan.Start = node.SpanStart Then

SolutionCrawler\VisualBasicDocumentDifferenceService.vb (2)

65Return TextSpan.FromBounds(list.First.SpanStart, list.Last.Span.End) 70Return TextSpan.FromBounds(list.First.SpanStart, list.Last.Span.End)

src\Analyzers\VisualBasic\CodeFixes\AddExplicitCast\ArgumentFixer.vb (2)

39Return semanticModel.GetSpeculativeSymbolInfo(parent.SpanStart, DirectCast(parent, AttributeSyntax)) 41Return semanticModel.GetSpeculativeSymbolInfo(parent.SpanStart, parent, SpeculativeBindingOption.BindAsExpression)

src\Compilers\VisualBasic\Portable\Syntax\LambdaUtilities.vb (1)

393If lambdaBody.SpanStart < groupByClause.ByKeyword.SpanStart Then

FlowAnalysis\FlowTestBase.vb (3)

174If startPosition <= startNode.SpanStart Then startPosition = startNode.SpanStart 175While startNode IsNot Nothing AndAlso startNode.SpanStart = startPosition

TestSyntaxNodes.vb (8)

335Assert.Equal(tree.SpanStart, tree.FullSpan.Start) 337VerifyListSpans(precedingTrivia, New TextSpan(tree.FullSpan.Start, (tree.SpanStart - tree.FullSpan.Start))) 639Assert.Equal(0, sepList(0).SpanStart) 641Assert.Equal(6, sepList(1).SpanStart) 643Assert.Equal(12, sepList(2).SpanStart) 663Assert.Equal(9 + 0, sepList(0).SpanStart) 665Assert.Equal(9 + 6, sepList(1).SpanStart) 667Assert.Equal(9 + 12, sepList(2).SpanStart)

ParserTestUtilities.vb (3)

449Assert.True(node.SpanStart >= node.Parent.SpanStart AndAlso 854Assert.True(node.SpanStart >= node.Parent.SpanStart AndAlso

SemanticModelTestBase.vb (1)

83Return " Syntax.SpanStart : " & syntax.SpanStart &

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

808Dim member = GetContainingMemberDeclaration(node, node.SpanStart)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Utilities\SpeculationAnalyzer.vb (1)

112Dim position = originalNode.SpanStart

CodeCleanup\AbstractCodeCleanerService.cs (2)

193return TryCreateTextSpan(node.SpanStart, GetNextTokenEndPosition(nextTokenMarker.Type, nextToken), out span); 219span = TextSpan.FromBounds(node.SpanStart, GetNextTokenEndPosition(nextTokenMarker.Type, nextToken));

FindSymbols\FindReferences\Finders\AbstractReferenceFinder.cs (2)

760syntaxFacts.GetContainingTypeDeclaration(node, node.SpanStart), 764syntaxFacts.GetContainingMemberDeclaration(node, node.SpanStart),

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

220var location = state.SyntaxTree.GetLocation(new TextSpan(indexerReference.SpanStart, 0));

ReassignedVariable\AbstractReassignedVariableService.cs (1)

313if (current.SpanStart <= localOrParameterDeclarationSpan.Start)

Recommendations\AbstractRecommendationServiceRunner.cs (2)

279semanticModel.GetEnclosingNamespace(declarationSyntax.SpanStart, _cancellationToken)); 281var symbols = semanticModel.LookupNamespacesAndTypes(declarationSyntax.SpanStart, containingNamespaceSymbol)

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

305Math.Min(fullSpan.Start, node.SpanStart), 321var end = endNode.SpanStart; 846=> x?.SpanStart == y?.SpanStart; 849=> obj.SpanStart; 926condDirectivesBuilder.Sort(static (n1, n2) => n1.SpanStart.CompareTo(n2.SpanStart));

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

108return node.SpanStart;

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

85var spanStart = documentationComment.SpanStart;

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

774!forEachExpression.Span.Contains(OriginalExpression.SpanStart)) 869newSymbol = this.OriginalSemanticModel.GetSpeculativeSymbolInfo(type.SpanStart, newType, bindingOption).Symbol;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.cs (1)

603return declarationSyntax != null && position < declarationSyntax.SpanStart;

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

205var afterMember = declarationList.LastOrDefault(m => m.SpanStart <= info.Context.AfterThisLocation.SourceSpan.Start);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Editing\ImportAdderService.cs (1)

259var containedNamespace = model.GetEnclosingNamespace(node.SpanStart, cancellationToken);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\SemanticsFactsService\AbstractSemanticFactsService.cs (1)

93=> semanticModel.LookupSymbols(location.SpanStart).Concat(semanticModel.GetAllDeclaredSymbols(container, cancellationToken));

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\SemanticModelReuse\AbstractSemanticModelReuseLanguageService.cs (2)

84if (previousBodyNode?.SpanStart != currentBodyNode.SpanStart)

Analyzers\RuntimeComApiUsageWithSourceGeneratedComAnalyzer.cs (2)

123operation.TargetMethod.ToMinimalDisplayString(operation.SemanticModel, operation.Syntax.SpanStart), 124targetType.ToMinimalDisplayString(operation.SemanticModel, operation.Syntax.SpanStart)));

Analyzers\CustomMarshallerAttributeFixer.cs (1)

158var entryPointTypeSymbol = (INamedTypeSymbol)model.GetEnclosingSymbol(node.SpanStart, ct);

CodeModel\CSharpCodeModelService.cs (3)

2799var deletionStart = attributeList.SpanStart; 2848var deletionStart = node.SpanStart; 3691var position = typeDeclaration.SpanStart;

CodeModel\CSharpCodeModelService.NodeLocator.cs (16)

CodeModel\VisualBasicCodeModelService.vb (1)

1280Dim deletionStart = node.SpanStart

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

305Math.Min(fullSpan.Start, node.SpanStart), 321var end = endNode.SpanStart; 846=> x?.SpanStart == y?.SpanStart; 849=> obj.SpanStart; 926condDirectivesBuilder.Sort(static (n1, n2) => n1.SpanStart.CompareTo(n2.SpanStart));

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

108return node.SpanStart;

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

85var spanStart = documentationComment.SpanStart;

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

774!forEachExpression.Span.Contains(OriginalExpression.SpanStart)) 869newSymbol = this.OriginalSemanticModel.GetSpeculativeSymbolInfo(type.SpanStart, newType, bindingOption).Symbol;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.cs (1)

603return declarationSyntax != null && position < declarationSyntax.SpanStart;

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

205var afterMember = declarationList.LastOrDefault(m => m.SpanStart <= info.Context.AfterThisLocation.SourceSpan.Start);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Editing\ImportAdderService.cs (1)

259var containedNamespace = model.GetEnclosingNamespace(node.SpanStart, cancellationToken);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\SemanticsFactsService\AbstractSemanticFactsService.cs (1)

93=> semanticModel.LookupSymbols(location.SpanStart).Concat(semanticModel.GetAllDeclaredSymbols(container, cancellationToken));

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\SemanticModelReuse\AbstractSemanticModelReuseLanguageService.cs (2)

84if (previousBodyNode?.SpanStart != currentBodyNode.SpanStart)

PreferNullLiteralCodeFixProvider.cs (1)

60var nullableContext = semanticModel.GetNullableContext(type.SpanStart);

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

72if (conditionalDirectives.First().SpanStart <= block.OpenBraceToken.SpanStart ||

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

338var potentialType = semanticModel.GetSpeculativeTypeInfo(expression.SpanStart, expression, SpeculativeBindingOption.BindAsTypeOrNamespace).Type;

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

125return semanticModel.LookupSymbols(expr.SpanStart, container: symbol, name: name, includeReducedExtensionMethods: true);

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

575if (!textSpan.Contains(directives[0].SpanStart) || 576!textSpan.Contains(directives.Last().SpanStart))

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

74if (trivia.Span.End == currentParent.SpanStart ||

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

922var member = GetContainingMemberDeclaration(node, node.SpanStart);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Utilities\SpeculationAnalyzer.cs (1)

118var position = originalNode.SpanStart;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Utilities\TypeStyle\CSharpUseImplicitTypeHelper.cs (1)

106var conflict = semanticModel.GetSpeculativeSymbolInfo(typeName.SpanStart, candidateReplacementNode, SpeculativeBindingOption.BindAsTypeOrNamespace).Symbol;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Utilities\UsingsAndExternAliasesOrganizer.cs (1)

119.OrderBy(n => n.SpanStart).ToList();

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

42var start = usings.First().SpanStart; 51var start = rootUsings.First().SpanStart;

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

360return syntaxTree.IsLocalFunctionDeclarationContext(token.Parent.SpanStart, validModifiers, cancellationToken); 883if (firstConstructorConstraint == null || firstConstructorConstraint.SpanStart > token.Span.End) 1373return IsAtStartOfPattern(syntaxTree, parenthesizedExpression.GetFirstToken().GetPreviousToken(), parenthesizedExpression.SpanStart); 1565=> node.FindTokenOnLeftOfPosition(node.SpanStart); 2897var tokenBeforeName = syntaxTree.FindTokenOnLeftOfPosition(nameExpr.SpanStart, cancellationToken); 2903if (syntaxTree.IsExpressionContext(nameExpr.SpanStart, tokenBeforeName, attributes: false, cancellationToken))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\ExpressionSyntaxExtensions.cs (2)

177name.SpanStart, name, SpeculativeBindingOption.BindAsExpression); 180name.SpanStart, name, SpeculativeBindingOption.BindAsExpression).Type;

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

35var end = destination.Members.First().SpanStart;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Indentation\CSharpIndentationService.Indenter.cs (1)

410if (firstToken.SpanStart <= clause.SpanStart)

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

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

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

39var visibleSymbols = semanticModel.LookupSymbols(location.SpanStart);

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

261return InferTypes(expression.SpanStart); 1296=> InferTypes(implicitArray.SpanStart); 2217if (descendant.SpanStart <= afterNode.Span.End)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\SemanticModelReuse\CSharpSemanticModelReuseLanguageService.cs (2)

59previousSemanticModel.TryGetSpeculativeSemanticModelForMethodBody(previousBaseMethod.Body.SpanStart, currentBaseMethod, out var speculativeModel)) 67previousSemanticModel.TryGetSpeculativeSemanticModelForMethodBody(previousAccessorDeclaration.Body.SpanStart, currentAccessorDeclaration, out speculativeModel))

BasicSpecializedEnumerableCreationAnalyzer.vb (1)

67Dim speculativeTypeInfo = semanticModel.GetSpeculativeTypeInfo(expression.SpanStart, expression, SpeculativeBindingOption.BindAsExpression)

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

808Dim member = GetContainingMemberDeclaration(node, node.SpanStart)

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

305Math.Min(fullSpan.Start, node.SpanStart), 321var end = endNode.SpanStart; 846=> x?.SpanStart == y?.SpanStart; 849=> obj.SpanStart; 926condDirectivesBuilder.Sort(static (n1, n2) => n1.SpanStart.CompareTo(n2.SpanStart));

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

108return node.SpanStart;

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

85var spanStart = documentationComment.SpanStart;

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

774!forEachExpression.Span.Contains(OriginalExpression.SpanStart)) 869newSymbol = this.OriginalSemanticModel.GetSpeculativeSymbolInfo(type.SpanStart, newType, bindingOption).Symbol;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.cs (1)

603return declarationSyntax != null && position < declarationSyntax.SpanStart;

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

305Math.Min(fullSpan.Start, node.SpanStart), 321var end = endNode.SpanStart; 846=> x?.SpanStart == y?.SpanStart; 849=> obj.SpanStart; 926condDirectivesBuilder.Sort(static (n1, n2) => n1.SpanStart.CompareTo(n2.SpanStart));

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

108return node.SpanStart;

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

85var spanStart = documentationComment.SpanStart;

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

774!forEachExpression.Span.Contains(OriginalExpression.SpanStart)) 869newSymbol = this.OriginalSemanticModel.GetSpeculativeSymbolInfo(type.SpanStart, newType, bindingOption).Symbol;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.cs (1)

603return declarationSyntax != null && position < declarationSyntax.SpanStart;

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

205var afterMember = declarationList.LastOrDefault(m => m.SpanStart <= info.Context.AfterThisLocation.SourceSpan.Start);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Editing\ImportAdderService.cs (1)

259var containedNamespace = model.GetEnclosingNamespace(node.SpanStart, cancellationToken);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\SemanticsFactsService\AbstractSemanticFactsService.cs (1)

93=> semanticModel.LookupSymbols(location.SpanStart).Concat(semanticModel.GetAllDeclaredSymbols(container, cancellationToken));

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\SemanticModelReuse\AbstractSemanticModelReuseLanguageService.cs (2)

84if (previousBodyNode?.SpanStart != currentBodyNode.SpanStart)