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)

299var variable = variables[i]; 356var variable = variables[i]; 398var variable = variables[i]; 423Debug.Assert((object?)variables[i].Single!.Type != null); 487var variable = lhsVariables[i];

Binder\Binder_Expressions.cs (15)

1186string inferredName = inferredElementNames[i]; 1187if (elementNames[i] == null && inferredName != null) 1223var inferredName = inferredElementNames[i]; 3518BoundExpression argument = arguments[arg]; 3627Debug.Assert(arguments[arg].Kind is not 3631paramsArgsBuilder.Add(arguments[arg]); 3671paramsArgsBuilder[i], 3825Debug.Assert(handlerArgumentIndexesBuilder[handlerParameterIndex] is BoundInterpolatedStringArgumentPlaceholder.UnspecifiedParameter); 3907arguments[argumentIndex].Syntax.Location, 3935placeholderSyntax = arguments[argumentIndex].Syntax; 3936isSuppressed = arguments[argumentIndex].IsSuppressed; 5457var arg = arguments[i]; 5528var end = analyzedArguments.Arguments[analyzedArguments.Arguments.Count - 1].Syntax.Span.End; 8964MethodSymbol method = methodGroup.Methods[i]; 9968BoundExpression argument = arguments.Arguments[i];

Binder\Binder_Invocation.cs (10)

279BoundExpression argument = analyzedArguments.Arguments[i]; 303analyzedArguments.Arguments[i] = BindToNaturalType(analyzedArguments.Arguments[i], diagnostics); 520if (arguments.Names[i] != null) 526Error(diagnostics, ErrorCode.ERR_NamedArgumentSpecificationBeforeFixedArgumentInDynamicInvocation, arguments.Arguments[i].Syntax); 538builder[i] = builder[i] switch 906var arg = arguments[i]; 1025var result = overloadResolutionResult.ResultsBuilder[i]; 1554Debug.Assert(argumentsBuilder[i].IsParamsArrayOrCollection); 1796argument = argumentsBuilder[argumentIndex]; 2165var argument = newArguments[i];

Binder\Binder_Lookup.cs (5)

645symbols[i] = UnwrapAliasNoDiagnostics(symbols[i]); 656var srcSymbol = symbols[best.Index]; 657var mdSymbol = symbols[secondBest.Index]; 1283var sym = hiddenSymbols[i]; 1289var hidingSym = hidingSymbols[j];

Binder\Binder_Patterns.cs (2)

1817TypeSymbol candidate = candidates[i]; 1823TypeSymbol candidate = candidates[i];

Binder\Binder_Query.cs (2)

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

Binder\Binder_Symbols.cs (7)

2040symbols[i] = UnwrapAlias(symbols[i], diagnostics, where); 2051var srcSymbol = symbols[best.Index]; 2052var mdSymbol = symbols[secondBest.Index]; 2110var first = symbols[best.Index]; 2111var second = symbols[secondBest.Index]; 2407ReportUseSite(symbols[i], diagnostics, where); 2563var symbol = symbols[i];

Binder\DecisionDagBuilder.cs (8)

586tests.Add(MakeTestsAndBindings(outParamTemps[i], pattern, bindings)); 1043usedTemps.UnionWith(usedTempsPerState[stateToIndex[trueBranch]]); 1048usedTemps.UnionWith(usedTempsPerState[stateToIndex[falseBranch]]); 2084public T this[int i] => _arrayBuilder[i]; 2804AddTempReplacement(ref tempMap, oldOutParamTemps[i], newOutParamTemps[i]); 3593switch (remainingTests[i]) 3675switch (remainingTests[i])

Binder\DecisionDagBuilder_CheckOrReachability.cs (7)

391casesBuilder.Add(previousCases[i]); 448BoundPattern pattern = patterns[i]; 728OperandOrOperation operandOrOperation = _evalSequence[evalPosition]; 878var left = _evalSequence[endOfLeft]; 1181_evalSequence[startOfLeft] = _evalSequence[startOfLeft].MakeCompilerGenerated(); 1264_evalSequence[startOfLeft] = _evalSequence[startOfLeft].MakeCompilerGenerated(); 1376_evalSequence[startOfLeft] = _evalSequence[startOfLeft].MakeCompilerGenerated();

Binder\Imports.cs (1)

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

Binder\PatternExplainer.cs (2)

476var oldPattern = subpatterns[effectiveIndex]; 524var oldPattern = subpatterns[index];

Binder\RefSafetyAnalysis.cs (2)

1157var variable = variables[i]; 1187var 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)) 1024MethodSymbol op = operators[i].Method; 1132if (candidates[index].Kind != OperatorAnalysisResultKind.Inapplicable && index != bestIndex) 1134candidates[index] = candidates[index].Worse(); 1143if (candidates[i].Kind != OperatorAnalysisResultKind.Applicable) 1151if (candidates[j].Kind == OperatorAnalysisResultKind.Inapplicable) 1156var better = BetterOperator(candidates[i].Signature, candidates[j].Signature, left, right, ref useSiteInfo); 1159candidates[j] = candidates[j].Worse(); 1163candidates[i] = candidates[i].Worse(); 1178if (candidates[index].Kind != OperatorAnalysisResultKind.Applicable) 1190var better = BetterOperator(candidates[currentBestIndex].Signature, candidates[index].Signature, left, right, ref useSiteInfo); 1207if (candidates[index].Kind == OperatorAnalysisResultKind.Inapplicable) 1212var better = BetterOperator(candidates[currentBestIndex].Signature, candidates[index].Signature, left, right, ref useSiteInfo); 1516var candidate = operators[i];

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

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

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

