Add

Binder\Binder.CapturedParametersFinder.cs (2)

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

Binder\Binder.cs (1)

864binders.Add(binder);

Binder\Binder.IdentifierUsedAsValueFinder.cs (1)

531state.allRangeVariables[y].Add(let.Identifier.ValueText);

Binder\Binder.QueryTranslationState.cs (1)

106b.Add(name);

Binder\Binder.ValueChecks.cs (18)

Binder\Binder_AnonymousTypes.cs (1)

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

Binder\Binder_Attributes.cs (4)

507boundNamedArgumentsBuilder.Add(boundNamedArgument); 776builder.Add(VisitExpression(argument, diagnostics, ref attrHasErrors, curArgumentHasErrors)); 798builder.Add(kv.Value); 884builder.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 (7)

926builder.Add(convertedElement); 967builder.Add(convertedElement!); 1570resultBuilder.Add(member); 1723builder.Add(result); 1982builder.Add(newCase); 2464locationBuilder.Add(argument.NameColon?.Name.Location); 2488convertedArguments.Add(CreateConversion(argument.Syntax, argument, elementConversion, isCast: isCast, elementConversionGroup, destType.Type, diagnostics));

Binder\Binder_Crefs.cs (8)

346sortedSymbolsBuilder.Add(result.Symbol); 572builder.Add(this.GetSpecialType(memberName == "nint" ? SpecialType.System_IntPtr : SpecialType.System_UIntPtr, diagnostics, syntax).AsNativeInteger()); 883unwrappedSymbols.Add(UnwrapAliasNoDiagnostics(wrapped)); 940candidates.Add(constructedCandidate); 1034viable.Add(candidate); 1051viable.Add(candidate); 1100typeArgumentsWithAnnotations.Add(typeArgument); 1144parameterBuilder.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 (49)

