BoundLocal

Binder\Binder_Deconstruct.cs (1)

644BoundLocal { DeclarationKind: BoundLocalDeclarationKind.WithExplicitType or BoundLocalDeclarationKind.WithInferredType, LocalSymbol: var symbol } => symbol,

Binder\Binder_Invocation.cs (1)

1432if (receiver is BoundLocal { LocalSymbol: { RefKind: RefKind.None } local } && (local.IsUsing || local.IsForEach))

Binder\Binder_Operators.cs (2)

4292BoundLocal localAccess = (BoundLocal)expr;

Binder\Binder_Statements.cs (1)

1496|| op1 is BoundParameter or BoundLocal

Binder\Binder.ValueChecks.cs (11)

1077var local = (BoundLocal)expr; 1313private bool CheckLocalValueKind(SyntaxNode node, BoundLocal local, BindValueKind valueKind, bool checkingReceiver, BindingDiagnosticBag diagnostics) 1358private bool CheckLocalRefEscape(SyntaxNode node, BoundLocal local, SafeContext escapeTo, bool checkingReceiver, BindingDiagnosticBag diagnostics) 2748if (argument is BoundDeconstructValuePlaceholder { VariableSymbol: not null } or BoundLocal { DeclarationKind: not BoundLocalDeclarationKind.None }) 3131BoundLocal { DeclarationKind: not BoundLocalDeclarationKind.None } l => l.LocalSymbol, 3746return GetLocalScopes(((BoundLocal)expr).LocalSymbol).RefEscapeScope; 4040var local = (BoundLocal)expr; 4409return GetLocalScopes(((BoundLocal)expr).LocalSymbol).ValEscapeScope; 5110var localSymbol = ((BoundLocal)expr).LocalSymbol;

Binder\LockOrUsingBinder.cs (1)

62lockedOrDisposedVariables = lockedOrDisposedVariables.Add(((BoundLocal)expression).LocalSymbol);

Binder\RefSafetyAnalysis.cs (1)

494public override BoundNode? VisitLocal(BoundLocal node)

BoundTree\BoundExpression.cs (1)

318public BoundLocal Update(LocalSymbol localSymbol, ConstantValue? constantValueOpt, TypeSymbol type)

BoundTree\BoundExpressionExtensions.cs (1)

25return ((BoundLocal)node).LocalSymbol.RefKind;

BoundTree\BoundImplicitIndexerAccess.cs (1)

20Debug.Assert(LengthOrCountAccess is BoundPropertyAccess or BoundArrayLength or BoundLocal or BoundBadExpression);

BoundTree\BoundTreeVisitors.cs (1)

102return VisitLocal(node as BoundLocal, arg);

BoundTree\Constructors.cs (1)

75var localSymbol = ((BoundLocal)receiver).LocalSymbol;

CodeGen\CodeGenerator_HasHome.cs (1)

111var local = ((BoundLocal)expression).LocalSymbol;

CodeGen\EmitAddress.cs (4)

34return EmitLocalAddress((BoundLocal)expression, addressKind, used); 290private LocalDefinition EmitLocalAddress(BoundLocal localAccess, AddressKind addressKind, bool used) 396var local = (BoundLocal)value;

CodeGen\EmitExpression.cs (17)

131EmitLocalLoad((BoundLocal)expression, used); 441(receiver.Kind == BoundKind.Local && IsStackLocal(((BoundLocal)receiver).LocalSymbol)) || 1297return ((BoundLocal)receiver).LocalSymbol.RefKind != RefKind.None; 1395private void EmitLocalLoad(BoundLocal local, bool used) 1587return ((BoundLocal)receiver).LocalSymbol.SynthesizedKind == SynthesizedLocalKind.FrameCache; 2149BoundLocal { LocalSymbol.IsKnownToReferToTempIfReferenceType: true } or 2260return ((BoundLocal)receiver).LocalSymbol.RefKind != RefKind.None; 2790var local = left as BoundLocal; 2820return ((BoundLocal)left).LocalSymbol.RefKind == RefKind.None; 2869var left = (BoundLocal)assignmentTarget; 3057if (lhs.Kind == BoundKind.Local && ((BoundLocal)lhs).LocalSymbol.SynthesizedKind.IsLongLived()) 3144BoundLocal local = (BoundLocal)expression; 4008var local = (BoundLocal)expr;