157var candidate = operators[i]; 337if (candidates[index].Kind != OperatorAnalysisResultKind.Inapplicable && index != bestIndex) 339candidates[index] = candidates[index].Worse(); 348if (candidates[i].Kind != OperatorAnalysisResultKind.Applicable) 356if (candidates[j].Kind == OperatorAnalysisResultKind.Inapplicable) 361var better = BetterOperator(candidates[i].Signature, candidates[j].Signature, operand, ref useSiteInfo); 364candidates[j] = candidates[j].Worse(); 368candidates[i] = candidates[i].Worse(); 382if (candidates[index].Kind != OperatorAnalysisResultKind.Applicable) 394var better = BetterOperator(candidates[currentBestIndex].Signature, candidates[index].Signature, operand, ref useSiteInfo); 411if (candidates[index].Kind == OperatorAnalysisResultKind.Inapplicable) 416var better = BetterOperator(candidates[currentBestIndex].Signature, candidates[index].Signature, operand, ref useSiteInfo); 793if (SourceMemberContainerTypeSymbol.DoOperatorsPair(signature1.Method, operators2[i].Method)) 858MethodSymbol 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)

1958ExactInference(sourceTypeArguments[arg], targetTypeArguments[arg], ref useSiteInfo); 2403var typeParameter = typeParameters[arg]; 2404var sourceTypeArgument = sourceTypeArguments[arg]; 2405var targetTypeArgument = targetTypeArguments[arg]; 2753var typeParameter = typeParameters[arg]; 2754var sourceTypeArgument = sourceTypeArguments[arg]; 2755var 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)

786if (((DeclaredScope(i) == ScopedKind.None && parameterScopesBuilder[i] == ScopedKind.ScopedRef) || 787DeclaredScope(i) == ScopedKind.ScopedValue || parameterScopesBuilder[i] == ScopedKind.ScopedValue) && 795Debug.Assert(lambdaSymbol.Parameters[i].EffectiveScope == parameterScopesBuilder[i]);

CodeGen\CodeGenerator.cs (4)

262int yieldOffset = _builder.GetILOffsetFromMarker(yieldPoints[i]); 263int resumeOffset = _builder.GetILOffsetFromMarker(resumePoints[i]); 449var span = sequencePoints[i].Span; 550var temp = _expressionTemps[i];

CodeGen\Optimizer.cs (3)

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

Compilation\CSharpCompilation.cs (2)

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

Emitter\Model\MostCommonNullableValueBuilder.cs (1)

96if (builder[i] != b)

Emitter\Model\PEModuleBuilder.cs (1)

874stack.Push((groupingTypes[i], index));

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; 1000var id = variableBySlot[i]; 1005variableBySlot[slot].Symbol.GetTypeOrReturnType().TypeKind == TypeKind.Struct; 1279var fieldIdentifier = variableBySlot[fieldSlot]; 1643VariableIdentifier variable = variableBySlot[containingSlot]; 1679VariableIdentifier id = variableBySlot[slot]; 1703id = variableBySlot[slot]; 1715VariableIdentifier id = variableBySlot[slot]; 1737id = variableBySlot[slot]; 2799VariableIdentifier 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)

