LocalSymbol

Binder\Binder.ValueChecks.cs (7)

829LocalSymbol localSymbol = local.LocalSymbol; 868LocalSymbol localSymbol = local.LocalSymbol; 2392BoundLocal { DeclarationKind: not BoundLocalDeclarationKind.None } l => l.LocalSymbol, 2963return GetLocalScopes(((BoundLocal)expr).LocalSymbol).RefEscapeScope; 3533return GetLocalScopes(((BoundLocal)expr).LocalSymbol).ValEscapeScope; 3940var localSymbol = ((BoundLocal)expr).LocalSymbol; 4635var local = ((BoundLocal)expression).LocalSymbol;

Binder\Binder_Deconstruct.cs (1)

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

Binder\Binder_Operators.cs (1)

2627LocalSymbol localSymbol = localAccess.LocalSymbol;

Binder\DecisionDagBuilder.cs (1)

1681var bindings = cd.Bindings.Select(bpb => $"{(bpb.VariableAccess is BoundLocal l ? l.LocalSymbol.Name : "<var>")}={tempName(bpb.TempContainingValue)}");

Binder\LockOrUsingBinder.cs (1)

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

Binder\RefSafetyAnalysis.cs (2)

380Debug.Assert(_localEscapeScopes?.ContainsKey(node.LocalSymbol) == true || 381(node.LocalSymbol.ContainingSymbol is SynthesizedSimpleProgramEntryPointSymbol entryPoint && _symbol != entryPoint));

BoundTree\BoundExpression.cs (1)

275get { return this.LocalSymbol; }

BoundTree\BoundExpressionExtensions.cs (1)

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

BoundTree\BoundNode.cs (1)

634CheckDeclared(node.LocalSymbol);

BoundTree\BoundNode_Source.cs (1)

177var symbol = local.LocalSymbol;

BoundTree\Constructors.cs (1)

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

CodeGen\EmitAddress.cs (2)

262var local = localAccess.LocalSymbol; 354var symbol = local.LocalSymbol;

CodeGen\EmitExpression.cs (16)

429(receiver.Kind == BoundKind.Local && IsStackLocal(((BoundLocal)receiver).LocalSymbol)) || 1252return ((BoundLocal)receiver).LocalSymbol.RefKind != RefKind.None; 1352bool isRefLocal = local.LocalSymbol.RefKind != RefKind.None; 1353if (IsStackLocal(local.LocalSymbol)) 1374EmitLoadIndirect(local.LocalSymbol.Type, local.Syntax); 1528return ((BoundLocal)receiver).LocalSymbol.SynthesizedKind == SynthesizedLocalKind.FrameCache; 1884BoundLocal { LocalSymbol.IsKnownToReferToTempIfReferenceType: true } or 1994return ((BoundLocal)receiver).LocalSymbol.RefKind != RefKind.None; 2545return ((BoundLocal)left).LocalSymbol.RefKind == RefKind.None; 2614if (left.LocalSymbol.RefKind != RefKind.None && !assignmentOperator.IsRef) 2616if (!IsStackLocal(left.LocalSymbol)) 2788if (lhs.Kind == BoundKind.Local && ((BoundLocal)lhs).LocalSymbol.SynthesizedKind.IsLongLived()) 2859if (local.LocalSymbol.RefKind != RefKind.None && !assignment.IsRef) 2861EmitIndirectStore(local.LocalSymbol.Type, local.Syntax); 2865if (IsStackLocal(local.LocalSymbol)) 3668if (this.IsStackLocal(local.LocalSymbol))

CodeGen\EmitStatement.cs (5)

536(receiver.Kind == BoundKind.Local && IsStackLocal(((BoundLocal)receiver).LocalSymbol)) || 1122Debug.Assert(exceptionSourceLocal.LocalSymbol.RefKind == RefKind.None); 1123if (!IsStackLocal(exceptionSourceLocal.LocalSymbol)) 1257var local = ((BoundLocal)expression).LocalSymbol; 1724var symbol = localExpression.LocalSymbol;

