Add

Binder\Binder.CapturedParametersFinder.cs (2)

173_captured.Add(parameter); 183_captured.Add(parameter);

Binder\Binder.cs (1)

Binder\Binder.QueryTranslationState.cs (1)

Binder\Binder.ValueChecks.cs (18)

462namesBuilder.Add(null); 466namesBuilder.Add((name, NoLocation.Singleton)); 2174argsToParamsBuilder.Add(0); 2177argsToParamsBuilder.Add(argsToParamsOpt[i] + 1); 2400escapeArguments.Add(tuple); 2404mixableArguments.Add(new MixableDestination(tuple.Parameter, receiver)); 2436mixableArguments.Add(new MixableDestination(parameter, argument)); 2450escapeArguments.Add(new EscapeArgument(parameter, argument, refKind)); 2533escapeArguments.Add(new EscapeArgument(parameter: null, argument, refKind, isArgList: true)); 2537mixableArguments.Add(new MixableDestination(argument, EscapeLevel.CallingMethod)); 2712escapeValues.Add(new EscapeValue(parameter: null, argument, EscapeLevel.ReturnOnly, isRefEscape: true)); 2717escapeValues.Add(new EscapeValue(parameter: null, argument, EscapeLevel.CallingMethod, isRefEscape: false)); 2725escapeValues.Add(new EscapeValue(parameter, argument, valEscapeLevel, isRefEscape: false)); 2732escapeValues.Add(new EscapeValue(parameter, argument, refEscapeLevel, isRefEscape: true)); 2788escapeValues.Add(new EscapeValue(parameter: null, argument, EscapeLevel.CallingMethod, isRefEscape: false)); 2796escapeValues.Add(new EscapeValue(parameter, argument, EscapeLevel.CallingMethod, isRefEscape: false)); 2801escapeValues.Add(new EscapeValue(parameter, argument, EscapeLevel.CallingMethod, isRefEscape: true)); 5857arguments.Add(call.Arguments[0]);

Binder\Binder_AnonymousTypes.cs (1)

126declarators.Add(new BoundAnonymousPropertyDeclaration(fieldSyntaxNodes[i], (PropertySymbol)symbol, field.Type));

Binder\Binder_Attributes.cs (4)

505boundNamedArgumentsBuilder.Add(boundNamedArgument); 774builder.Add(VisitExpression(argument, diagnostics, ref attrHasErrors, curArgumentHasErrors)); 796builder.Add(kv.Value); 882builder.Add(VisitCollectionExpressionElement(element, diagnostics, ref attrHasErrors, curArgumentHasErrors || element.HasAnyErrors));

Binder\Binder_Constraints.cs (4)

290constraintTypes.Add(type); 291syntaxBuilder!.Add(typeConstraintSyntax); 371builder.Add(GetDefaultTypeParameterConstraintClause(typeParameterSyntax)); 431constraintTypeBuilder.Add(constraintType);

Binder\Binder_Conversions.cs (6)

926builder.Add(convertedElement); 967builder.Add(convertedElement!); 1556resultBuilder.Add(member); 1741builder.Add(result); 2000builder.Add(newCase); 2506convertedArguments.Add(CreateConversion(argument.Syntax, argument, elementConversion, isCast: isCast, elementConversionGroup, destType.Type, diagnostics));

Binder\Binder_Crefs.cs (8)

347sortedSymbolsBuilder.Add(result.Symbol); 556builder.Add(this.GetSpecialType(memberName == "nint" ? SpecialType.System_IntPtr : SpecialType.System_UIntPtr, diagnostics, syntax).AsNativeInteger()); 867unwrappedSymbols.Add(UnwrapAliasNoDiagnostics(wrapped)); 924candidates.Add(constructedCandidate); 1018viable.Add(candidate); 1035viable.Add(candidate); 1084typeArgumentsWithAnnotations.Add(typeArgument); 1128parameterBuilder.Add(new SignatureOnlyParameterSymbol(TypeWithAnnotations.Create(type), ImmutableArray<CustomModifier>.Empty, isParamsArray: false, isParamsCollection: false, refKind: refKind));

Binder\Binder_Deconstruct.cs (15)

