Add

Binder\Binder.CapturedParametersFinder.cs (2)

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

Binder\Binder.cs (1)

840binders.Add(binder);

Binder\Binder.IdentifierUsedAsValueFinder.cs (1)

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

Binder\Binder.QueryTranslationState.cs (1)

103b.Add(name);

Binder\Binder.ValueChecks.cs (11)

2094escapeArguments.Add(tuple); 2098mixableArguments.Add(new MixableDestination(tuple.Parameter, receiver)); 2130mixableArguments.Add(new MixableDestination(parameter, argument)); 2144escapeArguments.Add(new EscapeArgument(parameter, argument, refKind)); 2195escapeArguments.Add(new EscapeArgument(parameter: null, argument, refKind, isArgList: true)); 2199mixableArguments.Add(new MixableDestination(argument, EscapeLevel.CallingMethod)); 2323escapeValues.Add(new EscapeValue(parameter: null, argument, EscapeLevel.ReturnOnly, isRefEscape: true)); 2328escapeValues.Add(new EscapeValue(parameter: null, argument, EscapeLevel.CallingMethod, isRefEscape: false)); 2336escapeValues.Add(new EscapeValue(parameter, argument, valEscapeLevel, isRefEscape: false)); 2343escapeValues.Add(new EscapeValue(parameter, argument, refEscapeLevel, isRefEscape: true)); 4552arguments.Add(call.Arguments[0]);

Binder\Binder_AnonymousTypes.cs (1)

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

Binder\Binder_Attributes.cs (3)

494boundNamedArgumentsBuilder.Add(boundNamedArgument); 869builder.Add(VisitExpression(argument, diagnostics, ref attrHasErrors, curArgumentHasErrors)); 891builder.Add(kv.Value);

Binder\Binder_Constraints.cs (4)

289constraintTypes.Add(type); 290syntaxBuilder!.Add(typeConstraintSyntax); 329builder.Add(GetDefaultTypeParameterConstraintClause(typeParameterSyntax)); 389constraintTypeBuilder.Add(constraintType);

Binder\Binder_Conversions.cs (3)

468builder.Add(newCase); 933locationBuilder.Add(argument.NameColon?.Name.Location); 957convertedArguments.Add(CreateConversion(argument.Syntax, argument, elementConversion, isCast: isCast, elementConversionGroup, destType.Type, diagnostics));

Binder\Binder_Crefs.cs (7)

373builder.Add(this.GetSpecialType(memberName == "nint" ? SpecialType.System_IntPtr : SpecialType.System_UIntPtr, diagnostics, syntax).AsNativeInteger()); 684unwrappedSymbols.Add(UnwrapAliasNoDiagnostics(wrapped)); 741candidates.Add(constructedCandidate); 835viable.Add(candidate); 852viable.Add(candidate); 901typeArgumentsWithAnnotations.Add(typeArgument); 940parameterBuilder.Add(new SignatureOnlyParameterSymbol(TypeWithAnnotations.Create(type), ImmutableArray<CustomModifier>.Empty, isParams: 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); 784builder.Add(BindDeconstructionVariables(arg.Expression, diagnostics, ref declaration, ref expression)); 842builder.Add(BindDeconstructionVariables(declTypeWithAnnotations, n, n, diagnostics));

Binder\Binder_Expressions.cs (38)

332boundArgs.Add(BindToNaturalType(arg, diagnostics, reportNoTargetType)); 927builder.Add(BindDeclarationVariablesForErrorRecovery(declTypeWithAnnotations, n, n, diagnostics)); 928namesBuilder.Add(InferTupleElementName(n)); 993elementLocations.Add(nameSyntax.Location); 997elementLocations.Add(argumentSyntax.Location); 1009boundArguments.Add(boundArgument); 1012elementTypesWithAnnotations.Add(elementTypeWithAnnotations); 1115builder.Add(true); 1119builder.Add(false); 3085result.RefKinds.Add(RefKind.None); 3092result.RefKinds.Add(refKind); 3106result.Names.Add(null); 3124result.Names.Add(null); 3127result.Arguments.Add(boundArgumentExpression); 3344sizes.Add(size); 3366sizes.Add(size); 3500exprBuilder.Add(boundExpression); 3532exprBuilder.Add(boundExpression); 3578initializers.Add(convertedExpression); 3606initializers.Add(init); 3828builder.Add(BindExpression(size, BindingDiagnosticBag.Discarded)); 4750children.Add(boundInitializer); 4849initializers.Add(boundMemberInitializer); 5355initializerBuilder.Add(boundElementInitializer); 5449exprBuilder.Add(BindValue(childElementInitializer, diagnostics, BindValueKind.RValue)); 5589builder?.Add(constructor); 5784childNodes.Add(boundInitializerOpt ?? makeBoundInitializerOpt()); 7065if ((object)m != null) builder.Add(m); 7131extensionMethodArguments.Arguments.Add(receiver); 7136extensionMethodArguments.Names.Add(null); 7142extensionMethodArguments.RefKinds.Add(RefKind.None); 7794methodOrPropertyGroup.Add(symbol); 8278indexerGroup.Add((PropertySymbol)symbol); 8681analyzedArguments.Arguments.Add(intPlaceholder); 8757analyzedArguments.Arguments.Add(startArgumentPlaceholder); 8758analyzedArguments.Arguments.Add(lengthArgumentPlaceholder); 9258fieldsBuilder.Add( 9269fieldsBuilder.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)); 337partsArrayBuilder.Add(unconvertedInterpolatedString.Parts); 469partsArrayBuilder.Add(unconvertedInterpolatedString.Parts); 570refKindsBuilder.Add(RefKind.None); 571refKindsBuilder.Add(RefKind.None); 581refKindsBuilder.Add(RefKind.Out); 674argumentsBuilder.Add(new BoundLiteral(syntax, ConstantValue.Create(baseStringLength), intType) { WasCompilerGenerated = true }); 676argumentsBuilder.Add(new BoundLiteral(syntax, ConstantValue.Create(numFormatHoles), intType) { WasCompilerGenerated = true }); 710partsBuilder.Add(insert.Update(newValue, insert.Alignment, insert.Format, isInterpolatedStringHandlerAppendCall: false)); 714partsBuilder?.Add(part); 720partsBuilder?.Add(part); 761argumentsBuilder.Add(insert.Value); 762parameterNamesAndLocationsBuilder.Add(null); 770argumentsBuilder.Add(insert.Alignment); 771parameterNamesAndLocationsBuilder.Add(("alignment", insert.Alignment.Syntax.Location)); 776argumentsBuilder.Add(insert.Format); 777parameterNamesAndLocationsBuilder.Add(("format", insert.Format.Syntax.Location)); 787argumentsBuilder.Add(boundLiteral.Update(ConstantValue.Create(literalText), boundLiteral.Type)); 808builderAppendCalls.Add(call); 809positionInfo.Add((isLiteral, hasAlignment, hasFormat)); 836builderAppendCallsArray.Add(builderAppendCalls.ToImmutableAndClear()); 837positionInfoArray.Add(positionInfo.ToImmutableAndClear()); 1028argumentPlaceholdersBuilder.Add( 1038argumentRefKindsBuilder.Add(refKind);

Binder\Binder_Invocation.cs (9)

57builder.Add(result.Member); 836finalCandidates.Add(result.Member); 1327argumentsBuilder.Add(bindDefaultArgument(node, parameter, containingMember, enableCallerInfo, diagnostics, argumentsBuilder, argumentsCount, argsToParamsOpt)); 1331argumentRefKindsBuilder.Add(RefKind.None); 1334argsToParamsBuilder?.Add(parameter.Ordinal); 1608constructedMethods.Add(m.ConstructedFrom == m && m.Arity == typeArgumentsWithAnnotations.Length ? m.Construct(typeArgumentsWithAnnotations) : m); 1651parameterListList.Add(m.Parameters); 1671parameterListList.Add(p.Parameters); 2016methodsBuilder.Add(funcPtr.Signature);

Binder\Binder_Lambda.cs (8)

71namesBuilder.Add(simple.Parameter.Identifier.ValueText); 197namesBuilder.Add(p.Identifier.ValueText); 198typesBuilder.Add(type); 199refKindsBuilder.Add(refKind); 200scopesBuilder.Add(scope); 201attributesBuilder.Add(syntax.Kind() == SyntaxKind.ParenthesizedLambdaExpression ? p.AttributeLists : default); 202defaultValueBuilder.Add(p.Default); 259discardsBuilder.Add(p.Identifier.IsUnderscoreToken());

Binder\Binder_Lookup.cs (2)

1110result.Add(@interface); 1270hidingSymbols.Add(sym); // not hidden

Binder\Binder_Operators.cs (2)

1307builder.Add(method); 1400builder.Add(method);

Binder\Binder_Patterns.cs (11)

236analyzedArguments.Arguments.Add(argumentPlaceholder); 282builder.Add(boundPattern); 385analyzedArguments.Arguments.Add(argumentPlaceholder); 1093patterns.Add(boundSubpattern); 1122patterns.Add(boundSubpattern); 1140patterns.Add(boundSubpattern); 1182patterns.Add(boundSubpattern); 1415subPatterns.Add(new BoundPositionalSubpattern(variable, symbol: null, pattern)); 1438subPatterns.Add(new BoundPositionalSubpattern(variable, symbol: null, pattern)); 1494builder.Add(new BoundPropertySubpattern(p, member, isLengthOrCount, boundPattern)); 1754candidates.Add(pat.NarrowedType);

Binder\Binder_Query.cs (1)

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

Binder\Binder_Statements.cs (5)

1147args.invalidDimensions.Add(size); 1877boundStatements.Add(boundStatement); 2773statementBuilder.Add(statement); 3129catchBlocks.Add(catchBlock); 3567boundStatements.Add(boundStatement);

Binder\Binder_Symbols.cs (7)

692types.Add(argumentType); 704locations.Add(nameToken.GetLocation()); 708locations.Add(argumentSyntax.Location); 770elementNames.Add(name); 779elementNames.Add(null); 781elementNames.Add(name); 1341args.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)

