69_factory = factory;

70_factory.CurrentFunction = containingMethod; 178=> _factory; 187=> _factory.InstrumentationState!; 197get { return _factory.CompilationState.ModuleBuilderOpt; } 328Debug.Assert(_factory.ModuleBuilderOpt is { }); 346_factory.ModuleBuilderOpt.EnsureParamCollectionAttributeExists(_diagnostics, location); 354var oldContainingSymbol = _factory.CurrentFunction; 363_factory.CurrentFunction = lambda; 373_factory.CurrentFunction = oldContainingSymbol; 387if (_factory.CompilationState.ModuleBuilderOpt is { } moduleBuilder) 404if (_factory.CompilationState.Compilation.ShouldEmitNullableAttributes(localFunction)) 419var oldContainingSymbol = _factory.CurrentFunction; 428_factory.CurrentFunction = localFunction; 440_dynamicFactory = new LoweredDynamicOperationFactory(_factory, _dynamicFactory.MethodOrdinal, localFunctionOrdinal); 447_factory.CurrentFunction = oldContainingSymbol; 770if (_factory.CurrentFunction?.IsStatic == false) 832var F = _factory; 1130_factory.CompilationState.ModuleBuilderOpt?.EnsureIsReadOnlyAttributeExists();

33_factory = localRewriter._factory;