346boundArgs.Add(BindToNaturalType(arg, diagnostics, reportNoTargetType)); 976builder.Add(BindDeclarationVariablesForErrorRecovery(declTypeWithAnnotations, n, n, diagnostics)); 977namesBuilder.Add(InferTupleElementName(n)); 1042elementLocations.Add(nameSyntax.Location); 1046elementLocations.Add(argumentSyntax.Location); 1058boundArguments.Add(boundArgument); 1061elementTypesWithAnnotations.Add(elementTypeWithAnnotations); 1164builder.Add(true); 1168builder.Add(false); 3365result.RefKinds.Add(RefKind.None); 3372result.RefKinds.Add(refKind); 3386result.Names.Add(null); 3404result.Names.Add(null); 3407result.Arguments.Add(boundArgumentExpression); 3570paramsArgsBuilder.Add(arguments[arg]); 3878argumentPlaceholdersBuilder.Add( 3888argumentRefKindsBuilder.Add(refKind == RefKind.RefReadOnlyParameter ? RefKind.In : refKind); 4075sizes.Add(size); 4097sizes.Add(size); 4231exprBuilder.Add(boundExpression); 4263exprBuilder.Add(boundExpression); 4309initializers.Add(convertedExpression); 4337initializers.Add(init); 4559builder.Add(BindToTypeForErrorRecovery(BindExpression(size, BindingDiagnosticBag.Discarded))); 5282builder.Add(bindElement(element, diagnostics, this, nestingLevel)); 5630children.Add(boundInitializer); 5729initializers.Add(boundMemberInitializer); 6313initializerBuilder.Add(boundElementInitializer); 6414exprBuilder.Add(BindValue(childElementInitializer, diagnostics, BindValueKind.RValue)); 6651builder?.Add(constructor); 6930childNodes.Add(MakeBoundInitializerOpt(typeNode, type, initializerSyntaxOpt, initializerTypeOpt, diagnostics)); 8315if ((object)m != null) builder.Add(m); 8383extensionMethodArguments.Arguments.Add(receiver); 8392extensionMethodArguments.Names.Add(null); 8398extensionMethodArguments.RefKinds.Add(RefKind.None); 8413extensionPropertyArguments.Arguments.Add(receiver); 8834properties.Add(property); 9291methodOrPropertyGroup.Add(symbol); 10014indexerGroup.Add((PropertySymbol)symbol); 10440analyzedArguments.Arguments.Add(intPlaceholder); 10512analyzedArguments.Arguments.Add(startArgumentPlaceholder); 10513analyzedArguments.Arguments.Add(lengthArgumentPlaceholder); 10884methods.Add(m); 10941methods.Add(substituted); 10946methods.Add(reduced); 11093methods.Add(substituted); 11152methods.Add(substituted); 11306fieldsBuilder.Add( 11317fieldsBuilder.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)

58builder.Add(result.Member); 991resultWithSingleCandidate.ResultsBuilder.Add(methodResolutionResult); 1040finalCandidates.Add(result); 1616argumentsBuilder.Add(bindDefaultArgument(node, parameter, containingMember, enableCallerInfo, diagnostics, extensionReceiver, argumentsBuilder, argumentsCount, argsToParamsOpt)); 1620argumentRefKindsBuilder.Add(RefKind.None); 1623argsToParamsBuilder?.Add(parameter.Ordinal); 1626namesBuilder.Add(null); 1640argumentsBuilder.Add(collection); 1641argsToParamsBuilder?.Add(paramsIndex); 1645argumentRefKindsBuilder.Add(RefKind.None); 1650namesBuilder.Add(null); 2064constructedMethods.Add(constructedMethod); 2117parameterListList.Add(m.GetParametersIncludingExtensionParameter(skipExtensionIfStatic: false)); 2138parameterListList.Add(p.Parameters); 2521methodsBuilder.Add(funcPtr.Signature);

Binder\Binder_Lambda.cs (8)

76namesBuilder.Add(simple.Parameter.Identifier.ValueText); 204namesBuilder.Add(p.Identifier.ValueText); 205typesBuilder.Add(typeOpt); 206refKindsBuilder.Add(refKind); 207scopesBuilder.Add(scope); 208attributesBuilder.Add(syntax.Kind() == SyntaxKind.ParenthesizedLambdaExpression ? p.AttributeLists : default); 209defaultValueBuilder.Add(p.Default); 269discardsBuilder.Add(p.Identifier.IsUnderscoreToken());

Binder\Binder_Lookup.cs (4)

217result.Add(resultOfThisMember); 241result.Add(resultOfThisMember); 1184result.Add(@interface); 1344hidingSymbols.Add(sym); // not hidden

Binder\Binder_Operators.cs (10)

440analyzedArguments.RefKinds.Add(RefKind.Ref); 441analyzedArguments.RefKinds.Add(RefKind.None); 445analyzedArguments.Arguments.Add(right); 2149builder.Add(method); 2295builder.Add(method); 3465analyzedArguments.RefKinds.Add(RefKind.Ref); 3723methods.Add(method); 3739methods.Add(method); 3785checkedMethods.Add(method); 3830methods.Add(op);

Binder\Binder_Patterns.cs (12)

248analyzedArguments.Arguments.Add(argumentPlaceholder); 294builder.Add(boundPattern); 397analyzedArguments.Arguments.Add(argumentPlaceholder); 1114patterns.Add(boundSubpattern); 1143patterns.Add(boundSubpattern); 1161patterns.Add(boundSubpattern); 1203patterns.Add(boundSubpattern); 1436subPatterns.Add(new BoundPositionalSubpattern(variable, symbol: null, pattern)); 1459subPatterns.Add(new BoundPositionalSubpattern(variable, symbol: null, pattern)); 1515builder.Add(new BoundPropertySubpattern(p, member, isLengthOrCount, boundPattern)); 1870narrowedTypeCandidates.Add(right.NarrowedType); 1884candidates.Add(pat.NarrowedType);

Binder\Binder_Query.cs (1)

767state.allRangeVariables[y].Add(let.Identifier.ValueText);

Binder\Binder_Statements.cs (5)

1146args.invalidDimensions.Add(size); 1924boundStatements.Add(boundStatement); 2911statementBuilder.Add(statement); 3267catchBlocks.Add(catchBlock); 3707boundStatements.Add(boundStatement);

Binder\Binder_Symbols.cs (7)

703types.Add(argumentType); 715locations.Add(nameToken.GetLocation()); 719locations.Add(argumentSyntax.Location); 781elementNames.Add(name); 790elementNames.Add(null); 792elementNames.Add(name); 1352args.Add(BindTypeArgument(argSyntax, diagnostics, basesBeingResolved));

Binder\Binder_TupleOperators.cs (2)

61builder.Add(ApplyConvertedTypes(arguments[i], multiple.Operators[i], isRight, diagnostics)); 241operatorsBuilder.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_CheckOrReachability.cs (5)

129existingCases.Add(builder.MakeTestsForPattern(++index, switchArm.Syntax, rootIdentifier, switchArm.Pattern, whenClause: switchArm.WhenClause, label: switchArm.Label)); 183existingCases.Add(builder.MakeTestsForPattern(++index, label.Syntax, rootIdentifier, label.Pattern, label.WhenClause, label.Label)); 451currentCases.Add(wrappedPattern); 557builder.Add(current.Left); 569builder.Add(pattern);

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); 423_variablesBuilder.Add(variable); 508_variablesBuilder.Add(variable);

