LocalSymbol

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

4293LocalSymbol localSymbol = localAccess.LocalSymbol;

Binder\Binder.ValueChecks.cs (6)

1321LocalSymbol localSymbol = local.LocalSymbol; 1360LocalSymbol localSymbol = local.LocalSymbol; 3131BoundLocal { DeclarationKind: not BoundLocalDeclarationKind.None } l => l.LocalSymbol, 3746return GetLocalScopes(((BoundLocal)expr).LocalSymbol).RefEscapeScope; 4409return GetLocalScopes(((BoundLocal)expr).LocalSymbol).ValEscapeScope; 5110var localSymbol = ((BoundLocal)expr).LocalSymbol;

Binder\LockOrUsingBinder.cs (1)

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

Binder\RefSafetyAnalysis.cs (2)

496Debug.Assert(_localEscapeScopes?.ContainsKey(node.LocalSymbol) == true || 497_symbol != node.LocalSymbol.ContainingSymbol);

BoundTree\BoundExpression.cs (1)

310get { return this.LocalSymbol; }

BoundTree\BoundExpressionExtensions.cs (1)

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

BoundTree\Constructors.cs (1)

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

CodeGen\CodeGenerator_HasHome.cs (1)

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

CodeGen\EmitAddress.cs (2)

292var local = localAccess.LocalSymbol; 397var symbol = local.LocalSymbol;

CodeGen\EmitExpression.cs (16)

441(receiver.Kind == BoundKind.Local && IsStackLocal(((BoundLocal)receiver).LocalSymbol)) || 1297return ((BoundLocal)receiver).LocalSymbol.RefKind != RefKind.None; 1397bool isRefLocal = local.LocalSymbol.RefKind != RefKind.None; 1398if (IsStackLocal(local.LocalSymbol)) 1419EmitLoadIndirect(local.LocalSymbol.Type, local.Syntax); 1587return ((BoundLocal)receiver).LocalSymbol.SynthesizedKind == SynthesizedLocalKind.FrameCache; 2149BoundLocal { LocalSymbol.IsKnownToReferToTempIfReferenceType: true } or 2260return ((BoundLocal)receiver).LocalSymbol.RefKind != RefKind.None; 2820return ((BoundLocal)left).LocalSymbol.RefKind == RefKind.None; 2890if (left.LocalSymbol.RefKind != RefKind.None && !assignmentOperator.IsRef) 2892if (!IsStackLocal(left.LocalSymbol)) 3057if (lhs.Kind == BoundKind.Local && ((BoundLocal)lhs).LocalSymbol.SynthesizedKind.IsLongLived()) 3145if (local.LocalSymbol.RefKind != RefKind.None && !assignment.IsRef) 3147EmitIndirectStore(local.LocalSymbol.Type, local.Syntax); 3151if (IsStackLocal(local.LocalSymbol)) 4009if (this.IsStackLocal(local.LocalSymbol))

CodeGen\EmitStatement.cs (5)

536(receiver.Kind == BoundKind.Local && IsStackLocal(((BoundLocal)receiver).LocalSymbol)) || 1170Debug.Assert(exceptionSourceLocal.LocalSymbol.RefKind == RefKind.None); 1171if (!IsStackLocal(exceptionSourceLocal.LocalSymbol)) 1309var local = ((BoundLocal)expression).LocalSymbol; 1781var symbol = localExpression.LocalSymbol;

CodeGen\Optimizer.cs (21)

761if (value != null && value.Kind == BoundKind.Local && ((BoundLocal)value).LocalSymbol == local) 835if (node.LocalSymbol == _local) 857if (node.LocalSymbol.RefKind != RefKind.None) 859RecordVarRead(node.LocalSymbol); 863RecordVarRef(node.LocalSymbol); 877if (node.LocalSymbol.RefKind != RefKind.None) 881RecordVarRead(node.LocalSymbol); 887RecordVarRead(node.LocalSymbol); 980LocalSymbol localSymbol = assignmentLocal.LocalSymbol; 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; 2193if (!_info.TryGetValue(node.LocalSymbol, out locInfo)) 2201return new BoundDup(node.Syntax, node.LocalSymbol.RefKind, node.Type); 2222if (left == null || !_info.TryGetValue(left.LocalSymbol, out locInfo)) 2229var isIndirectLocalStore = left.LocalSymbol.RefKind != RefKind.None && !node.IsRef; 2258left.LocalSymbol.RefKind == RefKind.Ref && 2368var sourceLocal = ((BoundLocal)exceptionSource).LocalSymbol;