CodeGen\Optimizer.cs (20)

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; 1048if (((BoundLocal)lhs).LocalSymbol.RefKind != RefKind.None) 1157if (unwrappedSequence is BoundLocal { LocalSymbol: { RefKind: not RefKind.None } localSymbol }) 1360var localSym = ((BoundLocal)boundExpression).LocalSymbol; 1573if (unwrappedSequence is BoundLocal { LocalSymbol: { } localSymbol }) 1632RecordVarWrite(((BoundLocal)exceptionSourceOpt).LocalSymbol); 1870((BoundLocal)top.Item1).LocalSymbol == local; 2059if (!_info.TryGetValue(node.LocalSymbol, out locInfo)) 2067return new BoundDup(node.Syntax, node.LocalSymbol.RefKind, node.Type); 2088if (left == null || !_info.TryGetValue(left.LocalSymbol, out locInfo)) 2095var isIndirectLocalStore = left.LocalSymbol.RefKind != RefKind.None && !node.IsRef; 2178var sourceLocal = ((BoundLocal)exceptionSource).LocalSymbol;

Compilation\CSharpSemanticModel.cs (2)

2088type = local.LocalSymbol.Type; 2089nullability = local.LocalSymbol.TypeWithAnnotations.NullableAnnotation.ToNullabilityInfo(type);

Compiler\AnonymousTypeMethodBodySynthesizer.cs (1)

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

FlowAnalysis\DataFlowsOutWalker.cs (1)

151return ((BoundLocal)node).LocalSymbol;

FlowAnalysis\DefiniteAssignment.cs (9)

808NoteRead(((BoundLocal)n).LocalSymbol); 944_usedVariables.Add(((BoundLocal)n).LocalSymbol); 980NoteWrite(((BoundLocal)n).LocalSymbol, value, read); 1338unassignedSlot = GetOrCreateSlot(((BoundLocal)node).LocalSymbol); 1430var result = ((BoundLocal)expression).LocalSymbol; 1500if (local.LocalSymbol.RefKind != RefKind.None && !isRef) 2189LocalSymbol localSymbol = node.LocalSymbol; 2194int slot = GetOrCreateSlot(node.LocalSymbol); 2433CheckAssigned(((BoundLocal)expr).LocalSymbol, node);

FlowAnalysis\LocalDataFlowPass.cs (1)

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

FlowAnalysis\NullableWalker.cs (3)

2937var local = node.LocalSymbol; 6751_variables.SetType(local.LocalSymbol, varType); 9391_variables.SetType(local.LocalSymbol, operandType.ToAnnotatedTypeWithAnnotations(compilation));

FlowAnalysis\NullableWalker_Patterns.cs (1)

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

FlowAnalysis\ReadWriteWalker.cs (1)

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

FlowAnalysis\VariablesDeclaredWalker.cs (1)

181_variablesDeclared.Add(node.LocalSymbol);

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

4431if (!Symbols.SymbolEqualityComparer.ConsiderEverything.Equals(localSymbol, this.LocalSymbol) || declarationKind != this.DeclarationKind || constantValueOpt != this.ConstantValueOpt || isNullableUnknown != this.IsNullableUnknown || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything)) 11079return node.Update(node.LocalSymbol, node.DeclarationKind, node.ConstantValueOpt, node.IsNullableUnknown, type); 13079LocalSymbol localSymbol = GetUpdatedSymbol(node, node.LocalSymbol); 15428new TreeDumperNode("localSymbol", node.LocalSymbol, null),

Lowering\AsyncRewriter\AsyncExceptionHandlerRewriter.cs (1)

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

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

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

Lowering\DiagnosticsPass_ExpressionTrees.cs (1)

172CheckReferenceToVariable(node, node.LocalSymbol);

Lowering\DiagnosticsPass_Warnings.cs (2)

206return local1.LocalSymbol == local2.LocalSymbol;

Lowering\Instrumentation\Instrumenter.cs (1)

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

Lowering\Instrumentation\LocalStateTracingInstrumenter.cs (5)

360Debug.Assert(original.Left is BoundLocal { LocalSymbol.SynthesizedKind: SynthesizedLocalKind.UserDefined } or BoundParameter); 368if (original.Right is BoundLocal { LocalSymbol.SynthesizedKind: SynthesizedLocalKind.UserDefined } rightLocal) 371refAssignmentSourceIndex = _factory.LocalId(rightLocal.LocalSymbol); 413if (node is BoundLocal { LocalSymbol: var localSymbol }) 605return _factory.Sequence(ImmutableArray.Create(temp.LocalSymbol), builder.ToImmutableAndFree(), temp);

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

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

Lowering\LocalRewriter\LocalRewriter_Await.cs (1)

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

Lowering\LocalRewriter\LocalRewriter_BinaryOperator.cs (12)

Lowering\LocalRewriter\LocalRewriter_Call.cs (9)