310nestedConversions.Add((operandPlaceholder, new BoundConversion(syntax, operandPlaceholder, nestedConversion, 330nestedConversions.Add((null, null)); 335nestedConversions.Add((operandPlaceholder, CreateConversion(syntax, operandPlaceholder, 518typesWithAnnotationsBuilder.Add(TypeWithAnnotations.Create(mergedType)); 519locationsBuilder.Add(element.Syntax.Location); 560namesBuilder.Add(null); 566namesBuilder.Add(ExtractDeconstructResultElementName(value)); 568valuesBuilder.Add(value); 569typesWithAnnotationsBuilder.Add(TypeWithAnnotations.Create(value.Type)); 570locationsBuilder.Add(variable.Syntax.Location); 646analyzedArguments.Arguments.Add(variable); 647analyzedArguments.RefKinds.Add(RefKind.Out); 648outVars.Add(variable); 785builder.Add(BindDeconstructionVariables(arg.Expression, diagnostics, ref declaration, ref expression)); 843builder.Add(BindDeconstructionVariables(declTypeWithAnnotations, n, n, diagnostics));

Binder\Binder_Expressions.cs (47)

340boundArgs.Add(BindToNaturalType(arg, diagnostics, reportNoTargetType)); 970builder.Add(BindDeclarationVariablesForErrorRecovery(declTypeWithAnnotations, n, n, diagnostics)); 971namesBuilder.Add(InferTupleElementName(n)); 1052boundArguments.Add(boundArgument); 1055elementTypesWithAnnotations.Add(elementTypeWithAnnotations); 1158builder.Add(true); 1162builder.Add(false); 3353result.RefKinds.Add(RefKind.None); 3360result.RefKinds.Add(refKind); 3374result.Names.Add(null); 3392result.Names.Add(null); 3395result.Arguments.Add(boundArgumentExpression); 3558paramsArgsBuilder.Add(arguments[arg]); 3866argumentPlaceholdersBuilder.Add( 3876argumentRefKindsBuilder.Add(refKind == RefKind.RefReadOnlyParameter ? RefKind.In : refKind); 4063sizes.Add(size); 4085sizes.Add(size); 4219exprBuilder.Add(boundExpression); 4251exprBuilder.Add(boundExpression); 4297initializers.Add(convertedExpression); 4325initializers.Add(init); 4547builder.Add(BindToTypeForErrorRecovery(BindExpression(size, BindingDiagnosticBag.Discarded))); 5270builder.Add(bindElement(element, diagnostics, this, nestingLevel)); 5612children.Add(boundInitializer); 5711initializers.Add(boundMemberInitializer); 6295initializerBuilder.Add(boundElementInitializer); 6396exprBuilder.Add(BindValue(childElementInitializer, diagnostics, BindValueKind.RValue)); 6633builder?.Add(constructor); 6911childNodes.Add(MakeBoundInitializerOpt(typeNode, type, initializerSyntaxOpt, initializerTypeOpt, diagnostics)); 8296if ((object)m != null) builder.Add(m); 8364extensionMethodArguments.Arguments.Add(receiver); 8373extensionMethodArguments.Names.Add(null); 8379extensionMethodArguments.RefKinds.Add(RefKind.None); 8394extensionPropertyArguments.Arguments.Add(receiver); 8812properties.Add(property); 9237methodOrPropertyGroup.Add(symbol); 9960indexerGroup.Add((PropertySymbol)symbol); 10386analyzedArguments.Arguments.Add(intPlaceholder); 10458analyzedArguments.Arguments.Add(startArgumentPlaceholder); 10459analyzedArguments.Arguments.Add(lengthArgumentPlaceholder); 10830methods.Add(m); 10886methods.Add(substituted); 10891methods.Add(reduced); 11038methods.Add(substituted); 11096methods.Add(substituted); 11250fieldsBuilder.Add( 11261fieldsBuilder.Add(new AnonymousTypeField(name: "", location, returnType, returnRefKind, ScopedKind.None));

Binder\Binder_Initializers.cs (3)

117boundInitializers.Add(boundInitializer); 132boundInitializers.Add(new BoundFieldEqualsValue(parameterSyntax, fieldSymbol, ImmutableArray<LocalSymbol>.Empty, 238boundInitializers.Add(boundInitializer);

Binder\Binder_InterpolatedString.cs (25)

140builder.Add(new BoundStringInsert(interpolation, value, alignment, format, isInterpolatedStringHandlerAppendCall: false)); 168builder.Add(new BoundLiteral(content, constantValue, stringType)); 376expressions.Add(null!); // format placeholder 403expressions.Add(value); // NOTE: must still be lowered 476partsArrayBuilder.Add(unconvertedInterpolatedString.Parts); 615partsArrayBuilder.Add(unconvertedInterpolatedString.Parts); 716refKindsBuilder.Add(RefKind.None); 717refKindsBuilder.Add(RefKind.None); 727refKindsBuilder.Add(RefKind.Out); 820argumentsBuilder.Add(new BoundLiteral(syntax, ConstantValue.Create(baseStringLength), intType) { WasCompilerGenerated = true }); 822argumentsBuilder.Add(new BoundLiteral(syntax, ConstantValue.Create(numFormatHoles), intType) { WasCompilerGenerated = true }); 878partsBuilder.Add(insert.Update(newValue, insert.Alignment, insert.Format, isInterpolatedStringHandlerAppendCall: false)); 882partsBuilder?.Add(part); 888partsBuilder?.Add(part); 929argumentsBuilder.Add(insert.Value); 930parameterNamesAndLocationsBuilder.Add(null); 938argumentsBuilder.Add(insert.Alignment); 939parameterNamesAndLocationsBuilder.Add(("alignment", insert.Alignment.Syntax.Location)); 944argumentsBuilder.Add(insert.Format); 945parameterNamesAndLocationsBuilder.Add(("format", insert.Format.Syntax.Location)); 955argumentsBuilder.Add(boundLiteral.Update(ConstantValue.Create(literalText), boundLiteral.Type)); 976builderAppendCalls.Add(call); 977positionInfo.Add((isLiteral, hasAlignment, hasFormat)); 1004builderAppendCallsArray.Add(builderAppendCalls.ToImmutableAndClear()); 1005positionInfoArray.Add(positionInfo.ToImmutableAndClear());

Binder\Binder_Invocation.cs (15)

57builder.Add(result.Member); 968resultWithSingleCandidate.ResultsBuilder.Add(methodResolutionResult); 1017finalCandidates.Add(result); 1606argumentsBuilder.Add(bindDefaultArgument(node, parameter, containingMember, enableCallerInfo, diagnostics, argumentsBuilder, argumentsCount, argsToParamsOpt)); 1610argumentRefKindsBuilder.Add(RefKind.None); 1613argsToParamsBuilder?.Add(parameter.Ordinal); 1616namesBuilder.Add(null); 1630argumentsBuilder.Add(collection); 1631argsToParamsBuilder?.Add(paramsIndex); 1635argumentRefKindsBuilder.Add(RefKind.None); 1640namesBuilder.Add(null); 2001constructedMethods.Add(constructedMethod); 2054parameterListList.Add(m.GetParametersIncludingExtensionParameter(skipExtensionIfStatic: false)); 2075parameterListList.Add(p.Parameters); 2456methodsBuilder.Add(funcPtr.Signature);

Binder\Binder_Lambda.cs (4)

204typesBuilder.Add(typeOpt); 205refKindsBuilder.Add(refKind); 206scopesBuilder.Add(scope); 268discardsBuilder.Add(p.Identifier.IsUnderscoreToken());

Binder\Binder_Lookup.cs (4)

220result.Add(resultOfThisMember); 243result.Add(resultOfThisMember); 1176result.Add(@interface); 1336hidingSymbols.Add(sym); // not hidden

Binder\Binder_Operators.cs (10)

440analyzedArguments.RefKinds.Add(RefKind.Ref); 441analyzedArguments.RefKinds.Add(RefKind.None); 445analyzedArguments.Arguments.Add(right); 2086builder.Add(method); 2232builder.Add(method); 3400analyzedArguments.RefKinds.Add(RefKind.Ref); 3651methods.Add(method); 3667methods.Add(method); 3713checkedMethods.Add(method); 3753methods.Add(op);

Binder\Binder_Patterns.cs (12)

237analyzedArguments.Arguments.Add(argumentPlaceholder); 283builder.Add(boundPattern); 386analyzedArguments.Arguments.Add(argumentPlaceholder); 1103patterns.Add(boundSubpattern); 1132patterns.Add(boundSubpattern); 1150patterns.Add(boundSubpattern); 1192patterns.Add(boundSubpattern); 1425subPatterns.Add(new BoundPositionalSubpattern(variable, symbol: null, pattern)); 1448subPatterns.Add(new BoundPositionalSubpattern(variable, symbol: null, pattern)); 1504builder.Add(new BoundPropertySubpattern(p, member, isLengthOrCount, boundPattern)); 1859narrowedTypeCandidates.Add(right.NarrowedType); 1873candidates.Add(pat.NarrowedType);

Binder\Binder_Statements.cs (4)

1146args.invalidDimensions.Add(size); 1901boundStatements.Add(boundStatement); 3244catchBlocks.Add(catchBlock); 3684boundStatements.Add(boundStatement);

Binder\Binder_Symbols.cs (6)

702types.Add(argumentType); 714locations.Add(nameToken.GetLocation()); 780elementNames.Add(name); 789elementNames.Add(null); 791elementNames.Add(name); 1351args.Add(BindTypeArgument(argSyntax, diagnostics, basesBeingResolved));

Binder\Binder_TupleOperators.cs (2)

61builder.Add(ApplyConvertedTypes(arguments[i], multiple.Operators[i], isRight, diagnostics)); 240operatorsBuilder.Add(BindTupleBinaryOperatorInfo(node, kind, leftParts[i], rightParts[i], diagnostics));

Binder\CatchClauseBinder.cs (1)

34locals.Add(SourceLocalSymbol.MakeLocal(this.ContainingMemberOrLambda, this, allowRefKind: false, allowScoped: false, declarationOpt.Type, declarationOpt.Identifier, LocalDeclarationKind.CatchVariable, initializer: null));

Binder\DecisionDagBuilder.cs (44)

Binder\DecisionDagBuilder_ListPatterns.cs (8)

29tests.Add(new Tests.One(new BoundDagTypeTest(list.Syntax, ErrorType(), input, hasErrors: true))); 43tests.Add(new Tests.One(lengthEvaluation)); 45tests.Add(new Tests.One(list.HasSlice 67tests.Add(new Tests.One(sliceEvaluation)); 69tests.Add(MakeTestsAndBindings(sliceTemp, slicePattern, bindings)); 82tests.Add(new Tests.One(indexEvaluation)); 84tests.Add(MakeTestsAndBindings(indexTemp, subpattern, bindings)); 90bindings.Add(new BoundPatternBinding(list.VariableAccess, input));

Binder\ExpressionVariableFinder.cs (6)

220_variablesBuilder.Add(variable); 246_variablesBuilder.Add(variable); 269_variablesBuilder.Add(variable); 281_variablesBuilder.Add(variable); 424_variablesBuilder.Add(variable); 507_variablesBuilder.Add(variable);

Binder\FixedStatementBinder.cs (1)

48locals.Add(MakeLocal(_syntax.Declaration, declarator, LocalDeclarationKind.FixedVariable, allowScoped: false));

Binder\ForEachLoopBinder.cs (3)

158locals.Add(localSymbol); 1433candidateMethods.Add((MethodSymbol)member); 1970argsBuilder.Add(extensionReceiverOpt);

Binder\ForLoopBinder.cs (1)

49locals.Add(localSymbol);

Binder\ImportChain.cs (5)

70usedNamespaces.Add(Cci.UsedNamespaceOrType.CreateExternAlias(alias.Alias.Name)); 84usedNamespaces.Add(Cci.UsedNamespaceOrType.CreateNamespace(ns.GetCciAdapter(), assemblyRef)); 90usedNamespaces.Add(Cci.UsedNamespaceOrType.CreateType(typeRef)); 114usedNamespaces.Add(Cci.UsedNamespaceOrType.CreateNamespace(ns.GetCciAdapter(), assemblyRef, alias)); 122usedNamespaces.Add(Cci.UsedNamespaceOrType.CreateType(typeRef, alias));

Binder\Imports.cs (3)

105expandedUsingsBuilder.Add(previousUsing); 110expandedUsingsBuilder.Add(new NamespaceOrTypeAndUsingDirective(expandedNamespace, previousUsing.UsingDirective, dependencies: default)); 132nameParts.Add(curr.Name);

Binder\LocalScopeBinder.cs (3)

217locals.Add(localSymbol); 327locals.Add(localSymbol); 373labels.Add(labelSymbol);

Binder\LookupResult.cs (2)

220_symbolList.Add(other.Symbol); 292_symbolList.Add(result.Symbol);

Binder\PatternExplainer.cs (3)

76result.Add(n); 272constraintBuilder.Add((test, sense)); 283evaluationBuilder.Add(e.Evaluation);

Binder\RefSafetyAnalysis.cs (7)

745placeholders.Add((interpolationData.ReceiverPlaceholder, _localScopeDepth)); 786placeholders.Add((placeholder, valEscapeScope)); 960placeholders.Add((placeholder, valEscapeScope)); 1011placeholders.Add((conversion.DeconstructionInfo.InputPlaceholder, GetValEscape(right, _localScopeDepth))); 1026placeholders.Add((arg, valEscape)); 1076builder.Add(getDeconstructionAssignmentVariable(arg)); 1149placeholders.Add((targetPlaceholder, collectionEscape));

Binder\Semantics\AccessCheck.cs (1)

665baseInterfaces.Add(definition);

Binder\Semantics\BestTypeInferrer.cs (2)

148candidateTypes.Add(type1); 163candidateTypes.Add(type2);

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

1119builder.Add(analysis.Operator);

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

215builder.Add(elementConversion); 441analyzedArguments.Arguments.Add(new BoundParameter(syntax, parameter) { WasCompilerGenerated = true }); 442analyzedArguments.RefKinds.Add(parameter.RefKind);

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

1204innerConversions.Add(nestedConversion); 2352argumentConversions.Add(result); 2425nestedConversions.Add(conversion);

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

105result.Add((iface, typeParameter)); 121result.Add((namedType, null)); 135result.Add((t, null));

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

255operators.Add(op2); 329u.Add(UserDefinedConversionAnalysis.Lifted(constrainedToTypeOpt, op, liftedFromConversion, liftedToConversion, nullableFrom, nullableTo)); 361u.Add(UserDefinedConversionAnalysis.Normal(constrainedToTypeOpt, op, fromConversion, toConversion, convertsFrom, convertsTo));

Binder\Semantics\Conversions\UserDefinedImplicitConversions.cs (2)

328u.Add(UserDefinedConversionAnalysis.Normal(constrainedToTypeOpt, op, fromConversion, toConversion, convertsFrom, convertsTo)); 356u.Add(UserDefinedConversionAnalysis.Lifted(constrainedToTypeOpt, op, liftedFromConversion, liftedToConversion, nullableFrom, nullableTo));

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

320result.Results.Add(BinaryOperatorAnalysisResult.Applicable(signature, leftConversion, rightConversion));

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

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

118result.Results.Add(UnaryOperatorAnalysisResult.Applicable(signature, conversion.Value));

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

131operators.Add(op); 512operators.Add(pointerOperator.Value); 529results.Add(UnaryOperatorAnalysisResult.Applicable(op, conversion)); 533results.Add(UnaryOperatorAnalysisResult.Inapplicable(op, conversion)); 565operators.Add(new UnaryOperatorSignature(kind | UnaryOperatorKind.Enum, enumType, enumType)); 566operators.Add(new UnaryOperatorSignature(kind | UnaryOperatorKind.Lifted | UnaryOperatorKind.Enum, nullableEnum, nullableEnum)); 801operators.Add(new UnaryOperatorSignature(UnaryOperatorKind.UserDefined | kind, operandType, resultType, op, constrainedToTypeOpt)); 833operators.Add(new UnaryOperatorSignature(

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

70builder.Add(Name(i));

Binder\Semantics\OverloadResolution\MethodGroup.cs (2)

37this.Methods.Add(method); 55this.Methods.Add(method);

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

3342builder.Add(fixedResult.Type); 3366builder.Add(value);

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

252unreducedMethods.Add(method.ReducedFrom ?? method); 301applicableMethods.Add(methods[index]); 913builder.Add(member); 939results.Add(new MemberResolutionResult<MethodSymbol>(constructor, constructor, MemberAnalysisResult.UnsupportedMetadata(), hasTypeArgumentInferredFromFunctionType: false)); 961results.Add(new MemberResolutionResult<MethodSymbol>(constructor, constructor, result, hasTypeArgumentInferredFromFunctionType: false)); 1158results.Add(new MemberResolutionResult<TMember>(member, leastOverriddenMember, MemberAnalysisResult.UnsupportedMetadata(), hasTypeArgumentInferredFromFunctionType: false)); 1219results.Add(result); 1889inapplicableMembers.Add(result); 3424_returns.Add(node); 3917types.Add(parameter.TypeWithAnnotations); 3927refs.Add(paramRefKind); 3932refs.Add(paramRefKind); 4065types.Add(paramsIterationType); 4069types.Add(type); 4075refs.Add(paramRefKind); 4636conversions.Add(conversion); 4642conversions.Add(conversion);

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

141result.Add(res.Member);

Binder\SwitchBinder.cs (1)

236labels.Add(new SourceLabelSymbol((MethodSymbol)this.ContainingMemberOrLambda, labelSyntax, boundLabelConstantOpt));

Binder\SwitchBinder_Patterns.cs (5)

128labelBuilder.Add(newLabel); 131sectionBuilder.Add(oldSection.Update(oldSection.Locals, labelBuilder.ToImmutableAndFree(), oldSection.Statements)); 171boundSwitchSectionsBuilder.Add(section); 196boundLabelsBuilder.Add(boundLabel); 208boundStatementsBuilder.Add(boundStatement);

Binder\SwitchExpressionBinder.cs (2)

148typesInOrder.Add(type); 184builder.Add(boundArm);

Binder\UsingStatementBinder.cs (1)

58locals.Add(MakeLocal(declarationSyntax, declarator, LocalDeclarationKind.UsingVariable, allowScoped: true));

BoundTree\BoundExpressionExtensions.cs (4)

178symbols.Add(delegateCreation.MethodOpt); 190symbols.Add(s); 199symbols.Add(ctor); 233symbols.Add(symbol);

BoundTree\BoundTreeRewriter.cs (3)

52newList.Add((T)visited); 185builder.Add(newSymbol); 189builder.Add(symbol);

BoundTree\Constructors.cs (1)

240builder.Add(refKind == RefKind.RefReadOnlyParameter ? RefKind.In : refKind);

BoundTree\LengthBasedStringSwitchData.cs (4)

158lengthCaseLabels.Add((stringLength, labelForLength)); 195charCaseLabels.Add((character, label)); 199charJumpTables.Add(charJumpTable); 257stringJumpTables.Add(stringJumpTable);

BoundTree\NullabilityRewriter.cs (1)

292builder.Add(updatedSymbol);

BoundTree\UnboundLambda.cs (7)

222types.Add((returnStatement.ExpressionOpt!, type, returnStatement.Checked)); 380_builder.Add((node, TypeWithAnnotations.Create(type))); 707parameterRefKindsBuilder.Add(refKind); 708parameterScopesBuilder.Add(scope); 709parameterTypesBuilder.Add(type); 1132refKindsBuilder.Add(p.RefKind); 1133typesBuilder.Add(p.TypeWithAnnotations);

CodeGen\CodeGenerator.cs (3)

254yieldPointBuilder.Add(yieldOffset); 255resumePointBuilder.Add(resumeOffset); 521exprTemps.Add(temp);

CodeGen\EmitStatement.cs (3)

152_asyncYieldPoints.Add(_builder.AllocateILMarker()); 158_asyncResumePoints.Add(_builder.AllocateILMarker()); 1990casesBuilder.Add((value, GetLabelClone(label)));

CodeGen\Optimizer.cs (10)

103dummies.Add(locInfo); 139defs.Add(def); 221defs.Add(newDef); 542_evalStack.Add((result, context)); 736rewrittenSideeffects.Add(rewrittenSideeffect); 1296rewrittenArguments.Add(rewrittenArg); 1788rewrittenInitializers.Add(rewrittenInitializer); 1937defs.Add(nextDef); 1959locInfo.LocalDefs.Add(locDef); 1989locInfo.LocalDefs.Add(locDef);

CommandLine\CSharpCommandLineParser.cs (8)

496instrumentationKinds.Add(instrumentationKind); 1746builder.Add(sdkDirectoryOpt); 1804defines.Add(id); 2093ids.Add(errorCode); 2096ids.Add(CSharp.MessageProvider.Instance.GetIdForErrorCode((int)ErrorCode.WRN_MissingNonNullTypesContextForAnnotation)); 2097ids.Add(CSharp.MessageProvider.Instance.GetIdForErrorCode((int)ErrorCode.WRN_MissingNonNullTypesContextForAnnotationInGeneratedCode)); 2106ids.Add(CSharp.MessageProvider.Instance.GetIdForErrorCode(number)); 2114ids.Add(id);

Compilation\BuiltInOperators.cs (5)

44builder.Add(GetSignature((UnaryOperatorKind)kind)); 255operators.Add(op); 297builder.Add(GetSignature((BinaryOperatorKind)kind)); 686operators.Add(op); 699operators.Add(utfConcatenation);

Compilation\CSharpCompilation.cs (13)

1336assemblies.Add(referenceManager.ReferencedAssemblies[i]); 1510builder.Add(referenceManager.ReferencedAssemblies[i].GlobalNamespace); 1595boundUsings.Add(previousUsing); 1992entryPointCandidates.Add(simpleProgramEntryPointSymbol); 2032taskEntryPoints.Add((IsCandidate, candidate, perCandidateBag)); 2045viableEntryPoints.Add(candidate); 2060viableEntryPoints.Add(Candidate); 2188entryPointCandidates.Add(method); 3942builder.Add((byte)b); 4196typesBuilder.Add(TypeWithAnnotations.Create(elementType, annotation)); 4264fields.Add(new AnonymousTypeField(name, location, TypeWithAnnotations.Create(type, nullableAnnotation), RefKind.None, ScopedKind.None)); 4958spine.Add(current); 4979spine.Add(current);

Compilation\CSharpCompilation.UsingsFromOptionsAndDiagnostics.cs (1)

63boundUsings.Add(new NamespaceOrTypeAndUsingDirective(imported, null, dependencies: directiveDiagnostics.DependenciesBag.ToImmutableArray()));

Compilation\CSharpCompilerDiagnosticAnalyzer.cs (1)

31builder.Add((int)errorCode);

Compilation\CSharpSemanticModel.cs (15)

1675results.Add(reduced.GetPublicSymbol()); 1683results.Add(compatibleSubstitutedMember.GetPublicSymbol()); 1709results.Add(RemapSymbolIfNecessary(uniqueSymbol).GetPublicSymbol()); 1767results.Add(RemapSymbolIfNecessary(singleSymbol).GetPublicSymbol()); 1773results.Add(RemapSymbolIfNecessary(symbol).GetPublicSymbol()); 1781results.Add(RemapSymbolIfNecessary(symbol).GetPublicSymbol()); 2012builder.Add(s); 3630if (query.Operation != null && (object)query.Operation.ExpressionSymbol != null) builder.Add(query.Operation.ExpressionSymbol); 3631if ((object)query.DefinedSymbol != null) builder.Add(query.DefinedSymbol); 3632if (query.Cast != null && (object)query.Cast.ExpressionSymbol != null) builder.Add(query.Cast.ExpressionSymbol); 4159builder.Add(indexer); 4543symbols.Add(param.GetPublicSymbol()); 4701members.Add(member); 4702filteredMembers.Add(substitutedMember); 5423builder.Add(new SimpleImportScope(

Compilation\SymbolInfoFactory.cs (1)

57result.Add(symbol.GetPublicSymbol());

Compilation\SyntaxAndDeclarationManager.cs (5)

181treesBuilder.Add(tree); 282loadDirectives.Add(new LoadDirective(resolvedFilePath, diagnostics.ToReadOnlyAndFree())); 528treesBuilder.Add(tree); 642builder.Add(new WeakReference<StrongBox<ImmutableSegmentedHashSet<string>>>(singleType.MemberNames)); 711treesBuilder.Add(tree);

Compilation\SyntaxTreeSemanticModel.cs (1)

2020builder.Add(field);

Compiler\AnonymousTypeMethodBodySynthesizer.cs (1)

136fields.Add(prop.BackingField);

Compiler\DocumentationCommentCompiler.cs (2)

503result.Add(elementSyntax); 751builder.Add(trivia);

Compiler\DocumentationCommentCompiler.DocumentationCommentWalker.cs (1)

212_includeElementNodes.Add((CSharpSyntaxNode)node);

Compiler\MethodBodySynthesizer.cs (5)

62statements.Add(baseConstructorCall); 70statements.Add(loweredBody); 102statements.Add(new BoundExpressionStatement(syntax, 119statements.Add( 147statements.Add(

Compiler\MethodBodySynthesizer.Lowered.cs (1)

462argBuilder.Add(F.Parameter(param));

Compiler\MethodCompiler.cs (5)

1268initializers.Add(factory.Assignment(factory.Field(factory.This(), field), factory.Parameter(parameter))); 1786awaiters.Add(null); 1798hoistedVariables.Add(new EncHoistedLocalInfo(true)); 1811awaiters.Add(null); 1817hoistedVariables.Add(new EncHoistedLocalInfo(true));

Compiler\TypeCompilationState.cs (1)

140_synthesizedMethods.Add(new MethodWithBody(method, body, CurrentImportChain));

CSharpCompilationOptions.cs (10)

CSharpParseOptions.cs (6)

224singleNamespaceBuilder.Add(@namespace.Slice(currentIndex, dotIndex - currentIndex).ToString()); 227singleNamespaceBuilder.Add(@namespace.Slice(currentIndex).ToString()); 231namespacesBuilder.Add(singleNamespaceBuilder.ToImmutable()); 254builder.Add(Diagnostic.Create(MessageProvider.Instance, (int)ErrorCode.ERR_BadLanguageVersion, LanguageVersion.ToString())); 263builder.Add(Diagnostic.Create(MessageProvider.Instance, (int)ErrorCode.ERR_InvalidPreprocessingSymbol, "null")); 267builder.Add(Diagnostic.Create(MessageProvider.Instance, (int)ErrorCode.ERR_InvalidPreprocessingSymbol, symbol));

Declarations\DeclarationTable.cs (1)

131builder.Add(_latestLazyRootDeclaration.Value);

Declarations\DeclarationTreeBuilder.cs (7)

154childrenBuilder.Add(namespaceOrType); 200childrenBuilder.Add(CreateSimpleProgram(firstGlobalStatement, hasAwaitExpressions, isIterator, hasReturnWithExpression, diagnostics)); 211childrenBuilder.Add(CreateImplicitClass(memberNames, container, declFlags)); 282rootChildren.Add(decl); 286scriptChildren.Add((SingleTypeDeclaration)decl); 294rootChildren.Add( 316directives.Add(new ReferenceDirective(directiveNode.File.ValueText, new SourceLocation(directiveNode)));

Declarations\MergedNamespaceDeclaration.cs (11)

72builder.Add(loc); 114types.Add(asType); 132namespaces.Add(asNamespace); 154children.Add(MergedNamespaceDeclaration.Create(namespaces.ToImmutableAndFree())); 168builder.Add(n); 175children.Add(MergedNamespaceDeclaration.Create(namespaceGroup.ToImmutableAndFree())); 187children.Add(new MergedTypeDeclaration(types.ToImmutableAndFree())); 207builder.Add((SingleTypeDeclaration)existingValue); 211builder.Add(t); 223children.Add(new MergedTypeDeclaration([t])); 228children.Add(new MergedTypeDeclaration(builder.ToImmutableAndFree()));

Declarations\MergedTypeDeclaration.cs (3)

98attributeSyntaxListBuilder.Add(attributesSyntaxList); 217nestedTypes.Add(asType); 231children.Add(new MergedTypeDeclaration(typeGroup));

DocumentationComments\SourceDocumentationCommentUtils.cs (1)

91builder.Add((DocumentationCommentTriviaSyntax)trivia.GetStructure());

Emitter\EditAndContinue\CSharpSymbolMatcher.cs (4)

424otherParamRefCustomModifiersBuilder.Add(VisitCustomModifiers(param.RefCustomModifiers)); 425otherParamsBuilder.Add(param.TypeWithAnnotations.WithTypeAndModifiers(otherType, VisitCustomModifiers(param.TypeWithAnnotations.CustomModifiers))); 934translatedParamsBuilder.Add(param.TypeWithAnnotations.WithTypeAndModifiers(translatedParamType, VisitCustomModifiers(param.TypeWithAnnotations.CustomModifiers))); 935translatedParamRefCustomModifiersBuilder.Add(VisitCustomModifiers(param.RefCustomModifiers));

Emitter\EditAndContinue\PEDeltaAssemblyBuilder.cs (1)

219builder.Add(new AnonymousTypeKeyField(fieldName, isKey: false, ignoreCase: false));

Emitter\Model\AttributeDataAdapter.cs (2)

31builder.Add(CreateMetadataExpression(argument, context)); 67builder.Add(CreateMetadataNamedArgument(namedArgument.Key, namedArgument.Value, context));

Emitter\Model\GenericTypeInstanceReference.cs (1)

44builder.Add(moduleBeingBuilt.Translate(type.Type, syntaxNodeOpt: (CSharpSyntaxNode)context.SyntaxNode, diagnostics: context.Diagnostics));

Emitter\Model\NamedTypeSymbolAdapter.cs (2)

888builder.Add(arg); 995builder.Add(@interface);

Emitter\Model\PEAssemblyBuilder.cs (4)

100builder.Add(_lazyEmbeddedAttribute); 136builder.Add((Cci.IFileReference)Translate(modules[i], context.Diagnostics)); 146builder.Add(resource); 183builder.Add(new Cci.ManagedResource(

Emitter\Model\PEModuleBuilder.cs (4)

275debugDocuments.Add(debugDocument); 593builder.Add(new Cci.ExportedType((Cci.ITypeReference)symbol.GetCciAdapter(), parentIndex, isForwarder: false)); 786builder.Add(new Cci.ExportedType(type.GetCciAdapter(), parentIndex, isForwarder: true)); 1408builder.Add(CreateParameterTypeInformationWrapper(param));

Emitter\Model\SpecializedGenericNestedTypeInstanceReference.cs (1)

43builder.Add(moduleBeingBuilt.Translate(type.Type, syntaxNodeOpt: (CSharpSyntaxNode)context.SyntaxNode, diagnostics: context.Diagnostics));

Emitter\Model\SynthesizedPrivateImplementationDetailsStaticConstructor.cs (3)

56body.Add(payloadInitialization); 61body.Add( 74body.Add(returnStatement);

Errors\LazyMissingNonNullTypesContextDiagnosticInfo.cs (2)

70infos.Add(info); 78infos.Add(new CSDiagnosticInfo(code));

FlowAnalysis\AbstractFlowPass.cs (1)

2721arg.parts.Add(interpolatedString);

FlowAnalysis\AbstractFlowPass.PendingBranchesCollection.cs (2)

91_unlabeledBranches.Add(branch); 96branches.Add(branch);

FlowAnalysis\ControlFlowPass.cs (1)

406_usingDeclarations.Add((local, node));

FlowAnalysis\DefiniteAssignment.cs (2)

279variableBySlot.Add(identifier); 655builder.Add(field);

FlowAnalysis\ExitPointsWalker.cs (9)

72if (IsInside) _labelsInside.Add(node.Label); 80_labelsInside.Add(node.BreakLabel); 81_labelsInside.Add(node.ContinueLabel); 90_labelsInside.Add(node.BreakLabel); 91_labelsInside.Add(node.ContinueLabel); 100_labelsInside.Add(node.BreakLabel); 101_labelsInside.Add(node.ContinueLabel); 110_labelsInside.Add(node.BreakLabel); 150_branchesOutOf.Add((StatementSyntax)pending.Branch.Syntax);

FlowAnalysis\FlowAnalysisPass.cs (4)

128builder.Add( 141builder.Add( 150builder.Add( 174builder.Add(AppendImplicitReturn((BoundBlock)statements[n - 1], method));

FlowAnalysis\NullableWalker.cs (32)

3086_returnTypesOpt.Add((node, result.ToTypeWithAnnotations(compilation))); 3239localFuncs.Add(localFunc); 3863resultBuilder.Add(_visitResult); 3905elementConversionCompletions.Add((_, targetCollectionType) => 3973elementConversionCompletions.Add((elementType, _) => completion(elementType)); 4611builder.Add( 4823expressionsNoConversions.Add(expressionNoConversion); 4824conversions.Add(conversion); 4827expressionTypes.Add(expressionType); 4831placeholderBuilder.Add(CreatePlaceholderIfNecessary(expressionNoConversion, expressionType.ToTypeWithAnnotations(compilation))); 4950resultTypes.Add(resultType); 4951placeholdersBuilder.Add(CreatePlaceholderIfNecessary(returnExpr, resultType)); 4997builder.Add(child); 5660slotBuilder.Add(slot); 6718builder.Add(0); 6721builder.Add(argsToParamsOpt[i] + 1); 7350notNullParametersBuilder?.Add(parameter); 7696resultsBuilder.Add(result); 7700resultsBuilder.Add(VisitArgumentEvaluate(arguments[i], GetRefKind(refKindsOpt, i), parameterAnnotationsOpt.IsDefault ? default : parameterAnnotationsOpt[i])); 7855conversionResultsBuilder?.Add(_visitResult); 7876conversionResultsBuilder?.Add(result); 7879conversionResultsBuilder?.Add(result); 8219argumentsBuilder.Add(argument); 8220conversionsBuilder.Add(conversion); 8401builder.Add(getArgumentForMethodTypeInference(arguments[i], visitArgumentResult)); 8432elementsBuilder.Add(getArgumentForMethodTypeInference(elementNoConversion, collectionExpressionVisitResults[i])); 8436elementsBuilder.Add(collection.Elements[i]); 10329arguments.Add(CreatePlaceholderIfNecessary(receiverOpt, receiverType.ToTypeWithAnnotations(compilation))); 10337arguments.Add(new BoundExpressionWithNullability(syntax, new BoundParameter(syntax, parameter), parameterType.NullableAnnotation, parameterType.Type)); 10712placeholderArgs.Add(CreatePlaceholderIfNecessary(right, rightResult.ToTypeWithAnnotations(compilation))); 10715placeholderArgs.Add(new BoundExpressionWithNullability(variables[i].Expression.Syntax, variables[i].Expression, NullableAnnotation.Oblivious, conversion.DeconstructionInfo.OutputPlaceholders[i].Type)); 10889builder.Add(getDeconstructionAssignmentVariable(argument));

FlowAnalysis\NullableWalker.Variables.cs (2)

280_variableBySlot.Add(identifier); 338builder.Add((variable, ConstructSlot(id, index)));

FlowAnalysis\NullableWalker_Patterns.cs (4)

935expressions.Add(expression); 936conversions.Add(conversion); 938resultTypes.Add(armType); 944placeholderBuilder.Add(CreatePlaceholderIfNecessary(expression, armType.ToTypeWithAnnotations(compilation)));

Lowering\AsyncRewriter\AsyncExceptionHandlerRewriter.cs (20)

222statements.Add(_F.HiddenSequencePoint()); 224locals.Add(pendingExceptionLocal); 225statements.Add(_F.Assignment(_F.Local(pendingExceptionLocal), _F.Default(pendingExceptionLocal.Type))); 226locals.Add(pendingBranchVar); 227statements.Add(_F.Assignment(_F.Local(pendingBranchVar), _F.Default(pendingBranchVar.Type))); 232locals.Add(returnLocal); 235statements.Add(catchAndPendException); 236statements.Add(syntheticFinally); 287bodyStatements.Add(_F.Label(proxy)); 290bodyStatements.Add(_F.Assignment(_F.Local(pendingBranchVar), _F.Literal(i))); 293bodyStatements.Add(_F.Goto(finallyLabel)); 316cases.Add(caseStatement); 354cases.Add(caseStatement); 491handlers.Add(_F.SwitchSection( 613prologueBuilder.Add(_F.ExpressionStatement(storePending)); 616prologueBuilder.Add(_F.ExpressionStatement(AssignCatchSource((BoundExpression)this.Visit(sourceOpt), currentAwaitCatchFrame))); 621prologueBuilder.Add(rewrittenPrologue); 641handlerStatements.Add(_F.HiddenSequencePoint()); 649handlerStatements.Add(_F.ExpressionStatement(assignSource)); 653handlerStatements.Add((BoundStatement)this.Visit(node.Body));

Lowering\AsyncRewriter\AsyncIteratorMethodToStateMachineRewriter.cs (12)

172builder.Add( 188builder.Add(GenerateClearCurrent()); 191builder.Add(GenerateCompleteOnBuilder()); 194builder.Add(F.ExpressionStatement(F.Call( 282blockBuilder.Add( 286blockBuilder.Add( 290blockBuilder.Add( 294blockBuilder.Add( 298blockBuilder.Add(F.HiddenSequencePoint()); 300blockBuilder.Add( 305blockBuilder.Add( 309blockBuilder.Add(

Lowering\AsyncRewriter\AsyncMethodToStateMachineRewriter.cs (34)

151bodyBuilder.Add(F.HiddenSequencePoint()); 152bodyBuilder.Add(F.Assignment(F.Local(cachedState), F.Field(F.This(), stateField))); 153bodyBuilder.Add(CacheThisIfNeeded()); 156bodyBuilder.Add( 169bodyBuilder.Add(F.Label(_exprReturnLabel)); 177bodyBuilder.Add(stateDone); 181bodyBuilder.Add(F.SequencePointWithSpan(block, block.CloseBraceToken.Span, stateDone)); 182bodyBuilder.Add(F.HiddenSequencePoint()); 186bodyBuilder.Add(GenerateCleanupForExit(rootScopeHoistedLocals)); 188bodyBuilder.Add(GenerateSetResultCall()); 191bodyBuilder.Add(F.Label(_exitLabel)); 192bodyBuilder.Add(F.Return()); 197locals.Add(cachedState); 198if ((object)cachedThis != null) locals.Add(cachedThis); 199if ((object)_exprRetValue != null) locals.Add(_exprRetValue); 285builder.Add(F.Assignment(F.Field(F.This(), hoistedLocal), F.NullOrDefault(hoistedLocal.Type))); 406statementsBuilder.Add(preamble); 408statementsBuilder.Add(awaitIfIncomplete); 409statementsBuilder.Add(getResultStatement); 479blockBuilder.Add( 483blockBuilder.Add( 487blockBuilder.Add( 495blockBuilder.Add(awaiterTemp.Type.IsDynamic() 499blockBuilder.Add( 507blockBuilder.Add(F.Label(dummyResumeLabel)); 511blockBuilder.Add( 514blockBuilder.Add( 518blockBuilder.Add( 527blockBuilder.Add( 530blockBuilder.Add( 566blockBuilder.Add( 574blockBuilder.Add(F.Assignment(F.Local(thisTemp), F.This())); 577blockBuilder.Add( 607blockBuilder.Add(

Lowering\AsyncRewriter\AsyncRewriter.AsyncIteratorRewriter.cs (12)

164bodyBuilder.Add(F.BaseInitialization()); 167bodyBuilder.Add(GenerateCreateAndAssignBuilder()); 169bodyBuilder.Add(F.Assignment(F.InstanceField(stateField), F.Parameter(F.CurrentFunction.Parameters[0]))); // this.state = state; 175bodyBuilder.Add(F.Assignment(F.InstanceField(initialThreadIdField), managedThreadId)); 182bodyBuilder.Add(F.Assignment(F.InstanceField(instanceIdField), F.Call(receiver: null, getId))); 185bodyBuilder.Add(F.Return()); 204bodyBuilder.Add( 267bodyBuilder.Add(GenerateParameterStorage(stateMachineVariable, proxies)); 270bodyBuilder.Add( 669builder.Add( 673builder.Add( 677builder.Add(

Lowering\AsyncRewriter\AsyncRewriter.cs (7)

207bodyBuilder.Add( 229bodyBuilder.Add( 236bodyBuilder.Add(GenerateParameterStorage(stateMachineVariable, proxies)); 239bodyBuilder.Add( 248bodyBuilder.Add( 260bodyBuilder.Add( 267bodyBuilder.Add(method.IsAsyncReturningVoid()

Lowering\AsyncRewriter\AsyncStateMachine.cs (6)

42interfaces.Add(compilation.GetWellKnownType(WellKnownType.System_Collections_Generic_IAsyncEnumerable_T).Construct(elementType)); 46interfaces.Add(compilation.GetWellKnownType(WellKnownType.System_Collections_Generic_IAsyncEnumerator_T).Construct(elementType)); 49interfaces.Add(compilation.GetWellKnownType(WellKnownType.System_Threading_Tasks_Sources_IValueTaskSource_T).Construct(compilation.GetSpecialType(SpecialType.System_Boolean))); 52interfaces.Add(compilation.GetWellKnownType(WellKnownType.System_Threading_Tasks_Sources_IValueTaskSource)); 55interfaces.Add(compilation.GetWellKnownType(WellKnownType.System_IAsyncDisposable)); 58interfaces.Add(compilation.GetWellKnownType(WellKnownType.System_Runtime_CompilerServices_IAsyncStateMachine));

Lowering\BoundTreeToDifferentEnclosingContextRewriter.cs (1)

50newLocals.Add(newLocal);

Lowering\ClosureConversion\ClosureConversion.Analysis.cs (3)

349closure.CapturedEnvironments.Add(env); 504closure.CapturedEnvironments.Add(targetEnv); 559closureDebugInfo.Add(new EncClosureInfo(new ClosureDebugInfo(syntaxOffset, closureId), parentClosureId, structCaptures));

Lowering\ClosureConversion\ClosureConversion.Analysis.Tree.cs (5)

524_labelsInScope.Peek().Add(node.Label); 576_currentScope.NestedFunctions.Add(new NestedFunction(functionSymbol, blockSyntax: null)); 583_currentScope.NestedFunctions.Add(function); 736_scopesAfterLabel[label].Add(scope); 748parentScope.NestedScopes.Add(newScope);

Lowering\ClosureConversion\ClosureConversion.cs (20)

305_addedStatements.Add(body); 492environments.Add(env.SynthesizedEnvironment); 646result.Add(stmt); 650result.Add(new BoundExpressionStatement(node.Syntax, (BoundExpression)(BoundNode)node)); 684prologue.Add(new BoundAssignmentOperator(syntax, 701prologue.Add(assignment); 727addedLocals.Add(framePointer); 817prologue.Add(assignToProxy); 915argumentsBuilder.Add(frame); 1009builder.Add(newTypeArg); 1146if (replacement != null) prologue.Add(replacement); 1177newStatements.Add(BoundSequencePoint.CreateHidden()); 1187newStatements.Add(replacement); 1263prologueBuilder.Add(new BoundExpressionStatement(p.Syntax, p) { WasCompilerGenerated = true }); 1320newStatements.Add((BoundStatement)this.Visit(s)); 1505_lambdaRuntimeRudeEditsBuilder.Add(new LambdaRuntimeRudeEditInfo(previousLambdaId, rudeEdit.Value)); 1510_lambdaDebugInfoBuilder.Add(new EncLambdaInfo(new LambdaDebugInfo(syntaxOffset, lambdaId, closureOrdinal), structClosureIds)); 1614_synthesizedMethods.Add( 1724_addedLocals.Add(cacheLocal); 1727_addedStatements.Add(F.Assignment(cache, F.Null(type)));

Lowering\ClosureConversion\ExpressionLambdaRewriter.cs (10)

320builder.Add(index); 331builder.Add(Visit(arg)); 842locals.Add(param); 844parameters.Add(parameterReference); 848initializers.Add(_bound.AssignmentExpression(parameterReference, parameter)); 963builder.Add(_bound.StaticCall(sym.Kind is SymbolKind.Property ? 972builder.Add(_bound.StaticCall(sym.Kind is SymbolKind.Property ? 981builder.Add(_bound.StaticCall(sym.Kind is SymbolKind.Property ? 1011builder.Add(elementInit); 1070membersBuilder.Add(_bound.MethodInfo(AnonymousTypeManager.GetAnonymousTypeProperty(anonType, i).GetMethod, _bound.WellKnownType(WellKnownType.System_Reflection_MethodInfo)));

Lowering\ClosureConversion\SynthesizedClosureEnvironment.cs (3)

76internal void AddHoistedField(LambdaCapturedVariable captured) => _membersBuilder.Add(captured); 117builder.Add(StaticConstructor); 118builder.Add(SingletonCache);

Lowering\ClosureConversion\SynthesizedClosureMethod.cs (1)

93constructedStructClosures.Add(constructed);

Lowering\InitializerRewriter.cs (2)

60boundStatements.Add(RewriteInitializersAsStatements(initializer)); 68boundStatements.Add(new BoundReturnStatement(lastStatement.Syntax, RefKind.None, trailingExpression, @checked: false));

Lowering\Instrumentation\CodeCoverageInstrumenter.cs (6)

199fileIndices.Add(methodBodyFactory.SourceDocumentIndex(document)); 302prologueStatements.Add(payloadInitialization); 303prologueStatements.Add(payloadIf); 306prologueStatements.Add(_methodEntryInstrumentation); 311prologueStatements.Add(previousPrologue); 507_spansBuilder.Add(new SourceSpan(

Lowering\Instrumentation\LocalStateTracingInstrumenter.cs (5)

315prologueBuilder.Add(_factory.ExpressionStatement(_factory.Call(receiver: _factory.Local(_scope.ContextVariable), parameterLogger, 322prologueBuilder.Add(previousPrologue); 568builder.Add(store); 572builder.Add(invocation); 595builder.Add(_factory.Call(

Lowering\IteratorRewriter\IteratorMethodToStateMachineRewriter.cs (8)

436bodyStatements.Add(F.Assignment(F.Field(F.This(), stateField), F.Literal(frame.finalizeState))); 437bodyStatements.Add(rewrittenBody); 438bodyStatements.Add(F.ExpressionStatement(F.Call(F.This(), finallyMethod))); 444bodyStatements.Add(F.Goto(dropThrough)); 453bodyStatements.Add(F.Label(proxy)); 456bodyStatements.Add(F.ExpressionStatement(F.Call(F.This(), finallyMethod))); 460bodyStatements.Add(F.Goto(parentProxy)); 463bodyStatements.Add(F.Label(dropThrough));

Lowering\IteratorRewriter\IteratorRewriter.cs (8)

281bodyBuilder.Add(F.BaseInitialization()); 282bodyBuilder.Add(F.Assignment(F.Field(F.This(), stateField), F.Parameter(F.CurrentFunction.Parameters[0]))); // this.state = state; 287bodyBuilder.Add(F.Assignment(F.Field(F.This(), initialThreadIdField), managedThreadId)); 293bodyBuilder.Add(F.Assignment(F.InstanceField(instanceIdField), F.Call(receiver: null, getId))); 296bodyBuilder.Add(F.Return()); 306bodyBuilder.Add( 316bodyBuilder.Add(GenerateParameterStorage(stateMachineVariable, proxies)); 319bodyBuilder.Add(

Lowering\IteratorRewriter\IteratorStateMachine.cs (5)

34interfaces.Add(ContainingAssembly.GetSpecialType(SpecialType.System_Collections_Generic_IEnumerable_T).Construct(ElementType.Type)); 35interfaces.Add(ContainingAssembly.GetSpecialType(SpecialType.System_Collections_IEnumerable)); 38interfaces.Add(ContainingAssembly.GetSpecialType(SpecialType.System_Collections_Generic_IEnumerator_T).Construct(ElementType.Type)); 39interfaces.Add(ContainingAssembly.GetSpecialType(SpecialType.System_IDisposable)); 40interfaces.Add(ContainingAssembly.GetSpecialType(SpecialType.System_Collections_IEnumerator));

Lowering\LocalRewriter\LocalRewriter.cs (2)

753statements.Add(RewriteFieldOrPropertyInitializer(initializer)); 757statements.Add(VisitStatement(initializer));

Lowering\LocalRewriter\LocalRewriter.DecisionDagRewriter.cs (39)

Lowering\LocalRewriter\LocalRewriter.PatternLocalRewriter.cs (4)

102_temps.Add(temp); 168refKindBuilder.Add(refKind); 169argBuilder.Add(expression); 633newArguments.Add(_tempAllocator.GetTemp(temp));

Lowering\LocalRewriter\LocalRewriter_BasePatternSwitchLocalRewriter.cs (1)

53armBuilder.Add(_factory.HiddenSequencePoint());

Lowering\LocalRewriter\LocalRewriter_BinaryOperator.cs (2)

1514sideeffects.Add(tempAssignment); 1515locals.Add(tempAccess.LocalSymbol);

Lowering\LocalRewriter\LocalRewriter_Block.cs (2)

48builder.Add(epilogue); 84builder.Add(statement);

Lowering\LocalRewriter\LocalRewriter_Call.cs (14)

312temps.Add(receiverTemp.LocalSymbol); 714tempsOpt.Add(receiverTemp.LocalSymbol); 739visitedArgumentsBuilder.Add(_factory.MakeTempForDiscard(discard, tempsOpt)); 752visitedArgumentsBuilder.Add(i == 0 && firstRewrittenArgument is not null 794storesOpt.Add(extraRefInitialization); 797storesOpt.Add(assignmentToTemp); 880tempsOpt.Add(local.LocalSymbol); 943temps.Add(cache.LocalSymbol); 949temps.Add(intermediateRef.LocalSymbol); 1288elementsBuilder.Add(replacement); 1292elementsBuilder.Add(replacement); 1401storesToTemps.Add(assignment); 1481temporariesBuilder.Add(((BoundLocal)s.Left).LocalSymbol); 1660temporariesBuilder.Add(boundTemp.LocalSymbol);

Lowering\LocalRewriter\LocalRewriter_CollectionExpression.cs (32)

Lowering\LocalRewriter\LocalRewriter_CompoundAssignmentOperator.cs (30)

Lowering\LocalRewriter\LocalRewriter_Conversion.cs (4)

148builder.Add(_factory.Literal(b)); 154builder.Add(_factory.Literal((byte)0)); 172stack.Add(node); 973fieldAccessorsBuilder.Add(convertedFieldAccess);

Lowering\LocalRewriter\LocalRewriter_DeconstructionAssignmentOperator.cs (13)

254effects.assignments.Add(MakeAssignmentOperator(resultPart.Syntax, leftTarget, resultPart, 259builder?.Add(resultPart!); 350effects.Add(assignmentToTemp); 351temps.Add(savedTuple.LocalSymbol); 365builder.Add(fieldAccess); 395temps.Add(localSymbol); 397outLocals.Add(localBound); 400effects.Add(VisitExpression(deconstruction.Invocation)); 428temps.Add(temp.LocalSymbol); 429effects.Add(store); 452assignmentTargets.Add(new Binder.DeconstructionVariable(variable, variable.Syntax)); 458assignmentTargets.Add(new Binder.DeconstructionVariable(GetAssignmentTargetsAndSideEffects(tuple, temps, effects), tuple.Syntax)); 465assignmentTargets.Add(new Binder.DeconstructionVariable(temp, variable.Syntax));

Lowering\LocalRewriter\LocalRewriter_Event.cs (2)

184if (clearCall != null) sideEffects.Add(clearCall); 185if (tempAssignment != null) sideEffects.Add(tempAssignment);

Lowering\LocalRewriter\LocalRewriter_FixedStatement.cs (4)

32statementBuilder.Add(InitializeFixedStatementLocal(localDecl, _factory, out pinnedTemp)); 33localBuilder.Add(pinnedTemp); 50statementBuilder.Add(rewrittenBody); 51statementBuilder.Add(_factory.HiddenSequencePoint());

Lowering\LocalRewriter\LocalRewriter_ForEachStatement.cs (1)

172builder.Add(firstRewrittenArgument);

Lowering\LocalRewriter\LocalRewriter_ForStatement.cs (18)

Lowering\LocalRewriter\LocalRewriter_IfStatement.cs (14)

56builder.Add(new BoundConditionalGoto(rewrittenCondition.Syntax, rewrittenCondition, false, afterif)); 57builder.Add(rewrittenConsequence); 78builder.Add(new BoundConditionalGoto(rewrittenCondition.Syntax, rewrittenCondition, false, alt)); 79builder.Add(rewrittenConsequence); 80builder.Add(BoundSequencePoint.CreateHidden()); 82builder.Add(new BoundGotoStatement(syntax, afterif)); 83builder.Add(new BoundLabelStatement(syntax, alt)); 87builder.Add(rewrittenAlternative); 104builder.Add(BoundSequencePoint.CreateHidden()); 105builder.Add(new BoundLabelStatement(syntax, afterif)); 137builder.Add(new BoundConditionalGoto(rewrittenCondition.Syntax, rewrittenCondition, false, afterif)); 138builder.Add(rewrittenConsequence); 139builder.Add(BoundSequencePoint.CreateHidden()); 140builder.Add(new BoundLabelStatement(syntax, afterif));

Lowering\LocalRewriter\LocalRewriter_IndexerAccess.cs (35)

Lowering\LocalRewriter\LocalRewriter_IsPatternOperator.cs (13)

Lowering\LocalRewriter\LocalRewriter_Literal.cs (10)

Lowering\LocalRewriter\LocalRewriter_MultipleLocalDeclarations.cs (1)

39inits.Add((BoundStatement)init);

Lowering\LocalRewriter\LocalRewriter_NullCoalescingAssignmentOperator.cs (4)

110stores.Add(store); 111temps.Add(lhsTemp.LocalSymbol); 119stores.Add(getValueOrDefaultStore); 120temps.Add(tmp.LocalSymbol);

Lowering\LocalRewriter\LocalRewriter_ObjectCreationExpression.cs (7)

168temps.Add(oldValue.LocalSymbol); 169sideEffects.Add(boundAssignmentToTemp); 214temps.Add(valueTemp.LocalSymbol); 215sideEffects.Add(boundAssignmentToTemp); 227builder.Add(initializerValue); 232builder.Add(_factory.Property(oldValue, property)); 277sideEffects.Add(boundAssignmentToTemp);

Lowering\LocalRewriter\LocalRewriter_ObjectOrCollectionInitializerExpression.cs (25)

108result.Add( 152result.Add(rewrittenInitializer); 378dynamicSiteInitializers.Add(setMember.SiteInitialization); 379result.Add(setMember.SiteInvocation); 390dynamicSiteInitializers.Add(getMember.SiteInitialization); 401result.Add(MakeStaticAssignmentOperator(assignment.Syntax, rewrittenAccess, rewrittenRight, isRef: assignment.IsRef, used: false)); 422dynamicSiteInitializers.Add(setMember.SiteInitialization); 423result.Add(setMember.SiteInvocation); 429dynamicSiteInitializers.Add(getMember.SiteInitialization); 458temps.Add(rangeTemp.LocalSymbol); 459result.Add(rangeStore); 473result.Add(MakeStaticAssignmentOperator(assignment.Syntax, rewrittenAccess, rewrittenRight, false, used: false)); 495temps.Add(temp.LocalSymbol); 496result.Add(store); 506result.Add(MakeStaticAssignmentOperator(assignment.Syntax, rewrittenAccess, rewrittenRight, false, used: false)); 540result.Add(MakeStaticAssignmentOperator(assignment.Syntax, rewrittenAccess, rewrittenRight, isRef: false, used: false)); 581result.Add(VisitExpression(element)); 586result.Add(VisitExpression(argument)); 592result.Add(VisitExpression(implicitIndexerAccess.Argument)); 598result.Add(VisitExpression(index)); 603result.Add(VisitExpression(pointerElementAccess.Index)); 659newArgs.Add(replacement); 663newArgs.Add(arg); 681temps.Add(temp.LocalSymbol); 682sideeffects.Add(store);

Lowering\LocalRewriter\LocalRewriter_PatternSwitchStatement.cs (10)

90result.Add(_factory.ExpressionStatement(instrumentedExpression)); 109result.Add(_factory.NoOp(NoOpStatementFlavor.Default)); 111result.Add(_factory.HiddenSequencePoint()); 120outerVariables.Add(_whenNodeIdentifierLocal); 124result.Add(_factory.Block(loweredDag)); 137sectionBuilder.Add(_factory.Label(switchLabel.Label)); 149result.Add(_factory.StatementList(statements)); 159result.Add(new BoundScope(section.Syntax, section.Locals, statements)); 171result.Add(_factory.HiddenSequencePoint()); 173result.Add(_factory.Label(node.BreakLabel));

Lowering\LocalRewriter\LocalRewriter_StackAlloc.cs (2)

82sideEffects.Add(tempAssignment); 83locals.Add(tempAccess.LocalSymbol);

Lowering\LocalRewriter\LocalRewriter_StringConcat.cs (3)

224destinationArguments.Add(visitedCompoundAssignmentLeftRead); 333finalArguments.Add(argument); 479localsBuilder.Add(temp.LocalSymbol);

Lowering\LocalRewriter\LocalRewriter_StringInterpolation.cs (4)

76resultExpressions.Add((BoundExpression)VisitCall(call)); 80resultExpressions.Add(VisitDynamicInvocation(dynamicInvocation, resultDiscarded: !usesBoolReturns)); 121resultExpressions.Add(handlerConstructionAssignment); 122resultExpressions.Add(currentExpression);

Lowering\LocalRewriter\LocalRewriter_SwitchExpression.cs (17)

68outerVariables.Add(_whenNodeIdentifierLocal); 74result.Add(new BoundSavePreviousSequencePoint(syntax, restorePointForEnclosingStatement)); 79result.Add(new BoundStepThroughSequencePoint(node.Syntax, span: spanForSwitchBody)); 80result.Add(new BoundSavePreviousSequencePoint(syntax, restorePointForSwitchBody)); 84result.Add(_factory.Block(loweredDag)); 96sectionBuilder.Add(_factory.Label(arm.Label)); 101sectionBuilder.Add(_factory.Assignment(_factory.Local(resultTemp), loweredValue)); 102sectionBuilder.Add(_factory.Goto(afterSwitchExpression)); 106result.Add(_factory.StatementList(statements)); 116result.Add(new BoundScope(arm.Syntax, arm.Locals, statements)); 123result.Add(_factory.Label(defaultLabel)); 125result.Add(new BoundRestorePreviousSequencePoint(node.Syntax, restorePointForSwitchBody)); 135result.Add(throwCall); 139result.Add(_factory.HiddenSequencePoint()); 140result.Add(_factory.Label(afterSwitchExpression)); 142result.Add(new BoundRestorePreviousSequencePoint(node.Syntax, restorePointForEnclosingStatement)); 144outerVariables.Add(resultTemp);

Lowering\LocalRewriter\LocalRewriter_TupleBinaryOperator.cs (6)

80builder.Add(newArgument); 122fieldAccessorsBuilder.Add(convertedFieldAccess); 157builder.Add(newArgument); 419effects.Add(assignmentToTemp); 420temps.Add(temp.LocalSymbol); 452argumentBuilder.Add(MakeBoundConversion(GetTuplePart(operand, i), underlyingConversions[i], types[i], conv));

Lowering\LocalRewriter\LocalRewriter_UnaryOperator.cs (14)

Lowering\MethodToClassRewriter.cs (1)

148visitedTypeArgs.Add(typeArg.WithTypeAndModifiers(VisitType(typeArg.Type), typeArg.CustomModifiers));

Lowering\SpillSequenceSpiller.cs (5)

129_locals.Add(local); 147_statements.Add(statement); 641result.Add(replacement); 650result.Add(lastSpillNode.Value); 654result.Add(newList[i]);

Lowering\StateMachineRewriter\MethodToStateMachineRewriter.cs (11)

229_stateDebugInfoBuilder.Add(new StateMachineStateDebugInfo(syntaxOffset, awaitId, state)); 338hoistedLocalsWithDebugScopes.Add(((CapturedToStateMachineFieldReplacement)proxy).HoistedField); 441cleanup.Add(F.AssignmentExpression(F.Field(F.This(), field), F.NullOrDefault(field.Type))); 487_fieldsForCleanup.Add(createdField); 505fields.Add(field); 599indices.Add(HoistExpression(index, awaitSyntaxOpt, syntaxOffset, RefKind.None, sideEffects, hoistedFields, ref needsSacrificialEvaluation)); 713_fieldsForCleanup.Add(hoistedField); 720hoistedFields.Add(hoistedField); 723sideEffects.Add(F.AssignmentExpression(replacement, expr)); 770newLocalsBuilder.Add(localToUse); 775hoistedLocalsWithDebugScopes.Add(((CapturedToStateMachineFieldReplacement)proxies[local]).HoistedField);

Lowering\StateMachineRewriter\StateMachineRewriter.cs (12)

226nonReusableFieldsForCleanupBuilder.Add(field); 299bodyBuilder.Add(GenerateStateMachineCreation(stateMachineVariable, frameType, proxies)); 323bodyBuilder.Add(F.Assignment(leftExpression, F.This())); 337bodyBuilder.Add(F.Assignment(leftExpression, F.Parameter(parameter))); 440thenBuilder.Add( 447thenBuilder.Add( 461bodyBuilder.Add(makeIterator); 479bodyBuilder.Add(F.Assignment(leftExpression, rightExpression)); 483bodyBuilder.Add(F.Label(thisInitialized)); 500bodyBuilder.Add(copy); 504bodyBuilder.Add(F.Return(F.Local(resultVariable))); 514builder.Add(

Lowering\StateMachineRewriter\StateMachineTypeSymbol.cs (1)

73builder.Add(attribute);

Lowering\StateMachineRewriter\SynthesizedStateMachineMethod.cs (1)

92builder.Add(attribute);

Lowering\SynthesizedMethodBaseSymbol.cs (2)

122builder.Add(SynthesizedParameterSymbol.Create( 139builder.Add(SynthesizedParameterSymbol.Create(this, this.TypeMap.SubstituteType(extra), ordinal++, RefKind.Ref));

Lowering\SyntheticBoundNodeFactory.cs (17)

883builder.Add(ArgumentRefKindFromParameterRefKind(refKind, useStrictArgumentRefKinds)); 964statements.Add(ConditionalGoto(condition, alt, false)); 965statements.Add(thenClause); 966statements.Add(Goto(afterif)); 971statements.Add(firstPart); 974statements.Add(Label(alt)); 975statements.Add(elseClauseOpt); 979statements.Add(ConditionalGoto(condition, afterif, false)); 980statements.Add(thenClause); 985statements.Add(firstPart); 989statements.Add(Label(afterif)); 1021builder.Add(parts[i]); 1096statements.Add(null!); // placeholder at statements[0] for the dispatch 1100statements.Add(Label(sectionLabel)); 1105caseBuilder.Add((ConstantValue.Create(value), sectionLabel)); 1109statements.Add(Label(breakLabel)); 1732temps.Add(temp);

Operations\CSharpOperationFactory.cs (6)

390builder.Add(operation); 411builder.Add((IVariableDeclaratorOperation)CreateVariableDeclaratorInternal(decl, decl.Syntax)); 2282builder.Add((IInterpolatedStringContentOperation)Create(part)); 2286builder.Add(CreateBoundInterpolatedStringTextOperation((BoundLiteral)part)); 2361builder.Add(new InterpolatedStringTextOperation(valueOperation, _semanticModel, part.Syntax, isImplicit)); 2371builder.Add(new InterpolationOperation(valueOperation, alignmentOperation, formatOperation, _semanticModel, part.Syntax, isImplicit));

Operations\CSharpOperationFactory_Methods.cs (5)

314argumentsBuilder.Add(operationFactory.CreateArgumentOperation(argumentKind, parameters[i].GetPublicSymbol(), arguments[i])); 323argumentsBuilder.Add(operationFactory.CreateArgumentOperation(argumentKind, null, arguments[i])); 380argumentsInEvaluationBuilder.Add(operationFactory.CreateArgumentOperation(kind, parameter.GetPublicSymbol(), argument)); 397builder.Add(receiverOpt); 468builder.Add(assignment);

Parser\LanguageParser_InterpolatedString.cs (1)

484builder.Add(sd.WithOffset(sd.Offset + offset));

Parser\Lexer_StringLiteral.cs (2)

870interpolations?.Add(new Interpolation( 934interpolations?.Add(new Interpolation(

src\Compilers\CSharp\CSharpAnalyzerDriver\CSharpDeclarationComputer.cs (16)

SymbolDisplay\SymbolDisplay.cs (1)

276builder.Add(new SymbolDisplayPart(SymbolDisplayPartKind.MethodName, symbol, "<top-level-statements-entry-point>"));

SymbolDisplay\SymbolDisplayVisitor.cs (17)

SymbolDisplay\SymbolDisplayVisitor.Members.cs (26)

SymbolDisplay\SymbolDisplayVisitor.Types.cs (20)

SymbolDisplay\SymbolDisplayVisitor_Constants.cs (1)

61this.Builder.Add(CreatePart(kind, null, valueString));

SymbolDisplay\SymbolDisplayVisitor_Minimal.cs (2)

40builder.Add(CreatePart(SymbolDisplayPartKind.AliasName, alias, aliasName)); 114Builder.Add(CreatePart(SymbolDisplayPartKind.NamespaceName, symbol, symbol.Name));

Symbols\AbstractTypeMap.cs (8)

74newTypeArguments.Add(newArgument); 150builder.Add(customModifiers[i].IsOptional ? CSharpCustomModifier.CreateOptional(substituted) : CSharpCustomModifier.CreateRequired(substituted)); 158builder.Add(customModifiers[i].IsOptional ? CSharpCustomModifier.CreateOptional(substituted) : CSharpCustomModifier.CreateRequired(substituted)); 162builder.Add(customModifiers[i]); 258builder.Add(substituted); 331result.Add(SubstituteType(t)); 359result.Add(substituteConstraintType(type)); 375result.Add(substituted);

Symbols\AnonymousTypes\AnonymousTypeManager.Templates.cs (5)

211typeArgumentsBuilder.Add(((ArrayTypeSymbol)field.Type).ElementTypeWithAnnotations); 215typeArgumentsBuilder.Add(field.TypeWithAnnotations); 615builder.Add(template); 633builder.Add(template); 655builder.Add(template);

Symbols\AnonymousTypes\PublicSymbols\AnonymousType.DelegatePublicSymbol.cs (1)

61parameters.Add(

Symbols\AnonymousTypes\PublicSymbols\AnonymousType.TypePublicSymbol.cs (4)

46members.Add(property); 47members.Add(property.GetMethod); 53members.Add(new AnonymousTypeConstructorSymbol(this, properties)); 96builder.Add(symbol);

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.ConstructorSymbol.cs (1)

33paramsArr.Add(SynthesizedParameterSymbol.Create(this, property.TypeWithAnnotations, index, RefKind.None, property.Name));

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.DelegateTemplateSymbol.cs (6)

60parameters.Add( 81typeParameters.Add(new AnonymousTypeManager.AnonymousTypeParameterSymbol(containingType, i, "T" + (i + 1), 87typeParameters.Add(new AnonymousTypeManager.AnonymousTypeParameterSymbol(containingType, parameterCount, "TResult", allowsRefLikeType: allowRefLikeTypes)); 141parameters.Add( 180typeParameters.Add(new AnonymousTypeParameterSymbol(this, i, "T" + (i + 1), 202parameters.Add(

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.TemplateSymbol.cs (7)

60typeParametersBuilder.Add(typeParameter); 64propertiesBuilder.Add(property); 67membersBuilder.Add(property); 68membersBuilder.Add(property.BackingField); 69membersBuilder.Add(property.GetMethod); 76membersBuilder.Add(new AnonymousTypeConstructorSymbol(this, this.Properties)); 132builder.Add(symbol);

Symbols\ArrayTypeSymbol.cs (2)

116constructedInterfaces.Add(new ConstructedNamedTypeSymbol(iListOfT, ImmutableArray.Create(elementTypeWithAnnotations))); 123constructedInterfaces.Add(new ConstructedNamedTypeSymbol(iReadOnlyListOfT, ImmutableArray.Create(elementTypeWithAnnotations)));

Symbols\AssemblySymbol.cs (2)

793nestedTypes.Add(currentTypeInfo); 880typeArgumentSymbols.Add(TypeWithAnnotations.Create(argSymbol));

Symbols\Attributes\AttributeData.cs (2)

276builder.Add(memberName); 327builder.Add(memberName);

Symbols\Compilation_UsedAssemblies.cs (1)

56builder.Add(reference);

Symbols\Compilation_WellKnownMembers.cs (9)

429builder.Add(new KeyValuePair<string, TypedConstant>( 924transformFlagsBuilder.Add(false); 945transformFlagsBuilder.Add(true); 954transformFlagsBuilder.Add(false); 963transformFlagsBuilder.Add(false); 988transformFlagsBuilder.Add(false); 1002transformFlagsBuilder.Add(false); 1021transformFlagsBuilder.Add(false); 1055builder.Add(type.IsNativeIntegerWrapperType);

Symbols\ConstraintsHelper.cs (27)

Symbols\Extensions\SourceExtensionImplementationMethodSymbol.cs (2)

129parameters.Add(new ExtensionMetadataMethodParameterSymbol(this, ((SourceNamedTypeSymbol)_originalMethod.ContainingType).ExtensionParameter!)); 134parameters.Add(new ExtensionMetadataMethodParameterSymbol(this, parameter));

Symbols\FunctionPointers\FunctionPointerMethodSymbol.cs (9)

178customModifiers.Add(modifier); 195customModifiers.Add(modifier); 294modifiersBuilder.Add(modifier); 372paramMergedTypesBuilder.Add(mergedParameterType); 412paramTypesBuilder.Add(transformedType); 467paramsBuilder.Add(new FunctionPointerParameterSymbol( 570paramsBuilder.Add(new FunctionPointerParameterSymbol(paramType, paramRefKind, i, parent, paramRefCustomMods)); 614paramTypesBuilder.Add(newParamType); 659builder.Add(modifier.ModifierSymbol);

Symbols\MergedNamespaceSymbol.cs (3)

145namespaceSymbols.Add((NamespaceSymbol)childSymbol); 149otherSymbols.Add(childSymbol); 156otherSymbols.Add(MergedNamespaceSymbol.Create(_extent, this, namespaceSymbols.ToImmutableAndFree()));

Symbols\Metadata\PE\DynamicTypeDecoder.cs (2)

289transformedTypeArgsBuilder.Add(typeArg.WithTypeAndModifiers(transformedTypeArg, typeArg.CustomModifiers)); 375paramsBuilder.Add(transformedParamType);

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

194builder.Add(transformedParam);

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

400builder.Add(@event);

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

1386explicitInterfaceImplementationsBuilder.Add(method);

Symbols\Metadata\PE\PEModuleSymbol.cs (2)

279moduleAssemblyAttributesBuilder.Add(new PEAttributeData(this, customAttributeHandle)); 399customAttributesBuilder.Add(new PEAttributeData(this, customAttributeHandle));

Symbols\Metadata\PE\PENamedTypeSymbol.cs (14)

791symbols.Add(namedTypeSymbol); 1131fieldDefs.Add(fieldDef); 1148builder.Add(new PEFieldSymbol(moduleSymbol, this, fieldDef)); 1217eventFields.Add(associatedField); 1254result.Add(field); 1311methodDefs.Add(methodDef); 1520members.Add(field); 1528members.Add(syntheticCtor); 1577members.Add(field); 1661members.Add(member); 2232fieldMembers.Add(symbol); 2271members.Add(method); 2300members.Add(PEPropertySymbol.Create(moduleSymbol, this, propertyDef, getMethod, setMethod)); 2335members.Add(new PEEventSymbol(moduleSymbol, this, eventRid, addMethod, removeMethod, privateFieldNameToSymbols));

Symbols\Metadata\PE\PENamespaceSymbol.cs (2)

88builder.Add(pair.Value); 294children.Add(PENamedTypeSymbol.Create(moduleSymbol, this, t, g.Key));

Symbols\Metadata\PE\PEParameterSymbol.cs (6)

901builder.Add(BoundInterpolatedStringArgumentPlaceholder.InstanceParameter); 908builder.Add(BoundInterpolatedStringArgumentPlaceholder.ExtensionReceiver); 915builder.Add(param.Ordinal); 1132builder.Add(new PEAttributeData(containingPEModuleSymbol, paramArrayAttribute)); 1137builder.Add(new PEAttributeData(containingPEModuleSymbol, paramCollectionAttribute)); 1142builder.Add(new PEAttributeData(containingPEModuleSymbol, constantAttribute));

Symbols\Metadata\PE\PEPropertySymbol.cs (2)

805builder.Add(prop); 815builder.Add(prop);

Symbols\Metadata\PE\PETypeParameterSymbol.cs (2)

190symbolsBuilder.Add(type); 552symbolsBuilder.Add(type);

Symbols\Metadata\PE\TupleTypeDecoder.cs (2)

223paramsBuilder.Add(decodedParam); 321decodedArgs.Add(decoded);

Symbols\NamedTypeSymbol.cs (6)

223operators.Add(method); 283constructors.Add(method); 291constructors.Add(method); 322indexers.Add((PropertySymbol)candidate); 371methods.Add(method); 1072allTypeArguments.Add(merged);

Symbols\NamespaceSymbol.cs (1)

375extensions.Add(nestedType);

Symbols\NativeIntegerTypeSymbol.cs (3)

109builder.Add(new NativeIntegerMethodSymbol(this, underlyingMethod, associatedSymbol: null)); 117builder.Add(new NativeIntegerMethodSymbol(this, underlyingMethod, associatedSymbol: null)); 130builder.Add(property);

Symbols\OverriddenOrHiddenMembersHelpers.cs (7)

263AccessOrGetInstance(ref hiddenBuilder).Add(correspondingAccessor); 355AccessOrGetInstance(ref hiddenBuilder).Add(correspondingAccessor); 453AccessOrGetInstance(ref hiddenBuilder).Add(currTypeBestMatch); 725overriddenBuilder.Add(representativeMember); 758AccessOrGetInstance(ref hiddenBuilder).Add(hiddenMember); 815overriddenBuilder.Add(otherMember); 822overriddenBuilder.Add(otherMember);

Symbols\ParameterSignature.cs (3)

44types.Add(parameter.TypeWithAnnotations); 52refs.Add(refKind); 57refs.Add(refKind);

Symbols\PublicModel\Symbol.cs (2)

25builder.Add(TypeWithAnnotations.Create(type, (typeArg?.NullableAnnotation.ToInternalAnnotation() ?? NullableAnnotation.NotAnnotated))); 49builder.Add(TypeWithAnnotations.Create(type, annotation));

Symbols\ReducedExtensionMethodSymbol.cs (3)

190builder.Add(TypeWithAnnotations.Create(ErrorTypeSymbol.UnknownResultType)); 194builder.Add(typeArg); 573parameters.Add(new ReducedExtensionMethodParameterSymbol(this, reducedFromParameters[i + 1]));

Symbols\ReferenceManager.cs (7)

584linkedReferencedAssembliesBuilder.Add(currentBindingResult.AssemblySymbol); 594linkedReferencedAssembliesBuilder.Add(linkedAssemblySymbol); 807moduleReferencesBuilder!.Add(references); 835unifiedAssemblies.Add(new UnifiedAssembly<AssemblySymbol>(assembly, referenceBinding.ReferenceIdentity)); 1024assemblies.Add(peAssembly!); 1119result.Add(sourceReferencedAssemblies[i]); 1139assemblies.Add(Compilation.Assembly);

Symbols\Retargeting\RetargetingEventSymbol.cs (1)

125builder.Add(retargeted);

Symbols\Retargeting\RetargetingMethodSymbol.cs (2)

179parameters.Add(new RetargetingMethodParameterSymbol(this, list[i])); 333builder.Add(retargeted);

Symbols\Retargeting\RetargetingNamespaceSymbol.cs (3)

90builder.Add(this.RetargetingTranslator.Retarget(s)); 129builder.Add(this.RetargetingTranslator.Retarget(t, RetargetOptions.RetargetPrimitiveTypesByName)); 240methods.Add(this.RetargetingTranslator.Retarget(underlyingMethod));

Symbols\Retargeting\RetargetingPropertySymbol.cs (1)

185builder.Add(retargeted);

Symbols\Retargeting\RetargetingSymbolTranslator.cs (8)

545newArguments.Add(newArg); 731newModifiers.Add(oldModifier.IsOptional ? 737newModifiers.Add(oldModifier); 780newParameterTypesBuilder.Add(newParameterType); 781newParameterCustomModifiersBuilder.Add(newModifiers); 1207newArguments.Add(retargetedArgument); 1281newArguments.Add(new KeyValuePair<string, TypedConstant>(oldArgument.Key, newConstant)); 1286newArguments.Add(oldArgument);

Symbols\Source\ConstantEvaluationHelpers.cs (3)

176set.Add(field); 210order.Add(new FieldInfo(item, startsCycle: false)); 253order.Add(new FieldInfo(field, startsCycle: true));

Symbols\Source\CustomModifierUtils.cs (2)

144builder.Add(destinationParameter.WithCustomModifiersAndParams(sourceParameter.Type, 151builder.Add(destinationParameter);

Symbols\Source\ExplicitInterfaceHelpers.cs (1)

118builder.Add(SubstituteExplicitInterfaceImplementation(unsubstitutedPropertyImplemented, map));

Symbols\Source\IndexedTypeParameterSymbol.cs (2)

96builder.Add(GetTypeParameter(i)); 113builder.Add(TypeWithAnnotations.Create(GetTypeParameter(i), NullableAnnotation.Ignored));

Symbols\Source\LambdaSymbol.cs (1)

370builder.Add(parameter);

Symbols\Source\LocalFunctionSymbol.cs (1)

468result.Add(typeParameter);

Symbols\Source\ParameterHelpers.cs (1)

202builder.Add(parameter);

Symbols\Source\SourceAssemblySymbol.cs (4)

132moduleBuilder.Add(new SourceModuleSymbol(this, compilation.Declarations, moduleName)); 139moduleBuilder.Add(new PEModuleSymbol(this, netModule, importOptions, moduleBuilder.Count)); 1298netModuleNameBuilder.Add(netModuleName); 1299moduleAssemblyAttributesBuilder.Add(attributeData);

Symbols\Source\SourceComplexParameterSymbol.cs (1)

1299ordinalsBuilder.Add(ordinal);

Symbols\Source\SourceDelegateMethodSymbol.cs (9)

75symbols.Add(invoke); 78symbols.Add(new Constructor(delegateType, voidType, objectType, intPtrType, syntax)); 89symbols.Add(new BeginInvokeMethod(invoke, iAsyncResultType, objectType, asyncCallbackType, syntax)); 92symbols.Add(new EndInvokeMethod(invoke, iAsyncResultType, syntax)); 362parameters.Add(synthesizedParam); 366parameters.Add(SynthesizedParameterSymbol.Create(this, asyncCallbackType, paramCount, RefKind.None, GetUniqueParameterName(parameters, "callback"))); 367parameters.Add(SynthesizedParameterSymbol.Create(this, objectType, paramCount + 1, RefKind.None, GetUniqueParameterName(parameters, "object"))); 406parameters.Add(synthesizedParam); 410parameters.Add(SynthesizedParameterSymbol.Create(this, iAsyncResultType, ordinal++, RefKind.None, GetUniqueParameterName(parameters, "result")));

Symbols\Source\SourceMemberContainerSymbol.cs (48)

Symbols\Source\SourceMemberContainerSymbol_ImplementationChecks.cs (2)

193forwardingMethods.Add(forwardingMethod); 200methodImpls.Add(methodImpl);

Symbols\Source\SourceMethodSymbolWithAttributes.cs (2)

1103namespaceNames.Add(containingNamespace.Name); 1303namespaceNames.Add(containingNamespace.Name);

Symbols\Source\SourceModuleSymbol.cs (4)

139buffer.Add(asm); 361toVisit.Add(GlobalNamespace); 378toVisit.Add(cursor); 398toVisit.Add(namespaceOrType);

Symbols\Source\SourceNamedTypeSymbol.cs (2)

368(otherPartialClauses ??= ArrayBuilder<ImmutableArray<TypeParameterConstraintClause>>.GetInstance()).Add(constraints); 450(otherPartialClauses ??= ArrayBuilder<ImmutableArray<TypeParameterConstraintClause>>.GetInstance()).Add(constraints);

Symbols\Source\SourceNamedTypeSymbol_Bases.cs (6)

362baseInterfaces.Add(t); 375baseInterfaces.Add(type); 580localInterfaces.Add((NamedTypeSymbol)baseType); 606localInterfaces.Add((NamedTypeSymbol)baseType); 678result.Add(new ExtendedErrorTypeSymbol(t, LookupResultKind.NotReferencable, 684result.Add(t);

Symbols\Source\SourceNamedTypeSymbol_Extension.cs (6)

156typeConstraintStrings.Add(constraintBuilder.ToStringAndFree()); 161typeConstraintStrings.Add("System.ValueType modreq(System.Runtime.InteropServices.UnmanagedType)"); 165typeConstraintStrings.Add("System.ValueType"); 705typeConstraintsBuilder.Add(stringBuilder.ToStringAndFree()); 833attributesBuilder.Add(stringBuilder.ToStringAndFree()); 883namedArgumentsBuilder.Add(stringBuilder.ToStringAndFree());

Symbols\Source\SourceNamespaceSymbol.AliasesAndUsings.cs (5)

338mergedNamespacesOrTypes.Add(namespaceOrType); 503builder.Add(new AliasAndExternAliasDirective(new AliasSymbolFromSyntax(declaringSymbol, aliasSyntax), aliasSyntax, skipInLookup)); 715usingAliases.Add(aliasAndDirective); 786getOrCreateUsingsBuilder(ref usings, globalUsingNamespacesOrTypes).Add(new NamespaceOrTypeAndUsingDirective(imported, usingDirective, dependencies: default)); 814getOrCreateUsingsBuilder(ref usings, globalUsingNamespacesOrTypes).Add(new NamespaceOrTypeAndUsingDirective(importedType, usingDirective, directiveDiagnostics.DependenciesBag.ToImmutableArray()));

Symbols\Source\SourceOrdinaryMethodSymbol.cs (1)

1202result.Add(typeParameter);

Symbols\Source\SourcePropertyAccessorSymbol.cs (2)

786parameters.Add(new SourcePropertyClonedParameterSymbolForAccessors(propertyParam, this)); 791parameters.Add(new SynthesizedPropertyAccessorValueParameterSymbol(this, parameters.Count));

Symbols\Source\TypeParameterBuilder.cs (2)

59arrayBuilder.Add(builder._location); 70arrayBuilder.Add(builder._syntaxRef);

Symbols\SubstitutedMethodSymbol.cs (1)

352substituted.Add(new SubstitutedParameterSymbol(this, map, p));

Symbols\SubstitutedNamedTypeSymbol.cs (7)

252builder.Add(((NamedTypeSymbol)t).AsMember(this)); 260builder.Add(t.SymbolAsMember(this)); 283builder.Add(existingMember); 302builder.Add(((NamedTypeSymbol)t).AsMember(this)); 310builder.Add(t.SymbolAsMember(this)); 351builder.Add(t.SymbolAsMember(this)); 406builder.Add(t.SymbolAsMember(this));

Symbols\Symbol.cs (3)

518builder.Add(node.GetReference()); 540builder.Add(found.GetReference()); 890attributes.Add(attribute);

Symbols\Symbol_Attributes.cs (2)

554boundAttributeArrayBuilder.Add(boundAttribute); 645bindersBuilder.Add(binder);

Symbols\Synthesized\ReadOnlyListType\SynthesizedReadOnlyListEnumeratorTypeSymbol.cs (8)

45membersBuilder.Add(_itemField); 46membersBuilder.Add(_moveNextCalledField); 47membersBuilder.Add( 73membersBuilder.Add( 92membersBuilder.Add( 105membersBuilder.Add( 116builder.Add(property); 117builder.Add(property.GetMethod);

Symbols\Synthesized\Records\SynthesizedRecordCopyCtor.cs (2)

54statements.Add(F.Assignment(F.Field(F.This(), field), F.Field(param, field))); 70statements.Add(new BoundSequencePointWithSpan(recordDeclaration, statementOpt: null,

Symbols\Synthesized\Records\SynthesizedRecordDeconstruct.cs (3)

85statementsBuilder.Add(F.Assignment(F.Parameter(parameter), F.Property(F.This(), property))); 89statementsBuilder.Add(F.Assignment(F.Parameter(parameter), F.Field(F.This(), field))); 94statementsBuilder.Add(F.Return());

Symbols\Synthesized\Records\SynthesizedRecordEquals.cs (1)

136fields.Add(f);

Symbols\Synthesized\Records\SynthesizedRecordPrintMembers.cs (6)

149block.Add(F.ExpressionStatement( 176block.Add(F.If(basePrintCall, makeAppendString(F, builder, ", "))); 197block.Add(makeAppendString(F, builder, memberHeader)); 211block.Add(F.ExpressionStatement( 219block.Add(F.ExpressionStatement( 226block.Add(F.Return(F.Literal(true)));

Symbols\Synthesized\Records\SynthesizedRecordToString.cs (6)

63block.Add(F.Assignment(builderLocal, F.New(stringBuilderCtor))); 66block.Add(makeAppendString(F, builderLocal, ContainingType.Name)); 69block.Add(makeAppendString(F, builderLocal, " { ")); 72block.Add(F.If(F.Call(F.This(), _printMethod, builderLocal), makeAppendChar(F, builderLocal, ' '))); 75block.Add(makeAppendChar(F, builderLocal, '}')); 78block.Add(F.Return(F.Call(builderLocal, F.SpecialMethod(SpecialMember.System_Object__ToString))));

Symbols\Synthesized\RefKindVector.cs (1)

133otherWords.Add(value);

Symbols\Synthesized\SynthesizedEmbeddedNativeIntegerAttributeSymbol.cs (2)

74statements.Add( 91statements.Add(

Symbols\Synthesized\SynthesizedEmbeddedNullableAttributeSymbol.cs (2)

78statements.Add( 92statements.Add(

Symbols\Synthesized\SynthesizedEmbeddedNullableContextAttributeSymbol.cs (1)

62statements.Add(

Symbols\Synthesized\SynthesizedEmbeddedNullablePublicOnlyAttributeSymbol.cs (1)

59statements.Add(

Symbols\Synthesized\SynthesizedEmbeddedRefSafetyRulesAttributeSymbol.cs (1)

54statements.Add(

Symbols\Synthesized\SynthesizedInstanceConstructor.cs (2)

306statements.Add(factory.ExpressionStatement(baseConstructorCall)); 308statements.Add(factory.Return());

Symbols\Tuples\TupleTypeSymbol.cs (9)

209underlyingTupleTypeChain.Add(currentType); 647members.Add(defaultTupleField); 664members.Add(defaultTupleField); 675members.Add(new TupleVirtualElementFieldSymbol(this, 763members.Add(defaultTupleField); 768members.Add(new TupleErrorFieldSymbol(this, 805fieldsForElements.Add((FieldSymbol?)getWellKnownMemberInType(members, wellKnownTupleField)); 829fields.Add(tupleField.UnderlyingField.OriginalDefinition); 833fields.Add(field.OriginalDefinition);

Symbols\TypeMap.cs (2)

130newTypeParametersBuilder.Add(newTp); 174parameters.Add(currentParameters[i]);

Symbols\TypeSymbol.cs (3)

365result.Add(@interface); 1343implementations.Add((candidate, bases)); 1347implementations.Add((candidate, null));

Symbols\TypeSymbolExtensions.cs (2)

2058paramsBuilder.Add(paramType); 2112builder.Add(attr);

Symbols\TypeWithAnnotations.cs (1)

647transforms.Add(flag);

Symbols\UnboundGenericType.cs (1)

55result.Add(TypeWithAnnotations.Create(new UnboundArgumentErrorTypeSymbol(name, errorInfo)));

Syntax\CSharpSyntaxNode.cs (1)

88(nodes ?? (nodes = ArrayBuilder<CSharpSyntaxNode>.GetInstance())).Add(node);

Syntax\CSharpSyntaxTree.cs (5)

260states.Add(currentState); 265states.Add(currentState); 270states.Add(currentState); 275states.Add(currentState); 280states.Add(currentState);

Syntax\NullableContextStateMap.cs (1)

170builder.Add(context);

Syntax\SyntaxNormalizer.cs (11)

Utilities\ValueSetFactory.NumericValueSet.cs (4)

141builder.Add((_tc.MinValue, _tc.Prev(_intervals[0].first))); 148builder.Add((_tc.Next(_intervals[i].last), _tc.Prev(_intervals[i + 1].first))); 154builder.Add((_tc.Next(_intervals[lastIndex].last), _tc.MaxValue)); 224builder.Add((first, last));