Binder\FixedStatementBinder.cs (1)

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

Binder\ForEachLoopBinder.cs (3)

158locals.Add(localSymbol); 1414candidateMethods.Add((MethodSymbol)member); 1958argsBuilder.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 (1)

220_symbolList.Add(other.Symbol);

Binder\PatternExplainer.cs (3)

76result.Add(n); 312constraintBuilder.Add((test, sense)); 323evaluationBuilder.Add(e.Evaluation);

Binder\RefSafetyAnalysis.cs (8)

880placeholders.Add((interpolationData.ReceiverPlaceholder, SafeContextAndLocation.Create(_localScopeDepth))); 919placeholders.Add((placeholder, SafeContextAndLocation.Create(valEscapeScope))); 1095placeholders.Add((placeholder, SafeContextAndLocation.Create(valEscapeScope))); 1100placeholders.Add((runtimePlaceholder, SafeContextAndLocation.Create(valEscapeScope))); 1153placeholders.Add((conversion.DeconstructionInfo.InputPlaceholder, SafeContextAndLocation.Create(GetValEscape(right, _localScopeDepth)))); 1168placeholders.Add((arg, SafeContextAndLocation.Create(valEscape))); 1224builder.Add(getDeconstructionAssignmentVariable(arg)); 1291placeholders.Add((targetPlaceholder, SafeContextAndLocation.Create(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); 521operators.Add(pointerOperator.Value); 538results.Add(UnaryOperatorAnalysisResult.Applicable(op, conversion)); 542results.Add(UnaryOperatorAnalysisResult.Inapplicable(op, conversion)); 574operators.Add(new UnaryOperatorSignature(kind | UnaryOperatorKind.Enum, enumType, enumType)); 575operators.Add(new UnaryOperatorSignature(kind | UnaryOperatorKind.Lifted | UnaryOperatorKind.Enum, nullableEnum, nullableEnum)); 835operators.Add(new UnaryOperatorSignature(UnaryOperatorKind.UserDefined | kind, operandType, resultType, op, constrainedToTypeOpt)); 865operators.Add(new UnaryOperatorSignature(

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

44Names.Add((name.Identifier.ValueText, name.Location)); 70builder.Add(Name(i));

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

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

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

3347builder.Add(fixedResult.Type); 3371builder.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); 3437_returns.Add(node); 3930types.Add(parameter.TypeWithAnnotations); 3940refs.Add(paramRefKind); 3945refs.Add(paramRefKind); 4078types.Add(paramsIterationType); 4082types.Add(type); 4088refs.Add(paramRefKind); 4649conversions.Add(conversion); 4655conversions.Add(conversion);

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

158result.Add(res.Member);

Binder\SwitchBinder.cs (1)

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

Binder\SwitchBinder_Patterns.cs (5)

138labelBuilder.Add(newLabel); 141sectionBuilder.Add(oldSection.Update(oldSection.Locals, labelBuilder.ToImmutableAndFree(), oldSection.Statements)); 181boundSwitchSectionsBuilder.Add(section); 206boundLabelsBuilder.Add(boundLabel); 218boundStatementsBuilder.Add(boundStatement);

Binder\SwitchExpressionBinder.cs (2)

159typesInOrder.Add(type); 195builder.Add(boundArm);

Binder\UsingStatementBinder.cs (1)

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

BoundTree\BoundExpressionExtensions.cs (4)

188symbols.Add(delegateCreation.MethodOpt); 200symbols.Add(s); 209symbols.Add(ctor); 243symbols.Add(symbol);

BoundTree\BoundTreeRewriter.cs (3)

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

BoundTree\Constructors.cs (1)

247builder.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)

327builder.Add(updatedSymbol);

BoundTree\UnboundLambda.cs (7)

234types.Add((returnStatement.ExpressionOpt!, type, returnStatement.Checked)); 395_builder.Add((node, TypeWithAnnotations.Create(type))); 727parameterRefKindsBuilder.Add(refKind); 728parameterScopesBuilder.Add(scope); 729parameterTypesBuilder.Add(type); 1168refKindsBuilder.Add(p.RefKind); 1169typesBuilder.Add(p.TypeWithAnnotations);

CodeGen\CodeGenerator.cs (3)

270yieldPointBuilder.Add(yieldOffset); 271resumePointBuilder.Add(resumeOffset); 540exprTemps.Add(temp);

CodeGen\EmitStatement.cs (3)

152_asyncYieldPoints.Add(_builder.AllocateILMarker()); 158_asyncResumePoints.Add(_builder.AllocateILMarker()); 2017casesBuilder.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); 1790rewrittenInitializers.Add(rewrittenInitializer); 1939defs.Add(nextDef); 1961locInfo.LocalDefs.Add(locDef); 1991locInfo.LocalDefs.Add(locDef);

CommandLine\CSharpCommandLineParser.cs (8)

497instrumentationKinds.Add(instrumentationKind); 1765builder.Add(sdkDirectoryOpt); 1823defines.Add(id); 2112ids.Add(errorCode); 2115ids.Add(CSharp.MessageProvider.Instance.GetIdForErrorCode((int)ErrorCode.WRN_MissingNonNullTypesContextForAnnotation)); 2116ids.Add(CSharp.MessageProvider.Instance.GetIdForErrorCode((int)ErrorCode.WRN_MissingNonNullTypesContextForAnnotationInGeneratedCode)); 2125ids.Add(CSharp.MessageProvider.Instance.GetIdForErrorCode(number)); 2133ids.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)