CodeGen\EmitStatement.cs (5)

536(receiver.Kind == BoundKind.Local && IsStackLocal(((BoundLocal)receiver).LocalSymbol)) || 1169var exceptionSourceLocal = (BoundLocal)exceptionSource; 1309var local = ((BoundLocal)expression).LocalSymbol; 1779private LocalDefinition GetLocal(BoundLocal localExpression)

CodeGen\Optimizer.cs (15)

401private BoundLocal _assignmentLocal; 761if (value != null && value.Kind == BoundKind.Local && ((BoundLocal)value).LocalSymbol == local) 833public override BoundNode VisitLocal(BoundLocal node) 850public override BoundNode VisitLocal(BoundLocal node) 925var assignmentLocal = _assignmentLocal; 1058if (((BoundLocal)lhs).LocalSymbol.RefKind != RefKind.None) 1232if (unwrappedSequence is BoundLocal { LocalSymbol: { RefKind: not RefKind.None } localSymbol }) 1438var localSym = ((BoundLocal)boundExpression).LocalSymbol; 1653if (unwrappedSequence is BoundLocal { LocalSymbol: { } localSymbol }) 1712RecordVarWrite(((BoundLocal)exceptionSourceOpt).LocalSymbol); 1956((BoundLocal)top.Item1).LocalSymbol == local; 2190public override BoundNode VisitLocal(BoundLocal node) 2219var left = node.Left as BoundLocal; 2368var sourceLocal = ((BoundLocal)exceptionSource).LocalSymbol;

Compilation\CSharpSemanticModel.cs (1)

2066case BoundLocal local:

Compiler\AnonymousTypeMethodBodySynthesizer.cs (1)

118BoundLocal boundLocal = F.StoreToTemp(F.As(F.Parameter(_parameters[0]), anonymousType), out assignmentToTemp);

Compiler\MethodBodySynthesizer.cs (2)

432BoundLocal[] boundTmps = new BoundLocal[numTemps];

FlowAnalysis\AbstractFlowPass.cs (3)

561VisitLvalue((BoundLocal)node); 618protected virtual void VisitLvalue(BoundLocal node) 1282public override BoundNode VisitLocal(BoundLocal node)

FlowAnalysis\DefiniteAssignment.cs (10)

781NoteRead(((BoundLocal)n).LocalSymbol); 933_usedVariables.Add(((BoundLocal)n).LocalSymbol); 969NoteWrite(((BoundLocal)n).LocalSymbol, value, read: read, isRef: isRef); 1352unassignedSlot = GetOrCreateSlot(((BoundLocal)node).LocalSymbol); 1450var result = ((BoundLocal)expression).LocalSymbol; 1523var local = (BoundLocal)node; 2308public override BoundNode VisitLocal(BoundLocal node) 2363if (DebugInfoInjector.TryGetConditionalBranchDiscriminatorCondition(node, out BoundExpression condition, out BoundLocal target)) 2586CheckAssigned(((BoundLocal)expr).LocalSymbol, node);

FlowAnalysis\LocalDataFlowPass.cs (1)

220return GetOrCreateSlot(((BoundLocal)node).LocalSymbol);

FlowAnalysis\NullableWalker_Patterns.cs (1)

632if (variableAccess is BoundLocal { LocalSymbol: SourceLocalSymbol local } boundLocal)

FlowAnalysis\NullableWalker.cs (5)