28tests.Add(new Tests.One(new BoundDagTypeTest(list.Syntax, ErrorType(), input, hasErrors: true))); 42tests.Add(new Tests.One(lengthEvaluation)); 44tests.Add(new Tests.One(list.HasSlice 66tests.Add(new Tests.One(sliceEvaluation)); 68tests.Add(MakeTestsAndBindings(sliceTemp, slicePattern, bindings)); 81tests.Add(new Tests.One(indexEvaluation)); 83tests.Add(MakeTestsAndBindings(indexTemp, subpattern, bindings)); 89bindings.Add(new BoundPatternBinding(list.VariableAccess, input));

Binder\ExpressionVariableFinder.cs (6)

229_variablesBuilder.Add(variable); 255_variablesBuilder.Add(variable); 278_variablesBuilder.Add(variable); 290_variablesBuilder.Add(variable); 367_variablesBuilder.Add(variable); 450_variablesBuilder.Add(variable);

Binder\FixedStatementBinder.cs (1)

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

Binder\ForEachLoopBinder.cs (3)

142locals.Add(localSymbol); 1199candidateMethods.Add((MethodSymbol)member); 1726argsBuilder.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)

216locals.Add(localSymbol); 281locals.Add(localSymbol); 327labels.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)

610placeholders.Add((interpolationData.ReceiverPlaceholder, _localScopeDepth)); 631placeholders.Add((placeholder, valEscapeScope)); 717placeholders.Add((placeholder, valEscapeScope)); 759placeholders.Add((conversion.DeconstructionInfo.InputPlaceholder, GetValEscape(right, _localScopeDepth))); 774placeholders.Add((arg, valEscape)); 823builder.Add(getDeconstructionAssignmentVariable(arg)); 867placeholders.Add((targetPlaceholder, collectionEscape));

Binder\Semantics\AccessCheck.cs (1)

664baseInterfaces.Add(definition);

Binder\Semantics\BestTypeInferrer.cs (2)

139candidateTypes.Add(type1); 155candidateTypes.Add(type2);

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

1020builder.Add(analysis.Operator);

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

323analyzedArguments.Arguments.Add(new BoundParameter(syntax, parameter) { WasCompilerGenerated = true }); 324analyzedArguments.RefKinds.Add(parameter.RefKind);

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

1122innerConversions.Add(nestedConversion); 2205argumentConversions.Add(result); 2278nestedConversions.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)

248candidates.Add(op2); 320u.Add(UserDefinedConversionAnalysis.Lifted(constrainedToTypeOpt, op, liftedFromConversion, liftedToConversion, nullableFrom, nullableTo)); 352u.Add(UserDefinedConversionAnalysis.Normal(constrainedToTypeOpt, op, fromConversion, toConversion, convertsFrom, convertsTo));

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

320u.Add(UserDefinedConversionAnalysis.Normal(constrainedToTypeOpt, op, fromConversion, toConversion, convertsFrom, convertsTo)); 348u.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 (41)

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

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

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

262operators.Add(pointerOperator.Value); 279results.Add(UnaryOperatorAnalysisResult.Applicable(op, conversion)); 283results.Add(UnaryOperatorAnalysisResult.Inapplicable(op, conversion)); 315operators.Add(new UnaryOperatorSignature(kind | UnaryOperatorKind.Enum, enumType, enumType)); 316operators.Add(new UnaryOperatorSignature(kind | UnaryOperatorKind.Lifted | UnaryOperatorKind.Enum, nullableEnum, nullableEnum)); 526operators.Add(new UnaryOperatorSignature(UnaryOperatorKind.UserDefined | kind, operandType, resultType, op, constrainedToTypeOpt)); 556operators.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)

38this.Methods.Add(method); 52this.Methods.Add((MethodSymbol)member);

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

3079builder.Add(fixedResult.Type);

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

682builder.Add(member); 708results.Add(new MemberResolutionResult<MethodSymbol>(constructor, constructor, MemberAnalysisResult.UnsupportedMetadata(), hasTypeArgumentInferredFromFunctionType: false)); 730results.Add(new MemberResolutionResult<MethodSymbol>(constructor, constructor, result, hasTypeArgumentInferredFromFunctionType: false)); 913results.Add(new MemberResolutionResult<TMember>(member, leastOverriddenMember, MemberAnalysisResult.UnsupportedMetadata(), hasTypeArgumentInferredFromFunctionType: false)); 972results.Add(result); 2693_returns.Add(node); 3158types.Add(parameter.TypeWithAnnotations); 3168refs.Add(paramRefKind); 3173refs.Add(paramRefKind); 3247types.Add(parm == parameters.Length - 1 ? ((ArrayTypeSymbol)type.Type).ElementTypeWithAnnotations : type); 3252refs.Add(paramRefKind); 3655badArguments.Add(argumentPosition); 3716badArguments.Add(argumentPosition); 3722conversions.Add(conversion); 3728conversions.Add(conversion);

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

141result.Add(res.Member);

Binder\SwitchBinder.cs (1)

232labels.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)

143typesInOrder.Add(type); 179builder.Add(boundArm);

Binder\UsingStatementBinder.cs (1)

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

BoundTree\BoundExpressionExtensions.cs (4)

160symbols.Add(delegateCreation.MethodOpt); 172symbols.Add(s); 181symbols.Add(ctor); 215symbols.Add(symbol);

BoundTree\BoundTreeRewriter.cs (1)

51newList.Add((T)visited);

BoundTree\LengthBasedStringSwitchData.cs (4)

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

BoundTree\NullabilityRewriter.cs (1)

207builder.Add(updatedSymbol);

BoundTree\UnboundLambda.cs (7)

222types.Add((returnStatement.ExpressionOpt!, type, returnStatement.Checked)); 380_builder.Add((node, TypeWithAnnotations.Create(type))); 650parameterRefKindsBuilder.Add(refKind); 651parameterScopesBuilder.Add(scope); 652parameterTypesBuilder.Add(type); 1071refKindsBuilder.Add(p.RefKind); 1072typesBuilder.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()); 1960casesBuilder.Add((value, GetLabelClone(label)));

CodeGen\Optimizer.cs (10)

104dummies.Add(locInfo); 140defs.Add(def); 222defs.Add(newDef); 543_evalStack.Add((result, context)); 736rewrittenSideeffects.Add(rewrittenSideeffect); 1220rewrittenArguments.Add(rewrittenArg); 1712rewrittenInitializers.Add(rewrittenInitializer); 1861defs.Add(nextDef); 1883locInfo.LocalDefs.Add(locDef); 1913locInfo.LocalDefs.Add(locDef);