Compilation\CSharpSemanticModel.cs (2)

2078type = local.LocalSymbol.Type; 2079nullability = local.LocalSymbol.TypeWithAnnotations.NullableAnnotation.ToNullabilityInfo(type);

Compiler\AnonymousTypeMethodBodySynthesizer.cs (1)

153F.CloseMethod(F.Block(ImmutableArray.Create<LocalSymbol>(boundLocal.LocalSymbol), assignment, retStatement));

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; 1524if (local.LocalSymbol.RefKind != RefKind.None && !isRef) 2310LocalSymbol localSymbol = node.LocalSymbol; 2365Debug.Assert(target.LocalSymbol.Type is not null); 2367if (target.LocalSymbol.Type.SpecialType == SpecialType.System_Boolean) 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 (4)

3296var local = node.LocalSymbol; 8480_variables.SetType(local.LocalSymbol, varType); 11470case BoundLocal { LocalSymbol.RefKind: RefKind.None }: 11661_variables.SetType(local.LocalSymbol, operandType.ToAnnotatedTypeWithAnnotations(compilation));

FlowAnalysis\ReadWriteWalker.cs (1)

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

FlowAnalysis\VariablesDeclaredWalker.cs (1)

266_variablesDeclared.Add(node.LocalSymbol);

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

4583if (!Symbols.SymbolEqualityComparer.ConsiderEverything.Equals(localSymbol, this.LocalSymbol) || declarationKind != this.DeclarationKind || constantValueOpt != this.ConstantValueOpt || isNullableUnknown != this.IsNullableUnknown || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything)) 11863LocalSymbol localSymbol = this.VisitLocalSymbol(node.LocalSymbol); 14042LocalSymbol localSymbol = GetUpdatedSymbol(node, node.LocalSymbol); 16517new TreeDumperNode("localSymbol", node.LocalSymbol, null),

Lowering\AsyncRewriter\AsyncExceptionHandlerRewriter.cs (1)

758if (catchFrame == null || !catchFrame.TryGetHoistedLocal(node.LocalSymbol, out hoistedLocal))

Lowering\AsyncRewriter\RuntimeAsyncRewriter.cs (12)

78rewriter._hoistedLocals.Add(hoistedThis.LocalSymbol); 223locals: [tmp.LocalSymbol], 295locals: [tmp.LocalSymbol], 327if (_variablesToHoist.Contains(leftLocal.LocalSymbol) && !_proxies.ContainsKey(leftLocal.LocalSymbol)) 329Debug.Assert(leftLocal.LocalSymbol.SynthesizedKind == SynthesizedLocalKind.Spill || 330(leftLocal.LocalSymbol.SynthesizedKind == SynthesizedLocalKind.ForEachArray && leftLocal.LocalSymbol.Type.HasInlineArrayAttribute(out _) && leftLocal.LocalSymbol.Type.TryGetInlineArrayElementField() is object)); 334leftLocal.LocalSymbol, 382if (TryReplaceWithProxy(node.LocalSymbol, node.Syntax, out BoundNode? replacement)) 387Debug.Assert(!_variablesToHoist.Contains(node.LocalSymbol));

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

489AddIfCaptured(node.LocalSymbol, node.Syntax);

Lowering\DiagnosticsPass_ExpressionTrees.cs (1)

183CheckReferenceToVariable(node, node.LocalSymbol);

Lowering\DiagnosticsPass_Warnings.cs (2)

206return local1.LocalSymbol == local2.LocalSymbol;