3284public override BoundNode? VisitLocal(BoundLocal node) 8477if (argument is BoundLocal local && local.DeclarationKind == BoundLocalDeclarationKind.WithInferredType) 9004if (argument is BoundLocal { DeclarationKind: BoundLocalDeclarationKind.WithInferredType } || IsTargetTypedExpression(argument)) 11470case BoundLocal { LocalSymbol.RefKind: RefKind.None }: 11657if (variable.Expression is BoundLocal { DeclarationKind: BoundLocalDeclarationKind.WithInferredType } local)

FlowAnalysis\ReadWriteWalker.cs (1)

193readOrWritten.Add(((BoundLocal)receiver).LocalSymbol);

FlowAnalysis\VariablesDeclaredWalker.cs (2)

257protected override void VisitLvalue(BoundLocal node) 262public override BoundNode? VisitLocal(BoundLocal node)

Generated\BoundNodes.xml.Generated.cs (10)

4581public BoundLocal Update(LocalSymbol localSymbol, BoundLocalDeclarationKind declarationKind, ConstantValue? constantValueOpt, bool isNullableUnknown, TypeSymbol type) 4585var result = new BoundLocal(this.Syntax, localSymbol, declarationKind, constantValueOpt, isNullableUnknown, type, this.HasErrors); 9315return VisitLocal((BoundLocal)node, arg); 9678public virtual R VisitLocal(BoundLocal node, A arg) => this.DefaultVisit(node, arg); 9919public virtual BoundNode? VisitLocal(BoundLocal node) => this.DefaultVisit(node); 10513public override BoundNode? VisitLocal(BoundLocal node) => null; 11861public override BoundNode? VisitLocal(BoundLocal node) 14040public override BoundNode? VisitLocal(BoundLocal node) 14043BoundLocal updatedNode; 16515public override TreeDumperNode VisitLocal(BoundLocal node, object? arg) => new TreeDumperNode("local", null, new TreeDumperNode[]

Lowering\AsyncRewriter\AsyncExceptionHandlerRewriter.cs (4)

359BoundLocal pendingValue = null; 616BoundLocal carchTempRef = _F.Local(catchTemp); 738BoundLocal pendingExceptionRef = _F.Local(currentAwaitCatchFrame.pendingCaughtException); 754public override BoundNode VisitLocal(BoundLocal node)

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

338var versionLocal = F.Local(versionSymbol); 390var instLocal = F.Local(instSymbol);

Lowering\AsyncRewriter\RuntimeAsyncRewriter.cs (9)

77var hoistedThis = rewriter._factory.StoreToTemp(rewriter._factory.This(), out BoundAssignmentOperator store, kind: SynthesizedLocalKind.AwaitByRefSpill); 91private readonly RefInitializationHoister<LocalSymbol, BoundLocal> _refInitializationHoister; 109_refInitializationHoister = new RefInitializationHoister<LocalSymbol, BoundLocal>(_factory, _factory.CurrentFunction, TypeMap.Empty); 197var tmp = _factory.StoreToTemp(getAwaiter, out BoundAssignmentOperator store, kind: SynthesizedLocalKind.Awaiter); 248var tmp = _factory.StoreToTemp(getAwaiter, out BoundAssignmentOperator store, kind: SynthesizedLocalKind.Awaiter); 320if (node.Left is not BoundLocal leftLocal) 346if (visitedLeftOrProxy is not BoundLocal visitLeftLocal) 364static BoundLocal createHoistedAccess(LocalSymbol local, RuntimeAsyncRewriter @this) 380public override BoundNode VisitLocal(BoundLocal node)

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

487public override BoundNode VisitLocal(BoundLocal node)

Lowering\ClosureConversion\ExpressionLambdaRewriter.cs (2)

863var parameterReference = _bound.Local(param); 913var parameterReference = _bound.Local(param);

Lowering\DiagnosticsPass_ExpressionTrees.cs (2)

181public override BoundNode VisitLocal(BoundLocal node) 532private void CheckOutDeclaration(BoundLocal local)

Lowering\DiagnosticsPass_Warnings.cs (6)

37var local = (BoundLocal)argument; 204var local1 = (BoundLocal)expr1; 205var local2 = (BoundLocal)expr2;

Lowering\Instrumentation\DebugInfoInjector_SequencePoints.cs (4)

199(TryGetConditionalBranchDiscriminatorCondition(sequence, out var roundtripCondition, out var roundtripTarget) && 214[NotNullWhen(returnValue: true)] out BoundLocal? target) 219SideEffects: [BoundAssignmentOperator { IsRef: false, Left: BoundLocal { LocalSymbol: var assignedLocal } left, Right: var conditionValue }], 220Value: BoundSequencePointExpression { Expression: BoundLocal { LocalSymbol: var valueLocal } },

Lowering\Instrumentation\Instrumenter.cs (1)

222Debug.Assert(original.Left is BoundLocal { LocalSymbol.SynthesizedKind: SynthesizedLocalKind.UserDefined } or BoundParameter);

Lowering\Instrumentation\LocalStateTracingInstrumenter.cs (5)

364Debug.Assert(original.Left is BoundLocal { LocalSymbol.SynthesizedKind: SynthesizedLocalKind.UserDefined } or BoundParameter); 372if (original.Right is BoundLocal { LocalSymbol.SynthesizedKind: SynthesizedLocalKind.UserDefined } rightLocal) 417if (node is BoundLocal { LocalSymbol: var localSymbol }) 462var addressOf = value is BoundLocal or BoundParameter ? 586BoundLocal? temp = null;

Lowering\IteratorRewriter\IteratorMethodToStateMachineRewriter.cs (2)

179var state = F.Local(stateLocal); 264private BoundStatement EmitFinallyFrame(IteratorFinallyFrame frame, BoundLocal state)

Lowering\LocalRewriter\LocalRewriter_AssignmentOperator.cs (1)

383BoundLocal capturedRight = _factory.StoreToTemp(rewrittenRight, out BoundAssignmentOperator assignmentToTemp, refKind: RefKind.None);

Lowering\LocalRewriter\LocalRewriter_Await.cs (1)

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

Lowering\LocalRewriter\LocalRewriter_BinaryOperator.cs (13)

Lowering\LocalRewriter\LocalRewriter_Call.cs (24)

311var receiverTemp = _factory.StoreToTemp(receiverOpt, out var assignmentToTemp); 584((BoundLocal)current).LocalSymbol.SynthesizedKind != SynthesizedLocalKind.UserDefined); 773BoundLocal receiverTemp = _factory.StoreToTemp(rewrittenReceiver, out assignmentToTemp, refKind is RefKind.RefReadOnlyParameter ? RefKind.In : refKind); 779if (capturedReceiver is not BoundLocal { LocalSymbol.IsRef: false } && 786Debug.Assert(capturedReceiver is BoundLocal); 792tempsOpt.Insert(insertTempHere, ((BoundLocal)capturedReceiver).LocalSymbol); 938BoundSequence { Value: BoundLocal l } => l, 939BoundLocal l => l, // Can happen for discard arguments 950BoundLocal local = _factory.StoreToTemp(visitedArgument, out var store, refKind: paramRefKind is RefKind.In or RefKind.RefReadOnlyParameter ? RefKind.In : argRefKind); 1069private BoundLocal ReferToTempIfReferenceTypeReceiver(BoundExpression receiver, [NotNull] ref BoundAssignmentOperator? assignmentToTemp, ArrayBuilder<BoundExpression> stores, ArrayBuilder<LocalSymbol> temps) 1071Debug.Assert(receiver is BoundArrayAccess { Type.IsReferenceType: false } or BoundLocal); 1073(array is BoundLocal && indices.All(e => e is BoundLocal or BoundLiteral))); 1074Debug.Assert(assignmentToTemp is not null == receiver is BoundLocal); 1077(assignmentToTemp.Left is BoundLocal { LocalSymbol: { } var1 } && 1078receiver is BoundLocal { LocalSymbol: { } var2 } && 1091BoundLocal result; 1095BoundLocal cache = _factory.Local(_factory.SynthesizedLocal(receiverType)); 1099if (receiver is BoundLocal receiverTemp) 1135else if (receiver is BoundLocal receiverTemp) 1582var temp = _factory.StoreToTemp( 1668temporariesBuilder.Add(((BoundLocal)s.Left).LocalSymbol); 1826var localRefKind = ((BoundLocal)argument).LocalSymbol.RefKind; 1837BoundLocal boundTemp = _factory.StoreToTemp(argument, out boundAssignmentToTemp);

Lowering\LocalRewriter\LocalRewriter_CollectionExpression.cs (21)

495BoundLocal temp = _factory.StoreToTemp(rewrittenReceiver, out assignmentToTemp); 535BoundExpression? rewriteCollectionInitializer(BoundLocal rewrittenReceiver, BoundExpression expressionElement) 726var temp = _factory.StoreToTemp(element, out var assignment); 742BoundLocal inlineArrayLocal = _factory.StoreToTemp(new BoundDefaultExpression(syntax, inlineArrayType), out assignmentToTemp); 931var localsBuilder = ArrayBuilder<BoundLocal>.GetInstance(); 938BoundLocal? indexTemp = null; 951BoundLocal arrayTemp = _factory.StoreToTemp( 1180ArrayBuilder<BoundLocal> localsBuilder, 1181BoundLocal indexTemp, 1197Debug.Assert((object)spreadOperandAsSpan != rewrittenSpreadOperand || spreadOperandAsSpan is BoundLocal { LocalSymbol.SynthesizedKind: SynthesizedLocalKind.LoweringTemp }); 1202localsBuilder.Add((BoundLocal)spreadOperandAsSpan); 1236var localsBuilder = ArrayBuilder<BoundLocal>.GetInstance(); 1263BoundLocal? knownLengthTemp = null; 1299BoundLocal listTemp = _factory.StoreToTemp(rewrittenReceiver, out assignmentToTemp); 1315BoundLocal spanTemp = _factory.StoreToTemp(_factory.Call(receiver: null, asSpan, listTemp), out assignmentToTemp); 1324BoundLocal? indexTemp = null; 1452ArrayBuilder<BoundLocal> locals, 1459BoundLocal temp = _factory.StoreToTemp(rewrittenExpression, out assignmentToTemp); 1468ArrayBuilder<BoundLocal> rewrittenExpressions, 1511private BoundExpression GetKnownLengthExpression(ImmutableArray<BoundNode> elements, int numberIncludingLastSpread, ArrayBuilder<BoundLocal> rewrittenExpressions) 1579var iterationLocal = _factory.Local(iterationVariable);

Lowering\LocalRewriter\LocalRewriter_CompoundAssignmentOperator.cs (22)

Lowering\LocalRewriter\LocalRewriter_Conversion.cs (3)

1032var savedTuple = _factory.StoreToTemp(rewrittenOperand, out assignmentToTemp); 1237var boundTemp = _factory.StoreToTemp(operand, out tempAssignment); 1509BoundLocal boundTemp = _factory.StoreToTemp(rewrittenOperand, out tempAssignment);

Lowering\LocalRewriter\LocalRewriter_DeconstructionAssignmentOperator.cs (4)

168case BoundLocal { LocalSymbol: { RefKind: RefKind.None } localSymbol }: 350BoundLocal savedTuple = _factory.StoreToTemp(expression, out assignmentToTemp); 393var localBound = new BoundLocal(target.Syntax, localSymbol, constantValueOpt: null, type: outputPlaceholder.Type) 428var temp = _factory.StoreToTemp(loweredArg, out store);

Lowering\LocalRewriter\LocalRewriter_Event.cs (1)

90BoundLocal? boundTemp = null;

Lowering\LocalRewriter\LocalRewriter_FixedStatement.cs (1)

334BoundLocal? nullableBoundTemp = null;

Lowering\LocalRewriter\LocalRewriter_ForEachStatement.cs (24)

Lowering\LocalRewriter\LocalRewriter_IndexerAccess.cs (23)

333localsBuilder.Insert(0, ((BoundLocal)possiblyRefCapturedReceiver).LocalSymbol); 357result = _factory.Sequence(ImmutableArray.Create(((BoundLocal)rewrittenReceiver).LocalSymbol), 582var receiverLocal = F.StoreToTemp( 595if (capturedReceiver is not BoundLocal { LocalSymbol.IsRef: false }) 618locals.Insert(insertTempHere, ((BoundLocal)capturedReceiver).LocalSymbol); 645locals.Add(((BoundLocal)makeOffsetInput).LocalSymbol); 704var integerTemp = F.StoreToTemp(integerArgument, out BoundAssignmentOperator integerStore); 718var integerTemp = F.StoreToTemp(integerArgument, out BoundAssignmentOperator integerStore); 925var receiverLocal = F.StoreToTemp( 938if (capturedReceiver is not BoundLocal { LocalSymbol.IsRef: false }) 979localsBuilder.Insert(insertTempHere, ((BoundLocal)capturedReceiver).LocalSymbol); 1116var lengthLocal = F.StoreToTemp(lengthAccess, out var lengthStore); 1129var startLocal = F.StoreToTemp(startExpr, out var startStore); 1134var rangeSizeLocal = F.StoreToTemp(rangeSizeExpr, out var rangeSizeStore); 1163localsBuilder.Add(((BoundLocal)expression).LocalSymbol); 1250startExpr is not BoundLocal { LocalSymbol.SynthesizedKind: not SynthesizedLocalKind.UserDefined }) 1252var startLocal = F.StoreToTemp(startExpr, out var startStore); 1264private (BoundLocal startExpr, BoundLocal rangeSizeExpr) 1269var rangeLocal = F.StoreToTemp(rewrittenRangeArg, out var rangeStore); 1275var lengthLocal = F.StoreToTemp(lengthAccess, out var lengthStore); 1281var startLocal = F.StoreToTemp( 1291var rangeSizeLocal = F.StoreToTemp(

Lowering\LocalRewriter\LocalRewriter_LockStatement.cs (3)

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

Lowering\LocalRewriter\LocalRewriter_NullCoalescingAssignmentOperator.cs (3)

48BoundLocal rightResult = _factory.StoreToTemp(loweredRight, out BoundAssignmentOperator assignmentToTemp, refKind: RefKind.None); 119var lhsTemp = _factory.StoreToTemp(lhsRead, out var store); 126var tmp = _factory.StoreToTemp(BoundCall.Synthesized(leftOperand.Syntax, lhsRead, initialBindingReceiverIsSubjectToCloning: ThreeState.Unknown, getValueOrDefault),

Lowering\LocalRewriter\LocalRewriter_NullCoalescingOperator.cs (2)

146if (unwrappedRight is { ConstantValueOpt: not null } or BoundLocal { LocalSymbol.IsRef: false } or BoundParameter { ParameterSymbol.RefKind: RefKind.None } && 160BoundLocal boundTemp = _factory.StoreToTemp(rewrittenLeft, out tempAssignment);

Lowering\LocalRewriter\LocalRewriter_ObjectCreationExpression.cs (3)

167BoundLocal oldValue = _factory.StoreToTemp(rewrittenReceiver, out BoundAssignmentOperator boundAssignmentToTemp); 218BoundLocal valueTemp = _factory.StoreToTemp(rewrittenRight, out BoundAssignmentOperator boundAssignmentToTemp); 271BoundLocal value = _factory.StoreToTemp(rewrittenExpression, out boundAssignmentToTemp, isKnownToReferToTempIfReferenceType: true);

Lowering\LocalRewriter\LocalRewriter_ObjectOrCollectionInitializerExpression.cs (3)

456var rangeTemp = _factory.StoreToTemp(rangeArgument, out BoundAssignmentOperator rangeStore); 488var temp = _factory.StoreToTemp(rewrittenIndex, out store); 676var temp = _factory.StoreToTemp(arg, out store, refKind);

Lowering\LocalRewriter\LocalRewriter_StackAlloc.cs (1)

81var tempAccess = _factory.StoreToTemp(constructorCall, out BoundAssignmentOperator tempAssignment, syntaxOpt: stackAllocNode.Syntax);

Lowering\LocalRewriter\LocalRewriter_StringConcat.cs (2)

525var temp = factory.StoreToTemp(arg, out var tempAssignment); 731var temp = _factory.StoreToTemp(expr, out var store);

Lowering\LocalRewriter\LocalRewriter_StringInterpolation.cs (5)

35BoundLocal builderTemp = _factory.Local(builderTempSymbol); 40BoundLocal? appendShouldProceedLocal = null; 262public readonly BoundLocal HandlerTemp; 264public InterpolationHandlerResult(ImmutableArray<BoundStatement> statements, BoundLocal handlerTemp, LocalSymbol outTemp, LocalRewriter rewriter) 273public InterpolationHandlerResult(ImmutableArray<BoundExpression> expressions, BoundLocal handlerTemp, LocalSymbol? outTemp, LocalRewriter rewriter)

Lowering\LocalRewriter\LocalRewriter_TupleBinaryOperator.cs (2)

423private BoundLocal MakeTemp(BoundExpression loweredExpression, ArrayBuilder<LocalSymbol> temps, ArrayBuilder<BoundExpression> effects) 425BoundLocal temp = _factory.StoreToTemp(loweredExpression, out BoundAssignmentOperator assignmentToTemp);

Lowering\LocalRewriter\LocalRewriter_UnaryOperator.cs (9)

204BoundLocal boundTemp = _factory.StoreToTemp(loweredOperand, out tempAssignment); 433BoundLocal boundTemp; 470BoundLocal boundTemp; 491BoundLocal capturedRight = _factory.StoreToTemp(rightOpt, out tempAssignment); 523static BoundCall makeIncrementCall(SyntaxNode syntax, BoundLocal boundTemp, BoundExpression? rightOpt, MethodSymbol operatorMethod) 528BoundExpression makeAssignmentBack(SyntaxNode syntax, BoundExpression transformedLHS, BoundLocal boundTemp, bool isChecked, AssignmentKind assignmentKind) 638return ((BoundLocal)expression).LocalSymbol.RefKind != RefKind.None; 671BoundLocal incrementResult = _factory.StoreToTemp(newValue, out BoundAssignmentOperator assignmentToTemp, refKind: RefKind.None); 830BoundLocal boundTemp = _factory.StoreToTemp(rewrittenArgument, out tempAssignment);

Lowering\LocalRewriter\LocalRewriter_UsingStatement.cs (4)

155BoundLocal boundTemp; 221BoundLocal boundLocal = new BoundLocal(declarationSyntax, localSymbol, localDeclaration.InitializerOpt.ConstantValueOpt, localType); 252BoundLocal boundTemp = _factory.StoreToTemp(tempInit, out tempAssignment, kind: SynthesizedLocalKind.Using); 283BoundLocal local,

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

578if (binding.VariableAccess is BoundLocal l)

Lowering\MethodToClassRewriter.cs (4)

216public sealed override BoundNode VisitLocal(BoundLocal node) 266var leftLocal = (BoundLocal)originalLeft; 306BoundLocal tempLocal = factory.StoreToTemp(rewrittenRight, out tempAssignment);

Lowering\SpillSequenceSpiller.cs (17)

210public override BoundNode VisitLocal(BoundLocal node) 360out BoundLocal referenceTypeReceiver)) 396var local = (BoundLocal)expression; 506var replacement = _F.StoreToTemp( 533out BoundLocal outReferenceTypeReceiver) 538Left: BoundLocal { LocalSymbol: { SynthesizedKind: SynthesizedLocalKind.LoweringTemp, RefKind: not RefKind.None } receiverRefLocal }, 550Left: BoundLocal { LocalSymbol: { SynthesizedKind: SynthesizedLocalKind.LoweringTemp, RefKind: RefKind.None } referenceTypeClone }, 554Value: BoundLocal { LocalSymbol: { SynthesizedKind: SynthesizedLocalKind.LoweringTemp, RefKind: RefKind.None } } referenceTypeReceiver 559&& (object)receiverRefLocal != (valueTypeReceiver as BoundLocal)?.LocalSymbol 573if (valueTypeReceiver is BoundLocal valueTypeReceiverLocal) 576&& originalReceiver is BoundLocal { LocalSymbol: { SynthesizedKind: SynthesizedLocalKind.LoweringTemp, RefKind: not RefKind.None } } originalReceiverLocal 589if (originalReceiverArrayAccess.Expression is not BoundLocal originalReceiverArrayAccessExpressionLocal 590|| valueTypeReceiverArrayAccess.Expression is not BoundLocal valueTypeReceiverArrayAccessExpressionLocal 611if (originalReceiverIndex is not BoundLocal originalReceiverIndexLocal 612|| valueTypeReceiverIndex is not BoundLocal valueTypeReceiverIndexLocal 1140var cache = _F.Local(_F.SynthesizedLocal(receiverType));

Lowering\StateMachineRewriter\IteratorAndAsyncCaptureWalker.cs (3)

255case BoundLocal { LocalSymbol: var symbol }: 362if (node is { IsRef: true, Left: BoundLocal { LocalSymbol: LocalSymbol { IsCompilerGenerated: true } local } }) 431public override BoundNode VisitLocal(BoundLocal node)

Lowering\StateMachineRewriter\MethodToStateMachineRewriter.cs (1)

625var leftLocal = ((BoundLocal)node.Left).LocalSymbol;

Lowering\StateMachineRewriter\RefInitializationHoister.cs (2)

285Debug.Assert(_reportedError || expr is BoundLocal { LocalSymbol.RefKind: RefKind.None } 290if (expr is BoundLocal { LocalSymbol.RefKind: RefKind.None }

Lowering\SyntheticBoundNodeFactory.cs (8)

451return (InstrumentationState?.IsSuppressed == false && left is BoundLocal { LocalSymbol.SynthesizedKind: SynthesizedLocalKind.UserDefined } or BoundParameter) ? 1040public BoundLocal Local(LocalSymbol local) 1634var source = Local(local); 1670public BoundLocal StoreToTemp( 1718var local = new BoundLocal( 1750internal BoundLocal MakeTempForDiscard(BoundDiscardExpression node, ArrayBuilder<LocalSymbol> temps) 1753BoundLocal result = MakeTempForDiscard(node, out temp); 1758internal BoundLocal MakeTempForDiscard(BoundDiscardExpression node, out LocalSymbol temp)

Operations\CSharpOperationFactory_Methods.cs (1)

93internal IVariableDeclaratorOperation? CreateVariableDeclarator(BoundLocal? boundLocal)

Operations\CSharpOperationFactory.cs (3)

43return CreateBoundLocalOperation((BoundLocal)boundNode); 559internal IOperation CreateBoundLocalOperation(BoundLocal boundLocal, bool createDeclaration = true) 2092IOperation? exceptionDeclarationOrExpression = CreateVariableDeclarator((BoundLocal?)boundCatchBlock.ExceptionSourceOpt);

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

60BoundLocal builderLocal = F.Local(builderLocalSymbol); 88static BoundStatement makeAppendString(SyntheticBoundNodeFactory F, BoundLocal builder, string value) 93static BoundStatement makeAppendChar(SyntheticBoundNodeFactory F, BoundLocal builder, char value)

Symbols\Synthesized\SynthesizedEntryPointSymbol.cs (2)

522var scriptLocal = new BoundLocal( 615var submissionLocal = new BoundLocal(

Symbols\Synthesized\SynthesizedHotReloadExceptionConstructorSymbol.cs (1)

70var actionTemp = factory.StoreToTemp(