1398assemblies.Add(referenceManager.ReferencedAssemblies[i]); 1572builder.Add(referenceManager.ReferencedAssemblies[i].GlobalNamespace); 1657boundUsings.Add(previousUsing); 2045entryPointCandidates.Add(simpleProgramEntryPointSymbol); 2085taskEntryPoints.Add((IsCandidate, candidate, perCandidateBag)); 2098viableEntryPoints.Add(candidate); 2113viableEntryPoints.Add(Candidate); 2241entryPointCandidates.Add(method); 4011builder.Add((byte)b); 4265typesBuilder.Add(TypeWithAnnotations.Create(elementType, annotation)); 4333fields.Add(new AnonymousTypeField(name, location, TypeWithAnnotations.Create(type, nullableAnnotation), RefKind.None, ScopedKind.None)); 5027spine.Add(current); 5048spine.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)

1678results.Add(reduced.GetPublicSymbol()); 1686results.Add(compatibleSubstitutedMember.GetPublicSymbol()); 1712results.Add(RemapSymbolIfNecessary(uniqueSymbol).GetPublicSymbol()); 1770results.Add(RemapSymbolIfNecessary(singleSymbol).GetPublicSymbol()); 1776results.Add(RemapSymbolIfNecessary(symbol).GetPublicSymbol()); 1784results.Add(RemapSymbolIfNecessary(symbol).GetPublicSymbol()); 2008builder.Add(s); 3620if (query.Operation != null && (object)query.Operation.ExpressionSymbol != null) builder.Add(query.Operation.ExpressionSymbol); 3621if ((object)query.DefinedSymbol != null) builder.Add(query.DefinedSymbol); 3622if (query.Cast != null && (object)query.Cast.ExpressionSymbol != null) builder.Add(query.Cast.ExpressionSymbol); 4154builder.Add(indexer); 4538symbols.Add(param.GetPublicSymbol()); 4696members.Add(member); 4697filteredMembers.Add(substitutedMember); 5430builder.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)

520result.Add(elementSyntax); 854builder.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)

1284initializers.Add(factory.Assignment(factory.Field(factory.This(), field), factory.Parameter(parameter))); 1819awaiters.Add(null); 1831hoistedVariables.Add(new EncHoistedLocalInfo(true)); 1844awaiters.Add(null); 1850hoistedVariables.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)

432otherParamRefCustomModifiersBuilder.Add(VisitCustomModifiers(param.RefCustomModifiers)); 433otherParamsBuilder.Add(param.TypeWithAnnotations.WithTypeAndModifiers(otherType, VisitCustomModifiers(param.TypeWithAnnotations.CustomModifiers))); 941translatedParamsBuilder.Add(param.TypeWithAnnotations.WithTypeAndModifiers(translatedParamType, VisitCustomModifiers(param.TypeWithAnnotations.CustomModifiers))); 942translatedParamRefCustomModifiersBuilder.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)

903builder.Add(arg); 1010builder.Add(@interface);

Emitter\Model\PEAssemblyBuilder.cs (4)

