262return _nodeOrParent.SpanStart;

85var spanStart = documentationComment.SpanStart;

100return node.SpanStart;

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

727!forEachExpression.Span.Contains(_expression.SpanStart)) 828newSymbol = this.OriginalSemanticModel.GetSpeculativeSymbolInfo(type.SpanStart, newType, bindingOption).Symbol;

149syntaxTree.GetLocation(TextSpan.FromBounds(match.SpanStart, arguments[0].SpanStart)),

136match.MemberAccessExpression.SpanStart, end));

155formatString, formatStringLiteralExpressionSyntax.SpanStart);

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

322Math.Min(fullSpan.Start, node.SpanStart), 338var end = endNode.SpanStart;

132_objectCreationExpression.SpanStart,

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

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

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

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

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

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

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

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

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

2026return node.SpanStart < localSymbolLocation.SourceSpan.Start; 4508var start = argSyntax.SpanStart;

3304Text.TextSpan.FromBounds(lambdaSyntax.SpanStart, lambdaSyntax.ArrowToken.Span.End)); 3308Text.TextSpan.FromBounds(anonymousMethodSyntax.SpanStart,

109int position = node.SpanStart; 163visitor.Initialize(position: typeDecl.SpanStart, memberDeclarationOpt: null, memberOpt: null); 179Binder result = visitor.VisitNamespaceDeclaration((BaseNamespaceDeclarationSyntax)unit, unit.SpanStart, inBody: true, inUsing: false);

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

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

449return this.ClassifyConversion(expression.SpanStart, expression, destination, isExplicitInSource); 1641CSharpSyntaxNode enclosingLambdaOrQuery = GetInnermostLambdaOrQuery(lambdaOrQuery, lambdaOrQuery.SpanStart, allowStarting: false);

178(binder: containing.GetEnclosingBinder(attribute.SpanStart), model: containing)); 196tuple.containing.GetEnclosingBinder(tuple.paramDecl.SpanStart).

982(binder: containing.GetEnclosingBinder(attribute.SpanStart), model: containing)); 1021tuple.containing.GetEnclosingBinder(tuple.paramDecl.SpanStart). 2223if (firstStatement.SpanStart > lastStatement.SpanStart)

556Location location = new SourceLocation(trivia.SyntaxTree, new TextSpan(trivia.SpanStart, 0));

181Binder binder = factory.GetBinder(nameAttr, nameAttr.Identifier.SpanStart);

202int startLocation = firstInRegion.Syntax.SpanStart;

66_branchesOutOf.Sort((x, y) => x.SpanStart - y.SpanStart);

7827int start = lambdaSyntax.SpanStart; 8589conversionOpt.Syntax.SpanStart != convertedNode.Syntax.SpanStart)

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

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

274iterationVarDeclSpan = TextSpan.FromBounds(forEachSyntax.Type.SpanStart, forEachSyntax.Identifier.Span.End);

31int start = declarationSyntax.Initializer.Value.SpanStart; 144part = TextSpan.FromBounds(declarationSyntax.SpanStart, declaratorSyntax.Span.End); 170int start = firstToken?.SpanStart ?? declarationSyntax.SpanStart;

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

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

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

207if (position == ctorSyntax.SpanStart)

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

1039return localPosition - bodySyntax.SpanStart;

33var directiveLineNumber = sourceText.Lines.IndexOf(directiveNode.SpanStart) + 1;

85else if (tr.UnderlyingNode == this.Green && tr.SpanStart == this.SpanStart && (object)d == this) 116else if (tr.UnderlyingNode == this.Green && tr.SpanStart == this.SpanStart && (object)d == this)

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

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

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

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

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

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

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

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

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

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

79firstUnreachableStatement.SpanStart != sourceSpan.Start)

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

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

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

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

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

209var anonymousFunctionStart = anonymousFunction.SpanStart; 366var localEnclosingSymbol = semanticModel.GetEnclosingSymbol(localDeclaration.SpanStart, cancellationToken);

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

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

23=> x.SpanStart == y.SpanStart; 26=> obj.SpanStart;

123condDirectives.Sort((n1, n2) => n1.SpanStart.CompareTo(n2.SpanStart));

652var speculativeSymbolInfo = semanticModel.GetSpeculativeSymbolInfo(expression.SpanStart, expression, SpeculativeBindingOption.BindAsTypeOrNamespace);

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

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

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

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

109var position = originalNode.SpanStart;

654if (!textSpan.Contains(directives[0].SpanStart) || 655!textSpan.Contains(directives[directives.Count - 1].SpanStart)) 948var expressionBodiedMemberBody = TextSpan.FromBounds(expressionBodiedMember.Expression.SpanStart, expressionBodiedMember.Expression.Span.End);

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

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

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

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

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

68.OrderBy(p => p.DeclaringSyntaxReferences[0].GetSyntax(cancellationToken).SpanStart)

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

53var start = usings.First().SpanStart; 62var start = rootUsings.First().SpanStart;

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

480.OrderBy(node => (node.FullWidth(), node.SpanStart));

48c => GetChangedDocumentAsync(context.Document, conditionalExpression.SpanStart, c),

112type.ToMinimalDisplayString(model, node.SpanStart), 113ienumerableGenericSymbol.ToMinimalDisplayString(model, node.SpanStart));

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

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

50foreach (var declaration in declarations.OrderByDescending(t => t.SpanStart))

48foreach (var typeDeclaration in typeDeclarations.OrderByDescending(t => t.SpanStart))

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

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

50.OrderByDescending(s => s.SpanStart)

263return InferTypes(expression.SpanStart); 1322=> InferTypes(implicitArray.SpanStart); 2270if (descendant.SpanStart <= afterNode.Span.End)

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

54.OrderByDescending(i => i.SpanStart)

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

175name.SpanStart, name, SpeculativeBindingOption.BindAsExpression); 178name.SpanStart, name, SpeculativeBindingOption.BindAsExpression).Type;

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

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

60blocks.OrderByDescending(b => b.SpanStart),

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

623CatchClauseSyntax catchClauseNode => catchClauseNode.Block.SpanStart, 624FinallyClauseSyntax finallyClauseNode => finallyClauseNode.Block.SpanStart,

397return caretPosition > condition.SpanStart && caretPosition <= condition.Span.End; 417&& caret.Position > currentNode.SpanStart;

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

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

97var start = literal.SpanStart; 100var delimiterQuoteCount = start - literal.SpanStart; 115startDelimiterSpan: TextSpan.FromBounds(literal.SpanStart, start), 156TextSpan.FromBounds(literal.SpanStart, rawStart), 169var start = literal.SpanStart; 186startDelimiterSpan: TextSpan.FromBounds(literal.SpanStart, start), 198var start = interpolatedString.SpanStart; 201var delimiterDollarCount = start - interpolatedString.SpanStart; 220result.Add(TextSpan.FromBounds(currentPosition, content.SpanStart)); 230startDelimiterSpan: TextSpan.FromBounds(interpolatedString.SpanStart, interpolatedString.StringStartToken.Span.End),

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

86statement.SpanStart, replacement,

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

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

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

117if (expr.SpanStart >= start && expr.Span.End <= end) 138if (expr.SpanStart >= start && expr.Span.End <= end) 159if (expr.SpanStart >= start && expr.Span.End <= end) 180if (firstStatement == null && stmt.SpanStart >= start)

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

3968var binder = model.GetEnclosingBinder(@switch.SpanStart); 4037var binder = model.GetEnclosingBinder(@switch.SpanStart); 4110var binder = model.GetEnclosingBinder(@switch.SpanStart); 4182var binder = model.GetEnclosingBinder(@is.SpanStart); 4226var binder = model.GetEnclosingBinder(@switch.SpanStart); 4273var binder = model.GetEnclosingBinder(@switch.SpanStart); 4355var binder = model.GetEnclosingBinder(@switch.SpanStart); 4437var binder = model.GetEnclosingBinder(@switch.SpanStart); 4519var binder = model.GetEnclosingBinder(@switch.SpanStart); 4601var binder = model.GetEnclosingBinder(@switch.SpanStart); 4685var binder = model.GetEnclosingBinder(@switch.SpanStart);

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

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

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

68.OrderBy(p => p.DeclaringSyntaxReferences[0].GetSyntax(cancellationToken).SpanStart)

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

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

211matchingNode.SpanStart; 419originalNode.SpanStart, 441originalNode.SpanStart, 457originalNode.SpanStart, 473originalNode.SpanStart, 494originalNode.SpanStart,

63if (position < member.SpanStart)

104if (identifier.SpanStart < variableDeclarator.SpanStart) 380if (!text.AreOnSameLine(expression.SpanStart, expression.Span.End))

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

145position = token.Parent.SpanStart; 153position = token.GetRequiredParent().SpanStart; 161position = token.GetRequiredParent().SpanStart;

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

79var namePosition = name.SpanStart; 87!semanticModel.IsAccessible(node.SpanStart, member))

95return (dotToken, expression.SpanStart);

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

95if (token.SpanStart < parentMember.SpanStart)

129spanStart = token.GetAncestor<GenericNameSyntax>()?.SpanStart ?? spanStart; 135spanStart = tokenLeftOfGenericName.Parent.SpanStart; 162return prevToken.Parent!.SpanStart;

