262return _nodeOrParent.SpanStart;

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

127var spanStart = firstBlock.Syntax.SpanStart;

191_objectCreationExpression.SpanStart,

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

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

155formatString, formatStringLiteralExpressionSyntax.SpanStart);

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

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));

100return node.SpanStart;

85var spanStart = documentationComment.SpanStart;

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

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

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

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

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

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

104ContainingType = semanticModel.GetEnclosingNamedType(methodDeclaration.SpanStart, cancellationToken); 153ContainingType = semanticModel.GetEnclosingNamedType(SimpleNameOpt.SpanStart, cancellationToken);

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

100.OrderByDescending(n => n.SpanStart)

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

40var expressionsToReWrite = diagnostics.Select(d => GetInvocation(root, d)).OrderByDescending(i => i.SpanStart);

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

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

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

92=> semanticModel.LookupSymbols(location.SpanStart).Concat(semanticModel.GetExistingSymbols(container, cancellationToken));

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

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

442if (position == node.SpanStart) 1315var position = node.SpanStart;

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

202int startLocation = firstInRegion.Syntax.SpanStart;

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

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

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

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

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

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

184if (position == ctorSyntax.SpanStart)

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

1153return localPosition - bodySyntax.SpanStart;

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

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

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

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

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

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

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

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

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

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

218expression.SpanStart,

69invocationExpression.SpanStart,

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

70expression.SpanStart, 110expression.SpanStart,

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

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

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

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

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

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

311var localStatementStart = _localStatement.SpanStart; 312var comparisonSpanStart = _comparison.SpanStart; 319var descendentNodeSpanStart = descendentNode.SpanStart;

175var localStatementStart = localStatement.SpanStart; 176var comparisonSpanStart = comparison.SpanStart; 180var descendentNodeSpanStart = descendentNode.SpanStart; 221var descendentNodeSpanStart = descendentNode.SpanStart; 242var descendentNodeSpanStart = descendentNode.SpanStart;

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

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

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

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

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

573if (!textSpan.Contains(directives[0].SpanStart) || 574!textSpan.Contains(directives.Last().SpanStart))

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

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

105var position = originalNode.SpanStart;

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

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

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

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

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

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

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

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

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

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

808var lineToConsider = text.Lines.GetLineFromPosition(expressionToReplace.SpanStart);

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

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

55var start = usings.First().SpanStart; 64var start = rootUsings.First().SpanStart;

882if (firstConstructorConstraint == null || firstConstructorConstraint.SpanStart > token.Span.End) 1366return IsAtStartOfPattern(syntaxTree, parenthesizedExpression.GetFirstToken().GetPreviousToken(), parenthesizedExpression.SpanStart); 1558=> node.FindTokenOnLeftOfPosition(node.SpanStart); 2890var tokenBeforeName = syntaxTree.FindTokenOnLeftOfPosition(nameExpr.SpanStart, cancellationToken); 2896if (syntaxTree.IsExpressionContext(nameExpr.SpanStart, tokenBeforeName, attributes: false, cancellationToken))

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

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

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

90spans.Add(TextSpan.FromBounds(namespaceMember.SpanStart, GetEndPosition(namespaceMember, namespaceMember.Members))); 97=> list.Count > 0 ? list[0].SpanStart : container.Span.End;

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

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

618CatchClauseSyntax catchClauseNode => catchClauseNode.Block.SpanStart, 619FinallyClauseSyntax finallyClauseNode => finallyClauseNode.Block.SpanStart,

421return caretPosition > condition.SpanStart && caretPosition <= condition.Span.End; 471if (caret.Position <= currentNode.SpanStart + 1) 474else if (caret.Position <= currentNode.SpanStart)

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

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),

85statement.SpanStart, replacement,

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

3583Assert.Same(symbol, model.LookupSymbols(decl.SpanStart, name: decl.Identifier.ValueText).Single()); 3584Assert.True(model.LookupNames(decl.SpanStart).Contains(decl.Identifier.ValueText)); 3603Assert.Same(symbol, model.LookupSymbols(reference.SpanStart, name: decl.Identifier.ValueText).Single()); 3604Assert.True(model.LookupNames(reference.SpanStart).Contains(decl.Identifier.ValueText)); 3615Assert.Same(field, model.LookupSymbols(decl.SpanStart, name: decl.Identifier.ValueText).Single()); 3617Assert.True(model.LookupNames(decl.SpanStart).Contains(decl.Identifier.ValueText)); 3622Assert.Same(field, model.LookupSymbols(reference.SpanStart, name: decl.Identifier.ValueText).Single()); 3623Assert.True(model.LookupNames(reference.SpanStart).Contains(decl.Identifier.ValueText));

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

127if (expr.SpanStart >= start && expr.Span.End <= end) 148if (expr.SpanStart >= start && expr.Span.End <= end) 180if (expr.SpanStart >= start && expr.Span.End <= end) 201if (firstStatement == null && stmt.SpanStart >= start)