478tempsOpt.Add(receiverTemp.LocalSymbol); 543if (receiverTemp.LocalSymbol.IsRef && 641tempsOpt.Add(local.LocalSymbol); 704temps.Add(cache.LocalSymbol); 710temps.Add(intermediateRef.LocalSymbol); 745((SynthesizedLocal)receiverTemp.LocalSymbol).SetIsKnownToReferToTempIfReferenceType(); 1364temporariesBuilder.Add(((BoundLocal)s.Left).LocalSymbol); 1501var localRefKind = ((BoundLocal)argument).LocalSymbol.RefKind; 1522temporariesBuilder.Add(boundTemp.LocalSymbol);

Lowering\LocalRewriter\LocalRewriter_CompoundAssignmentOperator.cs (17)

66eventTemps.Add(isEvent.LocalSymbol); 71eventTemps.Add(((BoundLocal)lhsRead).LocalSymbol); 73eventTemps.Add(storeNonEvent.LocalSymbol); 80eventTemps.Add(((BoundLocal)loweredRight).LocalSymbol); 205temps.Add(receiverTemp.LocalSymbol); 208receiverTemp.LocalSymbol.IsRef && 238temps.Add(receiverTemp.LocalSymbol); 354temps.Add(boundTemp.LocalSymbol); 376temps.Add(((BoundLocal)tempAssignment.Left).LocalSymbol); 442temps.Add(variableTemp.LocalSymbol); 489temps.Add(receiverTemp.LocalSymbol); 502temps.Add(temp.LocalSymbol); 520temps.Add(temp.LocalSymbol); 744temps.Add(variableTemp.LocalSymbol); 773temps.Add(arrayTemp.LocalSymbol); 784temps.Add(temp.LocalSymbol); 842return localsMayBeAssignedOrCaptured || ((BoundLocal)expression).LocalSymbol.RefKind != RefKind.None;

Lowering\LocalRewriter\LocalRewriter_Conversion.cs (3)

833return _factory.MakeSequence(savedTuple.LocalSymbol, assignmentToTemp, result); 1055locals: ImmutableArray.Create(boundTemp.LocalSymbol), 1316locals: ImmutableArray.Create(boundTemp.LocalSymbol),

Lowering\LocalRewriter\LocalRewriter_DeconstructionAssignmentOperator.cs (3)

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

Lowering\LocalRewriter\LocalRewriter_Event.cs (1)

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

Lowering\LocalRewriter\LocalRewriter_IndexerAccess.cs (13)

Lowering\LocalRewriter\LocalRewriter_LockStatement.cs (3)

125ImmutableArray.Create(boundLockTemp.LocalSymbol, boundLockTakenTemp.LocalSymbol), 175ImmutableArray.Create(boundLockTemp.LocalSymbol),

Lowering\LocalRewriter\LocalRewriter_NullCoalescingAssignmentOperator.cs (2)

98temps.Add(lhsTemp.LocalSymbol); 107temps.Add(tmp.LocalSymbol);

Lowering\LocalRewriter\LocalRewriter_NullCoalescingOperator.cs (1)

175locals: ImmutableArray.Create(boundTemp.LocalSymbol),

Lowering\LocalRewriter\LocalRewriter_ObjectCreationExpression.cs (4)

161temps.Add(oldValue.LocalSymbol); 207temps.Add(valueTemp.LocalSymbol); 284locals = ImmutableArray.Create(value.LocalSymbol); 288temps.Insert(0, value.LocalSymbol);

Lowering\LocalRewriter\LocalRewriter_ObjectOrCollectionInitializerExpression.cs (2)

429temps.Add(temp.LocalSymbol); 483temps.Add(temp.LocalSymbol);

Lowering\LocalRewriter\LocalRewriter_StackAlloc.cs (1)

83locals.Add(tempAccess.LocalSymbol);

Lowering\LocalRewriter\LocalRewriter_StringConcat.cs (1)

474ImmutableArray.Create(temp.LocalSymbol),

Lowering\LocalRewriter\LocalRewriter_StringInterpolation.cs (4)

177return new InterpolationHandlerResult(ImmutableArray.Create(_factory.ExpressionStatement(handlerConstructionAssignment), resultIf), builderTemp, appendShouldProceedLocal.LocalSymbol, this); 184return new InterpolationHandlerResult(resultExpressions.ToImmutableAndFree(), builderTemp, appendShouldProceedLocal?.LocalSymbol, this); 435? ImmutableArray.Create(HandlerTemp.LocalSymbol, _outTemp) 436: ImmutableArray.Create(HandlerTemp.LocalSymbol);

Lowering\LocalRewriter\LocalRewriter_TupleBinaryOperator.cs (1)

420temps.Add(temp.LocalSymbol);

Lowering\LocalRewriter\LocalRewriter_UnaryOperator.cs (3)

231locals: ImmutableArray.Create<LocalSymbol>(boundTemp.LocalSymbol), 485return ((BoundLocal)expression).LocalSymbol.RefKind != RefKind.None; 695locals: ImmutableArray.Create<LocalSymbol>(boundTemp.LocalSymbol),

Lowering\LocalRewriter\LocalRewriter_UsingStatement.cs (2)

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

Lowering\MethodToClassRewriter.cs (10)

397if (TryReplaceWithProxy(node.LocalSymbol, node.Syntax, out BoundNode? replacement)) 403Debug.Assert(!NeedsProxy(node.LocalSymbol)); 438if (this.localMap.TryGetValue(node.LocalSymbol, out LocalSymbol? replacementLocal)) 484if (leftLocal.LocalSymbol.RefKind != RefKind.None && 486NeedsProxy(leftLocal.LocalSymbol)) 488Debug.Assert(!proxies.ContainsKey(leftLocal.LocalSymbol)); 494if (NeedsProxy(leftLocal.LocalSymbol) && !proxies.ContainsKey(leftLocal.LocalSymbol)) 496Debug.Assert(leftLocal.LocalSymbol.DeclarationKind == LocalDeclarationKind.None); 527ImmutableArray.Create<LocalSymbol>(tempLocal.LocalSymbol),

Lowering\SpillSequenceSpiller.cs (15)

213if (!node.LocalSymbol.SynthesizedKind.IsLongLived()) 216if (_tempSubstitution.TryGetValue(node.LocalSymbol, out longLived)) 218Debug.Assert(!_receiverSubstitution.ContainsKey(node.LocalSymbol)); 223if (_receiverSubstitution.TryGetValue(node.LocalSymbol, out var receiver)) 398if (local.LocalSymbol.SynthesizedKind == SynthesizedLocalKind.Spill || refKind != RefKind.None) 449builder.AddLocal(replacement.LocalSymbol); 467Left: BoundLocal { LocalSymbol: { SynthesizedKind: SynthesizedLocalKind.LoweringTemp, RefKind: RefKind.Ref } receiverRefLocal }, 470ValueTypeReceiver: BoundLocal { LocalSymbol: { SynthesizedKind: SynthesizedLocalKind.LoweringTemp, RefKind: RefKind.Ref } } valueTypeReceiver, 479Left: BoundLocal { LocalSymbol: { SynthesizedKind: SynthesizedLocalKind.LoweringTemp, RefKind: RefKind.None } referenceTypeClone }, 480Right: BoundLocal { LocalSymbol: { SynthesizedKind: SynthesizedLocalKind.LoweringTemp, RefKind: RefKind.Ref } originalReceiverReference } 483Value: BoundLocal { LocalSymbol: { SynthesizedKind: SynthesizedLocalKind.LoweringTemp, RefKind: RefKind.None } } referenceTypeReceiver 487&& (object)referenceTypeClone == referenceTypeReceiver.LocalSymbol 488&& (object)originalReceiverReference == valueTypeReceiver.LocalSymbol 489&& (object)receiverRefLocal != valueTypeReceiver.LocalSymbol 986receiverBuilder.AddLocal(cache.LocalSymbol);

Lowering\StateMachineRewriter\IteratorAndAsyncCaptureWalker.cs (3)

210case BoundLocal { LocalSymbol: var symbol }: 315if (node is { IsRef: true, Left: BoundLocal { LocalSymbol: LocalSymbol { IsCompilerGenerated: true } local } }) 386Capture(node.LocalSymbol, node.Syntax);

Lowering\StateMachineRewriter\MethodToStateMachineRewriter.cs (1)

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

Lowering\SyntheticBoundNodeFactory.cs (1)

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

Operations\CSharpOperationFactory.cs (1)

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

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

Symbols\Synthesized\SynthesizedEntryPointSymbol.cs (2)

489ImmutableArray.Create<LocalSymbol>(scriptLocal.LocalSymbol), 605ImmutableArray.Create<LocalSymbol>(submissionLocal.LocalSymbol),