59var inferredTypes = typeInferrer.InferTypes(semanticModel, context.TargetToken.Parent!.SpanStart, cancellationToken) 64AddItems(inferredTypes, index.Value, completionContext, context.TargetToken.Parent.SpanStart);

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

282forEachInfo.ForEachStatement.SpanStart, cancellationToken)!; 290statement.SpanStart, cancellationToken), memberDeclarationSymbol)).Count();

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

78if (position < baseDeclaration.SpanStart)

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

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

480.OrderBy(node => (node.FullWidth(), node.SpanStart));

48c => GetChangedDocumentAsync(context.Document, conditionalExpression.SpanStart, c),

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

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

112type.ToMinimalDisplayString(model, node.SpanStart), 113ienumerableGenericSymbol.ToMinimalDisplayString(model, node.SpanStart));

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

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

50foreach (var declaration in declarations.OrderByDescending(t => t.SpanStart))

48foreach (var typeDeclaration in typeDeclarations.OrderByDescending(t => t.SpanStart))

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

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

79firstUnreachableStatement.SpanStart != sourceSpan.Start)

50.OrderByDescending(s => s.SpanStart)

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

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

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

209var anonymousFunctionStart = anonymousFunction.SpanStart; 366var localEnclosingSymbol = semanticModel.GetEnclosingSymbol(localDeclaration.SpanStart, cancellationToken);

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

54.OrderByDescending(i => i.SpanStart)

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

75if (statement != null && position < statement.SpanStart)

166nextStatement != null && _syntaxTree.GetText(cancellationToken).Lines.IndexOf(nextStatement.SpanStart) == line;

65return new DebugDataTipInfo(TextSpan.FromBounds(curr.SpanStart, expression.Span.End), text: null);

63var memberLine = text.Lines.GetLineFromPosition(accessor?.SpanStart ?? memberDeclaration.SpanStart).LineNumber;

89=> TextSpan.FromBounds(node.SpanStart, token.Span.End); 629position = variableDeclaration.SpanStart; 821return TextSpan.FromBounds(unit.Members[0].SpanStart, unit.Members.OfType<GlobalStatementSyntax>().Last().Span.End);

332if (position < declarationBody.SpanStart) 362position = declarationBody.SpanStart; 406Debug.Assert(position == ((PropertyDeclarationSyntax)node).Initializer!.SpanStart); 457Debug.Assert(position == ((SwitchExpressionArmSyntax)node).Expression.SpanStart); 489position < node.Expression.SpanStart ? ForEachPart.In : 496ForEachPart.VariableDeclaration => TextSpan.FromBounds(node.Type.SpanStart, node.Identifier.Span.End), 506ForEachPart.VariableDeclaration => TextSpan.FromBounds(node.Variable.SpanStart, node.Variable.Span.End), 882BreakpointSpans.TryGetClosestBreakpointSpan(node, propertyDeclaration.Initializer.SpanStart, out span)) 909return BreakpointSpans.TryGetClosestBreakpointSpan(node, node.SpanStart, out span); 1448return model.GetEnclosingSymbol(node.SpanStart, cancellationToken); 1491return (IMethodSymbol)model.GetRequiredEnclosingSymbol(bodyExpression.SpanStart, cancellationToken); 2661tryStatement.Catches.First().SpanStart,

173var leftPosition = leftNode.SpanStart;

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

194var currentType = semanticModel.GetSpeculativeTypeInfo(contextNode.SpanStart, typeName, SpeculativeBindingOption.BindAsTypeOrNamespace).Type; 215if (!leadingTrivia.Any(t => t.IsKind(SyntaxKind.EndOfLineTrivia)) && !methodDefinition.FindTokenOnLeftOfPosition(methodDefinition.SpanStart).IsKind(SyntaxKind.OpenBraceToken)) 221if (!originalMethodDefinition.FindTokenOnLeftOfPosition(originalMethodDefinition.SpanStart).TrailingTrivia.Any(SyntaxKind.EndOfLineTrivia))

166var postProcessor = new PostProcessor(semanticModel, context.SpanStart); 552var postProcessor = new PostProcessor(semanticModel, context.SpanStart);

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

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

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

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

404var earliestLocalFunctionCall = localFunctionCalls.Min(node => node.SpanStart);

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

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

222var spanStart = declaringNode.SpanStart; 231spanStart = fieldDeclaration.SpanStart; 253var start = enumMember.SpanStart;

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

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

75var spanStart = parent.SpanStart; 89spanStart = parent.Parent!.SpanStart; 158.TakeWhile(d => d.SpanStart < directiveTrivia.SpanStart)

96.Sort(semanticModel, attribute.SpanStart); 136var position = attribute.SpanStart;

101.Sort(semanticModel, constructorInitializer.SpanStart);

102.Sort(semanticModel, expression.SpanStart); 145currentSpan.Start != expression.SpanStart) 162offset = expression.SpanStart - conditionalAccessExpression.SpanStart; 172offset = expression.SpanStart - elementAccessExpression.SpanStart; 346return TextSpan.FromBounds(expression.SpanStart, openBracket.Parent.Span.End); 393(c, elementBindingExpression) => c.SpanStart < elementBindingExpression.SpanStart, elementBindingExpression)!;

154var offset = genericIdentifier.SpanStart - genericName.SpanStart;

99methods = methods.Sort(semanticModel, invocationExpression.SpanStart);

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

94.Sort(semanticModel, objectCreationExpression.SpanStart);

25objectCreationExpression.SpanStart,

26var position = objectCreationExpression.SpanStart;

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

85arrayBuilder.Add(new SnippetPlaceholder(identifier: type.ToString(), placeholderPositions: ImmutableArray.Create(type.SpanStart)));

65var openBraceLine = parsedDocument.Text.Lines.GetLineFromPosition(constructorDeclaration.Body!.SpanStart).LineNumber;

87var openBraceLine = parsedDocument.Text.Lines.GetLineFromPosition(elseClauseSyntax.Statement.SpanStart).LineNumber;

65arrayBuilder.Add(new SnippetPlaceholder(expression.ToString(), ImmutableArray.Create(expression.SpanStart))); 74var openBraceLine = parsedDocument.Text.Lines.GetLineFromPosition(foreachStatement.Statement.SpanStart).LineNumber;

51var openBraceLine = parsedDocument.Text.Lines.GetLineFromPosition(ifStatementSyntax.Statement.SpanStart).LineNumber;

51var openBraceLine = parsedDocument.Text.Lines.GetLineFromPosition(whileStatementSyntax.Statement.SpanStart).LineNumber;

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

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

150var holeStartLine = text.Lines.GetLineFromPosition(interpolation.SpanStart).LineNumber; 179var firstLine = text.Lines.GetLineFromPosition(expression.SpanStart);

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

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

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

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

60blocks.OrderByDescending(b => b.SpanStart),

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

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

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

3350var names = model.LookupNames(node1.SpanStart); 3358Assert.True(model.LookupSymbols(node1.SpanStart, name: "MathMin").IsEmpty); 3359Assert.Equal(1, model.LookupSymbols(node1.SpanStart, name: "MathMax").Length); 3360Assert.Equal(1, model.LookupSymbols(node1.SpanStart, name: "F1").Length); 3361Assert.True(model.LookupSymbols(node1.SpanStart, name: "F2").IsEmpty); 3362Assert.True(model.LookupSymbols(node1.SpanStart, name: "MathMax2").IsEmpty); 3363Assert.True(model.LookupSymbols(node1.SpanStart, name: "MathMax3").IsEmpty); 3365var symbols = model.LookupSymbols(node1.SpanStart);

9371int position = syntax.SpanStart;

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

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

941invocation.SpanStart, 1122.OrderByDescending(s => s.SpanStart); 3039var lambda = (IMethodSymbol)model.GetEnclosingSymbol(contentType.SpanStart); 3046lambda = (IMethodSymbol)model.GetEnclosingSymbol(b.SpanStart); 3051Assert.Equal("void Program.method1()", model.GetEnclosingSymbol(parameterSyntax.SpanStart).ToTestDisplayString()); 3972Assert.True(model.TryGetSpeculativeSemanticModelForMethodBody(m.Body.SpanStart, m, out model)); 8052Assert.True(model.TryGetSpeculativeSemanticModelForMethodBody(m2Syntax.Body.SpanStart, newMethod, out var speculativeModel)); 8132var methodBinder = getBinder<BlockBinder>(methodModel.GetEnclosingBinder(methodSyntax.Body.SpanStart)); 8133var 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()); 7369return tree.GetRoot().DescendantNodes().OfType<IdentifierNameSyntax>().Where(i => i.Identifier.ValueText == identifier).Single().SpanStart; 8658Assert.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));

