Binder\Binder_Constraints.cs (5)

70if (results[ordinal] == null) 97if (results[i] == null) 397constraintClauses[i] = RemoveInvalidConstraints(typeParameters[i], constraintClauses[i], syntaxNodes[i], performOnlyCycleSafeValidation, diagnostics); 419var syntax = syntaxNodesOpt[i];

Binder\Binder_Deconstruct.cs (5)

298var variable = variables[i]; 354var variable = variables[i]; 396var variable = variables[i]; 421Debug.Assert((object?)variables[i].Single!.Type != null); 485var variable = lhsVariables[i];

Binder\Binder_Expressions.cs (14)

1154string inferredName = inferredElementNames[i]; 1155if (elementNames[i] == null && inferredName != null) 1191var inferredName = inferredElementNames[i]; 3445BoundExpression argument = arguments[arg]; 3554Debug.Assert(arguments[arg].Kind is not 3558paramsArgsBuilder.Add(arguments[arg]); 3598paramsArgsBuilder[i], 3749Debug.Assert(handlerArgumentIndexesBuilder[handlerParameterIndex] is BoundInterpolatedStringArgumentPlaceholder.UnspecifiedParameter); 3831arguments[argumentIndex].Syntax.Location, 3859placeholderSyntax = arguments[argumentIndex].Syntax; 3860isSuppressed = arguments[argumentIndex].IsSuppressed; 5371var end = analyzedArguments.Arguments[analyzedArguments.Arguments.Count - 1].Syntax.Span.End; 8736MethodSymbol method = methodGroup.Methods[i]; 9688BoundExpression argument = arguments.Arguments[i];

Binder\Binder_Invocation.cs (10)

272BoundExpression argument = analyzedArguments.Arguments[i]; 296analyzedArguments.Arguments[i] = BindToNaturalType(analyzedArguments.Arguments[i], diagnostics); 513if (arguments.Names[i] != null) 519Error(diagnostics, ErrorCode.ERR_NamedArgumentSpecificationBeforeFixedArgumentInDynamicInvocation, arguments.Arguments[i].Syntax); 531builder[i] = builder[i] switch 883var arg = arguments[i]; 1002var result = overloadResolutionResult.ResultsBuilder[i]; 1546Debug.Assert(argumentsBuilder[i].IsParamsArrayOrCollection); 1704var argument = argumentsBuilder[argumentIndex]; 2095var argument = newArguments[i];

Binder\Binder_Lookup.cs (5)

674symbols[i] = UnwrapAliasNoDiagnostics(symbols[i]); 685var srcSymbol = symbols[best.Index]; 686var mdSymbol = symbols[secondBest.Index]; 1303var sym = hiddenSymbols[i]; 1309var hidingSym = hidingSymbols[j];

Binder\Binder_Operators.cs (1)

1911var op = operators[i];

Binder\Binder_Patterns.cs (2)

1806TypeSymbol candidate = candidates[i]; 1812TypeSymbol candidate = candidates[i];

Binder\Binder_Query.cs (2)

317var lastArgument = arguments[n - 1]; 318arguments[n - 1] = arguments[n - 2];

Binder\Binder_Symbols.cs (7)

2007symbols[i] = UnwrapAlias(symbols[i], diagnostics, where); 2018var srcSymbol = symbols[best.Index]; 2019var mdSymbol = symbols[secondBest.Index]; 2077var first = symbols[best.Index]; 2078var second = symbols[secondBest.Index]; 2374ReportUseSite(symbols[i], diagnostics, where); 2530var symbol = symbols[i];

Binder\DecisionDagBuilder.cs (4)

239newSequence[i] = scanAndSimplify(newSequence[i]); 1816public T this[int i] => _arrayBuilder[i]; 2401switch (remainingTests[i]) 2481switch (remainingTests[i])

Binder\Imports.cs (1)

142expandedNamespace = expandedNamespace.GetMembers(nameParts[i]).OfType<NamespaceSymbol>().Single();

Binder\PatternExplainer.cs (2)

436var oldPattern = subpatterns[effectiveIndex]; 484var oldPattern = subpatterns[index];

Binder\RefSafetyAnalysis.cs (2)

1020var variable = variables[i]; 1045var variable = variables[i];

Binder\Semantics\BestTypeInferrer.cs (2)

201TypeSymbol? type = checkType(types[i]); 236TypeSymbol? type = checkType(types[i]);

Binder\Semantics\Conversions\ConversionsBase.cs (3)

3176var sourceTypeArgument = sourceTypeArguments[paramIndex]; 3177var destinationTypeArgument = destinationTypeArguments[paramIndex]; 3186TypeParameterSymbol typeParameterSymbol = (TypeParameterSymbol)typeParameters[paramIndex].Type;

Binder\Semantics\Conversions\UserDefinedExplicitConversions.cs (1)

246if (SourceMemberContainerTypeSymbol.DoOperatorsPair(operators[i], op2))

Binder\Semantics\Operators\BinaryOperatorOverloadResolution.cs (18)

838var existingSignature = result[i].Signature; 973if (SourceMemberContainerTypeSymbol.DoOperatorsPair(signature1.Method, operators2[i].Method)) 1016MethodSymbol op = operators[i].Method; 1124if (candidates[index].Kind != OperatorAnalysisResultKind.Inapplicable && index != bestIndex) 1126candidates[index] = candidates[index].Worse(); 1135if (candidates[i].Kind != OperatorAnalysisResultKind.Applicable) 1143if (candidates[j].Kind == OperatorAnalysisResultKind.Inapplicable) 1148var better = BetterOperator(candidates[i].Signature, candidates[j].Signature, left, right, ref useSiteInfo); 1151candidates[j] = candidates[j].Worse(); 1155candidates[i] = candidates[i].Worse(); 1170if (candidates[index].Kind != OperatorAnalysisResultKind.Applicable) 1182var better = BetterOperator(candidates[currentBestIndex].Signature, candidates[index].Signature, left, right, ref useSiteInfo); 1199if (candidates[index].Kind == OperatorAnalysisResultKind.Inapplicable) 1204var better = BetterOperator(candidates[currentBestIndex].Signature, candidates[index].Signature, left, right, ref useSiteInfo); 1514var candidate = operators[i];

Binder\Semantics\Operators\BinaryOperatorOverloadResolutionResult.cs (1)

112if (this.Results[i].Kind == kind)

Binder\Semantics\Operators\UnaryOperatorOverloadResolution.cs (17)

163var candidate = operators[i]; 328if (candidates[index].Kind != OperatorAnalysisResultKind.Inapplicable && index != bestIndex) 330candidates[index] = candidates[index].Worse(); 339if (candidates[i].Kind != OperatorAnalysisResultKind.Applicable) 347if (candidates[j].Kind == OperatorAnalysisResultKind.Inapplicable) 352var better = BetterOperator(candidates[i].Signature, candidates[j].Signature, operand, ref useSiteInfo); 355candidates[j] = candidates[j].Worse(); 359candidates[i] = candidates[i].Worse(); 373if (candidates[index].Kind != OperatorAnalysisResultKind.Applicable) 385var better = BetterOperator(candidates[currentBestIndex].Signature, candidates[index].Signature, operand, ref useSiteInfo); 402if (candidates[index].Kind == OperatorAnalysisResultKind.Inapplicable) 407var better = BetterOperator(candidates[currentBestIndex].Signature, candidates[index].Signature, operand, ref useSiteInfo); 769if (SourceMemberContainerTypeSymbol.DoOperatorsPair(signature1.Method, operators2[i].Method)) 826MethodSymbol op = operators[i].Method;

Binder\Semantics\Operators\UnaryOperatorOverloadResolutionResult.cs (1)

112if (this.Results[i].Kind == kind)

Binder\Semantics\OverloadResolution\AnalyzedArguments.cs (5)

39return Arguments[i]; 54var nameAndLocation = Names[i]; 78return RefKinds.Count > 0 ? RefKinds[i] : Microsoft.CodeAnalysis.RefKind.None; 98var argument = Arguments[i]; 101if ((object?)argument.Type != null && argument.Type.IsDynamic() && (!hasRefKinds || RefKinds[i] == Microsoft.CodeAnalysis.RefKind.None))

Binder\Semantics\OverloadResolution\MethodTypeInference.cs (8)

1956ExactInference(sourceTypeArguments[arg], targetTypeArguments[arg], ref useSiteInfo); 2401var typeParameter = typeParameters[arg]; 2402var sourceTypeArgument = sourceTypeArguments[arg]; 2403var targetTypeArgument = targetTypeArguments[arg]; 2751var typeParameter = typeParameters[arg]; 2752var sourceTypeArgument = sourceTypeArguments[arg]; 2753var targetTypeArgument = targetTypeArguments[arg];

Binder\Semantics\OverloadResolution\OverloadResolution.cs (60)

Binder\Semantics\OverloadResolution\OverloadResolution_ArgsToParameters.cs (3)

269isNamedArgument = arguments.Names.Count > argumentPosition && arguments.Names[argumentPosition] != null; 321Debug.Assert(arguments.Names[argumentPosition].HasValue); 322var name = arguments.Names[argumentPosition].GetValueOrDefault().Name;

Binder\Semantics\OverloadResolution\OverloadResolutionResult.cs (10)

BoundTree\UnboundLambda.cs (3)

765if (((DeclaredScope(i) == ScopedKind.None && parameterScopesBuilder[i] == ScopedKind.ScopedRef) || 766DeclaredScope(i) == ScopedKind.ScopedValue || parameterScopesBuilder[i] == ScopedKind.ScopedValue) && 774Debug.Assert(lambdaSymbol.Parameters[i].EffectiveScope == parameterScopesBuilder[i]);

CodeGen\CodeGenerator.cs (4)

246int yieldOffset = _builder.GetILOffsetFromMarker(yieldPoints[i]); 247int resumeOffset = _builder.GetILOffsetFromMarker(resumePoints[i]); 430var span = sequencePoints[i].Span; 531var temp = _expressionTemps[i];

CodeGen\Optimizer.cs (3)

190var def = defs[i]; 203var def = defs[i]; 1934defs[last] = defs[last].WithEnd(_counter);

Compilation\CSharpCompilation.cs (2)

5005var symbol = GetCachedSymbol(spine[spine.Count - 1]); 5014current = GetSymbol(current, spine[i]);

Emitter\Model\MostCommonNullableValueBuilder.cs (1)

96if (builder[i] != b)

FlowAnalysis\AlwaysAssignedWalker.cs (1)

62var v = base.variableBySlot[i];

FlowAnalysis\DefiniteAssignment.cs (12)

286VariableIdentifier variableId = variableBySlot[slot]; 291variableId = variableBySlot[variableId.ContainingSlot]; 300int containingSlot = variableBySlot[slot].ContainingSlot; 1049var id = variableBySlot[i]; 1054variableBySlot[slot].Symbol.GetTypeOrReturnType().TypeKind == TypeKind.Struct; 1328var fieldIdentifier = variableBySlot[fieldSlot]; 1692VariableIdentifier variable = variableBySlot[containingSlot]; 1728VariableIdentifier id = variableBySlot[slot]; 1752id = variableBySlot[slot]; 1764VariableIdentifier id = variableBySlot[slot]; 1786id = variableBySlot[slot]; 2852VariableIdentifier id = variableBySlot[bit];

FlowAnalysis\DefiniteAssignment.LocalFunctions.cs (3)

51var symbol = variableBySlot[slot].Symbol; 104VariableIdentifier id = variableBySlot[slot]; 145var rootVarInfo = variableBySlot[RootSlot(slot)];

FlowAnalysis\DefinitelyAssignedWalker.cs (1)

95variableBySlot[slot].Symbol is { } symbol &&

FlowAnalysis\NullableWalker.cs (17)

3267if (localFuncs[i] is { } localFunc && HasLocalFuncUsagesCreated((LocalFunctionSymbol)localFunc.Symbol)) 3287if (localFuncs[i] is { } localFunc) 4851var expressionNoConversion = expressionsNoConversions[i]; 4852var expression = GetConversionIfApplicable(expressions[i], expressionNoConversion); 4853expressionTypes[i] = VisitConversion(expression, expressionNoConversion, conversions[i], inferredType, expressionTypes[i], checkConversion: true, 4865_ = VisitConversion(conversionOpt: null, conversionOperand: expressionsNoConversions[i], Conversion.Identity, targetTypeWithNullability: inferredType, operandType: expressionTypes[i], 4949var (returnExpr, resultType, _) = returns[i]; 4967Conversion conversion = conversionsWithoutNullability.ClassifyConversionFromExpression(placeholder, bestType, isChecked: returns[i].isChecked, ref discardedUseSiteInfo); 4968resultTypes[i] = walker.VisitConversion(conversionOpt: null, placeholder, conversion, bestTypeWithObliviousAnnotation, resultTypes[i].ToTypeWithState(), 9798AddPlaceholderReplacement(placeholder, expression: null, previousArgumentConversionResults[placeholder.ArgumentIndex + newExtensionFormOffset]); 10715placeholderArgs.Add(new BoundExpressionWithNullability(variables[i].Expression.Syntax, variables[i].Expression, NullableAnnotation.Oblivious, conversion.DeconstructionInfo.OutputPlaceholders[i].Type)); 10744var variable = variables[i]; 10764var variable = variables[i]; 10786var variable = variables[i];

FlowAnalysis\NullableWalker.Variables.cs (3)

291slot = _variableBySlot[index].ContainingSlot; 316return variables!._variableBySlot[index]; 335var variable = variableBySlot[index];

FlowAnalysis\NullableWalker_Patterns.cs (3)

1001var nodeForSyntax = expressions[i]; 1004resultTypes[i] = ConvertConditionalOperandOrSwitchExpressionArmResult(arm.Value, nodeForSyntax, conversions[i], inferredTypeWithAnnotations, resultTypes[i], armState, armState.Reachable);

Lowering\LocalRewriter\LocalRewriter.cs (2)

766var stmt = statements[i]; 792BoundStatement? rewritten = statements[i];

Lowering\LocalRewriter\LocalRewriter_Call.cs (7)

865local = visitedArgumentsBuilder[argIndex] switch 874Debug.Assert(visitedArgumentsBuilder[argIndex] != null); 878var visitedArgument = visitedArgumentsBuilder[argIndex]; 1553if (tempStores[i].Left == argument) 1563var value = tempStores[correspondingStore].Right; 1582sideeffects[s] = tempStores[firstUnclaimedStore + s]; 1627RefKind argRefKind = argsRefKindsBuilder[argIndex];

Lowering\LocalRewriter\LocalRewriter_CollectionExpression.cs (2)

1240rewrittenExpressions[i] : 1287AddPlaceholderReplacement(collectionPlaceholder, rewrittenExpressions[i]);

Lowering\LocalRewriter\LocalRewriter_DeconstructionAssignmentOperator.cs (2)

234if (leftTargets[i].NestedVariables is { } nested) 246BoundExpression? leftTarget = leftTargets[i].Single;

Lowering\LocalRewriter\LocalRewriter_IfStatement.cs (2)

100Debug.Assert(builder[conditionalGotoIndex] is BoundConditionalGoto); 110builder[conditionalGotoIndex] = Instrumenter.InstrumentIfStatementConditionalGoto(node, builder[conditionalGotoIndex]);

Lowering\LocalRewriter\LocalRewriter_ObjectCreationExpression.cs (1)

225if (valueTemps[property.MemberIndexOpt!.Value] is BoundExpression initializerValue)

Lowering\LocalRewriter\LocalRewriter_StringConcat.cs (2)

183visitedArguments[i] = ConvertConcatExprToString(visitedArguments[i]); 473BoundExpression? arg = args[i];

Lowering\StateMachineRewriter\IteratorAndAsyncCaptureWalker.cs (1)

155var symbol = variableBySlot[i].Symbol;

Parser\LanguageParser_InterpolatedString.cs (1)

104var interpolation = interpolations[i];

Symbols\AbstractTypeMap.cs (1)

379result[mergeWith] = ConstraintsHelper.ConstraintWithMostSignificantNullability(result[mergeWith], substituted);

Symbols\AssemblySymbol.cs (4)

803var symbol = (NamedTypeSymbol?)GetTypeByReflectionType(nestedTypes[i].AsType()); 811int forcedArity = nestedTypes[i].GenericTypeParameters.Length - nestedTypes[i + 1].GenericTypeParameters.Length; 812MetadataTypeName mdName = MetadataTypeName.FromTypeName(nestedTypes[i].Name, forcedArity: forcedArity);

Symbols\Metadata\PE\NativeIntegerTypeDecoder.cs (1)

135TypeWithAnnotations oldTypeArgument = allTypeArguments[i];

Symbols\NamedTypeSymbol.cs (2)

952TypeWithAnnotations oldTypeArgument = allTypeArguments[i]; 985TypeWithAnnotations oldTypeArgument = allTypeArguments[i];

Symbols\Retargeting\RetargetingSymbolTranslator.cs (3)

603if (IsOrClosedOverAnExplicitLocalType(oldArguments[i].Type)) 616if (MetadataDecoder.IsOrClosedOverATypeFromAssemblies(oldArguments[i].Type, assembliesToEmbedTypesFrom)) 629if (MetadataDecoder.IsOrClosedOverATypeFromAssemblies(newArguments[i].Type, linkedAssemblies))

Symbols\Source\SourceAssemblySymbol.cs (2)

1085NamedTypeSymbol x = topLevelTypesFromModules[i]; 1086NamedTypeSymbol y = topLevelTypesFromModules[i + 1];

Symbols\Source\SourceMemberContainerSymbol.cs (3)

3426Debug.Assert(insertedInitializers[insertedInitializers.Count - 1].Syntax.SyntaxTree == declaredInitializers[0].Syntax.SyntaxTree); 3427Debug.Assert(insertedInitializers[insertedInitializers.Count - 1].Syntax.Span.Start < declaredInitializers[0].Syntax.Span.Start); 4386Symbol s = symbols[i];

Symbols\Source\SourceMethodSymbolWithAttributes.cs (2)

1126if (namespaceSegments[i] != thisNamespaceNames[i]) 1326if (namespaceSegments[i] != thisNamespaceNames[i])

Symbols\Source\SourceNamedTypeSymbol.cs (1)

540Debug.Assert(originalConstraintTypes[j].Equals(mergedConstraintTypes[j], TypeCompareKind.ObliviousNullableModifierMatchesAny));

Symbols\Source\SourceNamedTypeSymbol_Extension.cs (3)

178builder.Append(typeConstraintStrings[i]); 287TypeWithAnnotations typeArgument = typeArguments[i]; 841builder.Append(attributesBuilder[i]);

Symbols\Source\SourceOrdinaryMethodSymbol.cs (1)

1176if (name == result[i].Name)

Symbols\SubstitutedTypeParameterSymbol.cs (1)

109TypeWithAnnotations type = constraintTypes[i];

Symbols\Tuples\TupleTypeSymbol.cs (2)

732if (!elementsMatchedByFields[i]) 1025if (builder[index]?.IsDefaultTupleElement != false)

Symbols\TypeSymbol.cs (2)

1298(MultiDictionary<Symbol, Symbol>.ValueSet methodSet, MultiDictionary<NamedTypeSymbol, NamedTypeSymbol> bases) = implementations[i]; 1336if (bases.ContainsKey(implementations[i].MethodSet.First().ContainingType))

Symbols\TypeSymbolExtensions.cs (1)

1976var typeWithModifier = typeArgumentsBuilder[i];

Syntax\CSharpPragmaWarningStateMap.cs (1)

96var currentDirective = directiveList[index];

Syntax\SyntaxNormalizer.cs (2)

181: _indentations[i - 1].ToString() + _indentWhitespace; 185return _indentations[count];