101builder.Add(_lazyEmbeddedAttribute); 138builder.Add((Cci.IFileReference)Translate(modules[i], context.Diagnostics)); 148builder.Add(resource); 185builder.Add(new Cci.ManagedResource(

Emitter\Model\PEModuleBuilder.cs (10)

279debugDocuments.Add(debugDocument); 593builder.Add(new Cci.ExportedType((Cci.ITypeReference)symbol.GetCciAdapter(), parentIndex, isForwarder: false)); 649groupingTypes.Add(groupingType); 857builder.Add(new Cci.ExportedType(type.GetCciAdapter(), parentIndex, isForwarder: true)); 890builder.Add(new Cci.ExportedType(groupingType, index, isForwarder: true)); 894builder.Add(new Cci.ExportedType(markerType, groupingIndex, isForwarder: true)); 907builder.Add(new Cci.ExportedType(item.GroupingType, index, isForwarder: true)); 911builder.Add(new Cci.ExportedType(markerType, groupingIndex, isForwarder: true)); 1560builder.Add(CreateParameterTypeInformationWrapper(param)); 2249builder.Add(type);

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)

2723arg.parts.Add(interpolatedString);

FlowAnalysis\AbstractFlowPass.PendingBranchesCollection.cs (2)

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

FlowAnalysis\ControlFlowPass.cs (1)

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

FlowAnalysis\DefiniteAssignment.cs (2)

279variableBySlot.Add(identifier); 606builder.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)