63432Assert.True(model1.TryGetSpeculativeSemanticModel(function1.SpanStart, function2, out var model2)); 142173ifStatement.SpanStart, 153657var found = model.LookupSymbols(item.SpanStart, i3.GetPublicSymbol()).Single(s => s.Name == "Item"); 153826var found = model.LookupSymbols(item.SpanStart, i3.GetPublicSymbol()).Single(s => s.Name == "Item"); 153864Assert.True(model.LookupNames(item.SpanStart, i3.GetPublicSymbol()).Contains("Item")); 153866var found = model.LookupSymbols(item.SpanStart, i3.GetPublicSymbol()).Single(s => s.Name == "Item"); 153904Assert.True(model.LookupNames(item.SpanStart, i3.GetPublicSymbol()).Contains("Item")); 153907var found = model.LookupSymbols(item.SpanStart, t.GetPublicSymbol()).Single(s => s.Name == "Item"); 153940Assert.True(model.LookupNames(item.SpanStart, t.GetPublicSymbol()).Contains("Item")); 153942var found = model.LookupSymbols(item.SpanStart, t.GetPublicSymbol()).Single(s => s.Name == "Item"); 154074Assert.True(model.LookupNames(item.SpanStart, i3.GetPublicSymbol()).Contains("Get")); 154076var found = model.LookupSymbols(item.SpanStart, i3.GetPublicSymbol()).Single(s => s.Name == "Get"); 154118var found = model.LookupSymbols(item.SpanStart, i3.GetPublicSymbol()).Single(s => s.Name == "Item"); 154162var found = model.LookupSymbols(item.SpanStart, t.GetPublicSymbol()).Single(s => s.Name == "Item"); 154199var found = model.LookupSymbols(item.SpanStart, t.GetPublicSymbol()).Single(s => s.Name == "Item");

7331var binder = model.GetEnclosingBinder(methodBody.SpanStart); 8814var binder = model.GetEnclosingBinder(methodBody.SpanStart);

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); 21285bool success = model.TryGetSpeculativeSemanticModel(GetReferences(tree, "SpeculateHere").Single().SpanStart, statement, out model); 21297var y1 = model.LookupSymbols(x1Ref[0].SpanStart, name: "y1").Single(); 22645Assert.False(model.LookupSymbols(decl.SpanStart, name: identifierText).Any()); 22647Assert.False(model.LookupNames(decl.SpanStart).Contains(identifierText)); 22660Assert.False(model.LookupSymbols(reference.SpanStart, name: reference.Identifier.ValueText).Any()); 22661Assert.DoesNotContain(reference.Identifier.ValueText, model.LookupNames(reference.SpanStart)); 32679var symbols = model.LookupSymbols(decl.SpanStart, name: decl.Identifier().ValueText); 32680var names = model.LookupNames(decl.SpanStart); 32707symbols = model.LookupSymbols(reference.SpanStart, name: decl.Identifier().ValueText); 32723Assert.True(model.LookupNames(reference.SpanStart).Contains(decl.Identifier().ValueText)); 35607bool success = model.TryGetSpeculativeSemanticModel(statementBefore.SpanStart, statementAfter, out model); 36305Assert.True(model.TryGetSpeculativeSemanticModelForMethodBody(method.Body.SpanStart, method, out var speculativeModel)); 36312Assert.True(model.TryGetSpeculativeSemanticModel(method.Body.SpanStart + 1, method.DescendantNodes().OfType<AttributeSyntax>().Single(), out speculativeModel)); 36352Assert.True(model.TryGetSpeculativeSemanticModelForMethodBody(method.Body.SpanStart, method, out var speculativeModel)); 36392Assert.True(model.TryGetSpeculativeSemanticModelForMethodBody(method.Body.SpanStart, method, out var speculativeModel)); 36400Assert.True(model.TryGetSpeculativeSemanticModel(equalsValue.Value.SpanStart, equalsValue, out speculativeModel)); 36434Assert.True(model.TryGetSpeculativeSemanticModelForMethodBody(method.Body.SpanStart, method, out var speculativeModel)); 36469Assert.True(model.TryGetSpeculativeSemanticModelForMethodBody(method.Body.SpanStart, method, out var speculativeModel)); 36478Assert.True(model.TryGetSpeculativeSemanticModel(equalsValue.Value.SpanStart, equalsValue, out speculativeModel)); 36507Assert.True(model.TryGetSpeculativeSemanticModelForMethodBody(method.Body.SpanStart, method, out var speculativeModel));