223return _factory.AssignmentExpression( 259return _factory.AssignmentExpression( 286Debug.Assert(_factory.CurrentFunction.IsConstructor()); 290return _factory.AssignmentExpression( 291_factory.Field(rewrittenReceiver, backingField), 325LocalSymbol rhsTemp = _factory.SynthesizedLocal(exprType);

48var tempAccess = _factory.StoreToTemp(rewrittenAwait, out BoundAssignmentOperator tempAssignment, syntaxOpt: rewrittenAwait.Syntax,

84var boundTemp = _factory.StoreToTemp(loweredLeft, out tempAssignment); 254return _factory.RewriteNullableNullEquality(syntax, operatorKind, loweredLeft, loweredRight, type); 315return _factory.MakeSequence(loweredRight, loweredLeft); 319return _factory.MakeSequence(loweredLeft, loweredRight); 465return _factory.MakeSequence(loweredRight, loweredLeft); 469return _factory.MakeSequence(loweredLeft, loweredRight); 570whenNullOpt = RewriteLiftedBinaryOperator(syntax, operatorKind, _factory.Default(loweredLeft.Type), loweredRight, type, method, constrainedToTypeOpt); 592return arrLength.Update(arrLength.Expression, _factory.SpecialType(SpecialType.System_UIntPtr)); 635return _factory.Literal(true); 655var local = _factory.StoreToTemp(loweredLeft, out assignment); 681result = _factory.Binary(BinaryOperatorKind.LogicalOr, boolean, leftTest, result); 698result = _factory.Conditional(leftTest, convertedLeft, op, type); 705return _factory.Sequence(ImmutableArray.Create(temp.LocalSymbol), ImmutableArray.Create<BoundExpression>(tempAssignment), result); 872BoundExpression callHasValue = _factory.MakeNullableHasValue(syntax, maybeNull); 881return _factory.MakeSequence(maybeNull, falseExpr); 919return _factory.MakeNullableHasValue(syntax, expression); 1029BoundLocal boundTempX = _factory.StoreToTemp(xNonNull ?? loweredLeft, out BoundAssignmentOperator tempAssignmentX); 1030BoundLocal boundTempY = _factory.StoreToTemp(yNonNull ?? loweredRight, out BoundAssignmentOperator tempAssignmentY); 1089binaryExpression = _factory.Not(binaryExpression); 1201BoundLocal boundTempX = _factory.StoreToTemp(xNonNull ?? loweredLeft, out tempAssignmentX); 1203BoundLocal boundTempY = _factory.StoreToTemp(yNonNull ?? loweredRight, out tempAssignmentY); 1495var tempAccess = _factory.StoreToTemp(operand, out tempAssignment, kind: kind); 1719BoundLocal boundTemp = _factory.StoreToTemp(notAlwaysNull, out tempAssignment); 1776BoundLocal boundTempX = _factory.StoreToTemp(leftNonNull ?? left, out tempAssignmentX); 1778BoundLocal boundTempY = _factory.StoreToTemp(rightNonNull ?? right, out tempAssignmentY); 1830BoundLocal boundTempX = _factory.StoreToTemp(loweredLeft, out tempAssignmentX); 1832BoundLocal boundTempY = _factory.StoreToTemp(loweredRight, out tempAssignmentY); 1844BoundExpression callX_HasValue = _factory.MakeNullableHasValue(syntax, boundTempX); 2213var oldSyntax = _factory.Syntax; 2214_factory.Syntax = loweredRight.Syntax; 2227loweredRight = _factory.Literal(shiftAmount); 2234loweredRight = _factory.Binary(andOperatorKind, rightType, 2236_factory.IntSubtract(_factory.IntMultiply(_factory.Sizeof(leftType), _factory.Literal(8)), _factory.Literal(1))); 2239_factory.Syntax = syntax; 2241? _factory.Binary(operatorKind, type, loweredLeft, loweredRight) 2245_factory.Syntax = oldSyntax; 2304var sizeOfExpression = _factory.Sizeof(pointerType.PointedAtType); 2370: _factory.Convert(_factory.SpecialType(destinationType), numericOperand, Conversion.IntegerToPointer); 2381TypeSymbol nativeIntType = _factory.SpecialType(SpecialType.System_IntPtr); 2387numericOperand = _factory.Convert(nativeIntType, numericOperand, Conversion.IntegerToPointer, isChecked); 2395TypeSymbol longType = _factory.SpecialType(SpecialType.System_Int64); 2396TypeSymbol nativeIntType = _factory.SpecialType(SpecialType.System_IntPtr); 2399numericOperand = _factory.Convert(longType, numericOperand, Conversion.ExplicitNumeric, isChecked); 2400sizeOfExpression = _factory.Convert(longType, sizeOfExpression, Conversion.ExplicitNumeric, isChecked); 2408TypeSymbol longType = _factory.SpecialType(SpecialType.System_Int64); 2409TypeSymbol nativeIntType = _factory.SpecialType(SpecialType.System_IntPtr); 2412sizeOfExpression = _factory.Convert(longType, sizeOfExpression, Conversion.ExplicitNumeric, isChecked); 2420TypeSymbol ulongType = _factory.SpecialType(SpecialType.System_UInt64); 2421TypeSymbol nativeUIntType = _factory.SpecialType(SpecialType.System_UIntPtr); 2424sizeOfExpression = _factory.Convert(ulongType, sizeOfExpression, Conversion.ExplicitNumeric, isChecked); 2440var multiplication = _factory.Binary(multiplicationKind, multiplicationResultType, numericOperand, sizeOfExpression); 2443: _factory.Convert(convertedMultiplicationResultType, multiplication, Conversion.IntegerToPointer); // NOTE: for some reason, dev10 doesn't check this conversion. 2457var sizeOfExpression = _factory.Sizeof(pointerType.PointedAtType); 2462return _factory.Convert( 2464_factory.Binary( 2466_factory.SpecialType(SpecialType.System_IntPtr), 2467_factory.Binary(

53else if (hasImplicitReceiver && _factory.TopLevelMethod is { RequiresInstanceReceiver: false }) 56Debug.Assert(_factory.CurrentType is { }); 57loweredReceiver = new BoundTypeExpression(node.Syntax, null, _factory.CurrentType); 187var containingMethod = this._factory.CurrentFunction; 291_factory.CurrentFunction, 295var receiverTemp = _factory.StoreToTemp(receiverOpt, out var assignmentToTemp); 297receiverOpt = _factory.Sequence(locals: [], sideEffects: [assignmentToTemp], receiverTemp); 706_factory.CurrentFunction, 715receiverTemp = _factory.StoreToTemp(rewrittenReceiver, out assignmentToTemp, refKind); 743visitedArgumentsBuilder.Add(_factory.MakeTempForDiscard(discard, tempsOpt)); 806rewrittenReceiver = _factory.Sequence( 882local = _factory.StoreToTemp(visitedArgument, out var store, refKind: paramRefKind is RefKind.In or RefKind.RefReadOnlyParameter ? RefKind.In : argRefKind); 884visitedArgumentsBuilder[argIndex] = _factory.Sequence(ImmutableArray<LocalSymbol>.Empty, ImmutableArray.Create<BoundExpression>(store), local); 944BoundLocal cache = _factory.Local(_factory.SynthesizedLocal(receiverType)); 951var intermediateRef = _factory.Local(_factory.SynthesizedLocal(receiverType, refKind: RefKind.Ref)); 964_factory.Sequence(new BoundExpression[] { _factory.AssignmentExpression(cache, intermediateRef) }, cache), 982_factory.Sequence(new BoundExpression[] { _factory.AssignmentExpression(cache, assignmentToTemp.Right) }, cache), 1384var temp = _factory.StoreToTemp( 1639BoundLocal boundTemp = _factory.StoreToTemp(argument, out boundAssignmentToTemp);

38var previousSyntax = _factory.Syntax; 39_factory.Syntax = node.Syntax; 73return _factory.Field(receiver: null, immutableArrayOfTargetCollectionTypeEmpty); 94_factory.Syntax = previousSyntax; 184result = _factory.Call(receiver: null, toListOfElementType, rewrittenSpreadExpression); 243return _factory.StaticCall(asImmutableArray.Construct(ImmutableArray.Create(elementType)), ImmutableArray.Create(arrayCreation)); 271return _factory.Default(collectionType); 279var constructor = ((MethodSymbol)_factory.WellKnownMember(WellKnownMember.System_ReadOnlySpan_T__ctor_Array)).AsMember(spanType); 281return _factory.New(constructor, _factory.Array(elementType.Type, rewrittenElements)); 297spanConstructor = ((MethodSymbol)_factory.WellKnownMember( 319var listToArray = ((MethodSymbol)_factory.WellKnownMember(WellKnownMember.System_Collections_Generic_List_T__ToArray)).AsMember((NamedTypeSymbol)list.Type); 320array = _factory.Call(list, listToArray); 343BoundLocal temp = _factory.StoreToTemp(rewrittenReceiver, out assignmentToTemp); 397Debug.Assert(_factory.ModuleBuilderOpt is { }); 431var synthesizedType = _factory.ModuleBuilderOpt.EnsureReadOnlyListTypeExists(syntax, kind: kind, _diagnostics.DiagnosticBag).Construct(typeArgs); 457return _factory.Convert(collectionType, arrayOrList); 548Debug.Assert(_factory.ModuleBuilderOpt is { }); 555&& _factory.WellKnownMember(asReadOnlySpan 560var spanType = _factory 565var temp = _factory.StoreToTemp(element, out var assignment); 567var call = _factory.New(constructor, arguments: [temp], argumentRefKinds: [asReadOnlySpan ? RefKindExtensions.StrictIn : RefKind.Ref]); 568return _factory.Sequence([assignment], call); 571var inlineArrayType = _factory.ModuleBuilderOpt.EnsureInlineArrayTypeExists(syntax, _factory, arrayLength, _diagnostics.DiagnosticBag).Construct(ImmutableArray.Create(elementType)); 574var intType = _factory.SpecialType(SpecialType.System_Int32); 575MethodSymbol elementRef = _factory.ModuleBuilderOpt.EnsureInlineArrayElementRefExists(syntax, intType, _diagnostics.DiagnosticBag). 581BoundLocal inlineArrayLocal = _factory.StoreToTemp(new BoundDefaultExpression(syntax, inlineArrayType), out assignmentToTemp); 593var call = _factory.Call(null, elementRef, inlineArrayLocal, _factory.Literal(i), useStrictArgumentRefKinds: true); 603_factory.ModuleBuilderOpt.EnsureInlineArrayAsReadOnlySpanExists(syntax, _factory.WellKnownType(WellKnownType.System_ReadOnlySpan_T), intType, _diagnostics.DiagnosticBag) : 604_factory.ModuleBuilderOpt.EnsureInlineArrayAsSpanExists(syntax, _factory.WellKnownType(WellKnownType.System_Span_T), intType, _diagnostics.DiagnosticBag); 606var span = _factory.Call( 610_factory.Literal(arrayLength), 671return _factory.Call(rewrittenSpreadExpression, listToArrayMethod.AsMember((NamedTypeSymbol)spreadExpression.Type!)); 675if (_factory.WellKnownMethod(WellKnownMember.System_Linq_Enumerable__ToArray, isOptional: true) is { } linqToArrayMethodGeneric) 683return _factory.Call(receiver: null, linqToArrayMethod, VisitExpression(spreadExpression)); 695return _factory.Call(rewrittenSpreadExpression, toArrayMethod.AsMember((NamedTypeSymbol)rewrittenSpreadExpression.Type!)); 703toArrayMethod = _factory.WellKnownMethod(wellKnownMember, isOptional: true); 765BoundLocal indexTemp = _factory.StoreToTemp( 766_factory.Literal(0), 772BoundLocal arrayTemp = _factory.StoreToTemp( 799_factory.ArrayAccess(arrayTemp, indexTemp), 810_factory.Binary(BinaryOperatorKind.Addition, indexTemp.Type, indexTemp, _factory.Literal(1)), 859&& _factory.WellKnownMethod(writableOnly ? WellKnownMember.System_Span_T__ctor_Array : WellKnownMember.System_ReadOnlySpan_T__ctor_Array, isOptional: true) is { } spanCtorArray) 884&& _factory.WellKnownMethod(WellKnownMember.System_Collections_Immutable_ImmutableArray_T__AsSpan, isOptional: true) is { } immutableArrayAsSpanMethod) 891&& _factory.WellKnownMethod(WellKnownMember.System_Runtime_InteropServices_CollectionsMarshal__AsSpan_T, isOptional: true) is { } collectionsMarshalAsSpanMethod) 924return _factory.New(constructor, spreadExpression); 928return _factory.Call(receiver: null, asSpanMethod, spreadExpression); 932return _factory.Call(spreadExpression, asSpanMethod); 949if (_factory.WellKnownMethod(WellKnownMember.System_Span_T__Slice_Int_Int, isOptional: true) is not { } spanSliceMethod) 971&& _factory.WellKnownMethod(getLengthMember, isOptional: true) is { } getLengthMethod 972&& _factory.WellKnownMethod(copyToMember, isOptional: true) is { } copyToMethod) 1003spreadOperandAsSpan = _factory.StoreToTemp(spreadOperandAsSpan, out var assignmentToTemp); 1009var spreadLength = _factory.Call(spreadOperandAsSpan, getLengthMethod.AsMember((NamedTypeSymbol)spreadOperandAsSpan.Type!)); 1010var targetSlice = _factory.Call(spanTemp, spanSliceMethod.AsMember((NamedTypeSymbol)spanTemp.Type!), indexTemp, spreadLength); 1011sideEffects.Add(_factory.Call(spreadOperandAsSpan, copyToMethod.AsMember((NamedTypeSymbol)spreadOperandAsSpan.Type!), targetSlice)); 1014sideEffects.Add(new BoundAssignmentOperator(rewrittenSpreadOperand.Syntax, indexTemp, _factory.Binary(BinaryOperatorKind.Addition, indexTemp.Type, indexTemp, spreadLength), isRef: false, indexTemp.Type)); 1026var collectionType = _factory.WellKnownType(WellKnownType.System_Collections_Generic_List_T).Construct(typeArguments); 1040if (useKnownLength && elements.Length > 0 && _factory.CurrentFunction?.IsAsync == false) 1058var constructor = ((MethodSymbol)_factory.WellKnownMember(WellKnownMember.System_Collections_Generic_List_T__ctorInt32)).AsMember(collectionType); 1066knownLengthTemp = _factory.StoreToTemp(knownLengthExpression, out assignmentToTemp); 1071rewrittenReceiver = _factory.New(constructor, ImmutableArray.Create<BoundExpression>(knownLengthTemp)); 1076rewrittenReceiver = _factory.New(constructor, ImmutableArray.Create(knownLengthExpression)); 1082var constructor = ((MethodSymbol)_factory.WellKnownMember(WellKnownMember.System_Collections_Generic_List_T__ctor)).AsMember(collectionType); 1083rewrittenReceiver = _factory.New(constructor, ImmutableArray<BoundExpression>.Empty); 1087BoundLocal listTemp = _factory.StoreToTemp(rewrittenReceiver, out assignmentToTemp); 1100sideEffects.Add(_factory.Call(receiver: null, setCount, listTemp, knownLengthTemp)); 1103BoundLocal spanTemp = _factory.StoreToTemp(_factory.Call(receiver: null, asSpan, listTemp), out assignmentToTemp); 1108var spanGetItem = ((MethodSymbol)_factory.WellKnownMember(WellKnownMember.System_Span_T__get_Item)).AsMember((NamedTypeSymbol)spanTemp.Type); 1111BoundLocal indexTemp = _factory.StoreToTemp( 1112_factory.Literal(0), 1135_factory.Call(spanTemp, spanGetItem, indexTemp), 1146_factory.Binary(BinaryOperatorKind.Addition, indexTemp.Type, indexTemp, _factory.Literal(1)), 1162var addMethod = _factory.WellKnownMethod(WellKnownMember.System_Collections_Generic_List_T__Add).AsMember(collectionType); 1163var addRangeMethod = _factory.WellKnownMethod(WellKnownMember.System_Collections_Generic_List_T__AddRange, isOptional: true)?.AsMember(collectionType); 1174_factory.Call(listTemp, addMethod, rewrittenValue)); 1188sideEffects.Add(_factory.Call(listTemp, addRangeMethod, rewrittenSpreadOperand)); 1222BoundLocal temp = _factory.StoreToTemp(rewrittenExpression, out assignmentToTemp); 1305var otherElements = _factory.Literal(initialLength); 1318_factory.Binary(BinaryOperatorKind.Addition, sum.Type!, sum, value); 1341var iterationVariable = _factory.SynthesizedLocal(enumeratorInfo.ElementType, node.Syntax); 1342var iterationLocal = _factory.Local(iterationVariable); 1419return _factory.SpillSequence( 1422result: _factory.Literal(0)); // result is unused

65var isEvent = _factory.StoreToTemp(_dynamicFactory.MakeDynamicIsEventTest(memberAccess.Name, memberAccess.Receiver).ToExpression(), out BoundAssignmentOperator isEventAssignment); 70lhsRead = _factory.StoreToTemp(lhsRead, out BoundAssignmentOperator receiverAssignment); 72var storeNonEvent = _factory.StoreToTemp(_factory.Conditional(_factory.Not(isEvent), receiverAssignment, _factory.Null(receiverAssignment.Type), receiverAssignment.Type), out BoundAssignmentOperator nonEventStore); 79loweredRight = _factory.StoreToTemp(loweredRight, out BoundAssignmentOperator possibleHandlerAssignment); 95var condition = _factory.Conditional(isEvent, invokeEventAccessor.ToExpression(), rewrittenAssignment, rewrittenAssignment.Type); 205var receiverTemp = _factory.StoreToTemp(rewrittenReceiver, out assignmentToTemp, refKind: variableRepresentsLocation ? RefKind.Ref : RefKind.None); 237var receiverTemp = _factory.StoreToTemp(rewrittenReceiver, out assignmentToTemp); 357var boundTemp = _factory.StoreToTemp(array, out storeToTemp); 448var variableTemp = _factory.StoreToTemp(arrayAccess, out assignmentToTemp, refKind: RefKind.Ref); 495var receiverTemp = _factory.StoreToTemp(rewrittenReceiver, out assignmentToTemp); 508var temp = _factory.StoreToTemp(VisitExpression(indexerAccess.Receiver), out assignmentToTemp); 526var temp = _factory.StoreToTemp(VisitExpression(arguments[i]), out assignmentToTemp, indexerAccess.ArgumentRefKindsOpt.RefKinds(i) != RefKind.None ? RefKind.Ref : RefKind.None); 754var variableTemp = _factory.StoreToTemp(rewrittenVariable, out assignmentToTemp2, refKind: RefKind.Ref); 783var arrayTemp = _factory.StoreToTemp(loweredExpression, out assignmentToArrayTemp); 794var temp = _factory.StoreToTemp(loweredIndices[i], out assignmentToTemp); 805return _factory.ArrayAccess(boundTempArray, boundTempIndices);

50return _factory.Default(node.Type); 96temp = _factory.SynthesizedLocal(receiverType); 97_currentConditionalAccessTarget = _factory.Local(temp); 136loweredAccessExpression = _factory.New((NamedTypeSymbol)nodeType, loweredAccessExpression); 167loweredReceiver = _factory.MakeSequence( 168_factory.AssignmentExpression(_factory.Local(temp), loweredReceiver), 169_factory.Local(temp)); 176var condition = _factory.IsNotNullReference(loweredReceiver); 183_factory.Default(nodeType), 190result = _factory.MakeSequence(temp, result);

99var save_Syntax = _factory.Syntax; 100_factory.Syntax = node.Syntax; 115result = new BoundObjectCreationExpression(node.Syntax, ctor.AsMember((NamedTypeSymbol)node.Type), utf8Bytes, _factory.Literal(0), _factory.Literal(length)); 118_factory.Syntax = save_Syntax; 150builder.Add(_factory.Literal(b)); 156builder.Add(_factory.Literal((byte)0)); 160ImmutableArray.Create<BoundExpression>(_factory.Literal(builder.Count)), 309Debug.Assert(_factory.ModuleBuilderOpt is { }); 454return _factory.ThrowExpression(operand.Expression, rewrittenType); 568var oldSyntax = _factory.Syntax; 569_factory.Syntax = (mg.ReceiverOpt ?? mg).Syntax; 570var receiver = (!method.RequiresInstanceReceiver && !oldNodeOpt.IsExtensionMethod && !method.IsAbstract && !method.IsVirtual) ? _factory.Type(method.ContainingType) : mg.ReceiverOpt; 572_factory.Syntax = oldSyntax; 578Debug.Assert(_factory.TopLevelMethod is { }); 580if (_factory.Compilation.LanguageVersion >= MessageID.IDS_FeatureCacheStaticMethodGroupConversion.RequiredVersion() 582&& _factory.TopLevelMethod.MethodKind != MethodKind.StaticConstructor // Avoid caching twice if people do it manually. 585var rewriter = _lazyDelegateCacheRewriter ??= new DelegateCacheRewriter(_factory, _topLevelMethodOrdinal); 603createSpan = _factory.ModuleBuilderOpt.EnsureInlineArrayAsReadOnlySpanExists(syntax, spanType.OriginalDefinition, _factory.SpecialType(SpecialType.System_Int32), _diagnostics.DiagnosticBag); 608createSpan = _factory.ModuleBuilderOpt.EnsureInlineArrayAsSpanExists(syntax, spanType.OriginalDefinition, _factory.SpecialType(SpecialType.System_Int32), _diagnostics.DiagnosticBag); 614return _factory.Call(null, createSpan, rewrittenOperand, _factory.Literal(length), useStrictArgumentRefKinds: true); 635rewrittenOperand = _factory.Convert(method.ParameterTypesWithAnnotations[0].Type, rewrittenOperand); 642return _factory.Call(null, method, rewrittenOperand); 658rewrittenOperand = _factory.Convert(implicitOperator.ParameterTypesWithAnnotations[0].Type, rewrittenOperand); 659rewrittenOperand = _factory.Call(null, implicitOperator, rewrittenOperand); 671return _factory.Call(null, castUpMethod, rewrittenOperand); 692rewrittenOperand = _factory.Convert(method.ParameterTypesWithAnnotations[0].Type, rewrittenOperand); 693return _factory.Call(null, method, rewrittenOperand); 707rewrittenOperand = _factory.Convert(method.ParameterTypesWithAnnotations[0].Type, rewrittenOperand); 708return _factory.Call(null, method, rewrittenOperand); 742Debug.Assert(_factory.ModuleBuilderOpt is { }); 748_factory.ModuleBuilderOpt.EnsureParamCollectionAttributeExists(_diagnostics, node.Location); 792return _factory.NullOrDefault(rewrittenType); 963var savedTuple = _factory.StoreToTemp(rewrittenOperand, out assignmentToTemp); 975return _factory.MakeSequence(savedTuple.LocalSymbol, assignmentToTemp, result); 1166var boundTemp = _factory.StoreToTemp(operand, out tempAssignment); 1434BoundLocal boundTemp = _factory.StoreToTemp(rewrittenOperand, out tempAssignment); 1438BoundExpression condition = _factory.MakeNullableHasValue(syntax, boundTemp);

52return _factory.Sequence(lhsTemps.ToImmutableAndFree(), lhsEffects.ToImmutableAndFree(), result); 97return _factory.Sequence(temps.ToImmutableAndFree(), effects.ToImmutableAndFree(), last); 106return _factory.Sequence(temps.ToImmutableAndFree(), effects.ToImmutableAndFree(), returnValue); 349BoundLocal savedTuple = _factory.StoreToTemp(expression, out assignmentToTemp); 390var localSymbol = new SynthesizedLocal(_factory.CurrentFunction, TypeWithAnnotations.Create(outputPlaceholder.Type), SynthesizedLocalKind.LoweringTemp); 427var temp = _factory.StoreToTemp(loweredArg, out store);

33var oldSyntax = _factory.Syntax; 34_factory.Syntax = (mg.ReceiverOpt ?? mg).Syntax; 35var receiver = (!method.RequiresInstanceReceiver && !node.IsExtensionMethod && !method.IsAbstract && !method.IsVirtual) ? _factory.Type(method.ContainingType) : VisitExpression(mg.ReceiverOpt)!; 36_factory.Syntax = oldSyntax;

30rewrittenCondition = Instrumenter.InstrumentDoStatementCondition(node, rewrittenCondition, _factory);

94boundTemp = _factory.StoreToTemp(rewrittenReceiverOpt!, out tempAssignment); 97NamedTypeSymbol tokenType = _factory.WellKnownType(WellKnownType.System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken); 98NamedTypeSymbol marshalType = _factory.WellKnownType(WellKnownType.System_Runtime_InteropServices_WindowsRuntime_WindowsRuntimeMarshal); 100NamedTypeSymbol actionType = _factory.WellKnownType(WellKnownType.System_Action_T).Construct(tokenType); 104BoundExpression delegateCreationArgument = boundTemp ?? rewrittenReceiverOpt ?? _factory.Type(eventType); 141NamedTypeSymbol func2Type = _factory.WellKnownType(WellKnownType.System_Func_T2).Construct(eventType, tokenType); 283return _factory.Call(getOrCreateCall, invocationListAccessor); 298SyntaxNode oldSyntax = _factory.Syntax; 299_factory.Syntax = node.Syntax; 301var ctor = _factory.WellKnownMethod(WellKnownMember.System_Runtime_InteropServices_ComAwareEventInfo__ctor); 305var addRemove = _factory.WellKnownMethod(node.IsAddition ? WellKnownMember.System_Runtime_InteropServices_ComAwareEventInfo__AddEventHandler : 310BoundExpression eventInfo = _factory.New(ctor, _factory.Typeof(node.Event.ContainingType, ctor.Parameters[0].Type), _factory.Literal(node.Event.MetadataName)); 311result = _factory.Call(eventInfo, addRemove, 312_factory.Convert(addRemove.Parameters[0].Type, rewrittenReceiver), 313_factory.Convert(addRemove.Parameters[1].Type, rewrittenArgument)); 317_factory.Syntax = oldSyntax;

63return _factory.BadExpression(tupleField.Type); 80return _factory.BadExpression(tupleField.Type); 87rewrittenReceiver = _factory.Field(rewrittenReceiver, nestedFieldSymbol); 95return _factory.Field(rewrittenReceiver, underlyingField);

32statementBuilder.Add(InitializeFixedStatementLocal(localDecl, _factory, out pinnedTemp)); 39cleanup[i] = _factory.Assignment(_factory.Local(pinnedTemp), _factory.Null(pinnedTemp.Type)); 44cleanup[i] = _factory.Assignment(_factory.Local(pinnedTemp), _factory.NullRef(pinnedTemp.TypeWithAnnotations), isRef: true); 51statementBuilder.Add(_factory.HiddenSequencePoint()); 62return _factory.Block( 65_factory.Syntax, 66_factory.Block(statementBuilder.ToImmutableAndFree()), 68_factory.Block(cleanup))); 73return _factory.Block(localBuilder.ToImmutableAndFree(), statementBuilder.ToImmutableAndFree()); 395rewrittenAlternative: _factory.Default(localType), 473BoundExpression notNullCheck = _factory.MakeNullCheck(factory.Syntax, factory.Local(localSymbol), BinaryOperatorKind.NotEqual); 527BoundExpression notNullCheck = _factory.MakeNullCheck(factory.Syntax, arrayTempInit, BinaryOperatorKind.NotEqual);

83lengthGet = (MethodSymbol?)_factory.WellKnownMember(WellKnownMember.System_Span_T__get_Length, isOptional: true)?.SymbolAsMember(spanType); 84indexerGet = (MethodSymbol?)_factory.WellKnownMember(WellKnownMember.System_Span_T__get_Item, isOptional: true)?.SymbolAsMember(spanType); 89lengthGet = (MethodSymbol?)_factory.WellKnownMember(WellKnownMember.System_ReadOnlySpan_T__get_Length, isOptional: true)?.SymbolAsMember(spanType); 90indexerGet = (MethodSymbol?)_factory.WellKnownMember(WellKnownMember.System_ReadOnlySpan_T__get_Item, isOptional: true)?.SymbolAsMember(spanType); 157LocalSymbol enumeratorVar = _factory.SynthesizedLocal(enumeratorType, syntax: forEachSyntax, kind: SynthesizedLocalKind.ForEachEnumerator); 337Debug.Assert(_factory.CurrentFunction is { }); 338var conversions = _factory.CurrentFunction.ContainingAssembly.CorLibrary.TypeConversions; 347containingMember: _factory.CurrentFunction, 348containingType: _factory.CurrentType, 402var objectType = _factory.SpecialType(SpecialType.System_Object); 405rewrittenCondition: _factory.IsNotNullReference(boundEnumeratorVar), 424LocalSymbol disposableVar = _factory.SynthesizedLocal(idisposableTypeSymbol); 623LocalSymbol collectionTemp = _factory.SynthesizedLocal(collectionType, forEachSyntax, kind: SynthesizedLocalKind.ForEachArray, refKind: collectionTempRefKind); 639LocalSymbol positionVar = _factory.SynthesizedLocal(intType, syntax: forEachSyntax, kind: SynthesizedLocalKind.ForEachArrayIndex); 754BoundLocal boundLocal = rewriter._factory.StoreToTemp(rewrittenExpression, out BoundAssignmentOperator? valueStore); 756collectionVarInitializationPreamble = rewriter._factory.ExpressionStatement(valueStore); 770Debug.Assert(rewriter._factory.ModuleBuilderOpt is { }); 773NamedTypeSymbol intType = rewriter._factory.SpecialType(SpecialType.System_Int32); 776elementRef = rewriter._factory.ModuleBuilderOpt.EnsureInlineArrayElementRefExists(syntax, intType, rewriter._diagnostics.DiagnosticBag); 781elementRef = rewriter._factory.ModuleBuilderOpt.EnsureInlineArrayElementRefReadOnlyExists(syntax, intType, rewriter._diagnostics.DiagnosticBag); 787return rewriter._factory.Call(null, elementRef, boundArrayVar, boundPositionVar, useStrictArgumentRefKinds: true); 797BoundExpression arrayLength = rewriter._factory.Literal(length); 917LocalSymbol arrayVar = _factory.SynthesizedLocal(arrayType, syntax: forEachSyntax, kind: SynthesizedLocalKind.ForEachArray); 928LocalSymbol positionVar = _factory.SynthesizedLocal(intType, syntax: forEachSyntax, kind: SynthesizedLocalKind.ForEachArrayIndex); 1073LocalSymbol arrayVar = _factory.SynthesizedLocal(arrayType, syntax: forEachSyntax, kind: SynthesizedLocalKind.ForEachArray); 1093upperVar[dimension] = _factory.SynthesizedLocal(intType, syntax: forEachSyntax, kind: SynthesizedLocalKind.ForEachArrayLimit); 1113positionVar[dimension] = _factory.SynthesizedLocal(intType, syntax: forEachSyntax, kind: SynthesizedLocalKind.ForEachArrayIndex);

29rewrittenCondition = Instrumenter.InstrumentForStatementCondition(node, rewrittenCondition, _factory);

14Debug.Assert(_factory.TopLevelMethod is { IsStatic: false }); 15Debug.Assert(_factory.CurrentType is { }); 19var thisReference = new BoundThisReference(syntax, _factory.CurrentType);

31rewrittenCondition = Instrumenter.InstrumentIfStatementCondition(node, rewrittenCondition, _factory);

201Debug.Assert(_factory.ModuleBuilderOpt is { }); 212rewrittenReceiver = _factory.StoreToTemp(rewrittenReceiver, out receiverStore); 266DeconstructRange(rewrittenRangeArg, _factory.Literal(length), localsBuilder, sideEffectsBuilder, out startExpr, out rangeSizeExpr); 273possiblyRefCapturedReceiver = _factory.StoreToTemp(possiblyRefCapturedReceiver, out var refCapture, createSpan.Parameters[0].RefKind == RefKind.In ? RefKindExtensions.StrictIn : RefKind.Ref); 283result = _factory.Call(null, createSpan, possiblyRefCapturedReceiver, rangeSizeExpr, useStrictArgumentRefKinds: true); 287result = _factory.Call(_factory.Call(null, createSpan, possiblyRefCapturedReceiver, _factory.Literal(length), useStrictArgumentRefKinds: true), 291result = _factory.Sequence(localsBuilder.ToImmutableAndFree(), sideEffectsBuilder.ToImmutableAndFree(), result); 297result = _factory.Sequence(ImmutableArray.Create(((BoundLocal)rewrittenReceiver).LocalSymbol), 311integerArgument = _factory.Literal(length - offset); 315integerArgument = MakePatternIndexOffsetExpression(makeOffsetInput, _factory.Literal(length), strategy); 328createSpan = _factory.ModuleBuilderOpt.EnsureInlineArrayAsReadOnlySpanExists(node.Syntax, spanType, intType, _diagnostics.DiagnosticBag); 332createSpan = _factory.ModuleBuilderOpt.EnsureInlineArrayAsSpanExists(node.Syntax, spanType, intType, _diagnostics.DiagnosticBag); 354elementRef = _factory.ModuleBuilderOpt.EnsureInlineArrayFirstElementRefExists(node.Syntax, _diagnostics.DiagnosticBag); 359elementRef = _factory.ModuleBuilderOpt.EnsureInlineArrayFirstElementRefReadOnlyExists(node.Syntax, _diagnostics.DiagnosticBag); 364return _factory.Call(null, elementRef, rewrittenReceiver, useStrictArgumentRefKinds: true); 373elementRef = _factory.ModuleBuilderOpt.EnsureInlineArrayElementRefExists(node.Syntax, intType, _diagnostics.DiagnosticBag); 378elementRef = _factory.ModuleBuilderOpt.EnsureInlineArrayElementRefReadOnlyExists(node.Syntax, intType, _diagnostics.DiagnosticBag); 383return _factory.Call(null, elementRef, rewrittenReceiver, index, useStrictArgumentRefKinds: true); 394return _factory.Call(_factory.Call(null, createSpan, rewrittenReceiver, _factory.Literal(length), useStrictArgumentRefKinds: true), getItemOrSliceHelper, index); 465return _factory.Sequence( 487var F = _factory; 650return _factory.Literal(0); 666return _factory.IntSubtract(lengthAccess, loweredExpr); 681return _factory.Call( 757var F = _factory; 787var F = _factory; 998var F = _factory; 1029var F = _factory;

73return _factory.MakeNullCheck(syntax, rewrittenOperand, BinaryOperatorKind.NotEqual);

17BoundDecisionDag decisionDag = node.GetDecisionDagForLowering(_factory.Compilation); 48result = this._factory.Not(result);

70var curMethod = _factory.CurrentFunction;

57_factory.AssignmentExpression(

62BoundLocal boundTemp = _factory.StoreToTemp(enterScopeCall, 100BoundLocal boundLockTemp = _factory.StoreToTemp(rewrittenArgument, out assignmentToLockTemp, syntaxOpt: lockSyntax, kind: SynthesizedLocalKind.Lock); 144BoundLocal boundLockTakenTemp = _factory.StoreToTemp(

96var lhsTemp = _factory.StoreToTemp(lhsRead, out var store); 103var tmp = _factory.StoreToTemp(BoundCall.Synthesized(leftOperand.Syntax, lhsRead, initialBindingReceiverIsSubjectToCloning: ThreeState.Unknown, getValueOrDefault), 129var alternative = _factory.Sequence(ImmutableArray<LocalSymbol>.Empty, ImmutableArray.Create(tmpAssignment, transformedLhsAssignment), tmp); 132var ternary = _factory.Conditional(lhsReadHasValue, tmp, alternative, tmp.Type); 134return _factory.Sequence(temps.ToImmutableAndFree(), stores.ToImmutableAndFree(), ternary);

160BoundLocal boundTemp = _factory.StoreToTemp(rewrittenLeft, out tempAssignment); 163BoundExpression nullCheck = _factory.MakeNullCheck(syntax, boundTemp, BinaryOperatorKind.NotEqual);

167BoundLocal oldValue = _factory.StoreToTemp(rewrittenReceiver, out BoundAssignmentOperator boundAssignmentToTemp); 171BoundExpression value = _factory.New(anonymousType, getAnonymousTypeValues(withExpr, oldValue, anonymousType, sideEffects, temps)); 186expression = _factory.Convert( 188_factory.Call( 213BoundLocal valueTemp = _factory.StoreToTemp(rewrittenRight, out BoundAssignmentOperator boundAssignmentToTemp); 232builder.Add(_factory.Property(oldValue, property)); 266BoundLocal value = _factory.StoreToTemp(rewrittenExpression, out boundAssignmentToTemp, isKnownToReferToTempIfReferenceType: true); 376SyntaxNode oldSyntax = _factory.Syntax; 377_factory.Syntax = node.Syntax; 379var ctor = _factory.WellKnownMethod(WellKnownMember.System_Guid__ctor); 385newGuid = _factory.New(ctor, _factory.Literal(node.GuidString)); 392var getTypeFromCLSID = _factory.WellKnownMethod(WellKnownMember.System_Runtime_InteropServices_Marshal__GetTypeFromCLSID, isOptional: true); 396getTypeFromCLSID = _factory.WellKnownMethod(WellKnownMember.System_Type__GetTypeFromCLSID); 403callGetTypeFromCLSID = _factory.Call(null, getTypeFromCLSID, newGuid); 410var createInstance = _factory.WellKnownMethod(WellKnownMember.System_Activator__CreateInstance); 415rewrittenObjectCreation = _factory.Convert(node.Type, _factory.Call(null, createInstance, callGetTypeFromCLSID)); 422_factory.Syntax = oldSyntax;

423var rangeTemp = _factory.StoreToTemp(rangeArgument, out BoundAssignmentOperator rangeStore); 455var temp = _factory.StoreToTemp(rewrittenIndex, out store); 642var temp = _factory.StoreToTemp(arg, out store, refKind);

16Debug.Assert(_factory.TopLevelMethod is { IsStatic: false }); 17Debug.Assert(_factory.CurrentType is { }); 23var thisReference = new BoundThisReference(syntax, _factory.CurrentType);

22var F = _factory; 161var F = _factory;

29(node.Syntax.Kind() == SyntaxKind.Block && _factory.CurrentFunction?.IsAsync == false)))) 41var method = _factory.CurrentFunction;

34return _factory.Default(type); 63constructorCall = _factory.New((MethodSymbol)spanConstructor.SymbolAsMember(spanType), stackAllocNode, countTemp); 81var tempAccess = _factory.StoreToTemp(constructorCall, out BoundAssignmentOperator tempAssignment, syntaxOpt: stackAllocNode.Syntax); 109TypeSymbol uintType = _factory.SpecialType(SpecialType.System_UInt32); 110TypeSymbol uintPtrType = _factory.SpecialType(SpecialType.System_UIntPtr); 117BoundExpression sizeOfExpression = _factory.Sizeof(elementType); 134return _factory.Convert(uintPtrType, _factory.Literal((uint)folded), Conversion.IntegerToPointer); 139BoundExpression convertedCount = _factory.Convert(uintType, countExpression, Conversion.ExplicitNumeric); 140convertedCount = _factory.Convert(uintPtrType, convertedCount, Conversion.IntegerToPointer); 149BoundExpression product = _factory.Binary(multiplicationKind, uintPtrType, convertedCount, sizeOfExpression);

88result = _factory.StringLiteral(string.Empty); 298return _factory.StringLiteral(concatenated); 307return _factory.Literal(string.Empty); 365return _factory.Coalesce(loweredOperand, _factory.Literal("")); 413var array = _factory.ArrayOrEmpty(_factory.SpecialType(SpecialType.System_String), loweredArgs); 481_factory, 640return _factory.StringLiteral(cv.CharValue.ToString()); 727var temp = _factory.StoreToTemp(expr, out var store); 728return _factory.Sequence(

34var builderTempSymbol = _factory.InterpolatedStringHandlerLocal(data.BuilderType, syntax); 35BoundLocal builderTemp = _factory.Local(builderTempSymbol); 59var outLocal = _factory.SynthesizedLocal(localType); 60appendShouldProceedLocal = _factory.Local(outLocal); 65var handlerConstructionAssignment = _factory.AssignmentExpression(builderTemp, (BoundExpression)VisitObjectCreationExpression(construction)); 115: _factory.LogicalAnd(currentExpression, actualCall); 131var resultIf = _factory.If(appendShouldProceedLocal, _factory.StatementList(appendCallsStatements)); 133return new InterpolationHandlerResult(ImmutableArray.Create(_factory.ExpressionStatement(handlerConstructionAssignment), resultIf), builderTemp, appendShouldProceedLocal.LocalSymbol, this); 162return _factory.StringLiteral(""); 178part = _factory.StringLiteral(part.ConstantValueOpt.StringValue); 183_factory.Binary(BinaryOperatorKind.StringConcatenation, node.Type, result, part); 197result = new BoundNullCoalescingOperator(result.Syntax, result, _factory.StringLiteral(""), leftPlaceholder: placeholder, leftConversion: placeholder, BoundNullCoalescingOperatorResultKind.LeftType, @checked: false, result.Type) { WasCompilerGenerated = true }; 291return _rewriter._factory.Sequence(locals, _expressions, result); 296return _rewriter._factory.SpillSequence(locals, _statements, result);

101_factory);

38BoundExpression result = _factory.Sequence(temps.ToImmutableAndFree(), initEffects.ToImmutableAndFree(), returnValue); 308BoundExpression innerSequence = _factory.Sequence(locals: ImmutableArray<LocalSymbol>.Empty, innerEffects.ToImmutableAndFree(), logicalExpression); 322return _factory.Sequence(ImmutableArray<LocalSymbol>.Empty, outerEffects.ToImmutableAndFree(), 323result: boolValue ? _factory.Not(leftHasValue) : leftHasValue); 330return _factory.Sequence(ImmutableArray<LocalSymbol>.Empty, outerEffects.ToImmutableAndFree(), 331result: boolValue ? _factory.Not(rightHasValue) : rightHasValue); 339_factory.Sequence(ImmutableArray<LocalSymbol>.Empty, outerEffects.ToImmutableAndFree(), 340_factory.Conditional( 341_factory.Binary(BinaryOperatorKind.Equal, boolType, leftHasValue, rightHasValue), 342_factory.Conditional(leftHasValue, innerSequence, MakeBooleanConstant(right.Syntax, boolValue), boolType), 411return _factory.MakeNullableHasValue(expr.Syntax, expr); 418BoundLocal temp = _factory.StoreToTemp(loweredExpression, out BoundAssignmentOperator assignmentToTemp); 503currentResult = _factory.Binary(logicalOperator, type, currentResult, nextLogicalOperand); 558return _factory.Not(MakeUnaryOperator(UnaryOperatorKind.DynamicFalse, left.Syntax, method: null, constrainedToTypeOpt: null, dynamicResult, boolType)); 572BoundExpression binary = MakeBinaryOperator(_factory.Syntax, single.Kind, left, right, single.MethodSymbolOpt?.ReturnType ?? boolType, single.MethodSymbolOpt, single.ConstrainedToTypeOpt); 588result = _factory.Not(result);

63return _factory.BadExpression(type); 80return _factory.BadExpression(type);

95return _factory.Literal(constant.BooleanValue); 97return MakeConversionNode(_factory.Literal(!constant.BooleanValue), type, @checked: false); 203BoundLocal boundTemp = _factory.StoreToTemp(loweredOperand, out tempAssignment); 207BoundExpression condition = _factory.MakeNullableHasValue(syntax, boundTemp); 443LocalSymbol tempSymbol = _factory.SynthesizedLocal(operandType); 669BoundLocal boundTemp = _factory.StoreToTemp(rewrittenArgument, out tempAssignment); 675BoundExpression condition = _factory.MakeNullableHasValue(node.Syntax, boundTemp); 841BoundExpression condition = _factory.MakeNullableHasValue(syntax, operand);

176boundTemp = _factory.StoreToTemp(tempInit, out tempAssignment, kind: SynthesizedLocalKind.Using); 181boundTemp = _factory.StoreToTemp(rewrittenExpression, out tempAssignment, syntaxOpt: usingSyntax, kind: SynthesizedLocalKind.Using); 252BoundLocal boundTemp = _factory.StoreToTemp(tempInit, out tempAssignment, kind: SynthesizedLocalKind.Using); 383ifCondition = _factory.MakeNullableHasValue(resourceSyntax, local); 392ifCondition = _factory.MakeNullCheck(resourceSyntax, local, BinaryOperatorKind.NotEqual);

28rewrittenCondition = Instrumenter.InstrumentWhileStatementCondition(node, rewrittenCondition, _factory);

21(!node.WasCompilerGenerated || (node.Syntax.Kind() == SyntaxKind.Block && _factory.CurrentFunction?.IsAsync == false)))