CommandLine\CSharpCommandLineParser.cs (8)

475instrumentationKinds.Add(instrumentationKind); 1715builder.Add(sdkDirectoryOpt); 1773defines.Add(id); 2087ids.Add(errorCode); 2090ids.Add(CSharp.MessageProvider.Instance.GetIdForErrorCode((int)ErrorCode.WRN_MissingNonNullTypesContextForAnnotation)); 2091ids.Add(CSharp.MessageProvider.Instance.GetIdForErrorCode((int)ErrorCode.WRN_MissingNonNullTypesContextForAnnotationInGeneratedCode)); 2100ids.Add(CSharp.MessageProvider.Instance.GetIdForErrorCode(number)); 2108ids.Add(id);

Compilation\BuiltInOperators.cs (5)

44builder.Add(GetSignature((UnaryOperatorKind)kind)); 255operators.Add(op); 297builder.Add(GetSignature((BinaryOperatorKind)kind)); 686operators.Add(op); 702operators.Add(_builtInUtf8Concatenation.Value);

Compilation\CSharpCompilation.cs (13)

1232assemblies.Add(referenceManager.ReferencedAssemblies[i]); 1406builder.Add(referenceManager.ReferencedAssemblies[i].GlobalNamespace); 1482boundUsings.Add(previousUsing); 1807entryPointCandidates.Add(simpleProgramEntryPointSymbol); 1847taskEntryPoints.Add((IsCandidate, candidate, perCandidateBag)); 1860viableEntryPoints.Add(candidate); 1875viableEntryPoints.Add(Candidate); 1986entryPointCandidates.Add(method); 3581builder.Add((byte)b); 3834typesBuilder.Add(TypeWithAnnotations.Create(elementType, annotation)); 3902fields.Add(new AnonymousTypeField(name, location, TypeWithAnnotations.Create(type, nullableAnnotation), RefKind.None, ScopedKind.None)); 4596spine.Add(current); 4617spine.Add(current);

Compilation\CSharpCompilation.UsingsFromOptionsAndDiagnostics.cs (1)

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

Compilation\CSharpCompilerDiagnosticAnalyzer.cs (1)

38builder.Add((int)errorCode);

Compilation\CSharpSemanticModel.cs (15)