905Assert.Same(symbol, model.LookupSymbols(x.SpanStart, name: "X").Single()); 906Assert.Contains("X", model.LookupNames(x.SpanStart)); 972Assert.Same(symbol.ContainingSymbol, model.GetEnclosingSymbol(x.SpanStart)); 973Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 974Assert.Contains("X", model.LookupNames(x.SpanStart)); 1199Assert.Same(symbol.ContainingSymbol, model.GetEnclosingSymbol(x.SpanStart)); 1200Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 1201Assert.Contains("X", model.LookupNames(x.SpanStart)); 1212Assert.Same(symbol.ContainingSymbol, model.GetEnclosingSymbol(x.SpanStart)); 1213Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "y")); 1214Assert.Contains("y", model.LookupNames(x.SpanStart)); 1223Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "Test")); 1224Assert.Contains("Test", model.LookupNames(x.SpanStart)); 1264Assert.Same("<global namespace>", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 1265Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 1266Assert.DoesNotContain("X", model.LookupNames(x.SpanStart)); 1310Assert.Same("<global namespace>", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 1311Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 1312Assert.DoesNotContain("X", model.LookupNames(x.SpanStart)); 1370Assert.Same("<global namespace>", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 1371Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 1372Assert.DoesNotContain("X", model.LookupNames(x.SpanStart)); 1428Assert.Same(symbol.ContainingSymbol, model.GetEnclosingSymbol(x.SpanStart)); 1429Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 1430Assert.Contains("X", model.LookupNames(x.SpanStart)); 1439Assert.Same("<global namespace>", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 1440Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 1441Assert.DoesNotContain("X", model.LookupNames(x.SpanStart)); 1517Assert.Same(symbol.ContainingSymbol, model.GetEnclosingSymbol(x.SpanStart)); 1518Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 1519Assert.Contains("X", model.LookupNames(x.SpanStart)); 1528Assert.Same("<global namespace>", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 1529Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 1530Assert.DoesNotContain("X", model.LookupNames(x.SpanStart)); 1713Assert.Same("<global namespace>", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 1714Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 1715Assert.DoesNotContain("X", model.LookupNames(x.SpanStart)); 1753Assert.Same("<global namespace>", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 1754Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 1755Assert.DoesNotContain("X", model.LookupNames(x.SpanStart)); 1794Assert.Equal("C..ctor(System.Int32 X)", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 1795Assert.Equal("System.Int32 X", model.LookupSymbols(x.SpanStart, name: "X").Single().ToTestDisplayString()); 1796Assert.Contains("X", model.LookupNames(x.SpanStart)); 1866Assert.Same(symbol.ContainingSymbol, model.GetEnclosingSymbol(x.SpanStart)); 1867Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 1868Assert.Contains("X", model.LookupNames(x.SpanStart)); 2065Assert.False(model.TryGetSpeculativeSemanticModel(tree.GetRoot().DescendantNodes().OfType<ReturnStatementSyntax>().Single().SpanStart, 2068var otherBasePosition = ((BaseListSyntax)baseWithargs.Parent).Types[1].SpanStart; 2071Assert.True(model.TryGetSpeculativeSemanticModel(baseWithargs.SpanStart, speculativePrimaryInitializer, out speculativeModel)); 2096symbolInfo = model.GetSpeculativeSymbolInfo(baseWithargs.SpanStart, (SyntaxNode)speculativePrimaryInitializer, SpeculativeBindingOption.BindAsExpression); 2099symbolInfo = CSharpExtensions.GetSpeculativeSymbolInfo(model, baseWithargs.SpanStart, speculativePrimaryInitializer); 2217Assert.False(model.TryGetSpeculativeSemanticModel(tree.GetRoot().DescendantNodes().OfType<ReturnStatementSyntax>().Single().SpanStart, 2220var otherBasePosition = ((BaseListSyntax)baseWithargs.Parent).Types[1].SpanStart; 2223Assert.False(model.TryGetSpeculativeSemanticModel(baseWithargs.SpanStart, speculativePrimaryInitializer, out _)); 2235symbolInfo = model.GetSpeculativeSymbolInfo(baseWithargs.SpanStart, (SyntaxNode)speculativePrimaryInitializer, SpeculativeBindingOption.BindAsExpression); 2238symbolInfo = CSharpExtensions.GetSpeculativeSymbolInfo(model, baseWithargs.SpanStart, speculativePrimaryInitializer); 2324Assert.Same("<global namespace>", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 2325Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 2326Assert.DoesNotContain("X", model.LookupNames(x.SpanStart)); 2384Assert.False(model.TryGetSpeculativeSemanticModel(baseWithoutParens.SpanStart + 2, speculativeBase, out _)); 2540Assert.Equal("System.Int32 C.Z", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 2541Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 2542Assert.Contains("X", model.LookupNames(x.SpanStart)); 2578Assert.Equal("System.Int32 C.Z", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 2579Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 2580Assert.Contains("X", model.LookupNames(x.SpanStart)); 2615Assert.Equal("System.Int32 C.Z", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 2616Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 2617Assert.Contains("X", model.LookupNames(x.SpanStart)); 2651Assert.Equal("lambda expression", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 2652Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 2653Assert.Contains("X", model.LookupNames(x.SpanStart)); 6247Assert.Contains("System.Int32 y", model.LookupSymbols(mCall.SpanStart).Select(s => s.ToTestDisplayString())); 6249Assert.DoesNotContain("System.Int32 y", model.LookupSymbols(mDefinition.SpanStart).Select(s => s.ToTestDisplayString())); 7190Assert.Empty(model.LookupSymbols(p1.SpanStart, name: "p1")); 7191Assert.DoesNotContain("p1", model.LookupNames(p1.SpanStart)); 7218Assert.Same(symbol, model.LookupSymbols(p1.SpanStart, name: "p1").Single()); 7219Assert.Contains("p1", model.LookupNames(p1.SpanStart)); 7754Assert.Contains("p1", model.LookupNames(p1.SpanStart)); 7755Assert.Contains(symbol, model.LookupSymbols(p1.SpanStart, name: "p1")); 8160Assert.Contains("p1", model.LookupNames(p1.SpanStart)); 8161Assert.Contains(symbol, model.LookupSymbols(p1.SpanStart, name: "p1"));

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)); 10792Assert.False(model.TryGetSpeculativeSemanticModel(baseWithoutParens.SpanStart + 2, speculativeBase, out _));

21163Assert.Same(symbol.ContainingSymbol, model.GetEnclosingSymbol(x.SpanStart)); 21164Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 21165Assert.Contains("X", model.LookupNames(x.SpanStart)); 21392Assert.Same(symbol.ContainingSymbol, model.GetEnclosingSymbol(x.SpanStart)); 21393Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 21394Assert.Contains("X", model.LookupNames(x.SpanStart)); 21405Assert.Same(symbol.ContainingSymbol, model.GetEnclosingSymbol(x.SpanStart)); 21406Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "y")); 21407Assert.Contains("y", model.LookupNames(x.SpanStart)); 21416Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "Test")); 21417Assert.Contains("Test", model.LookupNames(x.SpanStart)); 21457Assert.Same("<global namespace>", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 21458Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 21459Assert.DoesNotContain("X", model.LookupNames(x.SpanStart)); 21503Assert.Same("<global namespace>", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 21504Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 21505Assert.DoesNotContain("X", model.LookupNames(x.SpanStart)); 21563Assert.Same("<global namespace>", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 21564Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 21565Assert.DoesNotContain("X", model.LookupNames(x.SpanStart)); 21621Assert.Same(symbol.ContainingSymbol, model.GetEnclosingSymbol(x.SpanStart)); 21622Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 21623Assert.Contains("X", model.LookupNames(x.SpanStart)); 21632Assert.Same("<global namespace>", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 21633Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 21634Assert.DoesNotContain("X", model.LookupNames(x.SpanStart)); 21710Assert.Same(symbol.ContainingSymbol, model.GetEnclosingSymbol(x.SpanStart)); 21711Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 21712Assert.Contains("X", model.LookupNames(x.SpanStart)); 21721Assert.Same("<global namespace>", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 21722Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 21723Assert.DoesNotContain("X", model.LookupNames(x.SpanStart)); 21906Assert.Same("<global namespace>", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 21907Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 21908Assert.DoesNotContain("X", model.LookupNames(x.SpanStart)); 21943Assert.Same("<global namespace>", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 21944Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 21945Assert.DoesNotContain("X", model.LookupNames(x.SpanStart)); 21981Assert.Equal("C..ctor(System.Int32 X)", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 21982Assert.Equal("System.Int32 X", model.LookupSymbols(x.SpanStart, name: "X").Single().ToTestDisplayString()); 21983Assert.Contains("X", model.LookupNames(x.SpanStart)); 22018Assert.Same("<global namespace>", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 22019Assert.Empty(model.LookupSymbols(x.SpanStart, name: "X")); 22020Assert.DoesNotContain("X", model.LookupNames(x.SpanStart)); 22097Assert.Same(symbol.ContainingSymbol, model.GetEnclosingSymbol(x.SpanStart)); 22098Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 22099Assert.Contains("X", model.LookupNames(x.SpanStart)); 22296Assert.False(model.TryGetSpeculativeSemanticModel(tree.GetRoot().DescendantNodes().OfType<ReturnStatementSyntax>().Single().SpanStart, 22299var otherBasePosition = ((BaseListSyntax)baseWithargs.Parent!).Types[1].SpanStart; 22302Assert.True(model.TryGetSpeculativeSemanticModel(baseWithargs.SpanStart, speculativePrimaryInitializer, out speculativeModel!)); 22327symbolInfo = model.GetSpeculativeSymbolInfo(baseWithargs.SpanStart, (SyntaxNode)speculativePrimaryInitializer, SpeculativeBindingOption.BindAsExpression); 22330symbolInfo = CSharpExtensions.GetSpeculativeSymbolInfo(model, baseWithargs.SpanStart, speculativePrimaryInitializer); 22448Assert.False(model.TryGetSpeculativeSemanticModel(tree.GetRoot().DescendantNodes().OfType<ReturnStatementSyntax>().Single().SpanStart, 22451var otherBasePosition = ((BaseListSyntax)baseWithargs.Parent!).Types[1].SpanStart; 22454Assert.False(model.TryGetSpeculativeSemanticModel(baseWithargs.SpanStart, speculativePrimaryInitializer, out _)); 22466symbolInfo = model.GetSpeculativeSymbolInfo(baseWithargs.SpanStart, (SyntaxNode)speculativePrimaryInitializer, SpeculativeBindingOption.BindAsExpression); 22469symbolInfo = CSharpExtensions.GetSpeculativeSymbolInfo(model, baseWithargs.SpanStart, speculativePrimaryInitializer); 24661Assert.Equal("System.Int32 C.Z", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 24662Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 24663Assert.Contains("X", model.LookupNames(x.SpanStart)); 24696Assert.Equal("System.Int32 C.Z", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 24697Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 24698Assert.Contains("X", model.LookupNames(x.SpanStart)); 24730Assert.Equal("System.Int32 C.Z", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 24731Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 24732Assert.Contains("X", model.LookupNames(x.SpanStart)); 24765Assert.Equal("lambda expression", model.GetEnclosingSymbol(x.SpanStart).ToTestDisplayString()); 24766Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 24767Assert.Contains("X", model.LookupNames(x.SpanStart)); 30378Assert.Contains("System.Int32 y", model.LookupSymbols(mCall.SpanStart).Select(s => s.ToTestDisplayString())); 30380Assert.DoesNotContain("System.Int32 y", model.LookupSymbols(mDefinition.SpanStart).Select(s => s.ToTestDisplayString()));

3334var 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()); 1676var names = model1.LookupNames(localDecl.SpanStart); 1678var symbols = model1.LookupSymbols(localDecl.SpanStart); 1680Assert.Same(getHashCode, model1.LookupSymbols(localDecl.SpanStart, name: getHashCode.Name).Single()); 1685Assert.Same(declSymbol, model1.LookupSymbols(localDecl.SpanStart, name: "Test").Single()); 1687symbols = model1.LookupNamespacesAndTypes(localDecl.SpanStart); 1690Assert.Same(testType, model1.LookupNamespacesAndTypes(localDecl.SpanStart, name: "Test").Single()); 1708names = model.LookupNames(nameRef.SpanStart); 1712symbols = model.LookupSymbols(nameRef.SpanStart); 1714Assert.Empty(model.LookupSymbols(nameRef.SpanStart, name: getHashCode.Name)); 1718Assert.Same(testType, model.LookupSymbols(nameRef.SpanStart, name: "Test").Single()); 1723Assert.DoesNotContain(getHashCode.Name, model.LookupNames(nameRef.SpanStart)); 1739Assert.DoesNotContain(getHashCode.Name, model.LookupNames(nameRef.SpanStart)); 1749var names = model.LookupNames(nameRef.SpanStart); 1752var symbols = model.LookupSymbols(nameRef.SpanStart); 1755Assert.Same(declSymbol, model.LookupSymbols(nameRef.SpanStart, name: "Test").Single()); 1757symbols = model.LookupNamespacesAndTypes(nameRef.SpanStart); 1760Assert.Same(testType, model.LookupNamespacesAndTypes(nameRef.SpanStart, name: "Test").Single()); 1849var names = model1.LookupNames(localDecl.SpanStart); 1851var symbols = model1.LookupSymbols(localDecl.SpanStart); 1853Assert.Same(getHashCode, model1.LookupSymbols(localDecl.SpanStart, name: getHashCode.Name).Single()); 1858Assert.Same(declSymbol, model1.LookupSymbols(localDecl.SpanStart, name: "Test").Single()); 1860symbols = model1.LookupNamespacesAndTypes(localDecl.SpanStart); 1863Assert.Same(testType, model1.LookupNamespacesAndTypes(localDecl.SpanStart, name: "Test").Single()); 1876names = model2.LookupNames(nameRef.SpanStart); 1880symbols = model2.LookupSymbols(nameRef.SpanStart); 1882Assert.Empty(model2.LookupSymbols(nameRef.SpanStart, name: getHashCode.Name)); 1886Assert.Same(testType, model2.LookupSymbols(nameRef.SpanStart, name: "Test").Single()); 1891Assert.DoesNotContain(getHashCode.Name, model2.LookupNames(nameRef.SpanStart)); 1907Assert.DoesNotContain(getHashCode.Name, model2.LookupNames(nameRef.SpanStart)); 1917var names = model2.LookupNames(nameRef.SpanStart); 1920var symbols = model2.LookupSymbols(nameRef.SpanStart); 1923Assert.Same(declSymbol, model2.LookupSymbols(nameRef.SpanStart, name: "Test").Single()); 1925symbols = model2.LookupNamespacesAndTypes(nameRef.SpanStart); 1928Assert.Same(testType, model2.LookupNamespacesAndTypes(nameRef.SpanStart, name: "Test").Single()); 2075var names = model1.LookupNames(localDecl.SpanStart); 2076var symbols = model1.LookupSymbols(localDecl.SpanStart); 2081Assert.Same(declSymbol, model1.LookupSymbols(localDecl.SpanStart, name: "Test").Single()); 2083symbols = model1.LookupNamespacesAndTypes(localDecl.SpanStart); 2086Assert.Same(testType, model1.LookupNamespacesAndTypes(localDecl.SpanStart, name: "Test").Single()); 2094names = model1.LookupNames(nameRef.SpanStart); 2097symbols = model1.LookupSymbols(nameRef.SpanStart); 2101Assert.Same(testType, model1.LookupSymbols(nameRef.SpanStart, name: "Test").Single()); 2130var names = model2.LookupNames(nameRef.SpanStart); 2133var symbols = model2.LookupSymbols(nameRef.SpanStart); 2136Assert.Same(declSymbol, model2.LookupSymbols(nameRef.SpanStart, name: "Test").Single()); 2138symbols = model2.LookupNamespacesAndTypes(nameRef.SpanStart); 2141Assert.Same(testType, model2.LookupNamespacesAndTypes(nameRef.SpanStart, name: "Test").Single()); 2239var names = model1.LookupNames(localDecl.SpanStart); 2240var symbols = model1.LookupSymbols(localDecl.SpanStart); 2245Assert.Same(declSymbol, model1.LookupSymbols(localDecl.SpanStart, name: "Test").Single()); 2247symbols = model1.LookupNamespacesAndTypes(localDecl.SpanStart); 2250Assert.Same(testType, model1.LookupNamespacesAndTypes(localDecl.SpanStart, name: "Test").Single()); 2260names = model2.LookupNames(nameRef.SpanStart); 2263symbols = model2.LookupSymbols(nameRef.SpanStart); 2267Assert.Same(testType, model2.LookupSymbols(nameRef.SpanStart, name: "Test").Single()); 2296var names = model2.LookupNames(nameRef.SpanStart); 2299var symbols = model2.LookupSymbols(nameRef.SpanStart); 2302Assert.Same(declSymbol, model2.LookupSymbols(nameRef.SpanStart, name: "Test").Single()); 2304symbols = model2.LookupNamespacesAndTypes(nameRef.SpanStart); 2307Assert.Same(testType, model2.LookupNamespacesAndTypes(nameRef.SpanStart, name: "Test").Single()); 2418var names = model1.LookupNames(labelDecl.SpanStart); 2419var symbols = model1.LookupSymbols(labelDecl.SpanStart); 2424Assert.Same(testType, model1.LookupSymbols(labelDecl.SpanStart, name: "Test").Single()); 2426symbols = model1.LookupNamespacesAndTypes(labelDecl.SpanStart); 2429Assert.Same(testType, model1.LookupNamespacesAndTypes(labelDecl.SpanStart, name: "Test").Single()); 2431Assert.Same(declSymbol, model1.LookupLabels(labelDecl.SpanStart).Single()); 2432Assert.Same(declSymbol, model1.LookupLabels(labelDecl.SpanStart, name: "Test").Single()); 2440names = model1.LookupNames(nameRef.SpanStart); 2443symbols = model1.LookupSymbols(nameRef.SpanStart); 2447Assert.Same(testType, model1.LookupSymbols(nameRef.SpanStart, name: "Test").Single()); 2448Assert.Empty(model1.LookupLabels(nameRef.SpanStart)); 2449Assert.Empty(model1.LookupLabels(nameRef.SpanStart, name: "Test")); 2455names = model1.LookupNames(nameRef.SpanStart); 2458symbols = model1.LookupSymbols(nameRef.SpanStart); 2462Assert.Same(testType, model1.LookupSymbols(nameRef.SpanStart, name: "Test").Single()); 2463Assert.Same(declSymbol, model1.LookupLabels(nameRef.SpanStart).Single()); 2464Assert.Same(declSymbol, model1.LookupLabels(nameRef.SpanStart, name: "Test").Single()); 2493var names = model2.LookupNames(nameRef.SpanStart); 2496var symbols = model2.LookupSymbols(nameRef.SpanStart); 2499Assert.Same(testType, model2.LookupSymbols(nameRef.SpanStart, name: "Test").Single()); 2501symbols = model2.LookupNamespacesAndTypes(nameRef.SpanStart); 2504Assert.Same(testType, model2.LookupNamespacesAndTypes(nameRef.SpanStart, name: "Test").Single()); 2506Assert.Empty(model2.LookupLabels(nameRef.SpanStart)); 2507Assert.Empty(model2.LookupLabels(nameRef.SpanStart, name: "Test")); 2909Assert.NotEmpty(model1.LookupNamespacesAndTypes(nameRef.SpanStart, name: "alias1")); 2910Assert.Empty(model1.LookupNamespacesAndTypes(nameRef.SpanStart, name: "alias2")); 2931Assert.Empty(model2.LookupNamespacesAndTypes(nameRef.SpanStart, name: "alias1")); 2932Assert.NotEmpty(model2.LookupNamespacesAndTypes(nameRef.SpanStart, name: "alias2")); 3935var names = model.LookupNames(nameRef.SpanStart); 3938var symbols = model.LookupSymbols(nameRef.SpanStart); 3941Assert.Same(testType, model.LookupSymbols(nameRef.SpanStart, name: "args").Single()); 3949names = model.LookupNames(nameRef.SpanStart); 3952symbols = model.LookupSymbols(nameRef.SpanStart); 3955Assert.Same(parameter, model.LookupSymbols(nameRef.SpanStart, name: "args").Single()); 3957symbols = model.LookupNamespacesAndTypes(nameRef.SpanStart); 3960Assert.Same(testType, model.LookupNamespacesAndTypes(nameRef.SpanStart, name: "args").Single()); 3989var names = model.LookupNames(nameRef.SpanStart); 3992var symbols = model.LookupSymbols(nameRef.SpanStart); 3995Assert.Same(testType, model.LookupSymbols(nameRef.SpanStart, name: "args").Single()); 3997symbols = model.LookupNamespacesAndTypes(nameRef.SpanStart); 4000Assert.Same(testType, model.LookupNamespacesAndTypes(nameRef.SpanStart, name: "args").Single()); 4084var names = model.LookupNames(nameRef.SpanStart); 4087var symbols = model.LookupSymbols(nameRef.SpanStart); 4090Assert.Same(testType, model.LookupSymbols(nameRef.SpanStart, name: "args").Single()); 4119var names = model.LookupNames(nameRef.SpanStart); 4122var symbols = model.LookupSymbols(nameRef.SpanStart); 4125Assert.Same(testType, model.LookupSymbols(nameRef.SpanStart, name: "args").Single()); 4127symbols = model.LookupNamespacesAndTypes(nameRef.SpanStart); 4130Assert.Same(testType, model.LookupNamespacesAndTypes(nameRef.SpanStart, name: "args").Single()); 6029Assert.Contains(declSymbol.Name, model1.LookupNames(localRef.SpanStart)); 6030Assert.Contains(declSymbol, model1.LookupSymbols(localRef.SpanStart)); 6031Assert.Same(declSymbol, model1.LookupSymbols(localRef.SpanStart, name: declSymbol.Name).Single()); 6228Assert.Empty(semanticModel.LookupSymbols(invocation.SpanStart, container: a, name: "M")); 6234Assert.NotEmpty(semanticModel.LookupSymbols(invocation.SpanStart, container: a, name: "M")); 6270Assert.Same(x, semanticModel.LookupSymbols(localDecl.SpanStart, name: "x").Single()); 6272Assert.Same(x, semanticModel.LookupSymbols(localRef.SpanStart, name: "x").Single()); 6315Assert.Same(xDecl, semanticModel1.LookupSymbols(localDecl.SpanStart, name: "x").Single()); 6317Assert.Same(xRef, semanticModel1.LookupSymbols(localRef.SpanStart, name: "x").Single()); 6366Assert.Same(xDecl, semanticModel1.LookupSymbols(localDecl.SpanStart, name: "x").Single()); 6372Assert.Same(xRef, semanticModel2.LookupSymbols(localRef.SpanStart, name: "x").Single()); 8570symbols = model.LookupSymbols(invocations[0].SpanStart, name: "args"); 8575symbols = model.LookupSymbols(invocations[1].SpanStart, name: "args"); 8580symbols = model.LookupSymbols(invocations[2].SpanStart, name: "args"); 8641for (int i = id.SpanStart; i <= id.Span.End; i++) 8663for (int i = id.SpanStart; i <= id.Span.End; i++) 8685for (int i = id.SpanStart; i <= id.Span.End; i++)

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

75var lookupSymbol = model.LookupSymbols(memberAccessExpression.SpanStart, name: declaredLocal.Name).Single(); 1895var 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); 5179var symbols = model.LookupStaticMembers(methodDeclM.Body.SpanStart); 5209var 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);

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

5755int position = methodDecl.Body.SpanStart; 5767position = methodDecl.Body.SpanStart; 6540declarator.SpanStart, 6573declarator.SpanStart, 6585declarator.SpanStart, 6618declarator.SpanStart, 6632declarator.SpanStart, 7605symbol.ToMinimalDisplayParts(model, variable.SpanStart), 7700symbol.ToMinimalDisplayParts(model, constructor.SpanStart, format), 7760symbol.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);

2961memberAccess.SpanStart, 2969memberAccess.SpanStart,

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

1167Assert.True(syntaxContext.SemanticModel.TryGetSpeculativeSemanticModel(syntaxContext.Node.SpanStart, newSource, out var specModel)); 1374verifySpeculativeModel(ifStatement.SpanStart, PublicNullableFlowState.MaybeNull); 1377verifySpeculativeModel(ifStatement.Statement.SpanStart, PublicNullableFlowState.NotNull); 1380verifySpeculativeModel(conditionalAccessExpression.SpanStart, PublicNullableFlowState.MaybeNull); 1383verifySpeculativeModel(conditionalAccessExpression.WhenNotNull.SpanStart, PublicNullableFlowState.NotNull); 1386verifySpeculativeModel(ternary.WhenTrue.SpanStart, PublicNullableFlowState.MaybeNull); 1389verifySpeculativeModel(ternary.WhenFalse.SpanStart, PublicNullableFlowState.NotNull); 1401var referenceTypeInfo = speculativeModel.GetSpeculativeTypeInfo(whenTrue.SpanStart, newReference, SpeculativeBindingOption.BindAsExpression); 1403var coalesceTypeInfo = speculativeModel.GetSpeculativeTypeInfo(whenTrue.SpanStart, newCoalesce, SpeculativeBindingOption.BindAsExpression); 1408referenceTypeInfo = speculativeModel.GetSpeculativeTypeInfo(whenFalse.SpanStart, newReference, SpeculativeBindingOption.BindAsExpression); 1411coalesceTypeInfo = speculativeModel.GetSpeculativeTypeInfo(whenFalse.SpanStart, newCoalesce, SpeculativeBindingOption.BindAsExpression); 1442Assert.True(model.TryGetSpeculativeSemanticModel(returnStatement.SpanStart, newSource, out var specModel)); 1518verifySpeculativeTypeInfo(ifStatement.SpanStart, PublicNullableFlowState.MaybeNull); 1519verifySpeculativeTypeInfo(ifStatement.Statement.SpanStart, PublicNullableFlowState.NotNull); 1521verifySpeculativeTypeInfo(conditionalAccessExpression.SpanStart, PublicNullableFlowState.MaybeNull); 1522verifySpeculativeTypeInfo(conditionalAccessExpression.WhenNotNull.SpanStart, PublicNullableFlowState.NotNull); 1524verifySpeculativeTypeInfo(ternary.WhenTrue.SpanStart, PublicNullableFlowState.MaybeNull); 1525verifySpeculativeTypeInfo(ternary.WhenFalse.SpanStart, PublicNullableFlowState.NotNull); 1574verifySpeculativeTypeInfo(ifStatement.SpanStart, PublicNullableFlowState.MaybeNull); 1575verifySpeculativeTypeInfo(ifStatement.Statement.SpanStart, PublicNullableFlowState.NotNull); 1577verifySpeculativeTypeInfo(conditionalAccessExpression.SpanStart, PublicNullableFlowState.MaybeNull); 1578verifySpeculativeTypeInfo(conditionalAccessExpression.WhenNotNull.SpanStart, PublicNullableFlowState.NotNull); 1580verifySpeculativeTypeInfo(ternary.WhenTrue.SpanStart, PublicNullableFlowState.MaybeNull); 1581verifySpeculativeTypeInfo(ternary.WhenFalse.SpanStart, PublicNullableFlowState.NotNull); 2139Assert.True(model.TryGetSpeculativeSemanticModel(s2Assignment.SpanStart, newDeclaration, out var specModel)); 2143Assert.True(model.TryGetSpeculativeSemanticModel(lastDeclaration.SpanStart, newDeclaration, out specModel)); 3782Assert.True(model.TryGetSpeculativeSemanticModel(lambda.Body.SpanStart, newStatement, out var speculativeModel)); 4067Assert.True(model.TryGetSpeculativeSemanticModel(localFunction.SpanStart, speculativeAttribute, out var speculativeModel)); 4072Assert.True(model.TryGetSpeculativeSemanticModel(localFunction.ParameterList.Parameters[0].Default.SpanStart, speculativeInitializer, out speculativeModel)); 4215Assert.True(model.TryGetSpeculativeSemanticModel(attributeUsage.SpanStart, newAttributeUsage, out var specModel)); 4245model.TryGetSpeculativeSemanticModel(typeOf.Type.SpanStart, type, out model, SpeculativeBindingOption.BindAsTypeOrNamespace); 4369Assert.True(model.TryGetSpeculativeSemanticModel(type.SpanStart, statement, out var speculativeModel)); 4397Assert.True(model.TryGetSpeculativeSemanticModel(type.SpanStart, statement, out var speculativeModel)); 4427Assert.True(model.TryGetSpeculativeSemanticModel(type.SpanStart, statement, out var speculativeModel)); 4457Assert.True(model.TryGetSpeculativeSemanticModel(type.SpanStart, statement, out var speculativeModel)); 4487Assert.True(model.TryGetSpeculativeSemanticModel(type.SpanStart, statement, out var speculativeModel)); 4519Assert.True(model.TryGetSpeculativeSemanticModelForMethodBody(type.SpanStart, methodDeclaration, out var speculativeModel)); 4552Assert.True(model.TryGetSpeculativeSemanticModelForMethodBody(type.SpanStart, methodDeclaration, out var speculativeModel)); 4580Assert.True(model.TryGetSpeculativeSemanticModel(type.SpanStart, arrow, out var speculativeModel)); 4610Assert.True(model.TryGetSpeculativeSemanticModel(type.SpanStart, arrow, out var speculativeModel)); 4641Assert.True(model.TryGetSpeculativeSemanticModel(initializer.SpanStart, newInitializer, out var speculativeModel)); 4674Assert.True(model.TryGetSpeculativeSemanticModel(initializer.SpanStart, newInitializer, out var speculativeModel));

311var symbolInfo = model.GetSpeculativeSymbolInfo(base2.SpanStart, base2, SpeculativeBindingOption.BindAsTypeOrNamespace); 317symbolInfo = model.GetSpeculativeSymbolInfo(base3.SpanStart, base3, SpeculativeBindingOption.BindAsTypeOrNamespace); 323symbolInfo = model.GetSpeculativeSymbolInfo(base4.SpanStart, base4, SpeculativeBindingOption.BindAsTypeOrNamespace); 357var symbolInfo = model.GetSpeculativeSymbolInfo(base2.SpanStart, base2, SpeculativeBindingOption.BindAsTypeOrNamespace); 363symbolInfo = model.GetSpeculativeSymbolInfo(base3.SpanStart, base3, SpeculativeBindingOption.BindAsTypeOrNamespace); 369symbolInfo = model.GetSpeculativeSymbolInfo(base4.SpanStart, base4, SpeculativeBindingOption.BindAsTypeOrNamespace); 447var names = model.LookupNames(root.Members[0].SpanStart); 466var names = model.LookupNames(root.Members[0].SpanStart); 485var symbols = model.LookupSymbols(root.Members[0].SpanStart, name: "O"); 506var 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())); 13204Assert.Equal("System.Int32 I1.P01 { get; set; }", ((CSharpSemanticModel)model).LookupSymbols(node.SpanStart, m02.TypeParameters[0], "P01").Single().ToTestDisplayString()); 13205Assert.Equal("System.Int32 I1.P01 { get; set; }", ((CSharpSemanticModel)model).LookupStaticMembers(node.SpanStart, m02.TypeParameters[0], "P01").Single().ToTestDisplayString()); 13206Assert.Contains("System.Int32 I1.P01 { get; set; }", ((CSharpSemanticModel)model).LookupSymbols(node.SpanStart, m02.TypeParameters[0]).ToTestDisplayStrings()); 13207Assert.Contains("System.Int32 I1.P01 { get; set; }", ((CSharpSemanticModel)model).LookupStaticMembers(node.SpanStart, m02.TypeParameters[0]).ToTestDisplayStrings()); 13209Assert.Equal("System.Int32 I1.P01 { get; set; }", model.LookupSymbols(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol(), "P01").Single().ToTestDisplayString()); 13210Assert.Equal("System.Int32 I1.P01 { get; set; }", model.LookupStaticMembers(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol(), "P01").Single().ToTestDisplayString()); 13211Assert.Contains("System.Int32 I1.P01 { get; set; }", model.LookupSymbols(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol()).ToTestDisplayStrings()); 13212Assert.Contains("System.Int32 I1.P01 { get; set; }", model.LookupStaticMembers(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol()).ToTestDisplayStrings()); 13214Assert.Contains("P01", model.LookupNames(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol())); 13290Assert.Equal("System.Int32 I1.P01 { get; set; }", ((CSharpSemanticModel)model).LookupSymbols(node.SpanStart, m02.TypeParameters[0], "P01").Single().ToTestDisplayString()); 13291Assert.Equal("System.Int32 I1.P01 { get; set; }", ((CSharpSemanticModel)model).LookupStaticMembers(node.SpanStart, m02.TypeParameters[0], "P01").Single().ToTestDisplayString()); 13292Assert.Contains("System.Int32 I1.P01 { get; set; }", ((CSharpSemanticModel)model).LookupSymbols(node.SpanStart, m02.TypeParameters[0]).ToTestDisplayStrings()); 13293Assert.Contains("System.Int32 I1.P01 { get; set; }", ((CSharpSemanticModel)model).LookupStaticMembers(node.SpanStart, m02.TypeParameters[0]).ToTestDisplayStrings()); 13295Assert.Equal("System.Int32 I1.P01 { get; set; }", model.LookupSymbols(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol(), "P01").Single().ToTestDisplayString()); 13296Assert.Equal("System.Int32 I1.P01 { get; set; }", model.LookupStaticMembers(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol(), "P01").Single().ToTestDisplayString()); 13297Assert.Contains("System.Int32 I1.P01 { get; set; }", model.LookupSymbols(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol()).ToTestDisplayStrings()); 13298Assert.Contains("System.Int32 I1.P01 { get; set; }", model.LookupStaticMembers(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol()).ToTestDisplayStrings()); 13300Assert.Contains("P01", model.LookupNames(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol())); 13412Assert.Equal("System.Int32 I1.P01 { get; set; }", ((CSharpSemanticModel)model).LookupSymbols(node.SpanStart, m02.TypeParameters[0], "P01").Single().ToTestDisplayString()); 13413Assert.Equal("System.Int32 I1.P01 { get; set; }", ((CSharpSemanticModel)model).LookupStaticMembers(node.SpanStart, m02.TypeParameters[0], "P01").Single().ToTestDisplayString()); 13414Assert.Contains("System.Int32 I1.P01 { get; set; }", ((CSharpSemanticModel)model).LookupSymbols(node.SpanStart, m02.TypeParameters[0]).ToTestDisplayStrings()); 13415Assert.Contains("System.Int32 I1.P01 { get; set; }", ((CSharpSemanticModel)model).LookupStaticMembers(node.SpanStart, m02.TypeParameters[0]).ToTestDisplayStrings()); 13417Assert.Equal("System.Int32 I1.P01 { get; set; }", model.LookupSymbols(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol(), "P01").Single().ToTestDisplayString()); 13418Assert.Equal("System.Int32 I1.P01 { get; set; }", model.LookupStaticMembers(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol(), "P01").Single().ToTestDisplayString()); 13419Assert.Contains("System.Int32 I1.P01 { get; set; }", model.LookupSymbols(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol()).ToTestDisplayStrings()); 13420Assert.Contains("System.Int32 I1.P01 { get; set; }", model.LookupStaticMembers(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol()).ToTestDisplayStrings()); 13422Assert.Contains("P01", model.LookupNames(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol())); 14134Assert.Equal("event System.Action I1.E01", ((CSharpSemanticModel)model).LookupSymbols(node.SpanStart, m02.TypeParameters[0], "E01").Single().ToTestDisplayString()); 14135Assert.Equal("event System.Action I1.E01", ((CSharpSemanticModel)model).LookupStaticMembers(node.SpanStart, m02.TypeParameters[0], "E01").Single().ToTestDisplayString()); 14136Assert.Contains("event System.Action I1.E01", ((CSharpSemanticModel)model).LookupSymbols(node.SpanStart, m02.TypeParameters[0]).ToTestDisplayStrings()); 14137Assert.Contains("event System.Action I1.E01", ((CSharpSemanticModel)model).LookupStaticMembers(node.SpanStart, m02.TypeParameters[0]).ToTestDisplayStrings()); 14139Assert.Equal("event System.Action I1.E01", model.LookupSymbols(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol(), "E01").Single().ToTestDisplayString()); 14140Assert.Equal("event System.Action I1.E01", model.LookupStaticMembers(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol(), "E01").Single().ToTestDisplayString()); 14141Assert.Contains("event System.Action I1.E01", model.LookupSymbols(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol()).ToTestDisplayStrings()); 14142Assert.Contains("event System.Action I1.E01", model.LookupStaticMembers(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol()).ToTestDisplayStrings()); 14144Assert.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);

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

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

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

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

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

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

263return InferTypes(expression.SpanStart); 1322=> InferTypes(implicitArray.SpanStart); 2270if (descendant.SpanStart <= afterNode.Span.End)

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

23=> x.SpanStart == y.SpanStart; 26=> obj.SpanStart;

123condDirectives.Sort((n1, n2) => n1.SpanStart.CompareTo(n2.SpanStart));

652var speculativeSymbolInfo = semanticModel.GetSpeculativeSymbolInfo(expression.SpanStart, expression, SpeculativeBindingOption.BindAsTypeOrNamespace);

654if (!textSpan.Contains(directives[0].SpanStart) || 655!textSpan.Contains(directives[directives.Count - 1].SpanStart)) 948var expressionBodiedMemberBody = TextSpan.FromBounds(expressionBodiedMember.Expression.SpanStart, expressionBodiedMember.Expression.Span.End);

53var start = usings.First().SpanStart; 62var start = rootUsings.First().SpanStart;

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

175name.SpanStart, name, SpeculativeBindingOption.BindAsExpression); 178name.SpanStart, name, SpeculativeBindingOption.BindAsExpression).Type;

46if (globalStatements.Any(g => firstTypeOrNamespaceDecl.SpanStart < g.SpanStart))

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

229alias.SpanStart, 328return new RecommendedSymbols(_context.SemanticModel.LookupSymbols(position: name.SpanStart, container: symbol)); 331position: name.SpanStart, 377var speculativeSymbolInfo = _context.SemanticModel.GetSpeculativeSymbolInfo(expression.SpanStart, expression, SpeculativeBindingOption.BindAsTypeOrNamespace); 456!_context.SemanticModel.IsEventUsableAsField(originalExpression.SpanStart, ev)) 514var symbols = GetMemberSymbols(containerSymbol, position: originalExpression.SpanStart, excludeInstance, useBaseReferenceAccessibility, unwrapNullable, isForDereference);

1283var position = nodeToSpeculate.SpanStart;

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

63previousSemanticModel.TryGetSpeculativeSemanticModelForMethodBody(previousBaseMethod.Body.SpanStart, currentBaseMethod, out var speculativeModel)) 71previousSemanticModel.TryGetSpeculativeSemanticModelForMethodBody(previousAccessorDeclaration.Body.SpanStart, currentAccessorDeclaration, out speculativeModel))

99var result = speculatedExpression.CastIfPossible(targetType, speculatedExpression.SpanStart, speculativeSemanticModel, _cancellationToken); 671_semanticModel.SyntaxTree.IsNameOfContext(originalSimpleName.SpanStart, _semanticModel, _cancellationToken)) 689if (!Equals(_semanticModel.GetEnclosingNamedType(originalSimpleName.SpanStart, _cancellationToken), symbol.ContainingType)) 1076var speculationPosition = originalNode.SpanStart; 1080var binding = _semanticModel.GetSpeculativeSymbolInfo(originalNode.SpanStart, expression, SpeculativeBindingOption.BindAsExpression);

117node.SpanStart,

129var aliasTypeInfo = semanticModel.GetSpeculativeAliasInfo(node.SpanStart, aliasIdentifier, SpeculativeBindingOption.BindAsTypeOrNamespace); 232var scopes = model.GetImportScopes(firstMember.SpanStart, cancellationToken); 290var symbolInfo = semanticModel.GetSpeculativeSymbolInfo(node.SpanStart, aliasIdentifier, SpeculativeBindingOption.BindAsExpression); 295var typeInfo = semanticModel.GetSpeculativeTypeInfo(node.SpanStart, aliasIdentifier, SpeculativeBindingOption.BindAsExpression); 303var boundSymbols = semanticModel.LookupNamespacesAndTypes(node.SpanStart, name: aliasName); 359return @namespace.SpanStart; 414var symbols = semanticModel.LookupSymbols(expression.SpanStart, name: identifierName.Identifier.ValueText);

235? semanticModel.LookupSymbols(memberAccess.SpanStart, name: memberAccess.Name.Identifier.ValueText) 238? semanticModel.LookupNamespacesAndTypes(memberAccess.SpanStart, name: memberAccess.Name.Identifier.ValueText) 348var enclosingNamedType = semanticModel.GetEnclosingNamedType(memberAccess.SpanStart, cancellationToken); 371if (ancestorInvocation?.SpanStart == memberAccess.SpanStart) 426var enclosingSymbol = semanticModel.GetEnclosingSymbol(left.SpanStart);

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

109var position = originalNode.SpanStart;

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

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

145return node.SpanStart;

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

58While 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

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

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

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

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

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

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

149syntaxTree.GetLocation(TextSpan.FromBounds(match.SpanStart, arguments[0].SpanStart)),

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

136match.MemberAccessExpression.SpanStart, end));

155formatString, formatStringLiteralExpressionSyntax.SpanStart);

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

171positionForTypeBinding = syntax.SpanStart;

79ancestor.SpanStart < token.SpanStart)

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

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

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

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

165if (targetMember.SpanStart < documentationComment.SpanStart)

847var adjustedOldStatementStart = oldMember.FullSpan.Contains(oldStatementSpan.Start) ? oldStatementSpan.Start : oldMember.SpanStart; 2047if (!TryGetEnclosingBreakpointSpan(oldNode, oldNode.SpanStart, out var oldBreakpointSpan) || 2048!TryGetEnclosingBreakpointSpan(newNode, newNode.SpanStart, out var newBreakpointSpan)) 4779return newNode => newDeclaration.FullSpan.Contains(newNode.SpanStart) ? 4970(accumulate, node) => (node.SpanStart < accumulate.min) ? (node.SpanStart, node.Span) : accumulate).span; 5159orderby clause.SpanStart

162if (methodDefinition.SyntaxTree.IsHiddenPosition(methodDefinition.AsNode().SpanStart, cancellationToken) ||

130if (textSpan.End < stmt.SpanStart) 135if (stmt.SpanStart <= textSpan.Start) 179if (firstStatement == null && stmt.SpanStart >= textSpan.Start)

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

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

113constructorDocument.Id, constructorSyntax.SpanStart));

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

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

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

105ContainingType = semanticModel.GetEnclosingNamedType(methodDeclaration.SpanStart, cancellationToken); 154ContainingType = semanticModel.GetEnclosingNamedType(SimpleNameOpt.SpanStart, cancellationToken);

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

148var containingNamespace = semanticDocument.SemanticModel.GetEnclosingNamespace(node.SpanStart, cancellationToken); 169var containingNamespace = document.SemanticModel.GetEnclosingNamespace(node.SpanStart, cancellationToken); 255var outerTypeSymbol = semanticModel.GetEnclosingNamedType(state.SimpleName.SpanStart, cancellationToken);

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

185.OrderByDescending(n => n.SpanStart)

167var spanStart = imports.Count > 0 ? imports[0].SpanStart : 0;

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

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

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

77(int, Action) pair = (token.Parent.SpanStart, 114actionsToPerform.Add((node.SpanStart, () => RemoveOrReplaceNode(syntaxEditor, node, blockFacts)));

77return GetSignatureHelpSpan(argumentList, argumentList.GetRequiredParent().SpanStart, getCloseToken); 168var position = initializer.SpanStart;

34arrayBuilder.Add(new SnippetPlaceholder(identifier: condition.ToString(), placeholderPositions: ImmutableArray.Create(condition.SpanStart)));

158if (nearestExpressionStatement.SpanStart != position)

252if (closestNode.SpanStart != position)

132_objectCreationExpression.SpanStart,

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

736aggregate.AggregateKeyword.SpanStart < candidate.Syntax.SpanStart && 737aggregate.IntoKeyword.SpanStart > candidate.Syntax.SpanStart &&

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

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

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

1340Dim syntaxOffset = _method.CalculateLocalSyntaxOffset(syntax.SpanStart, syntax.SyntaxTree)

1116Dim binder As Binder = If(binderOpt, GetEnclosingBinder(boundNodes.LowestBoundNode.Syntax.SpanStart)) 1478Dim binder As Binder = If(binderOpt, GetEnclosingBinder(lowestBoundNode.Syntax.SpanStart)) 2994Dim binder = Me.GetEnclosingBinder(Root.SpanStart) ' should never return null. 3008Dim binder = Me.GetEnclosingBinder(Root.SpanStart) ' should never return null. 3022Dim binder = Me.GetEnclosingBinder(Root.SpanStart) ' should never return null. 3036Dim 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)

973Dim syntaxOffset As Integer = _topLevelMethod.CalculateLocalSyntaxOffset(syntax.SpanStart, syntax.SyntaxTree) 1014Dim 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)

1172New SynthesizedLocal(DirectCast(_semanticModel.GetEnclosingSymbol(boundForToStatement.Syntax.SpanStart), Symbol), boundForToStatement.ControlVariable.Type, 1414New SynthesizedLocal(DirectCast(_semanticModel.GetEnclosingSymbol(boundSyncLockStatement.Syntax.SpanStart), Symbol),

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

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

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

112Dim position = originalNode.SpanStart

795Dim member = GetContainingMemberDeclaration(node, node.SpanStart) 867Return TextSpan.FromBounds(list.First.SpanStart, list.Last.Span.End) 872Return TextSpan.FromBounds(list.First.SpanStart, list.Last.Span.End)

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

6371Assert.True(model.LookupNames(add.SpanStart, jsonObjType).Contains("Add")) 6372Assert.True(model.LookupSymbols(add.SpanStart, jsonObjType, "Add").Contains(addMethod)) 6373Assert.True(model.LookupSymbols(add.SpanStart, jsonObjType).Contains(addMethod))

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

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

180matchingNode.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)

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

104Dim leftPosition = leftNode.SpanStart

513If position < declarationBody.SpanStart Then 571position = declarationBody.SpanStart 588While node.Span.Length < span.Length AndAlso node.Parent.SpanStart = position 625If leftDeclarator.AsClause IsNot Nothing AndAlso leftNode.SpanStart >= leftDeclarator.AsClause.SpanStart Then 897Return BreakpointSpans.TryGetEnclosingBreakpointSpan(node, node.SpanStart, minLength, span)

105Dim symbolInfo = binding.GetSpeculativeSymbolInfo(contextNode.SpanStart, typeName, SpeculativeBindingOption.BindAsTypeOrNamespace)

113Dim postProcessor = New PostProcessor(semanticModel, context.SpanStart) 287Dim postProcessor = New PostProcessor(semanticModel, context.SpanStart)

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

53Dim position = typeAndDeclaration.Item2.SpanStart

213Dim 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)) 106currentSpan.Start = node.SpanStart Then

604Dim position As Integer = originalExpression.SpanStart

1431Dim position = FindNodeFromText(tree, "_a.F()").SpanStart

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

473Dim position = FindNodeFromText(tree, "_1.Value").SpanStart

334Assert.Equal(tree.SpanStart, tree.FullSpan.Start) 336VerifyListSpans(precedingTrivia, New TextSpan(tree.FullSpan.Start, (tree.SpanStart - tree.FullSpan.Start)))

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

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

1038Dim position = nodeToSpeculate.SpanStart

112Dim position = originalNode.SpanStart

795Dim member = GetContainingMemberDeclaration(node, node.SpanStart) 867Return TextSpan.FromBounds(list.First.SpanStart, list.Last.Span.End) 872Return TextSpan.FromBounds(list.First.SpanStart, list.Last.Span.End)

85var spanStart = documentationComment.SpanStart;

100return node.SpanStart;

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

727!forEachExpression.Span.Contains(_expression.SpanStart)) 828newSymbol = this.OriginalSemanticModel.GetSpeculativeSymbolInfo(type.SpanStart, newType, bindingOption).Symbol;

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

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

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

613if (semanticFacts.IsNamespaceDeclarationNameContext(semanticModel, node.SpanStart, cancellationToken)) 687if (semanticFacts.IsNamespaceDeclarationNameContext(semanticModel, node.SpanStart, cancellationToken)) 755syntaxFacts.GetContainingTypeDeclaration(node, node.SpanStart), 764syntaxFacts.GetContainingMemberDeclaration(node, node.SpanStart),

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

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

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

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

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

322Math.Min(fullSpan.Start, node.SpanStart), 338var end = endNode.SpanStart;

2803var deletionStart = attributeList.SpanStart; 2852var deletionStart = node.SpanStart; 3696var position = typeDeclaration.SpanStart;

229startPosition = node.SpanStart; 233startPosition = node.Expression.SpanStart; 266startPosition = node.Name.SpanStart; 296startPosition = node.SpanStart; 386var line = text.Lines.GetLineFromPosition(node.SpanStart); 466startPosition = node.SpanStart; 473var line = text.Lines.GetLineFromPosition(firstAccessorNode.SpanStart); 493var line = text.Lines.GetLineFromPosition(node.SpanStart); 526startPosition = node.SpanStart; 532var line = text.Lines.GetLineFromPosition(node.SpanStart); 579startPosition = node.Name.SpanStart; 665startPosition = node.SpanStart; 669startPosition = node.Name.SpanStart; 703startPosition = field.SpanStart; 743startPosition = node.SpanStart; 783startPosition = node.SpanStart;

111name = CodeModelService.GetFullyQualifiedName(name, node.SpanStart, semanticModel);

170var typeSymbol = CodeModelService.GetTypeSymbol(type, this.GetSemanticModel(), containerNode.SpanStart); 195var containerNodePosition = containerNode.SpanStart; 229var containerNodePosition = containerNode.SpanStart; 288var containerNodePosition = containerNode.SpanStart; 312var containerNodePosition = containerNode.SpanStart; 348var containerNodePosition = containerNode.SpanStart; 394var containerNodePosition = containerNode.SpanStart; 418var containerNodePosition = containerNode.SpanStart; 444var containerNodePosition = containerNode.SpanStart; 701var typeSymbol = CodeModelService.GetTypeSymbol(@base, semanticModel, node.SpanStart); 724var typeSymbol = CodeModelService.GetTypeSymbol(element, semanticModel, node.SpanStart); 737var typeSymbol = CodeModelService.GetTypeSymbol(@base, semanticModel, node.SpanStart); 762var typeSymbol = CodeModelService.GetTypeSymbol(element, semanticModel, node.SpanStart);

368=> Text.Lines.IndexOf(node.SpanStart);

1280Dim deletionStart = node.SpanStart