3285if (localFuncs[i] is { } localFunc && HasLocalFuncUsagesCreated((LocalFunctionSymbol)localFunc.Symbol)) 3305if (localFuncs[i] is { } localFunc) 5060var expressionNoConversion = expressionsNoConversions[i]; 5061var expression = GetConversionIfApplicable(expressions[i], expressionNoConversion); 5062expressionTypes[i] = VisitConversion(expression, expressionNoConversion, conversions[i], inferredType, expressionTypes[i], checkConversion: true, 5074_ = VisitConversion(conversionOpt: null, conversionOperand: expressionsNoConversions[i], Conversion.Identity, targetTypeWithNullability: inferredType, operandType: expressionTypes[i], 5158var (returnExpr, resultType, _) = returns[i]; 5176Conversion conversion = conversionsWithoutNullability.ClassifyConversionFromExpression(placeholder, bestType, isChecked: returns[i].isChecked, ref discardedUseSiteInfo); 5177resultTypes[i] = walker.VisitConversion(conversionOpt: null, placeholder, conversion, bestTypeWithObliviousAnnotation, resultTypes[i].ToTypeWithState(), 10105AddPlaceholderReplacement(placeholder, expression: null, previousArgumentConversionResults[placeholder.ArgumentIndex + extensionBlockFormOffset]); 11019placeholderArgs.Add(new BoundExpressionWithNullability(variables[i].Expression.Syntax, variables[i].Expression, NullableAnnotation.Oblivious, conversion.DeconstructionInfo.OutputPlaceholders[i].Type)); 11048var variable = variables[i]; 11068var variable = variables[i]; 11090var 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)

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

Lowering\LocalRewriter\LocalRewriter.cs (2)

775var stmt = statements[i]; 801BoundStatement? rewritten = statements[i];

Lowering\LocalRewriter\LocalRewriter_Call.cs (7)

887local = visitedArgumentsBuilder[argIndex] switch 896Debug.Assert(visitedArgumentsBuilder[argIndex] != null); 900var visitedArgument = visitedArgumentsBuilder[argIndex]; 1626if (tempStores[i].Left == argument) 1636var value = tempStores[correspondingStore].Right; 1655sideeffects[s] = tempStores[firstUnclaimedStore + s]; 1700RefKind argRefKind = argsRefKindsBuilder[argIndex];

Lowering\LocalRewriter\LocalRewriter_CollectionExpression.cs (2)

1408rewrittenExpressions[i] : 1455AddPlaceholderReplacement(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)

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

Lowering\LocalRewriter\LocalRewriter_StringConcat.cs (2)

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

Lowering\StateMachineRewriter\IteratorAndAsyncCaptureWalker.cs (1)

162var symbol = variableBySlot[i].Symbol;

Parser\LanguageParser_InterpolatedString.cs (1)

201var interpolation = interpolations[i];

Symbols\AbstractTypeMap.cs (1)

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

Symbols\AssemblySymbol.cs (4)

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

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

135TypeWithAnnotations oldTypeArgument = allTypeArguments[i];

Symbols\NamedTypeSymbol.cs (2)

1109TypeWithAnnotations oldTypeArgument = allTypeArguments[i]; 1142TypeWithAnnotations 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)

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

Symbols\Source\SourceMethodSymbolWithAttributes.cs (2)

1138if (namespaceSegments[i] != thisNamespaceNames[i]) 1338if (namespaceSegments[i] != thisNamespaceNames[i])

Symbols\Source\SourceNamedTypeSymbol.cs (1)

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

Symbols\Source\SourceNamedTypeSymbol_Extension.cs (3)

145builder.Append(typeConstraintStrings[i]); 254TypeWithAnnotations typeArgument = typeArguments[i]; 809builder.Append(attributesBuilder[i]);

Symbols\Source\SourceOrdinaryMethodSymbol.cs (1)

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

Symbols\SubstitutedTypeParameterSymbol.cs (1)

116TypeWithAnnotations type = constraintTypes[i];

Symbols\Tuples\TupleTypeSymbol.cs (2)

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

Symbols\TypeSymbol.cs (2)

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

Symbols\TypeSymbolExtensions.cs (1)

2004var typeWithModifier = typeArgumentsBuilder[i];

Syntax\CSharpPragmaWarningStateMap.cs (1)

96var currentDirective = directiveList[index];

Syntax\SyntaxNormalizer.cs (2)

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