973var other = model.LookupSymbols(decl.SpanStart, name: decl.Identifier().ValueText).Single(); 983Assert.True(model.LookupNames(decl.SpanStart).Contains(decl.Identifier().ValueText)); 992Assert.Same(symbol, model.LookupSymbols(reference.SpanStart, name: decl.Identifier().ValueText).Single()); 993Assert.True(model.LookupNames(reference.SpanStart).Contains(decl.Identifier().ValueText)); 1145Assert.NotEqual(symbol, model.LookupSymbols(decl.SpanStart, name: decl.Identifier().ValueText).Single()); 1146Assert.True(model.LookupNames(decl.SpanStart).Contains(decl.Identifier().ValueText)); 1156Assert.False(model.LookupSymbols(reference.SpanStart, name: reference.Identifier.ValueText).Any()); 1157Assert.False(model.LookupNames(reference.SpanStart).Contains(reference.Identifier.ValueText)); 1166Assert.Same(symbol, model.LookupSymbols(reference.SpanStart, name: reference.Identifier.ValueText).Single()); 1167Assert.True(model.LookupNames(reference.SpanStart).Contains(reference.Identifier.ValueText)); 1197Assert.Same(symbol, model.LookupSymbols(reference.SpanStart, name: reference.Identifier.ValueText).Single()); 1198Assert.True(model.LookupNames(reference.SpanStart).Contains(reference.Identifier.ValueText)); 1210if (dataFlowParent.Span.Contains(reference.Span) && reference.SpanStart > decl.SpanStart) 1299(containingReturnOrThrow == null || containingReturnOrThrow.Span.Contains(reference.SpanStart)) && 1300(reference.SpanStart > decl.SpanStart || 3464bool success = model.TryGetSpeculativeSemanticModel(GetReferences(tree, "SpeculateHere").Single().SpanStart, initializer, out model); 3505bool success = model.TryGetSpeculativeSemanticModel(GetReferences(tree, "SpeculateHere").Single().SpanStart, initializer, out model); 4004bool success = model.TryGetSpeculativeSemanticModel(GetReferences(tree, "SpeculateHere").Single().SpanStart, statement, out model); 5110bool success = model.TryGetSpeculativeSemanticModel(GetReferences(tree, "SpeculateHere").Single().SpanStart, statement, out model); 8804bool success = model.TryGetSpeculativeSemanticModel(GetReferences(tree, "SpeculateHere").Single().SpanStart, statement, out model); 9643bool success = model.TryGetSpeculativeSemanticModel(GetReferences(tree, "SpeculateHere").Single().SpanStart, statement, out model); 9654Assert.Equal("System.Int64 y1", model.LookupSymbols(x1Ref[0].SpanStart, name: "y1").Single().ToTestDisplayString()); 10211bool success = model.TryGetSpeculativeSemanticModel(GetReferences(tree, "SpeculateHere").Single().SpanStart, statement, out model); 10222Assert.Equal("System.Boolean y1", model.LookupSymbols(x1Ref[0].SpanStart, name: "y1").Single().ToTestDisplayString()); 10860bool success = model.TryGetSpeculativeSemanticModel(GetReferences(tree, "SpeculateHere").Single().SpanStart, statement, out model); 13340bool success = model.TryGetSpeculativeSemanticModel(GetReferences(tree, "SpeculateHere").Single().SpanStart, statement, out model); 13739bool success = model.TryGetSpeculativeSemanticModel(GetReferences(tree, "SpeculateHere").Single().SpanStart, statement, out model); 15260bool success = model.TryGetSpeculativeSemanticModel(GetReferences(tree, "SpeculateHere").Single().SpanStart, statement, out model); 16538bool success = model.TryGetSpeculativeSemanticModel(GetReferences(tree, "SpeculateHere").Single().SpanStart, statement, out model); 17097bool success = model.TryGetSpeculativeSemanticModel(GetReferences(tree, "SpeculateHere").Single().SpanStart, statement, out model); 17533bool success = model.TryGetSpeculativeSemanticModel(GetReferences(tree, "SpeculateHere").Single().SpanStart, statement, out model); 21296bool success = model.TryGetSpeculativeSemanticModel(GetReferences(tree, "SpeculateHere").Single().SpanStart, statement, out model); 21308var y1 = model.LookupSymbols(x1Ref[0].SpanStart, name: "y1").Single(); 22656Assert.False(model.LookupSymbols(decl.SpanStart, name: identifierText).Any()); 22658Assert.False(model.LookupNames(decl.SpanStart).Contains(identifierText)); 22671Assert.False(model.LookupSymbols(reference.SpanStart, name: reference.Identifier.ValueText).Any()); 22672Assert.DoesNotContain(reference.Identifier.ValueText, model.LookupNames(reference.SpanStart)); 32690var symbols = model.LookupSymbols(decl.SpanStart, name: decl.Identifier().ValueText); 32691var names = model.LookupNames(decl.SpanStart); 32718symbols = model.LookupSymbols(reference.SpanStart, name: decl.Identifier().ValueText); 32734Assert.True(model.LookupNames(reference.SpanStart).Contains(decl.Identifier().ValueText)); 35618bool success = model.TryGetSpeculativeSemanticModel(statementBefore.SpanStart, statementAfter, out model); 36316Assert.True(model.TryGetSpeculativeSemanticModelForMethodBody(method.Body.SpanStart, method, out var speculativeModel)); 36323Assert.True(model.TryGetSpeculativeSemanticModel(method.Body.SpanStart + 1, method.DescendantNodes().OfType<AttributeSyntax>().Single(), out speculativeModel)); 36362Assert.True(model.TryGetSpeculativeSemanticModelForMethodBody(method.Body.SpanStart, method, out var speculativeModel)); 36402Assert.True(model.TryGetSpeculativeSemanticModelForMethodBody(method.Body.SpanStart, method, out var speculativeModel)); 36410Assert.True(model.TryGetSpeculativeSemanticModel(equalsValue.Value.SpanStart, equalsValue, out speculativeModel)); 36444Assert.True(model.TryGetSpeculativeSemanticModelForMethodBody(method.Body.SpanStart, method, out var speculativeModel)); 36479Assert.True(model.TryGetSpeculativeSemanticModelForMethodBody(method.Body.SpanStart, method, out var speculativeModel)); 36488Assert.True(model.TryGetSpeculativeSemanticModel(equalsValue.Value.SpanStart, equalsValue, out speculativeModel)); 36517Assert.True(model.TryGetSpeculativeSemanticModelForMethodBody(method.Body.SpanStart, method, out var speculativeModel));

87var other = model.LookupSymbols(designation.SpanStart, name: designation.Identifier.ValueText).Single(); 97Assert.True(model.LookupNames(designation.SpanStart).Contains(designation.Identifier.ValueText)); 126Assert.Same(symbol, model.LookupSymbols(reference.SpanStart, name: designation.Identifier.ValueText).Single()); 127Assert.True(model.LookupNames(reference.SpanStart).Contains(designation.Identifier.ValueText)); 147Assert.NotEqual(symbol, model.LookupSymbols(designation.SpanStart, name: designation.Identifier.ValueText).Single()); 148Assert.True(model.LookupNames(designation.SpanStart).Contains(designation.Identifier.ValueText)); 173Assert.NotEqual(symbol, model.LookupSymbols(declarator.SpanStart, name: declarator.Identifier.ValueText).Single()); 174Assert.True(model.LookupNames(declarator.SpanStart).Contains(declarator.Identifier.ValueText)); 187Assert.NotEqual(symbol, model.LookupSymbols(designation.SpanStart, name: designation.Identifier.ValueText).Single()); 188Assert.True(model.LookupNames(designation.SpanStart).Contains(designation.Identifier.ValueText)); 197Assert.Same(symbol, model.LookupSymbols(reference.SpanStart, name: reference.Identifier.ValueText).Single()); 198Assert.True(model.LookupNames(reference.SpanStart).Contains(reference.Identifier.ValueText)); 210var other = model.LookupSymbols(reference.SpanStart, name: reference.Identifier.ValueText).Single(); 212Assert.True(model.LookupNames(reference.SpanStart).Contains(reference.Identifier.ValueText)); 218Assert.False(model.LookupSymbols(reference.SpanStart, name: reference.Identifier.ValueText).Any()); 219Assert.False(model.LookupNames(reference.SpanStart).Contains(reference.Identifier.ValueText)); 250var symbols = model.LookupSymbols(designation.SpanStart, name: designation.Identifier.ValueText); 251var names = model.LookupNames(designation.SpanStart); 302symbols = model.LookupSymbols(reference.SpanStart, name: designation.Identifier.ValueText); 318Assert.True(model.LookupNames(reference.SpanStart).Contains(designation.Identifier.ValueText)); 368Assert.False(model.LookupSymbols(designation.SpanStart, name: identifierText).Any()); 370Assert.False(model.LookupNames(designation.SpanStart).Contains(identifierText)); 411Assert.False(model.LookupSymbols(reference.SpanStart, name: reference.Identifier.ValueText).Any()); 412Assert.DoesNotContain(reference.Identifier.ValueText, model.LookupNames(reference.SpanStart)); 452var binder = model.GetEnclosingBinder(node.SpanStart);

408GetReferences(tree, "SpeculateHere").Single().SpanStart, 713tree.GetRoot().DescendantNodes().OfType<IdentifierNameSyntax>().Where(id => id.Identifier.ValueText == "SpeculateHere").Single().SpanStart, 982tree.GetRoot().DescendantNodes().OfType<IdentifierNameSyntax>().Where(id => id.Identifier.ValueText == "SpeculateHere").Single().SpanStart, 1286GetReferences(tree, "SpeculateHere").Single().SpanStart, 5342GetReferences(tree, "SpeculateHere").Single().SpanStart, 6472GetReferences(tree, "SpeculateHere").Single().SpanStart, 6484Assert.Equal("System.Int64 y1", model.LookupSymbols(x1Ref[0].SpanStart, name: "y1").Single().ToTestDisplayString()); 6884bool success = model.TryGetSpeculativeSemanticModel(tree.GetRoot().DescendantNodes().OfType<IdentifierNameSyntax>().Where(id => id.Identifier.ValueText == "SpeculateHere").Single().SpanStart, statement, out model); 6895Assert.Equal("System.Boolean y1", model.LookupSymbols(x1Ref[0].SpanStart, name: "y1").Single().ToTestDisplayString()); 7212GetReferences(tree, "SpeculateHere").Single().SpanStart, 7535GetReferences(tree, "SpeculateHere").Single().SpanStart, 9641GetReferences(tree, "SpeculateHere").Single().SpanStart, 10204GetReferences(tree, "SpeculateHere").Single().SpanStart, 10720tree.GetRoot().DescendantNodes().OfType<IdentifierNameSyntax>().Where(id => id.Identifier.ValueText == "SpeculateHere").Single().SpanStart, 12146bool success = model.TryGetSpeculativeSemanticModel(GetReferences(tree, "SpeculateHere").Single().SpanStart, statement, out model); 12158var y1 = model.LookupSymbols(x1Ref[0].SpanStart, name: "y1").Single();

4019var binder = model.GetEnclosingBinder(@switch.SpanStart); 4088var binder = model.GetEnclosingBinder(@switch.SpanStart); 4161var binder = model.GetEnclosingBinder(@switch.SpanStart); 4233var binder = model.GetEnclosingBinder(@is.SpanStart); 4277var binder = model.GetEnclosingBinder(@switch.SpanStart); 4324var binder = model.GetEnclosingBinder(@switch.SpanStart); 4406var binder = model.GetEnclosingBinder(@switch.SpanStart); 4488var binder = model.GetEnclosingBinder(@switch.SpanStart); 4570var binder = model.GetEnclosingBinder(@switch.SpanStart); 4652var binder = model.GetEnclosingBinder(@switch.SpanStart); 4736var binder = model.GetEnclosingBinder(@switch.SpanStart);

1013Assert.Same(symbol, model.LookupSymbols(x.SpanStart, name: "X").Single()); 1014Assert.Contains("X", model.LookupNames(x.SpanStart)); 1080Assert.Same(symbol.ContainingSymbol, model.GetEnclosingSymbol(x.SpanStart)); 1081Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 1082Assert.Contains("X", model.LookupNames(x.SpanStart)); 1307Assert.Same(symbol.ContainingSymbol, model.GetEnclosingSymbol(x.SpanStart)); 1308Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 1309Assert.Contains("X", model.LookupNames(x.SpanStart)); 1320Assert.Same(symbol.ContainingSymbol, model.GetEnclosingSymbol(x.SpanStart)); 1321Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "y")); 1322Assert.Contains("y", model.LookupNames(x.SpanStart)); 1331Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "Test")); 1332Assert.Contains("Test", model.LookupNames(x.SpanStart)); 1372Assert.Same("<global namespace>", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 1373Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 1374Assert.DoesNotContain("X", model.LookupNames(x.SpanStart)); 1418Assert.Same("<global namespace>", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 1419Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 1420Assert.DoesNotContain("X", model.LookupNames(x.SpanStart)); 1478Assert.Same("<global namespace>", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 1479Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 1480Assert.DoesNotContain("X", model.LookupNames(x.SpanStart)); 1536Assert.Same(symbol.ContainingSymbol, model.GetEnclosingSymbol(x.SpanStart)); 1537Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 1538Assert.Contains("X", model.LookupNames(x.SpanStart)); 1547Assert.Same("<global namespace>", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 1548Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 1549Assert.DoesNotContain("X", model.LookupNames(x.SpanStart)); 1625Assert.Same(symbol.ContainingSymbol, model.GetEnclosingSymbol(x.SpanStart)); 1626Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 1627Assert.Contains("X", model.LookupNames(x.SpanStart)); 1636Assert.Same("<global namespace>", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 1637Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 1638Assert.DoesNotContain("X", model.LookupNames(x.SpanStart)); 1821Assert.Same("<global namespace>", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 1822Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 1823Assert.DoesNotContain("X", model.LookupNames(x.SpanStart)); 1861Assert.Same("<global namespace>", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 1862Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 1863Assert.DoesNotContain("X", model.LookupNames(x.SpanStart)); 1902Assert.Equal("C..ctor(System.Int32 X)", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 1903Assert.Equal("System.Int32 X", model.LookupSymbols(x.SpanStart, name: "X").Single().ToTestDisplayString()); 1904Assert.Contains("X", model.LookupNames(x.SpanStart)); 1974Assert.Same(symbol.ContainingSymbol, model.GetEnclosingSymbol(x.SpanStart)); 1975Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 1976Assert.Contains("X", model.LookupNames(x.SpanStart)); 2173Assert.False(model.TryGetSpeculativeSemanticModel(tree.GetRoot().DescendantNodes().OfType<ReturnStatementSyntax>().Single().SpanStart, 2176var otherBasePosition = ((BaseListSyntax)baseWithargs.Parent).Types[1].SpanStart; 2179Assert.True(model.TryGetSpeculativeSemanticModel(baseWithargs.SpanStart, speculativePrimaryInitializer, out speculativeModel)); 2204symbolInfo = model.GetSpeculativeSymbolInfo(baseWithargs.SpanStart, (SyntaxNode)speculativePrimaryInitializer, SpeculativeBindingOption.BindAsExpression); 2207symbolInfo = CSharpExtensions.GetSpeculativeSymbolInfo(model, baseWithargs.SpanStart, speculativePrimaryInitializer); 2325Assert.False(model.TryGetSpeculativeSemanticModel(tree.GetRoot().DescendantNodes().OfType<ReturnStatementSyntax>().Single().SpanStart, 2328var otherBasePosition = ((BaseListSyntax)baseWithargs.Parent).Types[1].SpanStart; 2331Assert.False(model.TryGetSpeculativeSemanticModel(baseWithargs.SpanStart, speculativePrimaryInitializer, out _)); 2343symbolInfo = model.GetSpeculativeSymbolInfo(baseWithargs.SpanStart, (SyntaxNode)speculativePrimaryInitializer, SpeculativeBindingOption.BindAsExpression); 2346symbolInfo = CSharpExtensions.GetSpeculativeSymbolInfo(model, baseWithargs.SpanStart, speculativePrimaryInitializer); 2432Assert.Same("<global namespace>", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 2433Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 2434Assert.DoesNotContain("X", model.LookupNames(x.SpanStart)); 2492Assert.False(model.TryGetSpeculativeSemanticModel(baseWithoutParens.SpanStart + 2, speculativeBase, out _)); 2648Assert.Equal("System.Int32 C.Z", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 2649Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 2650Assert.Contains("X", model.LookupNames(x.SpanStart)); 2686Assert.Equal("System.Int32 C.Z", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 2687Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 2688Assert.Contains("X", model.LookupNames(x.SpanStart)); 2723Assert.Equal("System.Int32 C.Z", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 2724Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 2725Assert.Contains("X", model.LookupNames(x.SpanStart)); 2759Assert.Equal("lambda expression", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 2760Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 2761Assert.Contains("X", model.LookupNames(x.SpanStart)); 6862Assert.Contains("System.Int32 y", model.LookupSymbols(mCall.SpanStart).Select(s => s.ToTestDisplayString())); 6864Assert.DoesNotContain("System.Int32 y", model.LookupSymbols(mDefinition.SpanStart).Select(s => s.ToTestDisplayString())); 7808Assert.Empty(model.LookupSymbols(p1.SpanStart, name: "p1")); 7809Assert.DoesNotContain("p1", model.LookupNames(p1.SpanStart)); 7836Assert.Same(symbol, model.LookupSymbols(p1.SpanStart, name: "p1").Single()); 7837Assert.Contains("p1", model.LookupNames(p1.SpanStart)); 8767Assert.Contains("p1", model.LookupNames(p1.SpanStart)); 8768Assert.Contains(symbol, model.LookupSymbols(p1.SpanStart, name: "p1")); 9173Assert.Contains("p1", model.LookupNames(p1.SpanStart)); 9174Assert.Contains(symbol, model.LookupSymbols(p1.SpanStart, name: "p1"));

21152Assert.Same(symbol.ContainingSymbol, model.GetEnclosingSymbol(x.SpanStart)); 21153Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 21154Assert.Contains("X", model.LookupNames(x.SpanStart)); 21381Assert.Same(symbol.ContainingSymbol, model.GetEnclosingSymbol(x.SpanStart)); 21382Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 21383Assert.Contains("X", model.LookupNames(x.SpanStart)); 21394Assert.Same(symbol.ContainingSymbol, model.GetEnclosingSymbol(x.SpanStart)); 21395Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "y")); 21396Assert.Contains("y", model.LookupNames(x.SpanStart)); 21405Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "Test")); 21406Assert.Contains("Test", model.LookupNames(x.SpanStart)); 21446Assert.Same("<global namespace>", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 21447Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 21448Assert.DoesNotContain("X", model.LookupNames(x.SpanStart)); 21492Assert.Same("<global namespace>", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 21493Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 21494Assert.DoesNotContain("X", model.LookupNames(x.SpanStart)); 21552Assert.Same("<global namespace>", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 21553Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 21554Assert.DoesNotContain("X", model.LookupNames(x.SpanStart)); 21610Assert.Same(symbol.ContainingSymbol, model.GetEnclosingSymbol(x.SpanStart)); 21611Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 21612Assert.Contains("X", model.LookupNames(x.SpanStart)); 21621Assert.Same("<global namespace>", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 21622Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 21623Assert.DoesNotContain("X", model.LookupNames(x.SpanStart)); 21699Assert.Same(symbol.ContainingSymbol, model.GetEnclosingSymbol(x.SpanStart)); 21700Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 21701Assert.Contains("X", model.LookupNames(x.SpanStart)); 21710Assert.Same("<global namespace>", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 21711Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 21712Assert.DoesNotContain("X", model.LookupNames(x.SpanStart)); 21895Assert.Same("<global namespace>", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 21896Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 21897Assert.DoesNotContain("X", model.LookupNames(x.SpanStart)); 21932Assert.Same("<global namespace>", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 21933Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 21934Assert.DoesNotContain("X", model.LookupNames(x.SpanStart)); 21970Assert.Equal("C..ctor(System.Int32 X)", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 21971Assert.Equal("System.Int32 X", model.LookupSymbols(x.SpanStart, name: "X").Single().ToTestDisplayString()); 21972Assert.Contains("X", model.LookupNames(x.SpanStart)); 22007Assert.Same("<global namespace>", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 22008Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 22009Assert.DoesNotContain("X", model.LookupNames(x.SpanStart)); 22086Assert.Same(symbol.ContainingSymbol, model.GetEnclosingSymbol(x.SpanStart)); 22087Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 22088Assert.Contains("X", model.LookupNames(x.SpanStart)); 22285Assert.False(model.TryGetSpeculativeSemanticModel(tree.GetRoot().DescendantNodes().OfType<ReturnStatementSyntax>().Single().SpanStart, 22288var otherBasePosition = ((BaseListSyntax)baseWithargs.Parent!).Types[1].SpanStart; 22291Assert.True(model.TryGetSpeculativeSemanticModel(baseWithargs.SpanStart, speculativePrimaryInitializer, out speculativeModel!)); 22316symbolInfo = model.GetSpeculativeSymbolInfo(baseWithargs.SpanStart, (SyntaxNode)speculativePrimaryInitializer, SpeculativeBindingOption.BindAsExpression); 22319symbolInfo = CSharpExtensions.GetSpeculativeSymbolInfo(model, baseWithargs.SpanStart, speculativePrimaryInitializer); 22437Assert.False(model.TryGetSpeculativeSemanticModel(tree.GetRoot().DescendantNodes().OfType<ReturnStatementSyntax>().Single().SpanStart, 22440var otherBasePosition = ((BaseListSyntax)baseWithargs.Parent!).Types[1].SpanStart; 22443Assert.False(model.TryGetSpeculativeSemanticModel(baseWithargs.SpanStart, speculativePrimaryInitializer, out _)); 22455symbolInfo = model.GetSpeculativeSymbolInfo(baseWithargs.SpanStart, (SyntaxNode)speculativePrimaryInitializer, SpeculativeBindingOption.BindAsExpression); 22458symbolInfo = CSharpExtensions.GetSpeculativeSymbolInfo(model, baseWithargs.SpanStart, speculativePrimaryInitializer); 24650Assert.Equal("System.Int32 C.Z", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 24651Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 24652Assert.Contains("X", model.LookupNames(x.SpanStart)); 24685Assert.Equal("System.Int32 C.Z", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 24686Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 24687Assert.Contains("X", model.LookupNames(x.SpanStart)); 24719Assert.Equal("System.Int32 C.Z", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 24720Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 24721Assert.Contains("X", model.LookupNames(x.SpanStart)); 24754Assert.Equal("lambda expression", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 24755Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 24756Assert.Contains("X", model.LookupNames(x.SpanStart)); 30399Assert.Contains("System.Int32 y", model.LookupSymbols(mCall.SpanStart).Select(s => s.ToTestDisplayString())); 30401Assert.DoesNotContain("System.Int32 y", model.LookupSymbols(mDefinition.SpanStart).Select(s => s.ToTestDisplayString()));

62return IsSemanticTypeArgumentAsync(document, node.SpanStart, identifier, cancellationToken);

221matchingNode.SpanStart; 429originalNode.SpanStart, 451originalNode.SpanStart, 467originalNode.SpanStart, 483originalNode.SpanStart, 504originalNode.SpanStart,

104if (identifier.SpanStart < variableDeclarator.SpanStart)

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

142position = token.Parent.SpanStart;

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

77var namePosition = name.SpanStart;

94return (dotToken, expression.SpanStart);

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

95if (token.SpanStart < parentMember.SpanStart)

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

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

75if (position < baseDeclaration.SpanStart)

238var startLine = document.Text.Lines.GetLineFromPosition(GetAnchorNode(document, stringExpression).SpanStart); 352var interpolationLine = text.Lines.GetLineFromPosition(interpolation.SpanStart); 358interpolationLine.GetFirstNonWhitespacePosition() == interpolation.SpanStart) 361return GetIndentationStringForPosition(text, formattingOptions, interpolation.SpanStart);

116=> TextSpan.FromBounds(node.SpanStart, token.Span.End); 213if (position <= typeDeclaration.ParameterList.SpanStart) 810position = variableDeclaration.SpanStart;

217position = body.SpanStart; 261Debug.Assert(position == ((PropertyDeclarationSyntax)node).Initializer!.SpanStart); 312Debug.Assert(position == ((SwitchExpressionArmSyntax)node).Expression.SpanStart); 344position < node.Expression.SpanStart ? ForEachPart.In : 351ForEachPart.VariableDeclaration => TextSpan.FromBounds(node.Type.SpanStart, node.Identifier.Span.End), 361ForEachPart.VariableDeclaration => TextSpan.FromBounds(node.Variable.SpanStart, node.Variable.Span.End), 643BreakpointSpans.TryGetClosestBreakpointSpan(node, propertyDeclaration.Initializer.SpanStart, minLength, out span)) 683return BreakpointSpans.TryGetClosestBreakpointSpan(node, node.SpanStart, minLength, out span); 1416return model.GetEnclosingSymbol(node.SpanStart, cancellationToken); 1421return model.GetEnclosingSymbol(primaryCtorBase.ArgumentList.SpanStart, cancellationToken); 2707tryStatement.Catches.First().SpanStart,

178if (!leadingTrivia.Any(t => t.IsKind(SyntaxKind.EndOfLineTrivia)) && !methodDefinition.FindTokenOnLeftOfPosition(methodDefinition.SpanStart).IsKind(SyntaxKind.OpenBraceToken)) 184if (!originalMethodDefinition.FindTokenOnLeftOfPosition(originalMethodDefinition.SpanStart).TrailingTrivia.Any(SyntaxKind.EndOfLineTrivia))

159var postProcessor = new PostProcessor(semanticModel, insertionPointNode.SpanStart); 514var postProcessor = new PostProcessor(semanticModel, insertionPointNode.SpanStart);

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

203var start = nameOrMemberAccessExpression.SpanStart; 534=> semanticModel.GetEnclosingNamedType(simpleName.SpanStart, cancellationToken); 777if (await IsWithinTheImportingNamespaceAsync(document, simpleName.SpanStart, includeUsingsOrImports, cancellationToken).ConfigureAwait(false))

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

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

227var spanStart = declaringNode.SpanStart; 258var start = enumMember.SpanStart;

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

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

97.Sort(semanticModel, attribute.SpanStart); 137var position = attribute.SpanStart;

103.Sort(semanticModel, expression.SpanStart); 146currentSpan.Start != expression.SpanStart) 163offset = expression.SpanStart - conditionalAccessExpression.SpanStart; 173offset = expression.SpanStart - elementAccessExpression.SpanStart; 344return TextSpan.FromBounds(expression.SpanStart, openBracket.Parent.Span.End); 391(c, elementBindingExpression) => c.SpanStart < elementBindingExpression.SpanStart, elementBindingExpression)!;

41var position = invocationExpression.SpanStart;

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));

24objectCreationExpression.SpanStart,

25var position = objectCreationExpression.SpanStart;

93.Sort(semanticModel, baseTypeSyntax.SpanStart);

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

50if (currentSpan.Start == parenthesizedExpression.SpanStart) 76position = expression.SpanStart; 95position = expression.SpanStart; 135var inferredTypes = typeInferrer.InferTypes(semanticModel, targetExpression!.SpanStart, cancellationToken);

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

102placeholderBuilder.Add(left.ToString(), left.SpanStart); 107placeholderBuilder.Add(operand.ToString(), operand.SpanStart);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

218expression.SpanStart,

69invocationExpression.SpanStart,

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

70expression.SpanStart, 110expression.SpanStart,

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

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

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

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

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

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

311var localStatementStart = _localStatement.SpanStart; 312var comparisonSpanStart = _comparison.SpanStart; 319var descendentNodeSpanStart = descendentNode.SpanStart;

175var localStatementStart = localStatement.SpanStart; 176var comparisonSpanStart = comparison.SpanStart; 180var descendentNodeSpanStart = descendentNode.SpanStart; 221var descendentNodeSpanStart = descendentNode.SpanStart; 242var descendentNodeSpanStart = descendentNode.SpanStart;

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

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

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

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

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

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

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

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

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

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

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

808var lineToConsider = text.Lines.GetLineFromPosition(expressionToReplace.SpanStart);

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

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

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

142var holeStartLine = text.Lines.GetLineFromPosition(interpolation.SpanStart).LineNumber; 171var firstLine = text.Lines.GetLineFromPosition(expression.SpanStart);

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

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

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

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

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

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

39.OrderBy(node => node.SpanStart)

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

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

145var reservedNames = semanticModel.LookupSymbols(isExpression.SpanStart)

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)

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

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);

11188int position = syntax.SpanStart;

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

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

945invocation.SpanStart, 1126.OrderByDescending(s => s.SpanStart); 3043var lambda = (IMethodSymbol)model.GetEnclosingSymbol(contentType.SpanStart); 3050lambda = (IMethodSymbol)model.GetEnclosingSymbol(b.SpanStart); 3055Assert.Equal("void Program.method1()", model.GetEnclosingSymbol(parameterSyntax.SpanStart).ToTestDisplayString()); 3988Assert.True(model.TryGetSpeculativeSemanticModelForMethodBody(m.Body.SpanStart, m, out model)); 8092Assert.True(model.TryGetSpeculativeSemanticModelForMethodBody(m2Syntax.Body.SpanStart, newMethod, out var speculativeModel)); 8172var methodBinder = getBinder<BlockBinder>(methodModel.GetEnclosingBinder(methodSyntax.Body.SpanStart)); 8173var defaultValueBinder = getBinder<BlockBinder>(defaultValueModel.GetEnclosingBinder(defaultValue.SpanStart));

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()); 7451return tree.GetRoot().DescendantNodes().OfType<IdentifierNameSyntax>().Where(i => i.Identifier.ValueText == identifier).Single().SpanStart; 8740Assert.True(model.TryGetSpeculativeSemanticModelForMethodBody(method.Body.SpanStart, method, out var speculativeModel));

684var baseExprLocation = baseExprNode.SpanStart;

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));

64094Assert.True(model1.TryGetSpeculativeSemanticModel(function1.SpanStart, function2, out var model2)); 144657ifStatement.SpanStart, 156201var found = model.LookupSymbols(item.SpanStart, i3.GetPublicSymbol()).Single(s => s.Name == "Item"); 156370var found = model.LookupSymbols(item.SpanStart, i3.GetPublicSymbol()).Single(s => s.Name == "Item"); 156408Assert.True(model.LookupNames(item.SpanStart, i3.GetPublicSymbol()).Contains("Item")); 156410var found = model.LookupSymbols(item.SpanStart, i3.GetPublicSymbol()).Single(s => s.Name == "Item"); 156448Assert.True(model.LookupNames(item.SpanStart, i3.GetPublicSymbol()).Contains("Item")); 156451var found = model.LookupSymbols(item.SpanStart, t.GetPublicSymbol()).Single(s => s.Name == "Item"); 156484Assert.True(model.LookupNames(item.SpanStart, t.GetPublicSymbol()).Contains("Item")); 156486var found = model.LookupSymbols(item.SpanStart, t.GetPublicSymbol()).Single(s => s.Name == "Item"); 156618Assert.True(model.LookupNames(item.SpanStart, i3.GetPublicSymbol()).Contains("Get")); 156620var found = model.LookupSymbols(item.SpanStart, i3.GetPublicSymbol()).Single(s => s.Name == "Get"); 156662var found = model.LookupSymbols(item.SpanStart, i3.GetPublicSymbol()).Single(s => s.Name == "Item"); 156706var found = model.LookupSymbols(item.SpanStart, t.GetPublicSymbol()).Single(s => s.Name == "Item"); 156743var found = model.LookupSymbols(item.SpanStart, t.GetPublicSymbol()).Single(s => s.Name == "Item");

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

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

2601Assert.Equal("System.Int32 C.Z", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 2602Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 2603Assert.Contains("X", model.LookupNames(x.SpanStart)); 2636Assert.Equal("System.Int32 C.Z", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 2637Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 2638Assert.Contains("X", model.LookupNames(x.SpanStart)); 2670Assert.Equal("System.Int32 C.Z", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 2671Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 2672Assert.Contains("X", model.LookupNames(x.SpanStart)); 2705Assert.Equal("lambda expression", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 2706Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 2707Assert.Contains("X", model.LookupNames(x.SpanStart)); 10778Assert.False(model.TryGetSpeculativeSemanticModel(baseWithoutParens.SpanStart + 2, speculativeBase, out _));

3332var callPosition = callExpr.SpanStart;

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

197Assert.Contains(refSymbol.Name, model1.LookupNames(localRef.SpanStart)); 198Assert.Contains(refSymbol, model1.LookupSymbols(localRef.SpanStart)); 199Assert.Same(refSymbol, model1.LookupSymbols(localRef.SpanStart, name: refSymbol.Name).Single()); 240Assert.Contains(declSymbol.Name, model1.LookupNames(localDecl.SpanStart)); 241Assert.Contains(declSymbol, model1.LookupSymbols(localDecl.SpanStart)); 242Assert.Same(declSymbol, model1.LookupSymbols(localDecl.SpanStart, name: declSymbol.Name).Single()); 325Assert.DoesNotContain(name, model1.LookupNames(localRef.SpanStart)); 326Assert.Empty(model1.LookupSymbols(localRef.SpanStart).Where(s => s.Name == name)); 327Assert.Empty(model1.LookupSymbols(localRef.SpanStart, name: name)); 363Assert.Contains(declSymbol.Name, model2.LookupNames(localDecl.SpanStart)); 364Assert.Contains(declSymbol, model2.LookupSymbols(localDecl.SpanStart)); 365Assert.Same(declSymbol, model2.LookupSymbols(localDecl.SpanStart, name: declSymbol.Name).Single()); 484Assert.Contains(declSymbol.Name, model1.LookupNames(localDecl.SpanStart)); 485Assert.Contains(declSymbol, model1.LookupSymbols(localDecl.SpanStart)); 486Assert.Same(declSymbol, model1.LookupSymbols(localDecl.SpanStart, name: declSymbol.Name).Single()); 493Assert.Contains(declSymbol.Name, model1.LookupNames(localFuncRef.SpanStart)); 494Assert.Contains(declSymbol, model1.LookupSymbols(localFuncRef.SpanStart)); 495Assert.Same(declSymbol, model1.LookupSymbols(localFuncRef.SpanStart, name: declSymbol.Name).Single()); 504Assert.DoesNotContain(name, model2.LookupNames(localRef.SpanStart)); 505Assert.Empty(model2.LookupSymbols(localRef.SpanStart).Where(s => s.Name == name)); 506Assert.Empty(model2.LookupSymbols(localRef.SpanStart, name: name)); 536Assert.Contains(declSymbol.Name, model1.LookupNames(localDecl.SpanStart)); 537Assert.Contains(declSymbol, model1.LookupSymbols(localDecl.SpanStart)); 538Assert.Same(declSymbol, model1.LookupSymbols(localDecl.SpanStart, name: declSymbol.Name).Single()); 547Assert.Contains(declSymbol.Name, model1.LookupNames(localRef.SpanStart)); 548Assert.Contains(declSymbol, model1.LookupSymbols(localRef.SpanStart)); 549Assert.Same(declSymbol, model1.LookupSymbols(localRef.SpanStart, name: declSymbol.Name).Single()); 576Assert.Contains(declSymbol.Name, model1.LookupNames(localDecl.SpanStart)); 577Assert.Contains(declSymbol, model1.LookupSymbols(localDecl.SpanStart)); 578Assert.Same(declSymbol, model1.LookupSymbols(localDecl.SpanStart, name: declSymbol.Name).Single()); 585Assert.Contains(declSymbol.Name, model1.LookupNames(localFuncRef.SpanStart)); 586Assert.Contains(declSymbol, model1.LookupSymbols(localFuncRef.SpanStart)); 587Assert.Same(declSymbol, model1.LookupSymbols(localFuncRef.SpanStart, name: declSymbol.Name).Single()); 594Assert.Contains(refSymbol.Name, model1.LookupNames(localRef.SpanStart)); 595Assert.Contains(refSymbol, model1.LookupSymbols(localRef.SpanStart)); 596Assert.Same(refSymbol, model1.LookupSymbols(localRef.SpanStart, name: refSymbol.Name).Single()); 1688var names = model1.LookupNames(localDecl.SpanStart); 1690var symbols = model1.LookupSymbols(localDecl.SpanStart); 1692Assert.Same(getHashCode, model1.LookupSymbols(localDecl.SpanStart, name: getHashCode.Name).Single()); 1697Assert.Same(declSymbol, model1.LookupSymbols(localDecl.SpanStart, name: "Test").Single()); 1699symbols = model1.LookupNamespacesAndTypes(localDecl.SpanStart); 1702Assert.Same(testType, model1.LookupNamespacesAndTypes(localDecl.SpanStart, name: "Test").Single()); 1720names = model.LookupNames(nameRef.SpanStart); 1724symbols = model.LookupSymbols(nameRef.SpanStart); 1726Assert.Empty(model.LookupSymbols(nameRef.SpanStart, name: getHashCode.Name)); 1730Assert.Same(testType, model.LookupSymbols(nameRef.SpanStart, name: "Test").Single()); 1735Assert.DoesNotContain(getHashCode.Name, model.LookupNames(nameRef.SpanStart)); 1751Assert.DoesNotContain(getHashCode.Name, model.LookupNames(nameRef.SpanStart)); 1761var names = model.LookupNames(nameRef.SpanStart); 1764var symbols = model.LookupSymbols(nameRef.SpanStart); 1767Assert.Same(declSymbol, model.LookupSymbols(nameRef.SpanStart, name: "Test").Single()); 1769symbols = model.LookupNamespacesAndTypes(nameRef.SpanStart); 1772Assert.Same(testType, model.LookupNamespacesAndTypes(nameRef.SpanStart, name: "Test").Single()); 1861var names = model1.LookupNames(localDecl.SpanStart); 1863var symbols = model1.LookupSymbols(localDecl.SpanStart); 1865Assert.Same(getHashCode, model1.LookupSymbols(localDecl.SpanStart, name: getHashCode.Name).Single()); 1870Assert.Same(declSymbol, model1.LookupSymbols(localDecl.SpanStart, name: "Test").Single()); 1872symbols = model1.LookupNamespacesAndTypes(localDecl.SpanStart); 1875Assert.Same(testType, model1.LookupNamespacesAndTypes(localDecl.SpanStart, name: "Test").Single()); 1888names = model2.LookupNames(nameRef.SpanStart); 1892symbols = model2.LookupSymbols(nameRef.SpanStart); 1894Assert.Empty(model2.LookupSymbols(nameRef.SpanStart, name: getHashCode.Name)); 1898Assert.Same(testType, model2.LookupSymbols(nameRef.SpanStart, name: "Test").Single()); 1903Assert.DoesNotContain(getHashCode.Name, model2.LookupNames(nameRef.SpanStart)); 1919Assert.DoesNotContain(getHashCode.Name, model2.LookupNames(nameRef.SpanStart)); 1929var names = model2.LookupNames(nameRef.SpanStart); 1932var symbols = model2.LookupSymbols(nameRef.SpanStart); 1935Assert.Same(declSymbol, model2.LookupSymbols(nameRef.SpanStart, name: "Test").Single()); 1937symbols = model2.LookupNamespacesAndTypes(nameRef.SpanStart); 1940Assert.Same(testType, model2.LookupNamespacesAndTypes(nameRef.SpanStart, name: "Test").Single()); 2087var names = model1.LookupNames(localDecl.SpanStart); 2088var symbols = model1.LookupSymbols(localDecl.SpanStart); 2093Assert.Same(declSymbol, model1.LookupSymbols(localDecl.SpanStart, name: "Test").Single()); 2095symbols = model1.LookupNamespacesAndTypes(localDecl.SpanStart); 2098Assert.Same(testType, model1.LookupNamespacesAndTypes(localDecl.SpanStart, name: "Test").Single()); 2106names = model1.LookupNames(nameRef.SpanStart); 2109symbols = model1.LookupSymbols(nameRef.SpanStart); 2113Assert.Same(testType, model1.LookupSymbols(nameRef.SpanStart, name: "Test").Single()); 2142var names = model2.LookupNames(nameRef.SpanStart); 2145var symbols = model2.LookupSymbols(nameRef.SpanStart); 2148Assert.Same(declSymbol, model2.LookupSymbols(nameRef.SpanStart, name: "Test").Single()); 2150symbols = model2.LookupNamespacesAndTypes(nameRef.SpanStart); 2153Assert.Same(testType, model2.LookupNamespacesAndTypes(nameRef.SpanStart, name: "Test").Single()); 2251var names = model1.LookupNames(localDecl.SpanStart); 2252var symbols = model1.LookupSymbols(localDecl.SpanStart); 2257Assert.Same(declSymbol, model1.LookupSymbols(localDecl.SpanStart, name: "Test").Single()); 2259symbols = model1.LookupNamespacesAndTypes(localDecl.SpanStart); 2262Assert.Same(testType, model1.LookupNamespacesAndTypes(localDecl.SpanStart, name: "Test").Single()); 2272names = model2.LookupNames(nameRef.SpanStart); 2275symbols = model2.LookupSymbols(nameRef.SpanStart); 2279Assert.Same(testType, model2.LookupSymbols(nameRef.SpanStart, name: "Test").Single()); 2308var names = model2.LookupNames(nameRef.SpanStart); 2311var symbols = model2.LookupSymbols(nameRef.SpanStart); 2314Assert.Same(declSymbol, model2.LookupSymbols(nameRef.SpanStart, name: "Test").Single()); 2316symbols = model2.LookupNamespacesAndTypes(nameRef.SpanStart); 2319Assert.Same(testType, model2.LookupNamespacesAndTypes(nameRef.SpanStart, name: "Test").Single()); 2430var names = model1.LookupNames(labelDecl.SpanStart); 2431var symbols = model1.LookupSymbols(labelDecl.SpanStart); 2436Assert.Same(testType, model1.LookupSymbols(labelDecl.SpanStart, name: "Test").Single()); 2438symbols = model1.LookupNamespacesAndTypes(labelDecl.SpanStart); 2441Assert.Same(testType, model1.LookupNamespacesAndTypes(labelDecl.SpanStart, name: "Test").Single()); 2443Assert.Same(declSymbol, model1.LookupLabels(labelDecl.SpanStart).Single()); 2444Assert.Same(declSymbol, model1.LookupLabels(labelDecl.SpanStart, name: "Test").Single()); 2452names = model1.LookupNames(nameRef.SpanStart); 2455symbols = model1.LookupSymbols(nameRef.SpanStart); 2459Assert.Same(testType, model1.LookupSymbols(nameRef.SpanStart, name: "Test").Single()); 2460Assert.Empty(model1.LookupLabels(nameRef.SpanStart)); 2461Assert.Empty(model1.LookupLabels(nameRef.SpanStart, name: "Test")); 2467names = model1.LookupNames(nameRef.SpanStart); 2470symbols = model1.LookupSymbols(nameRef.SpanStart); 2474Assert.Same(testType, model1.LookupSymbols(nameRef.SpanStart, name: "Test").Single()); 2475Assert.Same(declSymbol, model1.LookupLabels(nameRef.SpanStart).Single()); 2476Assert.Same(declSymbol, model1.LookupLabels(nameRef.SpanStart, name: "Test").Single()); 2505var names = model2.LookupNames(nameRef.SpanStart); 2508var symbols = model2.LookupSymbols(nameRef.SpanStart); 2511Assert.Same(testType, model2.LookupSymbols(nameRef.SpanStart, name: "Test").Single()); 2513symbols = model2.LookupNamespacesAndTypes(nameRef.SpanStart); 2516Assert.Same(testType, model2.LookupNamespacesAndTypes(nameRef.SpanStart, name: "Test").Single()); 2518Assert.Empty(model2.LookupLabels(nameRef.SpanStart)); 2519Assert.Empty(model2.LookupLabels(nameRef.SpanStart, name: "Test")); 2921Assert.NotEmpty(model1.LookupNamespacesAndTypes(nameRef.SpanStart, name: "alias1")); 2922Assert.Empty(model1.LookupNamespacesAndTypes(nameRef.SpanStart, name: "alias2")); 2943Assert.Empty(model2.LookupNamespacesAndTypes(nameRef.SpanStart, name: "alias1")); 2944Assert.NotEmpty(model2.LookupNamespacesAndTypes(nameRef.SpanStart, name: "alias2")); 3947var names = model.LookupNames(nameRef.SpanStart); 3950var symbols = model.LookupSymbols(nameRef.SpanStart); 3953Assert.Same(testType, model.LookupSymbols(nameRef.SpanStart, name: "args").Single()); 3961names = model.LookupNames(nameRef.SpanStart); 3964symbols = model.LookupSymbols(nameRef.SpanStart); 3967Assert.Same(parameter, model.LookupSymbols(nameRef.SpanStart, name: "args").Single()); 3969symbols = model.LookupNamespacesAndTypes(nameRef.SpanStart); 3972Assert.Same(testType, model.LookupNamespacesAndTypes(nameRef.SpanStart, name: "args").Single()); 4001var names = model.LookupNames(nameRef.SpanStart); 4004var symbols = model.LookupSymbols(nameRef.SpanStart); 4007Assert.Same(testType, model.LookupSymbols(nameRef.SpanStart, name: "args").Single()); 4009symbols = model.LookupNamespacesAndTypes(nameRef.SpanStart); 4012Assert.Same(testType, model.LookupNamespacesAndTypes(nameRef.SpanStart, name: "args").Single()); 4096var names = model.LookupNames(nameRef.SpanStart); 4099var symbols = model.LookupSymbols(nameRef.SpanStart); 4102Assert.Same(testType, model.LookupSymbols(nameRef.SpanStart, name: "args").Single()); 4131var names = model.LookupNames(nameRef.SpanStart); 4134var symbols = model.LookupSymbols(nameRef.SpanStart); 4137Assert.Same(testType, model.LookupSymbols(nameRef.SpanStart, name: "args").Single()); 4139symbols = model.LookupNamespacesAndTypes(nameRef.SpanStart); 4142Assert.Same(testType, model.LookupNamespacesAndTypes(nameRef.SpanStart, name: "args").Single()); 6041Assert.Contains(declSymbol.Name, model1.LookupNames(localRef.SpanStart)); 6042Assert.Contains(declSymbol, model1.LookupSymbols(localRef.SpanStart)); 6043Assert.Same(declSymbol, model1.LookupSymbols(localRef.SpanStart, name: declSymbol.Name).Single()); 6240Assert.Empty(semanticModel.LookupSymbols(invocation.SpanStart, container: a, name: "M")); 6246Assert.NotEmpty(semanticModel.LookupSymbols(invocation.SpanStart, container: a, name: "M")); 6282Assert.Same(x, semanticModel.LookupSymbols(localDecl.SpanStart, name: "x").Single()); 6284Assert.Same(x, semanticModel.LookupSymbols(localRef.SpanStart, name: "x").Single()); 6327Assert.Same(xDecl, semanticModel1.LookupSymbols(localDecl.SpanStart, name: "x").Single()); 6329Assert.Same(xRef, semanticModel1.LookupSymbols(localRef.SpanStart, name: "x").Single()); 6378Assert.Same(xDecl, semanticModel1.LookupSymbols(localDecl.SpanStart, name: "x").Single()); 6384Assert.Same(xRef, semanticModel2.LookupSymbols(localRef.SpanStart, name: "x").Single()); 8582symbols = model.LookupSymbols(invocations[0].SpanStart, name: "args"); 8587symbols = model.LookupSymbols(invocations[1].SpanStart, name: "args"); 8592symbols = model.LookupSymbols(invocations[2].SpanStart, name: "args"); 8653for (int i = id.SpanStart; i <= id.Span.End; i++) 8675for (int i = id.SpanStart; i <= id.Span.End; i++) 8697for (int i = id.SpanStart; i <= id.Span.End; i++)

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

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

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;

49model.TryGetSpeculativeSemanticModelForMethodBody(indexerAccess.SpanStart, m2, out var speculativeModel); 730var symbolInfo = model.GetSpeculativeSymbolInfo(xdecl.SpanStart, speculate, SpeculativeBindingOption.BindAsTypeOrNamespace); 1365var info = model.GetSpeculativeSymbolInfo(oldSyntax.SpanStart, newSyntax); 1422int position = varDecl.Initializer.SpanStart; 1465bool success = model.TryGetSpeculativeSemanticModel(equalsValue.SpanStart, newEqualsValue, out speculativeModel); 1480model.TryGetSpeculativeSemanticModel(equalsValue.SpanStart, newEqualsValue, out speculativeModel); 1514bool success = model.TryGetSpeculativeSemanticModel(equalsValue.SpanStart, newEqualsValue, out speculativeModel); 1562bool success = model.TryGetSpeculativeSemanticModel(equalsValue.SpanStart, newEqualsValue, out speculativeModel); 1602bool success = model.TryGetSpeculativeSemanticModel(equalsValue.SpanStart, newEqualsValue, out speculativeModel); 1681int position = expressionBody.SpanStart; 1781bool success = model.TryGetSpeculativeSemanticModel(methodDecl.Body.Statements[0].SpanStart, statement, out speculativeModel); 1835bool success = model.TryGetSpeculativeSemanticModel(methodDecl.Body.Statements[0].SpanStart, statement, out speculativeModel); 1848success = model.TryGetSpeculativeSemanticModel(methodDecl.Body.Statements[0].SpanStart, statement, out speculativeModel); 1882bool success = model.TryGetSpeculativeSemanticModel(methodDecl.Body.Statements[0].SpanStart, labeledStatement, out statModel); 1995bool success = model.TryGetSpeculativeSemanticModel(methodDecl.Body.Statements[0].SpanStart, statement, out speculativeModel); 2028var position = oldSyntax.SpanStart; 2034bool success = model.TryGetSpeculativeSemanticModel(oldSyntax.SpanStart, 2048thisSyntax.SpanStart, 2077bool success = parentModel.TryGetSpeculativeSemanticModel(oldSyntax.SpanStart, newSyntax, out speculativeModel); 2094success = parentModel.TryGetSpeculativeSemanticModel(oldSyntax.SpanStart, newSyntax, out speculativeModel); 2110success = parentModel.TryGetSpeculativeSemanticModel(oldSyntax.SpanStart, newSyntax, out speculativeModel); 2146bool success = parentModel.TryGetSpeculativeSemanticModel(oldSyntax.SpanStart, newSyntax, out speculativeModel); 2181Assert.Throws<ArgumentNullException>(() => model.TryGetSpeculativeSemanticModel(statement.SpanStart, statement: null, speculativeModel: out speculativeModel)); 2182Assert.Throws<ArgumentNullException>(() => model.TryGetSpeculativeSemanticModel(statement.SpanStart, constructorInitializer: (ConstructorInitializerSyntax)null, speculativeModel: out speculativeModel)); 2183Assert.Throws<ArgumentNullException>(() => model.TryGetSpeculativeSemanticModel(statement.SpanStart, attribute: null, speculativeModel: out speculativeModel)); 2186Assert.Throws<ArgumentException>(() => model.TryGetSpeculativeSemanticModel(statement.SpanStart, statement: statement, speculativeModel: out speculativeModel)); 2187Assert.Throws<ArgumentException>(() => model.TryGetSpeculativeSemanticModel(ctorInitializer.SpanStart, constructorInitializer: ctorInitializer, speculativeModel: out speculativeModel)); 2188Assert.Throws<ArgumentException>(() => model.TryGetSpeculativeSemanticModel(attribute.SpanStart, attribute: attribute, speculativeModel: out speculativeModel)); 2192model.TryGetSpeculativeSemanticModel(statement.SpanStart, speculatedStatement, speculativeModel: out speculativeModel); 2193Assert.Throws<InvalidOperationException>(() => speculativeModel.TryGetSpeculativeSemanticModel(speculatedStatement.SpanStart, speculatedStatement, speculativeModel: out speculativeModel)); 2227var success = model.TryGetSpeculativeSemanticModel(statement.SpanStart, speculatedStatement, out speculativeModel); 2235Assert.Throws<InvalidOperationException>(() => speculativeModel.TryGetSpeculativeSemanticModel(speculatedStatement.SpanStart, newSpeculatedStatement, out newModel)); 2239Assert.Throws<InvalidOperationException>(() => speculativeModel.TryGetSpeculativeSemanticModel(speculatedStatement.SpanStart, newSpeculatedStatement, out newModel)); 2271var binder = ((CSharpSemanticModel)speculativeModel).GetEnclosingBinder(initializer.SpanStart); 2320var success = model.TryGetSpeculativeSemanticModel(statementSyntax.SpanStart, speculativeSyntax, out speculativeModel); 2356var success = model.TryGetSpeculativeSemanticModelForMethodBody(methodDecl.Body.Statements[0].SpanStart, speculatedMethod, out speculativeModel); 2452var success = model.TryGetSpeculativeSemanticModelForMethodBody(methodDecl.Body.Statements[0].SpanStart, speculatedMethod, out speculativeModel); 2494var success = model.TryGetSpeculativeSemanticModelForMethodBody(methodDecl.Body.Statements[0].SpanStart, speculatedMethod, out speculativeModel); 2539var success = model.TryGetSpeculativeSemanticModelForMethodBody(methodDecl.Body.Statements[0].SpanStart, speculatedMethod, out speculativeModel); 2571var success = model.TryGetSpeculativeSemanticModelForMethodBody(methodDecl.Body.Statements[0].SpanStart, speculatedMethod, out speculativeModel); 2586success = model.TryGetSpeculativeSemanticModelForMethodBody(methodDecl.Body.Statements[0].SpanStart, speculatedMethod, out speculativeModel); 2600success = model.TryGetSpeculativeSemanticModelForMethodBody(methodDecl.Body.Statements[0].SpanStart, speculatedMethod, out speculativeModel); 2643var success = model.TryGetSpeculativeSemanticModelForMethodBody(methodDecl.Body.Statements[0].SpanStart, speculatedMethod, out speculativeModel); 2779var success = model.TryGetSpeculativeSemanticModelForMethodBody(methodDecl.Body.Statements[0].SpanStart, speculatedMethod, out speculativeModel); 2836TestGetSpeculativeSemanticModelForTypeSyntax_Common(model, baseList.SpanStart, 2841model.TryGetSpeculativeSemanticModel(baseList.SpanStart, speculatedTypeExpression, out speculativeModel); 2867TestGetSpeculativeSemanticModelForTypeSyntax_Common(model, fieldDecl.SpanStart, 2870TestGetSpeculativeSemanticModelForTypeSyntax_Common(model, methodDecl.ReturnType.SpanStart, 2873TestGetSpeculativeSemanticModelForTypeSyntax_Common(model, methodDecl.ParameterList.Parameters.First().SpanStart, 2898var success = model.TryGetSpeculativeSemanticModel(fieldDecl.SpanStart, speculatedAliasName, out speculativeModel); 2932var success = model.TryGetSpeculativeSemanticModel(cref.SpanStart, speculatedCref, out speculativeModel); 2942symbol = model.GetSpeculativeSymbolInfo(cref.SpanStart, speculatedCref).Symbol; 2972var success = model.TryGetSpeculativeSemanticModel(cref.SpanStart, speculatedCref, out speculativeModel); 2982symbol = model.GetSpeculativeSymbolInfo(cref.SpanStart, speculatedCref).Symbol; 3017var success = model.TryGetSpeculativeSemanticModel(cref.SpanStart, speculatedCref, out speculativeModel); 3037symbol = model.GetSpeculativeSymbolInfo(cref.SpanStart, speculatedCref).Symbol; 3045success = model.TryGetSpeculativeSemanticModel(cref.SpanStart, speculatedCref, out speculativeModel); 3065symbol = model.GetSpeculativeSymbolInfo(cref.SpanStart, speculatedCref).Symbol; 3094var success = model.TryGetSpeculativeSemanticModel(typeDecl.SpanStart, speculatedCref, out speculativeModel); 3097success = model.TryGetSpeculativeSemanticModel(methodDecl.Body.SpanStart, speculatedCref, out speculativeModel); 3101var symbolInfo = model.GetSpeculativeSymbolInfo(methodDecl.Body.SpanStart, speculatedCref); 3621var speculativeSymbolInfo = semanticModel.GetSpeculativeSymbolInfo(crefSyntax.SpanStart, speculatedName, SpeculativeBindingOption.BindAsExpression); 3789Assert.True(model.TryGetSpeculativeSemanticModel(localFunctionBody.Block!.Statements[0].SpanStart + 1, @return, out var specModel)); 3848var symbol = model.LookupSymbols(syntax.SpanStart, name: "Alias").Single(); 4430Assert.True(model.TryGetSpeculativeSemanticModel(ifStatement.SpanStart, replacementIfStatement, out var specModel));

1058var symbols = model.LookupSymbols(memberDecl.SpanStart, null, "DateTime"); 1088var symbols = model.LookupSymbols(methodDecl.SpanStart, null, "B"); 1092symbols = model.LookupSymbols(localDecl.SpanStart, null, "B"); 1127int positionInB = someMemberInB.SpanStart; 1135int positionInC = someMemberInC.SpanStart; 1178var symbols = model.LookupNamespacesAndTypes(localDecl.SpanStart, name: "B"); 1213int positionInC = someMemberInC.SpanStart; 1224var namesInM = model.LookupNames(methodM.Body.SpanStart); 1250var namesInA = model.LookupNames(someMemberInA.SpanStart); 1284var namesInC = model.LookupNames(someMemberInC.SpanStart); 1335var names = model.LookupNames(methodDecl.SpanStart, paramSymbol.Type); 1347names = model.LookupNames(methodDecl.SpanStart, paramSymbol.Type); 1383int positionInC = someMemberInC.SpanStart; 1438var symbols = model.LookupSymbols(methodDecl.SpanStart, paramSymbol.Type); 1452symbols = model.LookupSymbols(methodDecl.SpanStart, paramSymbol.Type); 1598var symbols = model.LookupNamespacesAndTypes(someMemberInC.SpanStart); 1631int position = someMemberInC.SpanStart; 1670var symbols = model.LookupStaticMembers(someMemberInC.SpanStart, container: symbolC); 1716int statementStart = statement.SpanStart; 2056var symbols = model.LookupNamespacesAndTypes(someStatementInM.SpanStart, name: ""); 4001var typeofArgPosition = typeofArgSyntax.SpanStart; 4446var lookupSymbols = model.LookupSymbols(conversionDecl.DescendantNodes().OfType<ReturnStatementSyntax>().Single().SpanStart, name: WellKnownMemberNames.ImplicitConversionName); 4477var lookupSymbols = model.LookupSymbols(conversionDecl.DescendantNodes().OfType<ReturnStatementSyntax>().Single().SpanStart, name: WellKnownMemberNames.ExplicitConversionName); 4508var lookupSymbols = model.LookupSymbols(operatorDecl.DescendantNodes().OfType<ReturnStatementSyntax>().Single().SpanStart, name: WellKnownMemberNames.AdditionOperatorName); 5177var symbols = model.LookupStaticMembers(methodDeclM.Body.SpanStart); 5207var symbols = model.LookupStaticMembers(node.SpanStart);

1120symbols = model.LookupSymbols(expr.SpanStart, container: null, name: "F", includeReducedExtensionMethods: true); 1124symbols = model.LookupSymbols(expr.SpanStart, container: type, name: "F", includeReducedExtensionMethods: true); 1155symbols = model.LookupSymbols(expr.SpanStart, container: type, name: "F", includeReducedExtensionMethods: true); 1183symbols = model.LookupSymbols(expr.SpanStart, container: type, name: "F", includeReducedExtensionMethods: true); 1213symbols = model.LookupSymbols(expr.SpanStart, container: type, name: "F", includeReducedExtensionMethods: true); 1239symbols = model.LookupSymbols(expr.SpanStart, container: type, name: "F", includeReducedExtensionMethods: true); 1267symbols = model.LookupSymbols(expr.SpanStart, container: type, name: "F", includeReducedExtensionMethods: true); 1294symbols = model.LookupSymbols(expr.SpanStart, container: type, name: "F", includeReducedExtensionMethods: true); 1321symbols = model.LookupSymbols(expr.SpanStart, container: type, name: "F", includeReducedExtensionMethods: true); 1365symbols = model.LookupSymbols(expr.SpanStart, container: type, name: "F", includeReducedExtensionMethods: true); 1401symbols = model.LookupSymbols(expr.SpanStart, container: type, name: "F", includeReducedExtensionMethods: true);

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

6053var members = model.LookupSymbols(typeParameterSyntax.SpanStart, (ITypeSymbol)typeParameterSymbol); 6077var members = model.LookupSymbols(methodNameSyntax.SpanStart, ((IMethodSymbol)methodSymbol).ReturnType); 6330var crefPosition = cref.SpanStart; 6331var crefReturnTypePosition = crefReturnType.SpanStart; 6332var crefParameterTypePosition = crefParameterType.SpanStart; 6437Assert.Equal(0, model.LookupSymbols(syntax.SpanStart, derivedInterface).Length); 6475Assert.Equal(0, model.LookupSymbols(syntax.SpanStart, symbol).Length); 6677Assert.Empty(model.LookupSymbols(name.SpanStart, typeParameter, "GetAwaiter"));

5891int position = methodDecl.Body.SpanStart; 5903position = methodDecl.Body.SpanStart; 6676declarator.SpanStart, 6709declarator.SpanStart, 6721declarator.SpanStart, 6754declarator.SpanStart, 6768declarator.SpanStart, 7741symbol.ToMinimalDisplayParts(model, variable.SpanStart), 7836symbol.ToMinimalDisplayParts(model, constructor.SpanStart, format), 7896symbol.ToMinimalDisplayParts(model, constructor.SpanStart, format),

7219Assert.Equal("System.Int64 C0.op_CheckedExplicit(C0 x)", model.ClassifyConversion(xNode.SpanStart, xNode, int64, isExplicitInSource: false).Method.ToTestDisplayString()); 7220Assert.Equal("System.Int64 C0.op_CheckedExplicit(C0 x)", model.ClassifyConversion(xNode.SpanStart, xNode, int64, isExplicitInSource: true).Method.ToTestDisplayString()); 7222Assert.Equal("System.Int64 C0.op_CheckedExplicit(C0 x)", model.ClassifyConversion(yNode.SpanStart, yNode, int64, isExplicitInSource: false).Method.ToTestDisplayString()); 7223Assert.Equal("System.Int64 C0.op_CheckedExplicit(C0 x)", model.ClassifyConversion(yNode.SpanStart, yNode, int64, isExplicitInSource: true).Method.ToTestDisplayString()); 7291Assert.Equal("System.Int64 C0.op_Explicit(C0 x)", model.ClassifyConversion(xNode.SpanStart, xNode, int64, isExplicitInSource: false).Method.ToTestDisplayString()); 7292Assert.Equal("System.Int64 C0.op_Explicit(C0 x)", model.ClassifyConversion(xNode.SpanStart, xNode, int64, isExplicitInSource: true).Method.ToTestDisplayString()); 7293Assert.Equal("System.Int64 C0.op_Explicit(C0 x)", model.ClassifyConversion(yNode.SpanStart, yNode, int64, isExplicitInSource: false).Method.ToTestDisplayString()); 7294Assert.Equal("System.Int64 C0.op_Explicit(C0 x)", model.ClassifyConversion(yNode.SpanStart, yNode, int64, isExplicitInSource: true).Method.ToTestDisplayString()); 7362Assert.Equal("System.Int64 C0.op_Explicit(C0 x)", model.ClassifyConversion(xNode.SpanStart, xNode, int64, isExplicitInSource: false).Method.ToTestDisplayString()); 7363Assert.Equal("System.Int64 C0.op_Explicit(C0 x)", model.ClassifyConversion(xNode.SpanStart, xNode, int64, isExplicitInSource: true).Method.ToTestDisplayString()); 7365Assert.Equal("System.Int64 C0.op_Explicit(C0 x)", model.ClassifyConversion(yNode.SpanStart, yNode, int64, isExplicitInSource: false).Method.ToTestDisplayString()); 7366Assert.Equal("System.Int64 C0.op_Explicit(C0 x)", model.ClassifyConversion(yNode.SpanStart, yNode, int64, isExplicitInSource: true).Method.ToTestDisplayString()); 7435Assert.Equal("C0 C0.op_CheckedUnaryNegation(C0 a)", model.GetSpeculativeSymbolInfo(xNode.SpanStart, xNodeToSpeculate, SpeculativeBindingOption.BindAsExpression).Symbol.ToTestDisplayString()); 7436Assert.Equal("C0 C0.op_CheckedUnaryNegation(C0 a)", model.GetSpeculativeSymbolInfo(yNode.SpanStart, yNodeToSpeculate, SpeculativeBindingOption.BindAsExpression).Symbol.ToTestDisplayString()); 7499Assert.Equal("C0 C0.op_UnaryNegation(C0 a)", model.GetSpeculativeSymbolInfo(xNode.SpanStart, xNodeToSpeculate, SpeculativeBindingOption.BindAsExpression).Symbol.ToTestDisplayString()); 7500Assert.Equal("C0 C0.op_UnaryNegation(C0 a)", model.GetSpeculativeSymbolInfo(yNode.SpanStart, yNodeToSpeculate, SpeculativeBindingOption.BindAsExpression).Symbol.ToTestDisplayString());

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

2955memberAccess.SpanStart, 2963memberAccess.SpanStart,

273int positionInA = someMemberInA.SpanStart; 310int positionInA = someMemberInA.SpanStart;

1169Assert.True(syntaxContext.SemanticModel.TryGetSpeculativeSemanticModel(syntaxContext.Node.SpanStart, newSource, out var specModel)); 1376verifySpeculativeModel(ifStatement.SpanStart, PublicNullableFlowState.MaybeNull); 1379verifySpeculativeModel(ifStatement.Statement.SpanStart, PublicNullableFlowState.NotNull); 1382verifySpeculativeModel(conditionalAccessExpression.SpanStart, PublicNullableFlowState.MaybeNull); 1385verifySpeculativeModel(conditionalAccessExpression.WhenNotNull.SpanStart, PublicNullableFlowState.NotNull); 1388verifySpeculativeModel(ternary.WhenTrue.SpanStart, PublicNullableFlowState.MaybeNull); 1391verifySpeculativeModel(ternary.WhenFalse.SpanStart, PublicNullableFlowState.NotNull); 1403var referenceTypeInfo = speculativeModel.GetSpeculativeTypeInfo(whenTrue.SpanStart, newReference, SpeculativeBindingOption.BindAsExpression); 1405var coalesceTypeInfo = speculativeModel.GetSpeculativeTypeInfo(whenTrue.SpanStart, newCoalesce, SpeculativeBindingOption.BindAsExpression); 1410referenceTypeInfo = speculativeModel.GetSpeculativeTypeInfo(whenFalse.SpanStart, newReference, SpeculativeBindingOption.BindAsExpression); 1413coalesceTypeInfo = speculativeModel.GetSpeculativeTypeInfo(whenFalse.SpanStart, newCoalesce, SpeculativeBindingOption.BindAsExpression); 1444Assert.True(model.TryGetSpeculativeSemanticModel(returnStatement.SpanStart, newSource, out var specModel)); 1520verifySpeculativeTypeInfo(ifStatement.SpanStart, PublicNullableFlowState.MaybeNull); 1521verifySpeculativeTypeInfo(ifStatement.Statement.SpanStart, PublicNullableFlowState.NotNull); 1523verifySpeculativeTypeInfo(conditionalAccessExpression.SpanStart, PublicNullableFlowState.MaybeNull); 1524verifySpeculativeTypeInfo(conditionalAccessExpression.WhenNotNull.SpanStart, PublicNullableFlowState.NotNull); 1526verifySpeculativeTypeInfo(ternary.WhenTrue.SpanStart, PublicNullableFlowState.MaybeNull); 1527verifySpeculativeTypeInfo(ternary.WhenFalse.SpanStart, PublicNullableFlowState.NotNull); 1576verifySpeculativeTypeInfo(ifStatement.SpanStart, PublicNullableFlowState.MaybeNull); 1577verifySpeculativeTypeInfo(ifStatement.Statement.SpanStart, PublicNullableFlowState.NotNull); 1579verifySpeculativeTypeInfo(conditionalAccessExpression.SpanStart, PublicNullableFlowState.MaybeNull); 1580verifySpeculativeTypeInfo(conditionalAccessExpression.WhenNotNull.SpanStart, PublicNullableFlowState.NotNull); 1582verifySpeculativeTypeInfo(ternary.WhenTrue.SpanStart, PublicNullableFlowState.MaybeNull); 1583verifySpeculativeTypeInfo(ternary.WhenFalse.SpanStart, PublicNullableFlowState.NotNull); 2138Assert.True(model.TryGetSpeculativeSemanticModel(s2Assignment.SpanStart, newDeclaration, out var specModel)); 2142Assert.True(model.TryGetSpeculativeSemanticModel(lastDeclaration.SpanStart, newDeclaration, out specModel)); 3781Assert.True(model.TryGetSpeculativeSemanticModel(lambda.Body.SpanStart, newStatement, out var speculativeModel)); 4066Assert.True(model.TryGetSpeculativeSemanticModel(localFunction.SpanStart, speculativeAttribute, out var speculativeModel)); 4071Assert.True(model.TryGetSpeculativeSemanticModel(localFunction.ParameterList.Parameters[0].Default.SpanStart, speculativeInitializer, out speculativeModel)); 4214Assert.True(model.TryGetSpeculativeSemanticModel(attributeUsage.SpanStart, newAttributeUsage, out var specModel)); 4244model.TryGetSpeculativeSemanticModel(typeOf.Type.SpanStart, type, out model, SpeculativeBindingOption.BindAsTypeOrNamespace); 4368Assert.True(model.TryGetSpeculativeSemanticModel(type.SpanStart, statement, out var speculativeModel)); 4396Assert.True(model.TryGetSpeculativeSemanticModel(type.SpanStart, statement, out var speculativeModel)); 4426Assert.True(model.TryGetSpeculativeSemanticModel(type.SpanStart, statement, out var speculativeModel)); 4456Assert.True(model.TryGetSpeculativeSemanticModel(type.SpanStart, statement, out var speculativeModel)); 4486Assert.True(model.TryGetSpeculativeSemanticModel(type.SpanStart, statement, out var speculativeModel)); 4518Assert.True(model.TryGetSpeculativeSemanticModelForMethodBody(type.SpanStart, methodDeclaration, out var speculativeModel)); 4551Assert.True(model.TryGetSpeculativeSemanticModelForMethodBody(type.SpanStart, methodDeclaration, out var speculativeModel)); 4579Assert.True(model.TryGetSpeculativeSemanticModel(type.SpanStart, arrow, out var speculativeModel)); 4609Assert.True(model.TryGetSpeculativeSemanticModel(type.SpanStart, arrow, out var speculativeModel)); 4640Assert.True(model.TryGetSpeculativeSemanticModel(initializer.SpanStart, newInitializer, out var speculativeModel)); 4673Assert.True(model.TryGetSpeculativeSemanticModel(initializer.SpanStart, newInitializer, out var speculativeModel));

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");

8466Assert.Equal("void I1.M01()", ((CSharpSemanticModel)model).LookupSymbols(node.SpanStart, m02.TypeParameters[0], "M01").Single().ToTestDisplayString()); 8467Assert.Contains("void I1.M01()", ((CSharpSemanticModel)model).LookupSymbols(node.SpanStart, m02.TypeParameters[0]).ToTestDisplayStrings()); 8468Assert.Equal("void I1.M01()", ((CSharpSemanticModel)model).LookupStaticMembers(node.SpanStart, m02.TypeParameters[0], "M01").Single().ToTestDisplayString()); 8469Assert.Contains("void I1.M01()", ((CSharpSemanticModel)model).LookupStaticMembers(node.SpanStart, m02.TypeParameters[0]).ToTestDisplayStrings()); 8471Assert.Equal("void I1.M01()", model.LookupSymbols(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol(), "M01").Single().ToTestDisplayString()); 8472Assert.Contains("void I1.M01()", model.LookupSymbols(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol()).ToTestDisplayStrings()); 8473Assert.Equal("void I1.M01()", model.LookupStaticMembers(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol(), "M01").Single().ToTestDisplayString()); 8474Assert.Contains("void I1.M01()", model.LookupStaticMembers(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol()).ToTestDisplayStrings()); 8476Assert.Contains("M01", model.LookupNames(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol())); 13192Assert.Equal("System.Int32 I1.P01 { get; set; }", ((CSharpSemanticModel)model).LookupSymbols(node.SpanStart, m02.TypeParameters[0], "P01").Single().ToTestDisplayString()); 13193Assert.Equal("System.Int32 I1.P01 { get; set; }", ((CSharpSemanticModel)model).LookupStaticMembers(node.SpanStart, m02.TypeParameters[0], "P01").Single().ToTestDisplayString()); 13194Assert.Contains("System.Int32 I1.P01 { get; set; }", ((CSharpSemanticModel)model).LookupSymbols(node.SpanStart, m02.TypeParameters[0]).ToTestDisplayStrings()); 13195Assert.Contains("System.Int32 I1.P01 { get; set; }", ((CSharpSemanticModel)model).LookupStaticMembers(node.SpanStart, m02.TypeParameters[0]).ToTestDisplayStrings()); 13197Assert.Equal("System.Int32 I1.P01 { get; set; }", model.LookupSymbols(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol(), "P01").Single().ToTestDisplayString()); 13198Assert.Equal("System.Int32 I1.P01 { get; set; }", model.LookupStaticMembers(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol(), "P01").Single().ToTestDisplayString()); 13199Assert.Contains("System.Int32 I1.P01 { get; set; }", model.LookupSymbols(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol()).ToTestDisplayStrings()); 13200Assert.Contains("System.Int32 I1.P01 { get; set; }", model.LookupStaticMembers(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol()).ToTestDisplayStrings()); 13202Assert.Contains("P01", model.LookupNames(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol())); 13278Assert.Equal("System.Int32 I1.P01 { get; set; }", ((CSharpSemanticModel)model).LookupSymbols(node.SpanStart, m02.TypeParameters[0], "P01").Single().ToTestDisplayString()); 13279Assert.Equal("System.Int32 I1.P01 { get; set; }", ((CSharpSemanticModel)model).LookupStaticMembers(node.SpanStart, m02.TypeParameters[0], "P01").Single().ToTestDisplayString()); 13280Assert.Contains("System.Int32 I1.P01 { get; set; }", ((CSharpSemanticModel)model).LookupSymbols(node.SpanStart, m02.TypeParameters[0]).ToTestDisplayStrings()); 13281Assert.Contains("System.Int32 I1.P01 { get; set; }", ((CSharpSemanticModel)model).LookupStaticMembers(node.SpanStart, m02.TypeParameters[0]).ToTestDisplayStrings()); 13283Assert.Equal("System.Int32 I1.P01 { get; set; }", model.LookupSymbols(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol(), "P01").Single().ToTestDisplayString()); 13284Assert.Equal("System.Int32 I1.P01 { get; set; }", model.LookupStaticMembers(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol(), "P01").Single().ToTestDisplayString()); 13285Assert.Contains("System.Int32 I1.P01 { get; set; }", model.LookupSymbols(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol()).ToTestDisplayStrings()); 13286Assert.Contains("System.Int32 I1.P01 { get; set; }", model.LookupStaticMembers(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol()).ToTestDisplayStrings()); 13288Assert.Contains("P01", model.LookupNames(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol())); 13400Assert.Equal("System.Int32 I1.P01 { get; set; }", ((CSharpSemanticModel)model).LookupSymbols(node.SpanStart, m02.TypeParameters[0], "P01").Single().ToTestDisplayString()); 13401Assert.Equal("System.Int32 I1.P01 { get; set; }", ((CSharpSemanticModel)model).LookupStaticMembers(node.SpanStart, m02.TypeParameters[0], "P01").Single().ToTestDisplayString()); 13402Assert.Contains("System.Int32 I1.P01 { get; set; }", ((CSharpSemanticModel)model).LookupSymbols(node.SpanStart, m02.TypeParameters[0]).ToTestDisplayStrings()); 13403Assert.Contains("System.Int32 I1.P01 { get; set; }", ((CSharpSemanticModel)model).LookupStaticMembers(node.SpanStart, m02.TypeParameters[0]).ToTestDisplayStrings()); 13405Assert.Equal("System.Int32 I1.P01 { get; set; }", model.LookupSymbols(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol(), "P01").Single().ToTestDisplayString()); 13406Assert.Equal("System.Int32 I1.P01 { get; set; }", model.LookupStaticMembers(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol(), "P01").Single().ToTestDisplayString()); 13407Assert.Contains("System.Int32 I1.P01 { get; set; }", model.LookupSymbols(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol()).ToTestDisplayStrings()); 13408Assert.Contains("System.Int32 I1.P01 { get; set; }", model.LookupStaticMembers(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol()).ToTestDisplayStrings()); 13410Assert.Contains("P01", model.LookupNames(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol())); 14110Assert.Equal("event System.Action I1.E01", ((CSharpSemanticModel)model).LookupSymbols(node.SpanStart, m02.TypeParameters[0], "E01").Single().ToTestDisplayString()); 14111Assert.Equal("event System.Action I1.E01", ((CSharpSemanticModel)model).LookupStaticMembers(node.SpanStart, m02.TypeParameters[0], "E01").Single().ToTestDisplayString()); 14112Assert.Contains("event System.Action I1.E01", ((CSharpSemanticModel)model).LookupSymbols(node.SpanStart, m02.TypeParameters[0]).ToTestDisplayStrings()); 14113Assert.Contains("event System.Action I1.E01", ((CSharpSemanticModel)model).LookupStaticMembers(node.SpanStart, m02.TypeParameters[0]).ToTestDisplayStrings()); 14115Assert.Equal("event System.Action I1.E01", model.LookupSymbols(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol(), "E01").Single().ToTestDisplayString()); 14116Assert.Equal("event System.Action I1.E01", model.LookupStaticMembers(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol(), "E01").Single().ToTestDisplayString()); 14117Assert.Contains("event System.Action I1.E01", model.LookupSymbols(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol()).ToTestDisplayStrings()); 14118Assert.Contains("event System.Action I1.E01", model.LookupStaticMembers(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol()).ToTestDisplayStrings()); 14120Assert.Contains("E01", model.LookupNames(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol()));

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

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

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));

295alias.SpanStart, 491return new RecommendedSymbols(_context.SemanticModel.LookupSymbols(position: name.SpanStart, container: symbol)); 497position: name.SpanStart, 636reinterpretedBinding = semanticModel.GetSpeculativeSymbolInfo(identifier.SpanStart, identifier, SpeculativeBindingOption.BindAsExpression); 648reinterpretedBinding = semanticModel.GetSpeculativeSymbolInfo(identifier.SpanStart, identifier, SpeculativeBindingOption.BindAsTypeOrNamespace); 699!_context.SemanticModel.IsEventUsableAsField(originalExpression.SpanStart, ev)) 757var symbols = GetMemberSymbols(containerSymbol, position: originalExpression.SpanStart, excludeInstance, useBaseReferenceAccessibility, unwrapNullable, isForDereference);

1280var position = nodeToSpeculate.SpanStart;

60previousSemanticModel.TryGetSpeculativeSemanticModelForMethodBody(previousBaseMethod.Body.SpanStart, currentBaseMethod, out var speculativeModel)) 68previousSemanticModel.TryGetSpeculativeSemanticModelForMethodBody(previousAccessorDeclaration.Body.SpanStart, currentAccessorDeclaration, out speculativeModel))

673_semanticModel.SyntaxTree.IsNameOfContext(originalSimpleName.SpanStart, _semanticModel, _cancellationToken)) 691if (!Equals(_semanticModel.GetEnclosingNamedType(originalSimpleName.SpanStart, _cancellationToken), symbol.ContainingType)) 1077var speculationPosition = originalNode.SpanStart; 1081var binding = _semanticModel.GetSpeculativeSymbolInfo(originalNode.SpanStart, expression, SpeculativeBindingOption.BindAsExpression);

116node.SpanStart,

127var aliasTypeInfo = semanticModel.GetSpeculativeAliasInfo(node.SpanStart, aliasIdentifier, SpeculativeBindingOption.BindAsTypeOrNamespace); 230var scopes = model.GetImportScopes(firstMember.SpanStart, cancellationToken); 288var symbolInfo = semanticModel.GetSpeculativeSymbolInfo(node.SpanStart, aliasIdentifier, SpeculativeBindingOption.BindAsExpression); 293var typeInfo = semanticModel.GetSpeculativeTypeInfo(node.SpanStart, aliasIdentifier, SpeculativeBindingOption.BindAsExpression); 301var boundSymbols = semanticModel.LookupNamespacesAndTypes(node.SpanStart, name: aliasName); 412var symbols = semanticModel.LookupSymbols(expression.SpanStart, name: identifierName.Identifier.ValueText);

234? semanticModel.LookupSymbols(memberAccess.SpanStart, name: memberAccess.Name.Identifier.ValueText) 237? semanticModel.LookupNamespacesAndTypes(memberAccess.SpanStart, name: memberAccess.Name.Identifier.ValueText) 347var enclosingNamedType = semanticModel.GetEnclosingNamedType(memberAccess.SpanStart, cancellationToken); 370if (ancestorInvocation?.SpanStart == memberAccess.SpanStart) 425var enclosingSymbol = semanticModel.GetEnclosingSymbol(left.SpanStart);

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

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

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

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

573if (!textSpan.Contains(directives[0].SpanStart) || 574!textSpan.Contains(directives.Last().SpanStart))

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

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

105var position = originalNode.SpanStart;

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

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

55var start = usings.First().SpanStart; 64var start = rootUsings.First().SpanStart;

359return syntaxTree.IsLocalFunctionDeclarationContext(token.Parent.SpanStart, validModifiers, cancellationToken); 882if (firstConstructorConstraint == null || firstConstructorConstraint.SpanStart > token.Span.End) 1366return IsAtStartOfPattern(syntaxTree, parenthesizedExpression.GetFirstToken().GetPreviousToken(), parenthesizedExpression.SpanStart); 1558=> node.FindTokenOnLeftOfPosition(node.SpanStart); 2890var tokenBeforeName = syntaxTree.FindTokenOnLeftOfPosition(nameExpr.SpanStart, cancellationToken); 2896if (syntaxTree.IsExpressionContext(nameExpr.SpanStart, tokenBeforeName, attributes: false, cancellationToken))

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

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

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

90spans.Add(TextSpan.FromBounds(namespaceMember.SpanStart, GetEndPosition(namespaceMember, namespaceMember.Members))); 97=> list.Count > 0 ? list[0].SpanStart : container.Span.End;

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

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

143return node.SpanStart;

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

59While Not node Is Nothing And Not node.Parent Is Nothing And node.Parent.SpanStart = node.SpanStart

134While Not node Is Nothing And Not node.Parent Is Nothing And node.Parent.SpanStart = node.SpanStart

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

173positionForTypeBinding = syntax.SpanStart;

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

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

50var nullableContext = semanticModel.GetNullableContext(from.SpanStart);

205if (targetMember.SpanStart < documentationComment.SpanStart)

134/// In case there are multiple breakpoint spans starting at the <see cref="SyntaxNode.SpanStart"/> of the <paramref name="node"/>,

278var currentType = semanticModel.GetSpeculativeTypeInfo(contextNode.SpanStart, typeName, SpeculativeBindingOption.BindAsTypeOrNamespace).Type;

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

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

145var containingNamespace = semanticDocument.SemanticModel.GetEnclosingNamespace(node.SpanStart, cancellationToken); 166var containingNamespace = document.SemanticModel.GetEnclosingNamespace(node.SpanStart, cancellationToken); 252var outerTypeSymbol = semanticModel.GetEnclosingNamedType(state.SimpleName.SpanStart, cancellationToken);

389_state.SimpleName.SpanStart, _cancellationToken);

134if (!semanticFacts.IsTypeContext(semanticModel, NameOrMemberAccessExpression.SpanStart, cancellationToken) && 135!semanticFacts.IsExpressionContext(semanticModel, NameOrMemberAccessExpression.SpanStart, cancellationToken) && 136!semanticFacts.IsStatementContext(semanticModel, NameOrMemberAccessExpression.SpanStart, cancellationToken) && 138!semanticFacts.IsNamespaceContext(semanticModel, NameOrMemberAccessExpression.SpanStart, cancellationToken)) 367var namespaceSymbol = semanticModel.GetEnclosingNamespace(SimpleName.SpanStart, cancellationToken);

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

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

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

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

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

168var position = initializer.SpanStart;

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

103if (nearestExpression.SpanStart != position)

156var typeInfo = semanticModel.GetSpeculativeTypeInfo(expression.SpanStart, expression, SpeculativeBindingOption.BindAsExpression);

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

127var spanStart = firstBlock.Syntax.SpanStart;

191_objectCreationExpression.SpanStart,

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

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

155formatString, formatStringLiteralExpressionSyntax.SpanStart);

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

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

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

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

104ContainingType = semanticModel.GetEnclosingNamedType(methodDeclaration.SpanStart, cancellationToken); 153ContainingType = semanticModel.GetEnclosingNamedType(SimpleNameOpt.SpanStart, cancellationToken);

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

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

40var expressionsToReWrite = diagnostics.Select(d => GetInvocation(root, d)).OrderByDescending(i => i.SpanStart);

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

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

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

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

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

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.

173Return GetMemberSemanticModel(node.SpanStart)

25Return node.SpanStart

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

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

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

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

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

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

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

821Dim member = GetContainingMemberDeclaration(node, node.SpanStart) 893Return TextSpan.FromBounds(list.First.SpanStart, list.Last.Span.End) 898Return TextSpan.FromBounds(list.First.SpanStart, list.Last.Span.End)

112Dim position = originalNode.SpanStart

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

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

181matchingNode.SpanStart) 347originalNode.SpanStart, 382originalNode.SpanStart, 407originalNode.SpanStart, 428originalNode.SpanStart,

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

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

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

88If span.Start = InitializerActiveStatement.SpanStart Then

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

140position = body.SpanStart 157While node.Span.Length < span.Length AndAlso node.Parent.SpanStart = position 336Return BreakpointSpans.TryGetClosestBreakpointSpan(node, node.SpanStart, minLength, span)

105Dim postProcessor = New PostProcessor(semanticModel, insertionPointNode.SpanStart) 286Dim postProcessor = New PostProcessor(semanticModel, insertionPointNode.SpanStart)

214Dim position = expression.SpanStart

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

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

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

181If startPosition <= startNode.SpanStart Then startPosition = startNode.SpanStart 182While startNode IsNot Nothing AndAlso startNode.SpanStart = startPosition

334Assert.Equal(tree.SpanStart, tree.FullSpan.Start) 336VerifyListSpans(precedingTrivia, New TextSpan(tree.FullSpan.Start, (tree.SpanStart - tree.FullSpan.Start))) 638Assert.Equal(0, sepList(0).SpanStart) 640Assert.Equal(6, sepList(1).SpanStart) 642Assert.Equal(12, sepList(2).SpanStart) 662Assert.Equal(9 + 0, sepList(0).SpanStart) 664Assert.Equal(9 + 6, sepList(1).SpanStart) 666Assert.Equal(9 + 12, sepList(2).SpanStart)

452Assert.True(node.SpanStart >= node.Parent.SpanStart AndAlso 857Assert.True(node.SpanStart >= node.Parent.SpanStart AndAlso

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

821Dim member = GetContainingMemberDeclaration(node, node.SpanStart) 893Return TextSpan.FromBounds(list.First.SpanStart, list.Last.Span.End) 898Return TextSpan.FromBounds(list.First.SpanStart, list.Last.Span.End)

112Dim position = originalNode.SpanStart

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

757syntaxFacts.GetContainingTypeDeclaration(node, node.SpanStart), 761syntaxFacts.GetContainingMemberDeclaration(node, node.SpanStart),

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

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

280semanticModel.GetEnclosingNamespace(declarationSyntax.SpanStart, _cancellationToken)); 282var symbols = semanticModel.LookupNamespacesAndTypes(declarationSyntax.SpanStart, containingNamespaceSymbol)

74if (previousBodyNode.SpanStart != currentBodyNode.SpanStart)

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

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));

100return node.SpanStart;

85var spanStart = documentationComment.SpanStart;

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

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

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

92=> semanticModel.LookupSymbols(location.SpanStart).Concat(semanticModel.GetExistingSymbols(container, cancellationToken));

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

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

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

228startPosition = node.SpanStart; 232startPosition = node.Expression.SpanStart; 265startPosition = node.Name.SpanStart; 295startPosition = node.SpanStart; 385var line = text.Lines.GetLineFromPosition(node.SpanStart); 465startPosition = node.SpanStart; 472var line = text.Lines.GetLineFromPosition(firstAccessorNode.SpanStart); 492var line = text.Lines.GetLineFromPosition(node.SpanStart); 525startPosition = node.SpanStart; 531var line = text.Lines.GetLineFromPosition(node.SpanStart); 578startPosition = node.Name.SpanStart; 664startPosition = node.SpanStart; 668startPosition = node.Name.SpanStart; 702startPosition = field.SpanStart; 742startPosition = node.SpanStart; 782startPosition = node.SpanStart;

1280Dim deletionStart = node.SpanStart