Lowering\Instrumentation\DebugInfoInjector_SequencePoints.cs (3)

201ReferenceEquals(roundtripTarget.LocalSymbol, local))); 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) 375refAssignmentSourceIndex = _factory.LocalId(rightLocal.LocalSymbol); 417if (node is BoundLocal { LocalSymbol: var localSymbol }) 626return _factory.Sequence(ImmutableArray.Create(temp.LocalSymbol), builder.ToImmutableAndFree(), temp);

Lowering\LocalRewriter\LocalRewriter_AssignmentOperator.cs (1)

384argTempsBuilder.Add(capturedRight.LocalSymbol);

Lowering\LocalRewriter\LocalRewriter_Await.cs (1)

52locals: ImmutableArray.Create<LocalSymbol>(tempAccess.LocalSymbol),

Lowering\LocalRewriter\LocalRewriter_BinaryOperator.cs (12)

Lowering\LocalRewriter\LocalRewriter_Call.cs (14)

312temps.Add(receiverTemp.LocalSymbol); 584((BoundLocal)current).LocalSymbol.SynthesizedKind != SynthesizedLocalKind.UserDefined); 779if (capturedReceiver is not BoundLocal { LocalSymbol.IsRef: false } && 792tempsOpt.Insert(insertTempHere, ((BoundLocal)capturedReceiver).LocalSymbol); 951tempsOpt.Add(local.LocalSymbol); 1077(assignmentToTemp.Left is BoundLocal { LocalSymbol: { } var1 } && 1078receiver is BoundLocal { LocalSymbol: { } var2 } && 1096temps.Add(cache.LocalSymbol); 1103temps.Add(receiverTemp.LocalSymbol); 1104refKind = receiverTemp.LocalSymbol.RefKind; 1157((SynthesizedLocal)result.LocalSymbol).SetIsKnownToReferToTempIfReferenceType(); 1668temporariesBuilder.Add(((BoundLocal)s.Left).LocalSymbol); 1826var localRefKind = ((BoundLocal)argument).LocalSymbol.RefKind; 1847temporariesBuilder.Add(boundTemp.LocalSymbol);

Lowering\LocalRewriter\LocalRewriter_CollectionExpression.cs (6)

530ImmutableArray.Create(temp.LocalSymbol), 727_additionalLocals.Add(temp.LocalSymbol); 745_additionalLocals.Add(inlineArrayLocal.LocalSymbol); 1026var locals = localsBuilder.SelectAsArray(l => l.LocalSymbol); 1197Debug.Assert((object)spreadOperandAsSpan != rewrittenSpreadOperand || spreadOperandAsSpan is BoundLocal { LocalSymbol.SynthesizedKind: SynthesizedLocalKind.LoweringTemp }); 1430var locals = localsBuilder.SelectAsArray(l => l.LocalSymbol);

Lowering\LocalRewriter\LocalRewriter_CompoundAssignmentOperator.cs (18)

Lowering\LocalRewriter\LocalRewriter_Conversion.cs (3)

1044return _factory.MakeSequence(savedTuple.LocalSymbol, assignmentToTemp, result); 1268locals: ImmutableArray.Create(boundTemp.LocalSymbol), 1548locals: ImmutableArray.Create(boundTemp.LocalSymbol),

Lowering\LocalRewriter\LocalRewriter_DeconstructionAssignmentOperator.cs (3)

168case BoundLocal { LocalSymbol: { RefKind: RefKind.None } localSymbol }: 352temps.Add(savedTuple.LocalSymbol); 429temps.Add(temp.LocalSymbol);

Lowering\LocalRewriter\LocalRewriter_Event.cs (1)

181: ImmutableArray.Create<LocalSymbol>(boundTemp.LocalSymbol);

Lowering\LocalRewriter\LocalRewriter_FixedStatement.cs (1)

402locals: ImmutableArray.Create(nullableBoundTemp.LocalSymbol),

Lowering\LocalRewriter\LocalRewriter_ForEachStatement.cs (1)

756preambleLocal = boundLocal.LocalSymbol;

Lowering\LocalRewriter\LocalRewriter_IndexerAccess.cs (19)

Lowering\LocalRewriter\LocalRewriter_LockStatement.cs (4)

80locals: ImmutableArray.Create(boundTemp.LocalSymbol), 170ImmutableArray.Create(boundLockTemp.LocalSymbol, boundLockTakenTemp.LocalSymbol), 221ImmutableArray.Create(boundLockTemp.LocalSymbol),

Lowering\LocalRewriter\LocalRewriter_NullCoalescingAssignmentOperator.cs (3)

51assignment = new BoundSequence(syntax, [rightResult.LocalSymbol], [assignmentToTemp], assignment, assignment.Type); 121temps.Add(lhsTemp.LocalSymbol); 130temps.Add(tmp.LocalSymbol);

Lowering\LocalRewriter\LocalRewriter_NullCoalescingOperator.cs (2)

146if (unwrappedRight is { ConstantValueOpt: not null } or BoundLocal { LocalSymbol.IsRef: false } or BoundParameter { ParameterSymbol.RefKind: RefKind.None } && 184locals: ImmutableArray.Create(boundTemp.LocalSymbol),

Lowering\LocalRewriter\LocalRewriter_ObjectCreationExpression.cs (4)

168temps.Add(oldValue.LocalSymbol); 219temps.Add(valueTemp.LocalSymbol); 296locals = ImmutableArray.Create(value.LocalSymbol); 300temps.Insert(0, value.LocalSymbol);

Lowering\LocalRewriter\LocalRewriter_ObjectOrCollectionInitializerExpression.cs (3)

458temps.Add(rangeTemp.LocalSymbol); 495temps.Add(temp.LocalSymbol); 682temps.Add(temp.LocalSymbol);

Lowering\LocalRewriter\LocalRewriter_StackAlloc.cs (1)

83locals.Add(tempAccess.LocalSymbol);

Lowering\LocalRewriter\LocalRewriter_StringConcat.cs (2)

526localsBuilder.Add(temp.LocalSymbol); 733ImmutableArray.Create(temp.LocalSymbol),

Lowering\LocalRewriter\LocalRewriter_StringInterpolation.cs (4)

133return new InterpolationHandlerResult(ImmutableArray.Create(_factory.ExpressionStatement(handlerConstructionAssignment), resultIf), builderTemp, appendShouldProceedLocal.LocalSymbol, this); 140return new InterpolationHandlerResult(resultExpressions.ToImmutableAndFree(), builderTemp, appendShouldProceedLocal?.LocalSymbol, this); 286? ImmutableArray.Create(HandlerTemp.LocalSymbol, _outTemp) 287: ImmutableArray.Create(HandlerTemp.LocalSymbol);

Lowering\LocalRewriter\LocalRewriter_TupleBinaryOperator.cs (1)

427temps.Add(temp.LocalSymbol);

Lowering\LocalRewriter\LocalRewriter_UnaryOperator.cs (7)

237locals: ImmutableArray.Create<LocalSymbol>(boundTemp.LocalSymbol), 438locals: [boundTemp.LocalSymbol], 473tempSymbols.Add(boundTemp.LocalSymbol); 492tempSymbols.Add(capturedRight.LocalSymbol); 638return ((BoundLocal)expression).LocalSymbol.RefKind != RefKind.None; 672tempSymbols.Add(incrementResult.LocalSymbol); 873locals: ImmutableArray.Create<LocalSymbol>(boundTemp.LocalSymbol),

Lowering\LocalRewriter\LocalRewriter_UsingStatement.cs (2)

195locals: node.Locals.Add(boundTemp.LocalSymbol), 258locals: ImmutableArray.Create<LocalSymbol>(boundTemp.LocalSymbol), //localSymbol will be declared by an enclosing block

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

580Debug.Assert(l.LocalSymbol.DeclarationKind == LocalDeclarationKind.PatternVariable);

Lowering\MethodToClassRewriter.cs (9)

218if (TryReplaceWithProxy(node.LocalSymbol, node.Syntax, out BoundNode? replacement)) 224Debug.Assert(!NeedsProxy(node.LocalSymbol)); 270if (leftLocal.LocalSymbol.RefKind != RefKind.None && 272NeedsProxy(leftLocal.LocalSymbol)) 274Debug.Assert(!proxies.ContainsKey(leftLocal.LocalSymbol)); 280if (NeedsProxy(leftLocal.LocalSymbol) && !proxies.ContainsKey(leftLocal.LocalSymbol)) 282Debug.Assert(leftLocal.LocalSymbol.DeclarationKind == LocalDeclarationKind.None); 313ImmutableArray.Create<LocalSymbol>(tempLocal.LocalSymbol),

Lowering\SpillSequenceSpiller.cs (21)

212if (!node.LocalSymbol.SynthesizedKind.IsLongLived()) 215if (_tempSubstitution.TryGetValue(node.LocalSymbol, out longLived)) 217Debug.Assert(!_receiverSubstitution.ContainsKey(node.LocalSymbol)); 222if (_receiverSubstitution.TryGetValue(node.LocalSymbol, out var receiver)) 397if (local.LocalSymbol.SynthesizedKind == SynthesizedLocalKind.Spill || refKind != RefKind.None) 513builder.AddLocal(replacement.LocalSymbol); 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 558&& (object)referenceTypeClone == referenceTypeReceiver.LocalSymbol 559&& (object)receiverRefLocal != (valueTypeReceiver as BoundLocal)?.LocalSymbol 575if (valueTypeReceiverLocal is { LocalSymbol: { SynthesizedKind: SynthesizedLocalKind.LoweringTemp, RefKind: not RefKind.None } } 576&& originalReceiver is BoundLocal { LocalSymbol: { SynthesizedKind: SynthesizedLocalKind.LoweringTemp, RefKind: not RefKind.None } } originalReceiverLocal 577&& (object)originalReceiverLocal.LocalSymbol == valueTypeReceiverLocal.LocalSymbol 578&& receiverRefLocal.RefKind == valueTypeReceiverLocal.LocalSymbol.RefKind 591|| (object)originalReceiverArrayAccessExpressionLocal.LocalSymbol != valueTypeReceiverArrayAccessExpressionLocal.LocalSymbol 613|| (object)originalReceiverIndexLocal.LocalSymbol != valueTypeReceiverIndexLocal.LocalSymbol) 1141receiverBuilder.AddLocal(cache.LocalSymbol);

Lowering\StateMachineRewriter\IteratorAndAsyncCaptureWalker.cs (3)

255case BoundLocal { LocalSymbol: var symbol }: 362if (node is { IsRef: true, Left: BoundLocal { LocalSymbol: LocalSymbol { IsCompilerGenerated: true } local } }) 433Capture(node.LocalSymbol, node.Syntax);

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

451return (InstrumentationState?.IsSuppressed == false && left is BoundLocal { LocalSymbol.SynthesizedKind: SynthesizedLocalKind.UserDefined } or BoundParameter) ?

Operations\CSharpOperationFactory_Methods.cs (1)

95return boundLocal == null ? null : new VariableDeclaratorOperation(boundLocal.LocalSymbol.GetPublicSymbol(), initializer: null, ignoredArguments: ImmutableArray<IOperation>.Empty, semanticModel: _semanticModel, syntax: boundLocal.Syntax, isImplicit: false);

Operations\CSharpOperationFactory.cs (1)

561ILocalSymbol local = boundLocal.LocalSymbol.GetPublicSymbol();

Symbols\Synthesized\SynthesizedEntryPointSymbol.cs (2)

543ImmutableArray.Create<LocalSymbol>(scriptLocal.LocalSymbol), 660ImmutableArray.Create<LocalSymbol>(submissionLocal.LocalSymbol),

Symbols\Synthesized\SynthesizedHotReloadExceptionConstructorSymbol.cs (1)

75[actionTemp.LocalSymbol],