131builder.Add( 144builder.Add( 153builder.Add( 177builder.Add(AppendImplicitReturn((BoundBlock)statements[n - 1], method));

FlowAnalysis\NullableWalker.cs (32)

3104_returnTypesOpt.Add((node, result.ToTypeWithAnnotations(compilation))); 3256localFuncs.Add(localFunc); 3878resultBuilder.Add(_visitResult); 3920elementConversionCompletions.Add((_, targetCollectionType) => 3988elementConversionCompletions.Add((elementType, _) => completion(elementType)); 4662builder.Add( 4874expressionsNoConversions.Add(expressionNoConversion); 4875conversions.Add(conversion); 4878expressionTypes.Add(expressionType); 4882placeholderBuilder.Add(CreatePlaceholderIfNecessary(expressionNoConversion, expressionType.ToTypeWithAnnotations(compilation))); 5001resultTypes.Add(resultType); 5002placeholdersBuilder.Add(CreatePlaceholderIfNecessary(returnExpr, resultType)); 5048builder.Add(child); 5711slotBuilder.Add(slot); 6811builder.Add(0); 6814builder.Add(argsToParamsOpt[i] + 1); 7443notNullParametersBuilder?.Add(parameter); 7789resultsBuilder.Add(result); 7793resultsBuilder.Add(VisitArgumentEvaluate(arguments[i], GetRefKind(refKindsOpt, i), parameterAnnotationsOpt.IsDefault ? default : parameterAnnotationsOpt[i])); 7948conversionResultsBuilder?.Add(_visitResult); 7969conversionResultsBuilder?.Add(result); 7972conversionResultsBuilder?.Add(result); 8312argumentsBuilder.Add(argument); 8313conversionsBuilder.Add(conversion); 8540builder.Add(getArgumentForMethodTypeInference(arguments[i], visitArgumentResult)); 8571elementsBuilder.Add(getArgumentForMethodTypeInference(elementNoConversion, collectionExpressionVisitResults[i])); 8575elementsBuilder.Add(collection.Elements[i]); 10468arguments.Add(CreatePlaceholderIfNecessary(receiverOpt, receiverType.ToTypeWithAnnotations(compilation))); 10476arguments.Add(new BoundExpressionWithNullability(syntax, new BoundParameter(syntax, parameter), parameterType.NullableAnnotation, parameterType.Type)); 10849placeholderArgs.Add(CreatePlaceholderIfNecessary(right, rightResult.ToTypeWithAnnotations(compilation))); 10852placeholderArgs.Add(new BoundExpressionWithNullability(variables[i].Expression.Syntax, variables[i].Expression, NullableAnnotation.Oblivious, conversion.DeconstructionInfo.OutputPlaceholders[i].Type)); 11026builder.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)

259statements.Add(_F.HiddenSequencePoint()); 261locals.Add(pendingExceptionLocal); 262statements.Add(_F.Assignment(_F.Local(pendingExceptionLocal), _F.Default(pendingExceptionLocal.Type))); 263locals.Add(pendingBranchVar); 264statements.Add(_F.Assignment(_F.Local(pendingBranchVar), _F.Default(pendingBranchVar.Type))); 269locals.Add(returnLocal); 272statements.Add(catchAndPendException); 273statements.Add(syntheticFinally); 324bodyStatements.Add(_F.Label(proxy)); 327bodyStatements.Add(_F.Assignment(_F.Local(pendingBranchVar), _F.Literal(i))); 330bodyStatements.Add(_F.Goto(finallyLabel)); 353cases.Add(caseStatement); 391cases.Add(caseStatement); 544handlers.Add(_F.SwitchSection( 673prologueBuilder.Add(_F.ExpressionStatement(storePending)); 676prologueBuilder.Add(_F.ExpressionStatement(AssignCatchSource((BoundExpression)this.Visit(sourceOpt), currentAwaitCatchFrame))); 681prologueBuilder.Add(rewrittenPrologue); 701handlerStatements.Add(_F.HiddenSequencePoint()); 709handlerStatements.Add(_F.ExpressionStatement(assignSource)); 713handlerStatements.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))); 407statementsBuilder.Add(preamble); 409statementsBuilder.Add(awaitIfIncomplete); 410statementsBuilder.Add(getResultStatement); 480blockBuilder.Add( 484blockBuilder.Add( 488blockBuilder.Add( 496blockBuilder.Add(awaiterTemp.Type.IsDynamic() 500blockBuilder.Add( 508blockBuilder.Add(F.Label(dummyResumeLabel)); 512blockBuilder.Add( 515blockBuilder.Add( 519blockBuilder.Add( 528blockBuilder.Add( 531blockBuilder.Add( 567blockBuilder.Add( 575blockBuilder.Add(F.Assignment(F.Local(thisTemp), F.This())); 578blockBuilder.Add( 608blockBuilder.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\AsyncRewriter\RuntimeAsyncRewriter.cs (2)

64rewriter._hoistedLocals.Add(hoistedThis.LocalSymbol); 257@this._hoistedLocals.Add(hoistedLocal);

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)

321builder.Add(index); 332builder.Add(Visit(arg)); 843locals.Add(param); 845parameters.Add(parameterReference); 849initializers.Add(_bound.AssignmentExpression(parameterReference, parameter)); 964builder.Add(_bound.StaticCall(sym.Kind is SymbolKind.Property ? 973builder.Add(_bound.StaticCall(sym.Kind is SymbolKind.Property ? 982builder.Add(_bound.StaticCall(sym.Kind is SymbolKind.Property ? 1012builder.Add(elementInit); 1071membersBuilder.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)

95constructedStructClosures.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)

319prologueBuilder.Add(_factory.ExpressionStatement(_factory.Call(receiver: _factory.Local(_scope.ContextVariable), parameterLogger, 326prologueBuilder.Add(previousPrologue); 586builder.Add(store); 590builder.Add(invocation); 614builder.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_AssignmentOperator.cs (2)

370argTempsBuilder.Add(capturedRight.LocalSymbol); 371storesOpt.Add(assignmentToTemp);

Lowering\LocalRewriter\LocalRewriter_BasePatternSwitchLocalRewriter.cs (1)

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

Lowering\LocalRewriter\LocalRewriter_BinaryOperator.cs (2)

1515sideeffects.Add(tempAssignment); 1516locals.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); 734tempsOpt.Add(receiverTemp.LocalSymbol); 759visitedArgumentsBuilder.Add(_factory.MakeTempForDiscard(discard, tempsOpt)); 772visitedArgumentsBuilder.Add(i == 0 && firstRewrittenArgument is not null 816storesOpt.Add(extraRefInitialization); 819storesOpt.Add(assignmentToTemp); 902tempsOpt.Add(local.LocalSymbol); 1007temps.Add(cache.LocalSymbol); 1013temps.Add(intermediateRef.LocalSymbol); 1374elementsBuilder.Add(replacement); 1378elementsBuilder.Add(replacement); 1474storesToTemps.Add(assignment); 1554temporariesBuilder.Add(((BoundLocal)s.Left).LocalSymbol); 1733temporariesBuilder.Add(boundTemp.LocalSymbol);

Lowering\LocalRewriter\LocalRewriter_CollectionExpression.cs (32)

Lowering\LocalRewriter\LocalRewriter_CompoundAssignmentOperator.cs (29)

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)

175builder.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, AssignmentKind.SimpleAssignment)); 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, AssignmentKind.SimpleAssignment)); 495temps.Add(temp.LocalSymbol); 496result.Add(store); 506result.Add(MakeStaticAssignmentOperator(assignment.Syntax, rewrittenAccess, rewrittenRight, false, used: false, AssignmentKind.SimpleAssignment)); 540result.Add(MakeStaticAssignmentOperator(assignment.Syntax, rewrittenAccess, rewrittenRight, isRef: false, used: false, AssignmentKind.SimpleAssignment)); 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)

229destinationArguments.Add(visitedCompoundAssignmentLeftRead); 385finalArguments.Add(singleConcatArgument); 526localsBuilder.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); 642result.Add(replacement); 651result.Add(lastSpillNode.Value); 655result.Add(newList[i]);

Lowering\StateMachineRewriter\MethodToStateMachineRewriter.cs (8)

233_stateDebugInfoBuilder.Add(new StateMachineStateDebugInfo(syntaxOffset, awaitId, state)); 342hoistedLocalsWithDebugScopes.Add(((CapturedToStateMachineFieldReplacement)proxy).HoistedField); 445cleanup.Add(F.AssignmentExpression(F.Field(F.This(), field), F.NullOrDefault(field.Type))); 491_fieldsForCleanup.Add(createdField); 509fields.Add(field); 554newLocalsBuilder.Add(localToUse); 559hoistedLocalsWithDebugScopes.Add(((CapturedToStateMachineFieldReplacement)proxies[local]).HoistedField); 701@this._fieldsForCleanup.Add(hoistedSymbol);

Lowering\StateMachineRewriter\RefInitializationHoister.cs (3)

168indices.Add(HoistExpression( 297hoistedSymbols.Add(hoistedSymbol); 300sideEffects.Add(_factory.AssignmentExpression(replacement, expr));

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( 141builder.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)); 2273builder.Add((IInterpolatedStringContentOperation)Create(part)); 2277builder.Add(CreateBoundInterpolatedStringTextOperation((BoundLiteral)part)); 2352builder.Add(new InterpolatedStringTextOperation(valueOperation, _semanticModel, part.Syntax, isImplicit)); 2362builder.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)

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

Parser\Lexer_StringLiteral.cs (2)

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

SourceGeneration\CSharpSyntaxHelper.cs (2)

65targets.Add(container); 113aliases.Add((aliasName, symbolName));

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

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

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)

205typeArgumentsBuilder.Add(((ArrayTypeSymbol)field.Type).ElementTypeWithAnnotations); 209typeArgumentsBuilder.Add(field.TypeWithAnnotations); 571builder.Add(template); 589builder.Add(template); 611builder.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)

806nestedTypes.Add(currentTypeInfo); 893typeArgumentSymbols.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)

433builder.Add(new KeyValuePair<string, TypedConstant>( 940transformFlagsBuilder.Add(false); 961transformFlagsBuilder.Add(true); 970transformFlagsBuilder.Add(false); 979transformFlagsBuilder.Add(false); 1004transformFlagsBuilder.Add(false); 1018transformFlagsBuilder.Add(false); 1037transformFlagsBuilder.Add(false); 1071builder.Add(type.IsNativeIntegerWrapperType);

Symbols\ConstraintsHelper.cs (27)

Symbols\Extensions\SourceExtensionImplementationMethodSymbol.cs (2)

125parameters.Add(new ExtensionMetadataMethodParameterSymbol(this, ((SourceNamedTypeSymbol)_originalMethod.ContainingType).ExtensionParameter!)); 130parameters.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)

146namespaceSymbols.Add((NamespaceSymbol)childSymbol); 150otherSymbols.Add(childSymbol); 157otherSymbols.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)

1392explicitInterfaceImplementationsBuilder.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 (15)

809symbols.Add(namedTypeSymbol); 1166fieldDefs.Add(fieldDef); 1183builder.Add(new PEFieldSymbol(moduleSymbol, this, fieldDef)); 1252eventFields.Add(associatedField); 1289result.Add(field); 1346methodDefs.Add(methodDef); 1555members.Add(field); 1563members.Add(syntheticCtor); 1612members.Add(field); 1696members.Add(member); 2235groupingNestedTypes.Add(marker); 2336fieldMembers.Add(symbol); 2379members.Add(method); 2416members.Add(PEPropertySymbol.Create(moduleSymbol, this, propertyDef, getMethod, setMethod)); 2457members.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)

897builder.Add(BoundInterpolatedStringArgumentPlaceholder.InstanceParameter); 904builder.Add(BoundInterpolatedStringArgumentPlaceholder.ExtensionReceiver); 911builder.Add(param.Ordinal); 1128builder.Add(new PEAttributeData(containingPEModuleSymbol, paramArrayAttribute)); 1133builder.Add(new PEAttributeData(containingPEModuleSymbol, paramCollectionAttribute)); 1138builder.Add(new PEAttributeData(containingPEModuleSymbol, constantAttribute));

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

813builder.Add(prop); 823builder.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 (8)

224operators.Add(method); 235operators.Add(method); 295constructors.Add(method); 303constructors.Add(method); 334indexers.Add((PropertySymbol)candidate); 381methods.Add(method); 445members.Add(candidate); 1206allTypeArguments.Add(merged);

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\RetargetingNamedTypeSymbol.cs (2)

503markerTypes.Add(new ForwardedExtensionGroupingOrMarkerType(retargetedGroupingType, markerType)); 506builder.Add((retargetedGroupingType, markerTypes.ToImmutable()));

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)

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

Symbols\Source\ExtensionGroupingInfo.cs (2)

60builder.Add(new ExtensionGroupingType(pair.Key, pair.Value)); 696builder.Add(new ExtensionMarkerType(this, name: pair.Key, extensions: pair.Value));

Symbols\Source\IndexedTypeParameterSymbol.cs (2)

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

Symbols\Source\LambdaSymbol.cs (1)

375builder.Add(parameter);

Symbols\Source\LocalFunctionSymbol.cs (1)

485result.Add(typeParameter);

Symbols\Source\ParameterHelpers.cs (1)

202builder.Add(parameter);

Symbols\Source\SourceAssemblySymbol.cs (5)

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

Symbols\Source\SourceComplexParameterSymbol.cs (1)

1347ordinalsBuilder.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)); 364parameters.Add(synthesizedParam); 368parameters.Add(SynthesizedParameterSymbol.Create(this, asyncCallbackType, paramCount, RefKind.None, GetUniqueParameterName(parameters, "callback"))); 369parameters.Add(SynthesizedParameterSymbol.Create(this, objectType, paramCount + 1, RefKind.None, GetUniqueParameterName(parameters, "object"))); 410parameters.Add(synthesizedParam); 414parameters.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)

1115namespaceNames.Add(containingNamespace.Name); 1315namespaceNames.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); 588localInterfaces.Add((NamedTypeSymbol)baseType); 614localInterfaces.Add((NamedTypeSymbol)baseType); 686result.Add(new ExtendedErrorTypeSymbol(t, LookupResultKind.NotReferencable, 692result.Add(t);

Symbols\Source\SourceNamedTypeSymbol_Extension.cs (6)

123typeConstraintStrings.Add(constraintBuilder.ToStringAndFree()); 128typeConstraintStrings.Add("System.ValueType modreq(System.Runtime.InteropServices.UnmanagedType)"); 132typeConstraintStrings.Add("System.ValueType"); 670typeConstraintsBuilder.Add(stringBuilder.ToStringAndFree()); 800attributesBuilder.Add(stringBuilder.ToStringAndFree()); 851namedArgumentsBuilder.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)

1222result.Add(typeParameter);

Symbols\Source\SourcePropertyAccessorSymbol.cs (2)

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

Symbols\Source\SourceTypeParameterSymbol.cs (1)

126mergedAttributesBuilder.Add(syntax.AttributeLists);

Symbols\Source\TypeParameterBuilder.cs (2)

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

Symbols\SubstitutedMethodSymbol.cs (1)

356substituted.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 (4)

484builder.Add(location); 558boundAttributeArrayBuilder.Add(boundAttribute); 633syntaxBuilder.Add(attribute); 649bindersBuilder.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\SynthesizedEmbeddedExtensionMarkerNameAttributeSymbol.cs (1)

49statements.Add(f.Assignment(

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)

131newTypeParametersBuilder.Add(newTp); 175parameters.Add(currentParameters[i]);

Symbols\TypeSymbol.cs (3)

365result.Add(@interface); 1331implementations.Add((candidate, bases)); 1335implementations.Add((candidate, null));

Symbols\TypeSymbolExtensions.cs (2)

2068paramsBuilder.Add(paramType); 2122builder.Add(attr);

Symbols\TypeWithAnnotations.cs (1)

647transforms.Add(flag);

Symbols\UnboundGenericType.cs (1)

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

Syntax\CSharpPragmaWarningStateMap.cs (1)

72directiveList.Add(w);

Syntax\CSharpSyntaxNode.cs (1)

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

Syntax\CSharpSyntaxTree.cs (10)

260states.Add(currentState); 261positions.Add(((ElifDirectiveTriviaSyntax)directive).ElifKeyword.SpanStart); 265states.Add(currentState); 266positions.Add(((ElseDirectiveTriviaSyntax)directive).ElseKeyword.SpanStart); 270states.Add(currentState); 271positions.Add(((EndIfDirectiveTriviaSyntax)directive).EndIfKeyword.SpanStart); 275states.Add(currentState); 276positions.Add(((DefineDirectiveTriviaSyntax)directive).Name.SpanStart); 280states.Add(currentState); 281positions.Add(((UndefDirectiveTriviaSyntax)directive).Name.SpanStart);

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