1673results.Add(reduced.GetPublicSymbol()); 1698results.Add(RemapSymbolIfNecessary(uniqueSymbol).GetPublicSymbol()); 1756results.Add(RemapSymbolIfNecessary(singleSymbol).GetPublicSymbol()); 1762results.Add(RemapSymbolIfNecessary(symbol).GetPublicSymbol()); 1770results.Add(RemapSymbolIfNecessary(symbol).GetPublicSymbol()); 1806builder?.Add(result); 2022builder.Add(s); 3611if (query.Operation != null && (object)query.Operation.ExpressionSymbol != null) builder.Add(query.Operation.ExpressionSymbol); 3612if ((object)query.DefinedSymbol != null) builder.Add(query.DefinedSymbol); 3613if (query.Cast != null && (object)query.Cast.ExpressionSymbol != null) builder.Add(query.Cast.ExpressionSymbol); 4132builder.Add(indexer); 4509symbols.Add(param.GetPublicSymbol()); 4674methods.Add(method); 4675filteredMethods.Add(constructedMethod); 5328builder.Add(new SimpleImportScope(

Compilation\SyntaxAndDeclarationManager.cs (4)

163treesBuilder.Add(tree); 260loadDirectives.Add(new LoadDirective(resolvedFilePath, diagnostics.ToReadOnlyAndFree())); 496treesBuilder.Add(tree); 618treesBuilder.Add(tree);

Compilation\SyntaxTreeSemanticModel.cs (1)

1986builder.Add(field);

Compiler\AnonymousTypeMethodBodySynthesizer.cs (1)

136fields.Add(prop.BackingField);

Compiler\DocumentationCommentCompiler.cs (2)

461result.Add(elementSyntax); 709builder.Add(trivia);

Compiler\DocumentationCommentCompiler.DocumentationCommentWalker.cs (1)

206_includeElementNodes.Add((CSharpSyntaxNode)node);

Compiler\MethodBodySynthesizer.cs (5)

61statements.Add(baseConstructorCall); 69statements.Add(loweredBody); 101statements.Add(new BoundExpressionStatement(syntax, 118statements.Add( 146statements.Add(

Compiler\MethodBodySynthesizer.Lowered.cs (1)

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

Compiler\MethodCompiler.cs (5)

1280initializers.Add(factory.Assignment(factory.Field(factory.This(), field), factory.Parameter(parameter))); 1711awaiters.Add(null); 1723hoistedVariables.Add(new EncHoistedLocalInfo(true)); 1736awaiters.Add(null); 1742hoistedVariables.Add(new EncHoistedLocalInfo(true));

Compiler\TypeCompilationState.cs (1)

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

CSharpCompilationOptions.cs (10)

CSharpDeclarationComputer.cs (16)

CSharpParseOptions.cs (3)

185builder.Add(Diagnostic.Create(MessageProvider.Instance, (int)ErrorCode.ERR_BadLanguageVersion, LanguageVersion.ToString())); 194builder.Add(Diagnostic.Create(MessageProvider.Instance, (int)ErrorCode.ERR_InvalidPreprocessingSymbol, "null")); 198builder.Add(Diagnostic.Create(MessageProvider.Instance, (int)ErrorCode.ERR_InvalidPreprocessingSymbol, symbol));

Declarations\DeclarationTable.cs (1)

130builder.Add(_latestLazyRootDeclaration.Value);

Declarations\DeclarationTreeBuilder.cs (7)

78childrenBuilder.Add(namespaceOrType); 124childrenBuilder.Add(CreateSimpleProgram(firstGlobalStatement, hasAwaitExpressions, isIterator, hasReturnWithExpression, diagnostics)); 135childrenBuilder.Add(CreateImplicitClass(memberNames, container, declFlags)); 197rootChildren.Add(decl); 201scriptChildren.Add((SingleTypeDeclaration)decl); 209rootChildren.Add( 231directives.Add(new ReferenceDirective(directiveNode.File.ValueText, new SourceLocation(directiveNode)));

Declarations\MergedNamespaceDeclaration.cs (7)

71builder.Add(loc); 113types.Add(asType); 131namespaces.Add(asNamespace); 146children.Add(MergedNamespaceDeclaration.Create(namespaces.ToImmutableAndFree())); 155children.Add(MergedNamespaceDeclaration.Create(namespaceGroup)); 164children.Add(new MergedTypeDeclaration(types.ToImmutableAndFree())); 173children.Add(new MergedTypeDeclaration(typeGroup));

Declarations\MergedTypeDeclaration.cs (4)

96attributeSyntaxListBuilder.Add(attributesSyntaxList); 172builder.Add(loc); 194nestedTypes.Add(asType); 208children.Add(new MergedTypeDeclaration(typeGroup));

DocumentationComments\SourceDocumentationCommentUtils.cs (1)

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

Emitter\EditAndContinue\CSharpSymbolMatcher.cs (5)

248builder.Add((Cci.INamespaceTypeDefinition)member.GetCciAdapter()); 630otherParamRefCustomModifiersBuilder.Add(VisitCustomModifiers(param.RefCustomModifiers)); 631otherParamsBuilder.Add(param.TypeWithAnnotations.WithTypeAndModifiers(otherType, VisitCustomModifiers(param.TypeWithAnnotations.CustomModifiers))); 1127translatedParamsBuilder.Add(param.TypeWithAnnotations.WithTypeAndModifiers(translatedParamType, VisitCustomModifiers(param.TypeWithAnnotations.CustomModifiers))); 1128translatedParamRefCustomModifiersBuilder.Add(VisitCustomModifiers(param.RefCustomModifiers));

Emitter\EditAndContinue\PEDeltaAssemblyBuilder.cs (1)

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

872builder.Add(arg); 977builder.Add(@interface);

Emitter\Model\PEAssemblyBuilder.cs (3)

127builder.Add((Cci.IFileReference)Translate(modules[i], context.Diagnostics)); 137builder.Add(resource); 174builder.Add(new Cci.ManagedResource(

Emitter\Model\PEModuleBuilder.cs (4)

273debugDocuments.Add(debugDocument); 574builder.Add(new Cci.ExportedType((Cci.ITypeReference)symbol.GetCciAdapter(), parentIndex, isForwarder: false)); 767builder.Add(new Cci.ExportedType(type.GetCciAdapter(), parentIndex, isForwarder: true)); 1465builder.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)

2498arg.parts.Add(interpolatedString);

FlowAnalysis\AbstractFlowPass.PendingBranchesCollection.cs (2)

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

FlowAnalysis\ControlFlowPass.cs (1)

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

FlowAnalysis\DefiniteAssignment.cs (2)

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

123builder.Add( 132builder.Add( 154builder.Add(AppendImplicitReturn((BoundBlock)statements[n - 1], method));

FlowAnalysis\NullableWalker.cs (23)

2845_returnTypesOpt.Add((node, result.ToTypeWithAnnotations(compilation))); 3989builder.Add( 4193expressionsNoConversions.Add(expressionNoConversion); 4194conversions.Add(conversion); 4197expressionTypes.Add(expressionType); 4201placeholderBuilder.Add(CreatePlaceholderIfNecessary(expressionNoConversion, expressionType.ToTypeWithAnnotations(compilation))); 4322resultTypes.Add(resultType); 4323placeholdersBuilder.Add(CreatePlaceholderIfNecessary(returnExpr, resultType)); 4369builder.Add(child); 4933slotBuilder.Add(slot); 6271notNullParametersBuilder?.Add(parameter); 6472resultsBuilder.Add(VisitArgumentEvaluate(arguments[i], GetRefKind(refKindsOpt, i), parameterAnnotationsOpt.IsDefault ? default : parameterAnnotationsOpt[i])); 6603conversionResultsBuilder?.Add(_visitResult); 6624conversionResultsBuilder?.Add(result.VisitResult); 6627conversionResultsBuilder?.Add(result.VisitResult); 6966argumentsBuilder.Add(argument); 6967conversionsBuilder.Add(conversion); 7139builder.Add(getArgumentForMethodTypeInference(arguments[i], argumentResult, lambdaState)); 8923arguments.Add(CreatePlaceholderIfNecessary(receiverOpt, receiverType.ToTypeWithAnnotations(compilation))); 8931arguments.Add(new BoundExpressionWithNullability(syntax, new BoundParameter(syntax, parameter), parameterType.NullableAnnotation, parameterType.Type)); 9297placeholderArgs.Add(CreatePlaceholderIfNecessary(right, rightResult.ToTypeWithAnnotations(compilation))); 9300placeholderArgs.Add(new BoundExpressionWithNullability(variables[i].Expression.Syntax, variables[i].Expression, NullableAnnotation.Oblivious, conversion.DeconstructionInfo.OutputPlaceholders[i].Type)); 9470builder.Add(getDeconstructionAssignmentVariable(argument));

FlowAnalysis\NullableWalker.Variables.cs (2)

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

FlowAnalysis\NullableWalker_Patterns.cs (4)

893expressions.Add(expression); 894conversions.Add(conversion); 896resultTypes.Add(armType); 900placeholderBuilder.Add(CreatePlaceholderIfNecessary(expression, armType.ToTypeWithAnnotations(compilation)));

Lowering\AsyncRewriter\AsyncExceptionHandlerRewriter.cs (20)

210statements.Add(_F.HiddenSequencePoint()); 212locals.Add(pendingExceptionLocal); 213statements.Add(_F.Assignment(_F.Local(pendingExceptionLocal), _F.Default(pendingExceptionLocal.Type))); 214locals.Add(pendingBranchVar); 215statements.Add(_F.Assignment(_F.Local(pendingBranchVar), _F.Default(pendingBranchVar.Type))); 220locals.Add(returnLocal); 223statements.Add(catchAndPendException); 224statements.Add(syntheticFinally); 274bodyStatements.Add(_F.Label(proxy)); 277bodyStatements.Add(_F.Assignment(_F.Local(pendingBranchVar), _F.Literal(i))); 280bodyStatements.Add(_F.Goto(finallyLabel)); 303cases.Add(caseStatement); 341cases.Add(caseStatement); 472handlers.Add(_F.SwitchSection( 582prologueBuilder.Add(_F.ExpressionStatement(storePending)); 585prologueBuilder.Add(_F.ExpressionStatement(AssignCatchSource((BoundExpression)this.Visit(sourceOpt), currentAwaitCatchFrame))); 590prologueBuilder.Add(rewrittenPrologue); 610handlerStatements.Add(_F.HiddenSequencePoint()); 618handlerStatements.Add(_F.ExpressionStatement(assignSource)); 622handlerStatements.Add((BoundStatement)this.Visit(node.Body));

Lowering\AsyncRewriter\AsyncIteratorMethodToStateMachineRewriter.cs (12)

160builder.Add( 176builder.Add(GenerateClearCurrent()); 179builder.Add(GenerateCompleteOnBuilder()); 182builder.Add(F.ExpressionStatement(F.Call( 270blockBuilder.Add( 274blockBuilder.Add( 278blockBuilder.Add( 282blockBuilder.Add( 286blockBuilder.Add(F.HiddenSequencePoint()); 288blockBuilder.Add( 293blockBuilder.Add( 297blockBuilder.Add(

Lowering\AsyncRewriter\AsyncMethodToStateMachineRewriter.cs (30)

144bodyBuilder.Add(F.HiddenSequencePoint()); 145bodyBuilder.Add(F.Assignment(F.Local(cachedState), F.Field(F.This(), stateField))); 146bodyBuilder.Add(CacheThisIfNeeded()); 149bodyBuilder.Add( 162bodyBuilder.Add(F.Label(_exprReturnLabel)); 170bodyBuilder.Add(stateDone); 174bodyBuilder.Add(F.SequencePointWithSpan(block, block.CloseBraceToken.Span, stateDone)); 175bodyBuilder.Add(F.HiddenSequencePoint()); 179bodyBuilder.Add(GenerateHoistedLocalsCleanup(rootScopeHoistedLocals)); 181bodyBuilder.Add(GenerateSetResultCall()); 184bodyBuilder.Add(F.Label(_exitLabel)); 185bodyBuilder.Add(F.Return()); 190locals.Add(cachedState); 191if ((object)cachedThis != null) locals.Add(cachedThis); 192if ((object)_exprRetValue != null) locals.Add(_exprRetValue); 283builder.Add(F.Assignment(F.Field(F.This(), hoistedLocal), F.NullOrDefault(hoistedLocal.Type))); 465blockBuilder.Add( 469blockBuilder.Add( 473blockBuilder.Add( 481blockBuilder.Add(awaiterTemp.Type.IsDynamic() 485blockBuilder.Add( 488blockBuilder.Add( 491blockBuilder.Add( 495blockBuilder.Add( 504blockBuilder.Add( 507blockBuilder.Add( 543blockBuilder.Add( 551blockBuilder.Add(F.Assignment(F.Local(thisTemp), F.This())); 554blockBuilder.Add( 584blockBuilder.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( 266bodyBuilder.Add(GenerateParameterStorage(stateMachineVariable, proxies)); 269bodyBuilder.Add( 668builder.Add( 672builder.Add( 676builder.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\ClosureConversion\ClosureConversion.Analysis.cs (3)

344closure.CapturedEnvironments.Add(env); 499closure.CapturedEnvironments.Add(targetEnv); 539closureDebugInfo.Add(new ClosureDebugInfo(syntaxOffset, closureId));

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

505_labelsInScope.Peek().Add(node.Label); 557_currentScope.NestedFunctions.Add(new NestedFunction(functionSymbol, blockSyntax: null)); 564_currentScope.NestedFunctions.Add(function); 716_scopesAfterLabel[label].Add(scope); 728parentScope.NestedScopes.Add(newScope);

Lowering\ClosureConversion\ClosureConversion.cs (19)

295_addedStatements.Add(body); 479environments.Add(env.SynthesizedEnvironment); 630result.Add(stmt); 634result.Add(new BoundExpressionStatement(node.Syntax, (BoundExpression)(BoundNode)node)); 668prologue.Add(new BoundAssignmentOperator(syntax, 685prologue.Add(assignment); 711addedLocals.Add(framePointer); 797prologue.Add(assignToProxy); 895argumentsBuilder.Add(frame); 989builder.Add(newTypeArg); 1125if (replacement != null) prologue.Add(replacement); 1156newStatements.Add(BoundSequencePoint.CreateHidden()); 1166newStatements.Add(replacement); 1244prologueBuilder.Add(new BoundExpressionStatement(p.Syntax, p) { WasCompilerGenerated = true }); 1301newStatements.Add((BoundStatement)this.Visit(s)); 1479_lambdaDebugInfoBuilder.Add(new LambdaDebugInfo(syntaxOffset, lambdaId, closureOrdinal)); 1583_synthesizedMethods.Add( 1693_addedLocals.Add(cacheLocal); 1696_addedStatements.Add(F.Assignment(cache, F.Null(type)));

Lowering\ClosureConversion\ExpressionLambdaRewriter.cs (10)

322builder.Add(index); 333builder.Add(Visit(arg)); 763locals.Add(param); 765parameters.Add(parameterReference); 769initializers.Add(_bound.AssignmentExpression(parameterReference, parameter)); 884builder.Add(ExprFactory("ListBind", left, value)); 890builder.Add(ExprFactory("Bind", left, value)); 896builder.Add(ExprFactory("MemberBind", left, value)); 921builder.Add(elementInit); 980membersBuilder.Add(_bound.MethodInfo(AnonymousTypeManager.GetAnonymousTypeProperty(anonType, i).GetMethod));

Lowering\ClosureConversion\SynthesizedClosureEnvironment.cs (3)

68internal void AddHoistedField(LambdaCapturedVariable captured) => _membersBuilder.Add(captured); 109builder.Add(StaticConstructor); 110builder.Add(SingletonCache);

Lowering\ClosureConversion\SynthesizedClosureMethod.cs (1)

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

310prologueBuilder.Add(_factory.ExpressionStatement(_factory.Call(receiver: _factory.Local(_scope.ContextVariable), parameterLogger, 317prologueBuilder.Add(previousPrologue); 570builder.Add(store); 574builder.Add(invocation); 597builder.Add(_factory.Call(

Lowering\IteratorRewriter\IteratorMethodToStateMachineRewriter.cs (8)

430bodyStatements.Add(F.Assignment(F.Field(F.This(), stateField), F.Literal(frame.finalizeState))); 431bodyStatements.Add(rewrittenBody); 432bodyStatements.Add(F.ExpressionStatement(F.Call(F.This(), finallyMethod))); 438bodyStatements.Add(F.Goto(dropThrough)); 447bodyStatements.Add(F.Label(proxy)); 450bodyStatements.Add(F.ExpressionStatement(F.Call(F.This(), finallyMethod))); 454bodyStatements.Add(F.Goto(parentProxy)); 457bodyStatements.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 (3)

625statements.Add(block.Update(block.Locals, block.LocalFunctions, block.HasUnsafeModifier, block.Instrumentation, ImmutableArray.Create(statement))); 629statements.Add(RewriteExpressionStatement((BoundExpressionStatement)initializer, suppressInstrumentation: true)); 634statements.Add(VisitStatement(initializer));

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

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

102_temps.Add(temp); 166refKindBuilder.Add(refKind); 167argBuilder.Add(expression); 629newArguments.Add(_tempAllocator.GetTemp(temp));

Lowering\LocalRewriter\LocalRewriter_BasePatternSwitchLocalRewriter.cs (1)

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

Lowering\LocalRewriter\LocalRewriter_BinaryOperator.cs (2)

1415sideeffects.Add(tempAssignment); 1416locals.Add(tempAccess.LocalSymbol);

Lowering\LocalRewriter\LocalRewriter_Block.cs (2)

38builder.Add(epilogue); 59builder.Add(statement);

Lowering\LocalRewriter\LocalRewriter_Call.cs (18)

478tempsOpt.Add(receiverTemp.LocalSymbol); 503visitedArgumentsBuilder.Add(_factory.MakeTempForDiscard(discard, tempsOpt)); 516visitedArgumentsBuilder.Add(VisitExpression(argument)); 556storesOpt.Add(extraRefInitialization); 559storesOpt.Add(assignmentToTemp); 641tempsOpt.Add(local.LocalSymbol); 704temps.Add(cache.LocalSymbol); 710temps.Add(intermediateRef.LocalSymbol); 975argumentsBuilder.Add(operationFactory.CreateArgumentOperation(argumentKind, parameters[i].GetPublicSymbol(), arguments[i])); 984argumentsBuilder.Add(operationFactory.CreateArgumentOperation(argumentKind, null, arguments[i])); 1115storesToTemps.Add(assignment); 1182paramArray.Add(arguments[i]); 1191argumentsInEvaluationBuilder.Add(operationFactory.CreateArgumentOperation(kind, parameter.GetPublicSymbol(), argument)); 1204argumentsInEvaluationBuilder.Add(operationFactory.CreateArgumentOperation(kind, lastParam.GetPublicSymbol(), argument)); 1256paramArray.Add(tempStoreArgument); 1269paramArray.Add(argument); 1364temporariesBuilder.Add(((BoundLocal)s.Left).LocalSymbol); 1522temporariesBuilder.Add(boundTemp.LocalSymbol);

Lowering\LocalRewriter\LocalRewriter_CompoundAssignmentOperator.cs (30)

Lowering\LocalRewriter\LocalRewriter_Conversion.cs (4)

143builder.Add(_factory.Literal(b)); 149builder.Add(_factory.Literal((byte)0)); 167stack.Add(node); 829fieldAccessorsBuilder.Add(convertedFieldAccess);

Lowering\LocalRewriter\LocalRewriter_DeconstructionAssignmentOperator.cs (13)

254effects.assignments.Add(MakeAssignmentOperator(resultPart.Syntax, leftTarget, resultPart, leftTarget.Type, 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)

175if (clearCall != null) sideEffects.Add(clearCall); 176if (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)

135builder.Add(receiver);

Lowering\LocalRewriter\LocalRewriter_ForStatement.cs (18)

Lowering\LocalRewriter\LocalRewriter_IfStatement.cs (12)

64builder.Add(new BoundConditionalGoto(rewrittenCondition.Syntax, rewrittenCondition, false, afterif)); 65builder.Add(rewrittenConsequence); 66builder.Add(BoundSequencePoint.CreateHidden()); 67builder.Add(new BoundLabelStatement(syntax, afterif)); 89builder.Add(new BoundConditionalGoto(rewrittenCondition.Syntax, rewrittenCondition, false, alt)); 90builder.Add(rewrittenConsequence); 91builder.Add(BoundSequencePoint.CreateHidden()); 92builder.Add(new BoundGotoStatement(syntax, afterif)); 93builder.Add(new BoundLabelStatement(syntax, alt)); 94builder.Add(rewrittenAlternativeOpt); 95builder.Add(BoundSequencePoint.CreateHidden()); 96builder.Add(new BoundLabelStatement(syntax, afterif));

Lowering\LocalRewriter\LocalRewriter_IndexerAccess.cs (27)

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)

97stores.Add(store); 98temps.Add(lhsTemp.LocalSymbol); 106stores.Add(getValueOrDefaultStore); 107temps.Add(tmp.LocalSymbol);

Lowering\LocalRewriter\LocalRewriter_ObjectCreationExpression.cs (7)

161temps.Add(oldValue.LocalSymbol); 162sideEffects.Add(boundAssignmentToTemp); 207temps.Add(valueTemp.LocalSymbol); 208sideEffects.Add(boundAssignmentToTemp); 220builder.Add(initializerValue); 225builder.Add(_factory.Property(oldValue, property)); 270sideEffects.Add(boundAssignmentToTemp);

Lowering\LocalRewriter\LocalRewriter_ObjectOrCollectionInitializerExpression.cs (16)

114result.Add(rewrittenInitializer); 335dynamicSiteInitializers.Add(setMember.SiteInitialization); 336result.Add(setMember.SiteInvocation); 347dynamicSiteInitializers.Add(getMember.SiteInitialization); 357result.Add(MakeStaticAssignmentOperator(assignment.Syntax, rewrittenAccess, rewrittenRight, isRef: assignment.IsRef, assignment.Type, used: false)); 379dynamicSiteInitializers.Add(setMember.SiteInitialization); 380result.Add(setMember.SiteInvocation); 386dynamicSiteInitializers.Add(getMember.SiteInitialization); 406result.Add(MakeStaticAssignmentOperator(assignment.Syntax, rewrittenAccess, rewrittenRight, false, assignment.Type, used: false)); 429temps.Add(temp.LocalSymbol); 430result.Add(store); 439result.Add(MakeStaticAssignmentOperator(assignment.Syntax, rewrittenAccess, rewrittenRight, false, assignment.Type, used: false)); 477newArgs.Add(temp); 483temps.Add(temp.LocalSymbol); 484sideeffects.Add(store); 488newArgs.Add(arg);

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

145flattened.Add(lowered);

Lowering\LocalRewriter\LocalRewriter_StringInterpolation.cs (5)

120resultExpressions.Add((BoundExpression)VisitCall(call)); 124resultExpressions.Add(VisitDynamicInvocation(dynamicInvocation, resultDiscarded: !usesBoolReturns)); 165resultExpressions.Add(handlerConstructionAssignment); 166resultExpressions.Add(currentExpression); 240expressions.Add(value); // NOTE: must still be lowered

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

439tempSymbols.Add(tempSymbol); 554tempInitializers.Add(operandAssignment);

Lowering\MethodToClassRewriter.cs (2)

86newLocals.Add(newLocal); 334visitedTypeArgs.Add(typeArg.WithTypeAndModifiers(VisitType(typeArg.Type), typeArg.CustomModifiers));

Lowering\SpillSequenceSpiller.cs (5)

130_locals.Add(local); 148_statements.Add(statement); 570result.Add(replacement); 579result.Add(lastSpillNode.Value); 583result.Add(newList[i]);

Lowering\StateMachineRewriter\MethodToStateMachineRewriter.cs (9)

224_stateDebugInfoBuilder.Add(new StateMachineStateDebugInfo(syntaxOffset, state)); 332hoistedLocalsWithDebugScopes.Add(((CapturedToStateMachineFieldReplacement)proxy).HoistedField); 428cleanup.Add(F.AssignmentExpression(F.Field(F.This(), field), F.NullOrDefault(field.Type))); 487fields.Add(field); 559indices.Add(HoistExpression(index, awaitSyntaxOpt, syntaxOffset, RefKind.None, sideEffects, hoistedFields, ref needsSacrificialEvaluation)); 677hoistedFields.Add(hoistedField); 680sideEffects.Add(F.AssignmentExpression(replacement, expr)); 727newLocalsBuilder.Add(localToUse); 732hoistedLocalsWithDebugScopes.Add(((CapturedToStateMachineFieldReplacement)proxies[local]).HoistedField);

Lowering\StateMachineRewriter\StateMachineRewriter.cs (11)

294bodyBuilder.Add(GenerateStateMachineCreation(stateMachineVariable, frameType, proxies)); 313bodyBuilder.Add(F.Assignment(proxy.Replacement(F.Syntax, frameType1 => F.Local(stateMachineVariable)), F.This())); 322bodyBuilder.Add(F.Assignment(proxy.Replacement(F.Syntax, frameType1 => F.Local(stateMachineVariable)), 426thenBuilder.Add( 433thenBuilder.Add( 447bodyBuilder.Add(makeIterator); 458bodyBuilder.Add( 465bodyBuilder.Add(F.Label(thisInitialized)); 478bodyBuilder.Add(copy); 482bodyBuilder.Add(F.Return(F.Local(resultVariable))); 492builder.Add(

Lowering\StateMachineRewriter\StateMachineTypeSymbol.cs (1)

73builder.Add(attribute);

Lowering\StateMachineRewriter\SynthesizedStateMachineMethod.cs (1)

92builder.Add(attribute);

Lowering\SynthesizedMethodBaseSymbol.cs (2)

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

Lowering\SyntheticBoundNodeFactory.cs (16)

883statements.Add(ConditionalGoto(condition, alt, false)); 884statements.Add(thenClause); 885statements.Add(Goto(afterif)); 890statements.Add(firstPart); 893statements.Add(Label(alt)); 894statements.Add(elseClauseOpt); 898statements.Add(ConditionalGoto(condition, afterif, false)); 899statements.Add(thenClause); 904statements.Add(firstPart); 908statements.Add(Label(afterif)); 940builder.Add(parts[i]); 1015statements.Add(null!); // placeholder at statements[0] for the dispatch 1019statements.Add(Label(sectionLabel)); 1024caseBuilder.Add((ConstantValue.Create(value), sectionLabel)); 1028statements.Add(Label(breakLabel)); 1590temps.Add(temp);

Operations\CSharpOperationFactory.cs (6)

387builder.Add(operation); 408builder.Add((IVariableDeclaratorOperation)CreateVariableDeclaratorInternal(decl, decl.Syntax)); 2165builder.Add((IInterpolatedStringContentOperation)Create(part)); 2169builder.Add(CreateBoundInterpolatedStringTextOperation((BoundLiteral)part)); 2244builder.Add(new InterpolatedStringTextOperation(valueOperation, _semanticModel, part.Syntax, isImplicit)); 2254builder.Add(new InterpolationOperation(valueOperation, alignmentOperation, formatOperation, _semanticModel, part.Syntax, isImplicit));

Operations\CSharpOperationFactory_Methods.cs (2)

317builder.Add(receiverOpt); 388builder.Add(assignment);

Parser\LanguageParser_InterpolatedString.cs (1)

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

Parser\Lexer_StringLiteral.cs (2)

863interpolations?.Add(new Interpolation( 927interpolations?.Add(new Interpolation(

SourceGeneration\CSharpSyntaxHelper.cs (2)

54targets.Add(container); 102aliases.Add((aliasName, symbolName));

SymbolDisplay\SymbolDisplayVisitor.cs (16)

SymbolDisplay\SymbolDisplayVisitor.Members.cs (27)

SymbolDisplay\SymbolDisplayVisitor.Types.cs (18)

SymbolDisplay\SymbolDisplayVisitor_Constants.cs (1)

63this.builder.Add(CreatePart(kind, null, valueString));

SymbolDisplay\SymbolDisplayVisitor_Minimal.cs (2)

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

Symbols\AbstractTypeMap.cs (8)

73newTypeArguments.Add(newArgument); 149builder.Add(customModifiers[i].IsOptional ? CSharpCustomModifier.CreateOptional(substituted) : CSharpCustomModifier.CreateRequired(substituted)); 157builder.Add(customModifiers[i].IsOptional ? CSharpCustomModifier.CreateOptional(substituted) : CSharpCustomModifier.CreateRequired(substituted)); 161builder.Add(customModifiers[i]); 257builder.Add(substituted); 330result.Add(SubstituteType(t)); 358result.Add(substituteConstraintType(type)); 374result.Add(substituted);

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

208typeArgumentsBuilder.Add(((ArrayTypeSymbol)field.Type).ElementTypeWithAnnotations); 212typeArgumentsBuilder.Add(field.TypeWithAnnotations); 609builder.Add(template); 627builder.Add(template); 649builder.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)

59parameters.Add( 78typeParameters.Add(new AnonymousTypeManager.AnonymousTypeParameterSymbol(containingType, i, "T" + (i + 1))); 83typeParameters.Add(new AnonymousTypeManager.AnonymousTypeParameterSymbol(containingType, parameterCount, "TResult")); 134parameters.Add( 173typeParameters.Add(new AnonymousTypeParameterSymbol(this, i, "T" + (i + 1))); 194parameters.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)

114constructedInterfaces.Add(new ConstructedNamedTypeSymbol(iListOfT, ImmutableArray.Create(elementTypeWithAnnotations))); 121constructedInterfaces.Add(new ConstructedNamedTypeSymbol(iReadOnlyListOfT, ImmutableArray.Create(elementTypeWithAnnotations)));

Symbols\AssemblySymbol.cs (2)

756nestedTypes.Add(currentTypeInfo); 843typeArgumentSymbols.Add(TypeWithAnnotations.Create(argSymbol));

Symbols\Attributes\AttributeData.cs (2)

298builder.Add(memberName); 349builder.Add(memberName);

Symbols\Compilation_UsedAssemblies.cs (1)

59builder.Add(reference);

Symbols\Compilation_WellKnownMembers.cs (9)

424builder.Add(new KeyValuePair<string, TypedConstant>( 894transformFlagsBuilder.Add(false); 915transformFlagsBuilder.Add(true); 924transformFlagsBuilder.Add(false); 933transformFlagsBuilder.Add(false); 958transformFlagsBuilder.Add(false); 972transformFlagsBuilder.Add(false); 991transformFlagsBuilder.Add(false); 1025builder.Add(type.IsNativeIntegerWrapperType);

Symbols\ConstraintsHelper.cs (24)

Symbols\FunctionPointers\FunctionPointerMethodSymbol.cs (9)

178customModifiers.Add(modifier); 195customModifiers.Add(modifier); 294modifiersBuilder.Add(modifier); 370paramMergedTypesBuilder.Add(mergedParameterType); 410paramTypesBuilder.Add(transformedType); 465paramsBuilder.Add(new FunctionPointerParameterSymbol( 568paramsBuilder.Add(new FunctionPointerParameterSymbol(paramType, paramRefKind, i, parent, paramRefCustomMods)); 611paramTypesBuilder.Add(newParamType); 656builder.Add(modifier.ModifierSymbol);

Symbols\MergedNamespaceSymbol.cs (3)

148namespaceSymbols.Add((NamespaceSymbol)childSymbol); 152otherSymbols.Add(childSymbol); 159otherSymbols.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)

195builder.Add(transformedParam);

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

400builder.Add(@event);

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

1294explicitInterfaceImplementationsBuilder.Add(method);

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

277moduleAssemblyAttributesBuilder.Add(new PEAttributeData(this, customAttributeHandle)); 397customAttributesBuilder.Add(new PEAttributeData(this, customAttributeHandle));

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

572symbols.Add(namedTypeSymbol); 912fieldDefs.Add(fieldDef); 929builder.Add(new PEFieldSymbol(moduleSymbol, this, fieldDef)); 998eventFields.Add(associatedField); 1035result.Add(field); 1092methodDefs.Add(methodDef); 1301members.Add(field); 1309members.Add(syntheticCtor); 1358members.Add(field); 1442members.Add(member); 1923fieldMembers.Add(symbol); 1958members.Add(method); 1987members.Add(PEPropertySymbol.Create(moduleSymbol, this, propertyDef, getMethod, setMethod)); 2022members.Add(new PEEventSymbol(moduleSymbol, this, eventRid, addMethod, removeMethod, privateFieldNameToSymbols));

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

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

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

874builder.Add(BoundInterpolatedStringArgumentPlaceholder.InstanceParameter); 881builder.Add(param.Ordinal); 1065builder.Add(new PEAttributeData(containingPEModuleSymbol, paramArrayAttribute)); 1070builder.Add(new PEAttributeData(containingPEModuleSymbol, constantAttribute));

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

690builder.Add(prop); 700builder.Add(prop);

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

189symbolsBuilder.Add(type); 551symbolsBuilder.Add(type);

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

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

Symbols\NamedTypeSymbol.cs (6)

225operators.Add(candidate); 287constructors.Add(method); 295constructors.Add(method); 326indexers.Add((PropertySymbol)candidate); 374methods.Add(method); 1067allTypeArguments.Add(merged);

Symbols\NativeIntegerTypeSymbol.cs (3)

108builder.Add(new NativeIntegerMethodSymbol(this, underlyingMethod, associatedSymbol: null)); 116builder.Add(new NativeIntegerMethodSymbol(this, underlyingMethod, associatedSymbol: null)); 129builder.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)

184builder.Add(TypeWithAnnotations.Create(ErrorTypeSymbol.UnknownResultType)); 188builder.Add(typeArg); 563parameters.Add(new ReducedExtensionMethodParameterSymbol(this, reducedFromParameters[i + 1]));

Symbols\ReferenceManager.cs (5)

585linkedReferencedAssembliesBuilder.Add(currentBindingResult.AssemblySymbol); 595linkedReferencedAssembliesBuilder.Add(linkedAssemblySymbol); 808moduleReferencesBuilder!.Add(references); 836unifiedAssemblies.Add(new UnifiedAssembly<AssemblySymbol>(assembly, referenceBinding.ReferenceIdentity)); 1109result.Add(sourceReferencedAssemblies[i]);

Symbols\Retargeting\RetargetingEventSymbol.cs (1)

125builder.Add(retargeted);

Symbols\Retargeting\RetargetingMethodSymbol.cs (2)

179parameters.Add(new RetargetingMethodParameterSymbol(this, list[i])); 328builder.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 (15)

545newArguments.Add(newArg); 731newModifiers.Add(oldModifier.IsOptional ? 737newModifiers.Add(oldModifier); 780newParameterTypesBuilder.Add(newParameterType); 781newParameterCustomModifiersBuilder.Add(newModifiers); 833symbols.Add(Retarget(s)); 849result.Add(Retarget(nts, RetargetOptions.RetargetPrimitiveTypesByName)); 863result.Add(Retarget(ts, RetargetOptions.RetargetPrimitiveTypesByName)); 875result.Add(Retarget(ts, RetargetOptions.RetargetPrimitiveTypesByName)); 887parameters.Add(Retarget(tps)); 1026targetParamsBuilder.Add( 1104targetParamsBuilder.Add( 1244newArguments.Add(retargetedArgument); 1318newArguments.Add(new KeyValuePair<string, TypedConstant>(oldArgument.Key, newConstant)); 1323newArguments.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)

363builder.Add(parameter);

Symbols\Source\LocalFunctionSymbol.cs (1)

427result.Add(typeParameter);

Symbols\Source\ParameterHelpers.cs (1)

195builder.Add(parameter);

Symbols\Source\SourceAssemblySymbol.cs (5)

133moduleBuilder.Add(new SourceModuleSymbol(this, compilation.Declarations, moduleName)); 140moduleBuilder.Add(new PEModuleSymbol(this, netModule, importOptions, moduleBuilder.Count)); 1291netModuleNameBuilder.Add(netModuleName); 1292moduleAssemblyAttributesBuilder.Add(attributeData); 1551builder.Add(root.AttributeLists);

Symbols\Source\SourceComplexParameterSymbol.cs (3)

1269parameters.Add(parameter); 1288parameters.Add(parameter); 1289ordinalsBuilder.Add(ordinal);

Symbols\Source\SourceDelegateMethodSymbol.cs (9)

71symbols.Add(invoke); 74symbols.Add(new Constructor(delegateType, voidType, objectType, intPtrType, syntax)); 85symbols.Add(new BeginInvokeMethod(invoke, iAsyncResultType, objectType, asyncCallbackType, syntax)); 88symbols.Add(new EndInvokeMethod(invoke, iAsyncResultType, syntax)); 376parameters.Add(synthesizedParam); 380parameters.Add(SynthesizedParameterSymbol.Create(this, asyncCallbackType, paramCount, RefKind.None, GetUniqueParameterName(parameters, "callback"))); 381parameters.Add(SynthesizedParameterSymbol.Create(this, objectType, paramCount + 1, RefKind.None, GetUniqueParameterName(parameters, "object"))); 425parameters.Add(synthesizedParam); 429parameters.Add(SynthesizedParameterSymbol.Create(this, iAsyncResultType, ordinal++, RefKind.None, GetUniqueParameterName(parameters, "result")));

Symbols\Source\SourceMemberContainerSymbol.cs (46)

1328symbols.Add(t); 2958groupsBuilder.Add(insertedInitializers.ToImmutableAndFree()); 2968groupsBuilder.Add(InstanceInitializersForPositionalMembers.ToImmutableAndFree()); 2987InstanceInitializersForPositionalMembers.Add(initializer); 3003NonTypeMembers.Add(member); 3034builder.Add(group.ToImmutableAndFree()); 3183builder.Add(new SynthesizedSimpleProgramEntryPointSymbol(this, singleDecl, diagnostics)); 3318memberBuilder.Add(member); 3559builder.Add(s); 3734result.NonTypeMembers.Add(symbol); 3761initializers.Add(new FieldOrPropertyInitializer(fieldOpt, node)); 3770allInitializers.Add(siblingsOpt); 3912members.Add(ctor); 3961members.Add(ctor); 4041members.Add(new SynthesizedRecordDeconstruct(this, ctor, positionalMembers, memberOffset: members.Count, diagnostics)); 4089members.Add(copyCtor); 4110members.Add(new SynthesizedRecordClone(this, memberOffset: members.Count, diagnostics)); 4137members.Add(printMembersMethod); 4213members.Add(toStringMethod); 4287existingOrAddedMembers.Add(field); 4301existingOrAddedMembers.Add(prop); 4315existingOrAddedMembers.Add(property); 4316members.Add(property); 4319members.Add(property.GetMethod); 4320members.Add(property.SetMethod); 4321members.Add(property.BackingField); 4343members.Add(new SynthesizedRecordObjEquals(this, thisEquals, memberOffset: members.Count, diagnostics)); 4367members.Add(getHashCode); 4397members.Add(equalityContract); 4398members.Add(equalityContract.GetMethod); 4465members.Add(thisEquals); 4506members.Add(new SynthesizedRecordBaseEquals(this, memberOffset: members.Count, diagnostics)); 4512members.Add(new SynthesizedRecordEqualityOperator(this, memberOffset: members.Count, diagnostics)); 4513members.Add(new SynthesizedRecordInequalityOperator(this, memberOffset: members.Count, diagnostics)); 4665builder.NonTypeMembers.Add(fieldSymbol); 4703builder.NonTypeMembers.Add(method); 4718builder.NonTypeMembers.Add(constructor); 4740builder.NonTypeMembers.Add(destructor); 4754builder.NonTypeMembers.Add(property); 4766builder.NonTypeMembers.Add(backingField); 4808builder.NonTypeMembers.Add(@event); 4860builder.NonTypeMembers.Add(@event); 4880builder.NonTypeMembers.Add(indexer); 4897builder.NonTypeMembers.Add(method); 4912builder.NonTypeMembers.Add(method); 4990symbols.Add(accessorOpt);

Symbols\Source\SourceMemberContainerSymbol_ImplementationChecks.cs (2)

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

Symbols\Source\SourceModuleSymbol.cs (1)

138buffer.Add(asm);

Symbols\Source\SourceNamedTypeSymbol.cs (2)

369(otherPartialClauses ??= ArrayBuilder<ImmutableArray<TypeParameterConstraintClause>>.GetInstance()).Add(constraints); 451(otherPartialClauses ??= ArrayBuilder<ImmutableArray<TypeParameterConstraintClause>>.GetInstance()).Add(constraints);

Symbols\Source\SourceNamedTypeSymbol_Bases.cs (6)

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

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

327mergedNamespacesOrTypes.Add(namespaceOrType); 492builder.Add(new AliasAndExternAliasDirective(new AliasSymbolFromSyntax(declaringSymbol, aliasSyntax), aliasSyntax, skipInLookup)); 704usingAliases.Add(aliasAndDirective); 751getOrCreateUsingsBuilder(ref usings, globalUsingNamespacesOrTypes).Add(new NamespaceOrTypeAndUsingDirective(imported, usingDirective, dependencies: default)); 779getOrCreateUsingsBuilder(ref usings, globalUsingNamespacesOrTypes).Add(new NamespaceOrTypeAndUsingDirective(importedType, usingDirective, directiveDiagnostics.DependenciesBag.ToImmutableArray()));

Symbols\Source\SourceNamespaceSymbol.cs (2)

532builder.Add((NamespaceOrTypeSymbol)item); 535builder.Add(symbol);

Symbols\Source\SourceOrdinaryMethodSymbol.cs (1)

598result.Add(typeParameter);

Symbols\Source\SourcePropertyAccessorSymbol.cs (2)

755parameters.Add(new SourcePropertyClonedParameterSymbolForAccessors(propertyParam, this)); 760parameters.Add(new SynthesizedAccessorValueParameterSymbol(this, _property.TypeWithAnnotations, parameters.Count));

Symbols\Source\SourceTypeParameterSymbol.cs (1)

124mergedAttributesBuilder.Add(syntax.AttributeLists);

Symbols\Source\TypeParameterBuilder.cs (2)

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

Symbols\SubstitutedMethodSymbol.cs (1)

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

Symbols\SubstitutedNamedTypeSymbol.cs (7)

221builder.Add(((NamedTypeSymbol)t).AsMember(this)); 229builder.Add(t.SymbolAsMember(this)); 250builder.Add(existingMember); 269builder.Add(((NamedTypeSymbol)t).AsMember(this)); 277builder.Add(t.SymbolAsMember(this)); 318builder.Add(t.SymbolAsMember(this)); 373builder.Add(t.SymbolAsMember(this));

Symbols\Symbol.cs (3)

387builder.Add(node.GetReference()); 409builder.Add(found.GetReference()); 757attributes.Add(attribute);

Symbols\Symbol_Attributes.cs (4)

465builder.Add(location); 539boundAttributeArrayBuilder.Add(boundAttribute); 613syntaxBuilder.Add(attribute); 629bindersBuilder.Add(binder);

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

55statements.Add(F.Assignment(F.Field(F.This(), field), F.Field(param, field)));

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

95statementsBuilder.Add(F.Assignment(F.Parameter(parameter), F.Property(F.This(), property))); 99statementsBuilder.Add(F.Assignment(F.Parameter(parameter), F.Field(F.This(), field))); 104statementsBuilder.Add(F.Return());

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

142fields.Add(f);

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

150block.Add(F.ExpressionStatement( 177block.Add(F.If(basePrintCall, makeAppendString(F, builder, ", "))); 198block.Add(makeAppendString(F, builder, memberHeader)); 212block.Add(F.ExpressionStatement( 219block.Add(F.ExpressionStatement( 226block.Add(F.Return(F.Literal(true)));

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

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

Symbols\Synthesized\RefKindVector.cs (1)

129otherWords.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\Synthesized\SynthesizedParameterSymbol.cs (1)

286builder.Add(Create(

Symbols\Tuples\TupleTypeSymbol.cs (9)

216underlyingTupleTypeChain.Add(currentType); 654members.Add(defaultTupleField); 671members.Add(defaultTupleField); 682members.Add(new TupleVirtualElementFieldSymbol(this, 770members.Add(defaultTupleField); 775members.Add(new TupleErrorFieldSymbol(this, 812fieldsForElements.Add((FieldSymbol?)getWellKnownMemberInType(members, wellKnownTupleField)); 836fields.Add(tupleField.UnderlyingField.OriginalDefinition); 840fields.Add(field.OriginalDefinition);

Symbols\TypeMap.cs (2)

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

Symbols\TypeSymbol.cs (3)

365result.Add(@interface); 1323implementations.Add((candidate, bases)); 1327implementations.Add((candidate, null));

Symbols\TypeSymbolExtensions.cs (2)

1966paramsBuilder.Add(paramType); 2020builder.Add(attr);

Symbols\TypeWithAnnotations.cs (1)

619transforms.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)

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

Syntax\CSharpSyntaxTree.cs (10)

261states.Add(currentState); 262positions.Add(((ElifDirectiveTriviaSyntax)directive).ElifKeyword.SpanStart); 266states.Add(currentState); 267positions.Add(((ElseDirectiveTriviaSyntax)directive).ElseKeyword.SpanStart); 271states.Add(currentState); 272positions.Add(((EndIfDirectiveTriviaSyntax)directive).EndIfKeyword.SpanStart); 276states.Add(currentState); 277positions.Add(((DefineDirectiveTriviaSyntax)directive).Name.SpanStart); 281states.Add(currentState); 282positions.Add(((UndefDirectiveTriviaSyntax)directive).Name.SpanStart);

Syntax\NullableContextStateMap.cs (1)

170builder.Add(context);

Syntax\SyntaxNormalizer.cs (11)

Utilities\ValueSetFactory.NumericValueSet.cs (4)

144builder.Add((tc.MinValue, tc.Prev(_intervals[0].first))); 151builder.Add((tc.Next(_intervals[i].last), tc.Prev(_intervals[i + 1].first))); 157builder.Add((tc.Next(_intervals[lastIndex].last), tc.MaxValue)); 227builder.Add((first, last));