LocalSymbol

Binder\Binder.cs (2)

185internal virtual ImmutableArray<LocalSymbol> GetDeclaredLocalsForScope(SyntaxNode scopeDesignator) 479internal virtual LocalSymbol? LocalInProgress

Binder\Binder.ValueChecks.cs (4)

1276LocalSymbol localSymbol = local.LocalSymbol; 1315LocalSymbol localSymbol = local.LocalSymbol; 3414private static void ReportReadonlyLocalError(SyntaxNode node, LocalSymbol local, BindValueKind kind, bool checkingReceiver, BindingDiagnosticBag diagnostics) 5056var localSymbol = ((BoundLocal)expr).LocalSymbol;

Binder\Binder_Expressions.cs (4)

1532Debug.Assert(symbol is null or LocalSymbol or LocalFunctionSymbol or RangeVariableSymbol or TypeParameterSymbol); 2024var localSymbol = (LocalSymbol)symbol; 2274bool isUsedBeforeDeclaration(SimpleNameSyntax node, LocalSymbol localSymbol)

Binder\Binder_Initializers.cs (1)

132boundInitializers.Add(new BoundFieldEqualsValue(parameterSyntax, fieldSymbol, ImmutableArray<LocalSymbol>.Empty,

Binder\Binder_Operators.cs (1)

4129LocalSymbol localSymbol = localAccess.LocalSymbol;

Binder\Binder_Query.cs (1)

707return lambdaBodyBinder.CreateBlockFromExpression(node, ImmutableArray<LocalSymbol>.Empty, RefKind.None, construction, null, d);

Binder\Binder_Statements.cs (9)

Binder\BlockBinder.cs (2)

33protected override ImmutableArray<LocalSymbol> BuildLocals() 66internal override ImmutableArray<LocalSymbol> GetDeclaredLocalsForScope(SyntaxNode scopeDesignator)

Binder\BuckStopsHereBinder.cs (2)

89internal override LocalSymbol? LocalInProgress 176internal override ImmutableArray<LocalSymbol> GetDeclaredLocalsForScope(SyntaxNode scopeDesignator)

Binder\CatchClauseBinder.cs (3)

27protected override ImmutableArray<LocalSymbol> BuildLocals() 29var locals = ArrayBuilder<LocalSymbol>.GetInstance(); 45internal override ImmutableArray<LocalSymbol> GetDeclaredLocalsForScope(SyntaxNode scopeDesignator)

Binder\EmbeddedStatementBinder.cs (4)

31protected override ImmutableArray<LocalSymbol> BuildLocals() 33ArrayBuilder<LocalSymbol> locals = ArrayBuilder<LocalSymbol>.GetInstance(DefaultLocalSymbolArrayCapacity); 69internal override ImmutableArray<LocalSymbol> GetDeclaredLocalsForScope(SyntaxNode scopeDesignator)

Binder\ExpressionListVariableBinder.cs (3)

26protected override ImmutableArray<LocalSymbol> BuildLocals() 28var builder = ArrayBuilder<LocalSymbol>.GetInstance(); 41internal override ImmutableArray<LocalSymbol> GetDeclaredLocalsForScope(SyntaxNode scopeDesignator)

Binder\ExpressionVariableBinder.cs (3)

26protected override ImmutableArray<LocalSymbol> BuildLocals() 28var builder = ArrayBuilder<LocalSymbol>.GetInstance(); 34internal override ImmutableArray<LocalSymbol> GetDeclaredLocalsForScope(SyntaxNode scopeDesignator)

Binder\ExpressionVariableFinder.cs (6)

544internal class ExpressionVariableFinder : ExpressionVariableFinder<LocalSymbol> 551ArrayBuilder<LocalSymbol> builder, 573ArrayBuilder<LocalSymbol> builder, 592protected override LocalSymbol MakePatternVariable(TypeSyntax type, SingleVariableDesignationSyntax designation, SyntaxNode nodeToBind) 618protected override LocalSymbol MakeDeclarationExpressionVariable(DeclarationExpressionSyntax node, SingleVariableDesignationSyntax designation, BaseArgumentListSyntax argumentListSyntaxOpt, SyntaxNode nodeToBind) 640protected override LocalSymbol MakeDeconstructionVariable(

Binder\FixedStatementBinder.cs (4)

29protected override ImmutableArray<LocalSymbol> BuildLocals() 33var locals = new ArrayBuilder<LocalSymbol>(_syntax.Declaration.Variables.Count); 57return ImmutableArray<LocalSymbol>.Empty; 60internal override ImmutableArray<LocalSymbol> GetDeclaredLocalsForScope(SyntaxNode scopeDesignator)

Binder\ForEachLoopBinder.cs (7)

47internal override ImmutableArray<LocalSymbol> GetDeclaredLocalsForScope(SyntaxNode scopeDesignator) 70protected override ImmutableArray<LocalSymbol> BuildLocals() 77var locals = ArrayBuilder<LocalSymbol>.GetInstance(); 94return ImmutableArray.Create<LocalSymbol>(iterationVariable); 104ArrayBuilder<LocalSymbol> locals, 141ArrayBuilder<LocalSymbol> locals, 434ImmutableArray<LocalSymbol> iterationVariables = this.Locals;

Binder\ForLoopBinder.cs (4)

28protected override ImmutableArray<LocalSymbol> BuildLocals() 30var locals = ArrayBuilder<LocalSymbol>.GetInstance(); 92var innerLocals = ImmutableArray<LocalSymbol>.Empty; 140internal override ImmutableArray<LocalSymbol> GetDeclaredLocalsForScope(SyntaxNode scopeDesignator)

Binder\LocalInProgressBinder.cs (3)

22private LocalSymbol? _localSymbol; 30internal override LocalSymbol LocalInProgress 40internal void SetLocalSymbol(LocalSymbol local)

Binder\LocalScopeBinder.cs (17)

21private ImmutableArray<LocalSymbol> _locals; 35internal sealed override ImmutableArray<LocalSymbol> Locals 41ImmutableInterlocked.InterlockedCompareExchange(ref _locals, BuildLocals(), default(ImmutableArray<LocalSymbol>)); 48protected virtual ImmutableArray<LocalSymbol> BuildLocals() 50return ImmutableArray<LocalSymbol>.Empty; 89private SmallDictionary<string, LocalSymbol> _lazyLocalsMap; 90private SmallDictionary<string, LocalSymbol> LocalsMap 148protected ImmutableArray<LocalSymbol> BuildLocals(SyntaxList<StatementSyntax> statements, Binder enclosingBinder) 164ArrayBuilder<LocalSymbol> locals = ArrayBuilder<LocalSymbol>.GetInstance(DefaultLocalSymbolArrayCapacity); 173internal void BuildLocals(Binder enclosingBinder, StatementSyntax statement, ArrayBuilder<LocalSymbol> locals) 287static void findExpressionVariablesInRankSpecifier(ExpressionSyntax expression, (LocalScopeBinder localScopeBinder, ArrayBuilder<LocalSymbol> locals, Binder localDeclarationBinder) args) 383LocalSymbol result = null; 389foreach (var local in this.Locals) 444LocalSymbol localSymbol; 510declaredInThisScope |= newSymbolKind == SymbolKind.Local && this.Locals.Contains((LocalSymbol)newSymbol); 543LocalSymbol existingLocal = null;

Binder\RefSafetyAnalysis.cs (15)

64private Dictionary<LocalSymbol, (SafeContext RefEscapeScope, SafeContext ValEscapeScope)>? _localEscapeScopes; 93private readonly ImmutableArray<LocalSymbol> _locals; 95public LocalScope(RefSafetyAnalysis analysis, ImmutableArray<LocalSymbol> locals) 100foreach (var local in locals) 108foreach (var local in _locals) 212private (SafeContext RefEscapeScope, SafeContext ValEscapeScope) GetLocalScopes(LocalSymbol local) 221private void SetLocalScopes(LocalSymbol local, SafeContext refEscapeScope, SafeContext valEscapeScope) 476private void AddLocalScopes(LocalSymbol local, SafeContext refEscapeScope, SafeContext valEscapeScope) 503private void AddOrSetLocalScopes(LocalSymbol local, SafeContext refEscapeScope, SafeContext valEscapeScope) 505_localEscapeScopes ??= new Dictionary<LocalSymbol, (SafeContext RefEscapeScope, SafeContext ValEscapeScope)>(); 510private void RemoveLocalScopes(LocalSymbol local) 707if (pattern.Variable is LocalSymbol local) 1261using var _ = new LocalScope(this, ImmutableArray<LocalSymbol>.Empty); 1263foreach (var local in node.IterationVariables) 1290foreach (var local in node.IterationVariables)

Binder\ScriptLocalScopeBinder.cs (1)

42internal override ImmutableArray<LocalSymbol> GetDeclaredLocalsForScope(SyntaxNode scopeDesignator)

Binder\SimpleLocalScopeBinder.cs (4)

17private readonly ImmutableArray<LocalSymbol> _locals; 19public SimpleLocalScopeBinder(ImmutableArray<LocalSymbol> locals, Binder next) : 25protected override ImmutableArray<LocalSymbol> BuildLocals() 30internal override ImmutableArray<LocalSymbol> GetDeclaredLocalsForScope(SyntaxNode scopeDesignator)

Binder\SimpleProgramBinder.cs (4)

26protected override ImmutableArray<LocalSymbol> BuildLocals() 28ArrayBuilder<LocalSymbol> locals = ArrayBuilder<LocalSymbol>.GetInstance(DefaultLocalSymbolArrayCapacity); 87internal override ImmutableArray<LocalSymbol> GetDeclaredLocalsForScope(SyntaxNode scopeDesignator)

Binder\SimpleProgramUnitBinder.cs (2)

26protected override ImmutableArray<LocalSymbol> BuildLocals() 57internal override ImmutableArray<LocalSymbol> GetDeclaredLocalsForScope(SyntaxNode scopeDesignator)

Binder\SwitchBinder.cs (3)

134protected override ImmutableArray<LocalSymbol> BuildLocals() 136var builder = ArrayBuilder<LocalSymbol>.GetInstance(); 328internal override ImmutableArray<LocalSymbol> GetDeclaredLocalsForScope(SyntaxNode scopeDesignator)

Binder\SwitchBinder_Patterns.cs (1)

43ImmutableArray<LocalSymbol> locals = GetDeclaredLocalsForScope(node);

Binder\SwitchExpressionArmBinder.cs (1)

41ImmutableArray<LocalSymbol> locals = _armScopeBinder.Locals;

Binder\UsingStatementBinder.cs (4)

27protected override ImmutableArray<LocalSymbol> BuildLocals() 36var locals = ArrayBuilder<LocalSymbol>.GetInstance(); 42var locals = ArrayBuilder<LocalSymbol>.GetInstance(declarationSyntax.Variables.Count); 310internal override ImmutableArray<LocalSymbol> GetDeclaredLocalsForScope(SyntaxNode scopeDesignator)

Binder\WhileBinder.cs (3)

48protected override ImmutableArray<LocalSymbol> BuildLocals() 50var locals = ArrayBuilder<LocalSymbol>.GetInstance(); 69internal override ImmutableArray<LocalSymbol> GetDeclaredLocalsForScope(SyntaxNode scopeDesignator)

Binder\WithLambdaParametersBinder.cs (1)

170internal override ImmutableArray<LocalSymbol> GetDeclaredLocalsForScope(SyntaxNode scopeDesignator)

BoundTree\BoundExpression.cs (2)

303public BoundLocal(SyntaxNode syntax, LocalSymbol localSymbol, ConstantValue? constantValueOpt, TypeSymbol type, bool hasErrors = false) 308public BoundLocal Update(LocalSymbol localSymbol, ConstantValue? constantValueOpt, TypeSymbol type)

BoundTree\BoundNode.cs (9)

487public readonly PooledHashSet<LocalSymbol> DeclaredLocals = PooledHashSet<LocalSymbol>.GetInstance(); 500private void AddAll(ImmutableArray<LocalSymbol> locals) 502foreach (var local in locals) 511private void RemoveAll(ImmutableArray<LocalSymbol> locals) 513foreach (var local in locals) 522private void CheckDeclared(LocalSymbol local) 559foreach (var local in instrumentation.Locals) 576foreach (var local in instrumentation.Locals)

BoundTree\BoundNode_Source.cs (3)

95foreach (var local in block.Locals) 193var symbol = local.LocalSymbol; 543void appendLocal(LocalSymbol symbol)

BoundTree\BoundSpillSequence.cs (1)

17ImmutableArray<LocalSymbol> locals,

BoundTree\BoundTreeRewriter.cs (5)

82public virtual LocalSymbol VisitLocalSymbol(LocalSymbol symbol) 131return VisitLocalSymbol((LocalSymbol)symbol); 196protected virtual ImmutableArray<LocalSymbol> VisitLocals(ImmutableArray<LocalSymbol> locals) => locals;

BoundTree\Constructors.cs (5)

75var localSymbol = ((BoundLocal)receiver).LocalSymbol; 591public BoundBlock(SyntaxNode syntax, ImmutableArray<LocalSymbol> locals, ImmutableArray<BoundStatement> statements, bool hasErrors = false) 598return new BoundBlock(syntax, ImmutableArray<LocalSymbol>.Empty, ImmutableArray.Create(statement)) 604return new BoundBlock(syntax, ImmutableArray<LocalSymbol>.Empty, statements) { WasCompilerGenerated = true }; 609return new BoundBlock(syntax, ImmutableArray<LocalSymbol>.Empty, statements.AsImmutableOrNull()) { WasCompilerGenerated = true };

CodeGen\CodeGenerator.cs (4)

36private readonly HashSet<LocalSymbol> _stackLocals; 218internal static bool IsStackLocal(LocalSymbol local, HashSet<LocalSymbol> stackLocalsOpt) 221private bool IsStackLocal(LocalSymbol local) => IsStackLocal(local, _stackLocals);

CodeGen\CodeGenerator_HasHome.cs (3)

47HashSet<LocalSymbol> stackLocalsOpt) 93var local = ((BoundLocal)expression).LocalSymbol; 176HashSet<LocalSymbol> stackLocalsOpt)

CodeGen\EmitAddress.cs (3)

265var local = localAccess.LocalSymbol; 351private static LocalSymbol DigForValueLocal(BoundSequence topSequence, BoundExpression value) 357var symbol = local.LocalSymbol;

CodeGen\EmitExpression.cs (3)

889foreach (var local in sequence.Locals) 904foreach (var local in sequence.Locals) 923foreach (var local in sequence.Locals)

CodeGen\EmitStatement.cs (12)

684foreach (var local in instrumentation.Locals) 740foreach (var local in instrumentation.Locals) 757foreach (var local in block.Locals) 785foreach (var local in block.Locals) 808foreach (var local in block.Locals) 1137foreach (var local in catchBlock.Locals) 1309var local = ((BoundLocal)expression).LocalSymbol; 1781var symbol = localExpression.LocalSymbol; 1785private LocalDefinition GetLocal(LocalSymbol symbol) 1790private LocalDefinition DefineLocal(LocalSymbol local, SyntaxNode syntaxNode) 1914private bool IsSlotReusable(LocalSymbol local) 1922private void FreeLocal(LocalSymbol local)

CodeGen\Optimizer.cs (32)

Compilation\CSharpSemanticModel.cs (4)

1796case LocalSymbol _: 3295LocalSymbol local = foreachBinder.GetDeclaredLocalsForScope(forEachStatement).FirstOrDefault(); 3308internal abstract LocalSymbol GetAdjustedLocalSymbol(SourceLocalSymbol originalSymbol); 3334LocalSymbol local = catchBinder.GetDeclaredLocalsForScope(catchClause).FirstOrDefault();

Compilation\MemberSemanticModel.cs (5)

693private LocalSymbol GetDeclaredLocal(CSharpSyntaxNode declarationSyntax, SyntaxToken declaredIdentifier) 697foreach (var local in binder.Locals) 710internal override LocalSymbol GetAdjustedLocalSymbol(SourceLocalSymbol local) 712return GetRemappedSymbol<LocalSymbol>(local); 2381Debug.Assert(symbol is LocalSymbol or ParameterSymbol or MethodSymbol { MethodKind: MethodKind.LambdaMethod });

Compilation\SpeculativeSemanticModelWithMemberModel.cs (1)

340internal override LocalSymbol GetAdjustedLocalSymbol(SourceLocalSymbol local)

Compilation\SyntaxTreeSemanticModel.cs (2)

1891internal override LocalSymbol GetAdjustedLocalSymbol(SourceLocalSymbol originalSymbol) 2451Debug.Assert(symbol is LocalSymbol or ParameterSymbol or MethodSymbol { MethodKind: MethodKind.LambdaMethod });

Compiler\AnonymousTypeMethodBodySynthesizer.cs (1)

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

Compiler\MethodBodySynthesizer.cs (4)

429LocalSymbol[] tmps = new LocalSymbol[numTemps]; 565ImmutableArray<LocalSymbol>.Empty, 573ImmutableArray<LocalSymbol>.Empty,

Compiler\MethodBodySynthesizer.Lowered.cs (6)

55LocalSymbol i = F.SynthesizedLocal(F.SpecialType(SpecialType.System_Int32)); 56LocalSymbol hashCode = F.SynthesizedLocal(F.SpecialType(SpecialType.System_UInt32)); 83ImmutableArray.Create<LocalSymbol>(hashCode, i), 153LocalSymbol i = F.SynthesizedLocal(F.SpecialType(SpecialType.System_Int32)); 154LocalSymbol hashCode = F.SynthesizedLocal(F.SpecialType(SpecialType.System_UInt32)); 175ImmutableArray.Create<LocalSymbol>(hashCode, i),

Compiler\MethodCompiler.cs (2)

1006body = new BoundBlock(methodSymbol.GetNonNullSyntaxNode(), ImmutableArray<LocalSymbol>.Empty, ImmutableArray<BoundStatement>.Empty) { WasCompilerGenerated = true }; 1049new BoundBlock(analyzedInitializers.Syntax, ImmutableArray<LocalSymbol>.Empty, analyzedInitializers.Statements), // The block is necessary to establish the right local scope for the analysis

FlowAnalysis\ControlFlowPass.cs (3)

22private readonly ArrayBuilder<(LocalSymbol symbol, BoundBlock block)> _usingDeclarations = ArrayBuilder<(LocalSymbol, BoundBlock)>.GetInstance(); 402foreach (var local in node.Locals)

FlowAnalysis\DataFlowsOutWalker.cs (2)

124return ((BoundObjectPattern)node).Variable as LocalSymbol; 161var local = ((BoundCatchBlock)node).Locals.FirstOrDefault();

FlowAnalysis\DefiniteAssignment.cs (22)

66private readonly PooledHashSet<LocalSymbol> _usedVariables = PooledHashSet<LocalSymbol>.GetInstance(); 708var local = variable as LocalSymbol; 814var local = variable as LocalSymbol; 1157if (symbol is LocalSymbol local && local.IsConst) 1449var result = ((BoundLocal)expression).LocalSymbol; 1496var symbol = pattern.Variable as LocalSymbol; 1513LocalSymbol symbol = local.LocalSymbol; 2105foreach (var local in node.Locals) 2223foreach (LocalSymbol local in localsOpt) 2251private void DeclareVariables(ImmutableArray<LocalSymbol> locals) 2253foreach (var symbol in locals) 2259private void DeclareVariable(LocalSymbol symbol) 2269private void ReportUnusedVariables(ImmutableArray<LocalSymbol> locals) 2271foreach (var symbol in locals) 2277private void ReportIfUnused(LocalSymbol symbol, bool assigned) 2309LocalSymbol localSymbol = node.LocalSymbol; 2647foreach (var local in catchBlock.Locals) 2723foreach (var iterationVariable in node.IterationVariables)

FlowAnalysis\FlowAnalysisPass.cs (1)

86block = new BoundBlock(block.Syntax, ImmutableArray<LocalSymbol>.Empty, newStatements) { WasCompilerGenerated = true };

FlowAnalysis\LocalDataFlowPass.cs (1)

81if (symbol is LocalSymbol { SynthesizedKind: SynthesizedLocalKind.LocalStoreTracker })

FlowAnalysis\NullableWalker.cs (10)

2034var local = (LocalSymbol)symbol; 3197var local = node.LocalSymbol; 3623private void DeclareLocal(LocalSymbol local) 3636private void DeclareLocals(ImmutableArray<LocalSymbol> locals) 3638foreach (var local in locals) 3646var local = node.LocalSymbol; 11443private TypeWithAnnotations GetDeclaredLocalResult(LocalSymbol local) 11940foreach (var iterationVariable in node.IterationVariables) 12967LocalSymbol local = node.Locals[0];

FlowAnalysis\NullableWalker.PlaceholderLocal.cs (2)

61internal override ConstantValue GetConstantValue(SyntaxNode node, LocalSymbol inProgress, BindingDiagnosticBag diagnostics = null) => null; 65internal override LocalSymbol WithSynthesizedLocalKindAndSyntax(

FlowAnalysis\NullableWalker.Variables.cs (1)

357case LocalSymbol:

FlowAnalysis\VariablesDeclaredWalker.cs (1)

149var local = catchBlock.Locals.FirstOrDefault();

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

Lowering\AsyncRewriter\AsyncExceptionHandlerRewriter.cs (27)

256var locals = ArrayBuilder<LocalSymbol>.GetInstance(); 266LocalSymbol returnLocal = frame.returnValue; 285LocalSymbol pendingBranchVar, 320LocalSymbol pendingBranchVar, 441private BoundStatement UnpendException(LocalSymbol pendingExceptionLocal) 454LocalSymbol obj = _F.SynthesizedLocal(_F.SpecialType(SpecialType.System_Object)); 459ImmutableArray.Create<LocalSymbol>(obj), 463BoundStatement checkAndThrow(LocalSymbol obj) 476private BoundStatement Rethrow(LocalSymbol obj) 488var ex = _F.SynthesizedLocal(_F.WellKnownType(WellKnownType.System_Exception)); 552ImmutableArray.Create<LocalSymbol>( 615var catchTemp = _F.SynthesizedLocal(catchType); 632ImmutableArray<LocalSymbol> handlerLocals; 658handlerLocals = ImmutableArray<LocalSymbol>.Empty; 662foreach (var local in node.Locals) 744LocalSymbol hoistedLocal; 1113private readonly Dictionary<LocalSymbol, LocalSymbol> _hoistedLocals; 1114private readonly List<LocalSymbol> _orderedHoistedLocals; 1123_hoistedLocals = new Dictionary<LocalSymbol, LocalSymbol>(); 1124_orderedHoistedLocals = new List<LocalSymbol>(); 1127public void HoistLocal(LocalSymbol local, SyntheticBoundNodeFactory F) 1142var newLocal = F.SynthesizedLocal(local.Type, pendingCatch.SyntaxOpt, kind: SynthesizedLocalKind.ExceptionFilterAwaitHoistedExceptionLocal); 1148public IEnumerable<LocalSymbol> GetHoistedLocals() 1153public bool TryGetHoistedLocal(LocalSymbol originalLocal, out LocalSymbol hoistedLocal)

Lowering\AsyncRewriter\AsyncIteratorMethodToStateMachineRewriter.cs (1)

180protected override BoundStatement GenerateSetExceptionCall(LocalSymbol exceptionLocal)

Lowering\AsyncRewriter\AsyncMethodToStateMachineRewriter.cs (18)

57private readonly LocalSymbol? _exprRetValue; 155var exceptionLocal = F.SynthesizedLocal(F.WellKnownType(WellKnownType.System_Exception)); 158F.Block(ImmutableArray<LocalSymbol>.Empty, 196var locals = ArrayBuilder<LocalSymbol>.GetInstance(); 218BoundCatchBlock generateExceptionHandling(LocalSymbol exceptionLocal, ImmutableArray<StateMachineFieldSymbol> rootHoistedLocals) 291protected virtual BoundStatement GenerateSetExceptionCall(LocalSymbol exceptionLocal) 379var awaiterTemp = F.SynthesizedLocal(getAwaiter.Type, syntax: node.Syntax, kind: SynthesizedLocalKind.Awaiter); 449private BoundExpression GenerateGetIsCompleted(LocalSymbol awaiterTemp, MethodSymbol getIsCompletedMethod) 467private BoundBlock GenerateAwaitForIncompleteTask(LocalSymbol awaiterTemp, BoundAwaitExpressionDebugInfo debugInfo) 538private BoundStatement GenerateAwaitOnCompletedDynamic(LocalSymbol awaiterTemp) 555var criticalNotifyCompletedTemp = F.SynthesizedLocal( 559var notifyCompletionTemp = F.SynthesizedLocal( 563LocalSymbol thisTemp = (F.CurrentType.TypeKind == TypeKind.Class) ? F.SynthesizedLocal(F.CurrentType) : null; 618private BoundStatement GenerateAwaitOnCompleted(TypeSymbol loweredAwaiterType, LocalSymbol awaiterTemp) 624LocalSymbol thisTemp = (F.CurrentType.TypeKind == TypeKind.Class) ? F.SynthesizedLocal(F.CurrentType) : null; 657private static ImmutableArray<LocalSymbol> SingletonOrPair(LocalSymbol first, LocalSymbol secondOpt)

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

200protected override void InitializeStateMachine(ArrayBuilder<BoundStatement> bodyBuilder, NamedTypeSymbol frameType, LocalSymbol stateMachineLocal) 263protected override BoundStatement GenerateStateMachineCreation(LocalSymbol stateMachineVariable, NamedTypeSymbol frameType, IReadOnlyDictionary<Symbol, CapturedSymbolReplacement> proxies) 325out LocalSymbol instSymbol, 337var versionSymbol = F.SynthesizedLocal(F.SpecialType(SpecialType.System_Int16)); 368private void GetPartsForStartingMachine(out BoundExpressionStatement callReset, out LocalSymbol instSymbol, out BoundStatement instAssignment, 435out LocalSymbol instSymbol,

Lowering\AsyncRewriter\AsyncRewriter.cs (2)

202protected override void InitializeStateMachine(ArrayBuilder<BoundStatement> bodyBuilder, NamedTypeSymbol frameType, LocalSymbol stateMachineLocal) 214protected override BoundStatement GenerateStateMachineCreation(LocalSymbol stateMachineVariable, NamedTypeSymbol frameType, IReadOnlyDictionary<Symbol, CapturedSymbolReplacement> proxies)

Lowering\AsyncRewriter\RuntimeAsyncRewriter.cs (9)

28var hoistedLocals = ArrayBuilder<LocalSymbol>.GetInstance(); 76private readonly RefInitializationHoister<LocalSymbol, BoundLocal> _refInitializationHoister; 77private readonly ArrayBuilder<LocalSymbol> _hoistedLocals; 80private RuntimeAsyncRewriter(SyntheticBoundNodeFactory factory, IReadOnlySet<Symbol> variablesToHoist, ArrayBuilder<LocalSymbol> hoistedLocals) 86_refInitializationHoister = new RefInitializationHoister<LocalSymbol, BoundLocal>(_factory, _factory.CurrentFunction, TypeMap.Empty); 254static LocalSymbol createHoistedLocal(TypeSymbol type, RuntimeAsyncRewriter @this, LocalSymbol local) 256var hoistedLocal = @this._factory.SynthesizedLocal(type, syntax: local.GetDeclaratorSyntax(), kind: SynthesizedLocalKind.AwaitByRefSpill); 261static BoundLocal createHoistedAccess(LocalSymbol local, RuntimeAsyncRewriter @this)

Lowering\BoundTreeToDifferentEnclosingContextRewriter.cs (18)

24private readonly Dictionary<LocalSymbol, LocalSymbol> localMap = new Dictionary<LocalSymbol, LocalSymbol>(); 44protected void RewriteLocals(ImmutableArray<LocalSymbol> locals, ArrayBuilder<LocalSymbol> newLocals) 46foreach (var local in locals) 48if (TryRewriteLocal(local, out LocalSymbol? newLocal)) 55protected virtual bool TryRewriteLocal(LocalSymbol local, [NotNullWhen(true)] out LocalSymbol? newLocal) 77protected sealed override ImmutableArray<LocalSymbol> VisitLocals(ImmutableArray<LocalSymbol> locals) 80var newLocals = ArrayBuilder<LocalSymbol>.GetInstance(); 85public sealed override LocalSymbol VisitLocalSymbol(LocalSymbol local) 87if (!TryRewriteLocal(local, out var newLocal)) 95protected bool TryGetRewrittenLocal(LocalSymbol local, [NotNullWhen(true)] out LocalSymbol? localToUse)

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

619if (symbol is LocalSymbol local && local.IsConst) 686type = ((LocalSymbol)capturedVariable).Type;

Lowering\ClosureConversion\ClosureConversion.cs (28)

Lowering\ClosureConversion\ExpressionLambdaRewriter.cs (3)

836var locals = ArrayBuilder<LocalSymbol>.GetInstance(); 841var param = _bound.SynthesizedLocal(ParameterExpressionType); 893var param = _bound.SynthesizedLocal(ParameterExpressionType);

Lowering\ClosureConversion\LambdaCapturedVariable.cs (4)

48Debug.Assert(captured is LocalSymbol || captured is ParameterSymbol); 83if (variable is LocalSymbol local) 118var local = variable as LocalSymbol;

Lowering\Instrumentation\CodeCoverageInstrumenter.cs (3)

34private readonly LocalSymbol _methodPayload; 168LocalSymbol methodPayload, 237public override void InstrumentBlock(BoundBlock original, LocalRewriter rewriter, ref TemporaryArray<LocalSymbol> additionalLocals, out BoundStatement? prologue, out BoundStatement? epilogue, out BoundBlockInstrumentation? instrumentation)

Lowering\Instrumentation\CompoundInstrumenter.cs (1)

89public override void InstrumentBlock(BoundBlock original, LocalRewriter rewriter, ref TemporaryArray<LocalSymbol> additionalLocals, out BoundStatement? prologue, out BoundStatement? epilogue, out BoundBlockInstrumentation? instrumentation)

Lowering\Instrumentation\DebugInfoInjector.cs (1)

186public override void InstrumentBlock(BoundBlock original, LocalRewriter rewriter, ref TemporaryArray<LocalSymbol> additionalLocals, out BoundStatement? prologue, out BoundStatement? epilogue, out BoundBlockInstrumentation? instrumentation)

Lowering\Instrumentation\DebugInfoInjector_SequencePoints.cs (1)

182var local = factory.SynthesizedLocal(condition.Type, synthesizedVariableSyntax, kind: SynthesizedLocalKind.ConditionalBranchDiscriminator);

Lowering\Instrumentation\Instrumenter.cs (1)

74public virtual void InstrumentBlock(BoundBlock original, LocalRewriter rewriter, ref TemporaryArray<LocalSymbol> additionalLocals, out BoundStatement? prologue, out BoundStatement? epilogue, out BoundBlockInstrumentation? instrumentation)

Lowering\Instrumentation\LocalStateTracingInstrumenter.cs (9)

90public LocalSymbol ContextVariable; 91private ArrayBuilder<LocalSymbol>? _lazyPreviousContextVariables; 93public Scope(LocalSymbol contextVariable) 98public void Open(LocalSymbol local) 100_lazyPreviousContextVariables ??= ArrayBuilder<LocalSymbol>.GetInstance(); 284public override void InstrumentBlock(BoundBlock original, LocalRewriter rewriter, ref TemporaryArray<LocalSymbol> additionalLocals, out BoundStatement? prologue, out BoundStatement? epilogue, out BoundBlockInstrumentation? instrumentation) 493LocalSymbol local => _factory.Local(local), 521var targetSymbol = original.Locals.FirstOrDefault(l => l.SynthesizedKind == SynthesizedLocalKind.UserDefined); 628return _factory.Sequence(ImmutableArray<LocalSymbol>.Empty, builder.ToImmutableAndFree(), lastExpression);

Lowering\Instrumentation\ModuleCancellationInstrumenter.cs (1)

67public override void InstrumentBlock(BoundBlock original, LocalRewriter rewriter, ref TemporaryArray<LocalSymbol> additionalLocals, out BoundStatement? prologue, out BoundStatement? epilogue, out BoundBlockInstrumentation? instrumentation)

Lowering\Instrumentation\StackOverflowProbingInstrumenter.cs (1)

57public override void InstrumentBlock(BoundBlock original, LocalRewriter rewriter, ref TemporaryArray<LocalSymbol> additionalLocals, out BoundStatement? prologue, out BoundStatement? epilogue, out BoundBlockInstrumentation? instrumentation)

Lowering\IteratorRewriter\IteratorMethodToStateMachineRewriter.cs (5)

35private LocalSymbol? _methodValue; 178var stateLocal = F.SynthesizedLocal(stateField.Type); 182ImmutableArray.Create<LocalSymbol>(stateLocal), 210ImmutableArray.Create<LocalSymbol>(_methodValue), 417ImmutableArray<LocalSymbol>.Empty,

Lowering\IteratorRewriter\IteratorRewriter.cs (2)

301protected override void InitializeStateMachine(ArrayBuilder<BoundStatement> bodyBuilder, NamedTypeSymbol frameType, LocalSymbol stateMachineLocal) 312protected override BoundStatement GenerateStateMachineCreation(LocalSymbol stateMachineVariable, NamedTypeSymbol frameType, IReadOnlyDictionary<Symbol, CapturedSymbolReplacement> proxies)

Lowering\LocalRewriter\LocalRewriter.cs (2)

40private ArrayBuilder<LocalSymbol>? _additionalLocals; 704_additionalLocals = ArrayBuilder<LocalSymbol>.GetInstance();

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

51internal LocalSymbol? _whenNodeIdentifierLocal;

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

57private readonly ArrayBuilder<LocalSymbol> _temps = ArrayBuilder<LocalSymbol>.GetInstance(); 99LocalSymbol temp = _factory.SynthesizedLocal(dagTemp.Type, syntax: _node, kind: kind); 126public ImmutableArray<LocalSymbol> AllTemps()

Lowering\LocalRewriter\LocalRewriter_AsOperator.cs (1)

73locals: ImmutableArray<LocalSymbol>.Empty,

Lowering\LocalRewriter\LocalRewriter_AssignmentOperator.cs (2)

320ArrayBuilder<LocalSymbol>? argTempsBuilder = null; 398LocalSymbol rhsTemp = _factory.SynthesizedLocal(exprType);

Lowering\LocalRewriter\LocalRewriter_Await.cs (1)

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

Lowering\LocalRewriter\LocalRewriter_BinaryOperator.cs (10)

Lowering\LocalRewriter\LocalRewriter_Block.cs (3)

28_additionalLocals = ArrayBuilder<LocalSymbol>.GetInstance(); 35var additionalLocals = TemporaryArray<LocalSymbol>.Empty; 130? new BoundBlock(node.Syntax, ImmutableArray<LocalSymbol>.Empty, ImmutableArray<BoundStatement>.Empty)

Lowering\LocalRewriter\LocalRewriter_Call.cs (17)

Lowering\LocalRewriter\LocalRewriter_CollectionExpression.cs (4)

675locals: ImmutableArray<LocalSymbol>.Empty, 1332new BoundBlock(iteratorBody.Syntax, locals: ImmutableArray<LocalSymbol>.Empty, statements); 1411var iterationVariable = _factory.SynthesizedLocal(enumeratorInfo.ElementType, node.Syntax); 1489ImmutableArray<LocalSymbol>.Empty,

Lowering\LocalRewriter\LocalRewriter_CompoundAssignmentOperator.cs (13)

Lowering\LocalRewriter\LocalRewriter_ConditionalAccess.cs (1)

79LocalSymbol? temp = null;

Lowering\LocalRewriter\LocalRewriter_DeconstructionAssignmentOperator.cs (9)

39var lhsTemps = ArrayBuilder<LocalSymbol>.GetInstance(); 77var temps = ArrayBuilder<LocalSymbol>.GetInstance(); 214ArrayBuilder<LocalSymbol> temps, 278ArrayBuilder<LocalSymbol> temps, DeconstructionSideEffects effects, ref bool inInit) 334private ImmutableArray<BoundExpression> AccessTupleFields(BoundExpression expression, ArrayBuilder<LocalSymbol> temps, 371ArrayBuilder<LocalSymbol> temps, ArrayBuilder<BoundExpression> effects) 382ArrayBuilder<BoundExpression> effects, ArrayBuilder<LocalSymbol> temps) 421ArrayBuilder<LocalSymbol> temps) 443private ArrayBuilder<Binder.DeconstructionVariable> GetAssignmentTargetsAndSideEffects(BoundTupleExpression variables, ArrayBuilder<LocalSymbol> temps, ArrayBuilder<BoundExpression> effects)

Lowering\LocalRewriter\LocalRewriter_Event.cs (3)

179ImmutableArray<LocalSymbol> tempSymbols = boundTemp == null 180? ImmutableArray<LocalSymbol>.Empty 181: ImmutableArray.Create<LocalSymbol>(boundTemp.LocalSymbol);

Lowering\LocalRewriter\LocalRewriter_FixedStatement.cs (13)

22var localBuilder = ArrayBuilder<LocalSymbol>.GetInstance(node.Locals.Length); 31LocalSymbol pinnedTemp; 197out LocalSymbol pinnedTemp) 202LocalSymbol localSymbol = localDecl.LocalSymbol; 234LocalSymbol localSymbol, 237out LocalSymbol pinnedTemp) 301LocalSymbol localSymbol, 304out LocalSymbol pinnedTemp) 381locals: ImmutableArray<LocalSymbol>.Empty, 438LocalSymbol localSymbol, 441out LocalSymbol pinnedTemp) 507LocalSymbol localSymbol, 510out LocalSymbol pinnedTemp)

Lowering\LocalRewriter\LocalRewriter_ForEachStatement.cs (27)

146ImmutableArray<LocalSymbol> iterationVariables, 161LocalSymbol enumeratorVar = _factory.SynthesizedLocal(enumeratorType, syntax: forEachSyntax, kind: SynthesizedLocalKind.ForEachEnumerator); 264tryBlock: new BoundBlock(forEachSyntax, locals: ImmutableArray<LocalSymbol>.Empty, statements: ImmutableArray.Create(whileLoop)), 415locals: ImmutableArray<LocalSymbol>.Empty, 428LocalSymbol disposableVar = _factory.SynthesizedLocal(idisposableTypeSymbol); 594ImmutableArray<LocalSymbol> iterationVariables, 609LocalSymbol? preambleLocal = null; 614LocalSymbol collectionTemp = _factory.SynthesizedLocal(collectionType, forEachSyntax, kind: SynthesizedLocalKind.ForEachArray, refKind: collectionTempRefKind); 630LocalSymbol positionVar = _factory.SynthesizedLocal(intType, syntax: forEachSyntax, kind: SynthesizedLocalKind.ForEachArrayIndex); 684outerLocals: preambleLocal is null ? ImmutableArray.Create<LocalSymbol>(collectionTemp, positionVar) : ImmutableArray.Create<LocalSymbol>(preambleLocal, collectionTemp, positionVar), 698private delegate BoundStatement? GetForEachStatementAsForPreamble(LocalRewriter rewriter, SyntaxNode syntax, ForEachEnumeratorInfo enumeratorInfo, ref BoundExpression rewrittenExpression, out LocalSymbol? preambleLocal, out RefKind collectionTempRefKind); 737return static (LocalRewriter rewriter, SyntaxNode syntax, ForEachEnumeratorInfo enumeratorInfo, ref BoundExpression rewrittenExpression, out LocalSymbol? preambleLocal, out RefKind collectionTempRefKind) => 803ImmutableArray<LocalSymbol> iterationVariables, 829ImmutableArray<LocalSymbol> iterationVariables, 890ImmutableArray<LocalSymbol> iterationVariables, 908LocalSymbol arrayVar = _factory.SynthesizedLocal(arrayType, syntax: forEachSyntax, kind: SynthesizedLocalKind.ForEachArray); 919LocalSymbol positionVar = _factory.SynthesizedLocal(intType, syntax: forEachSyntax, kind: SynthesizedLocalKind.ForEachArrayIndex); 980outerLocals: ImmutableArray.Create<LocalSymbol>(arrayVar, positionVar), 1039ImmutableArray<LocalSymbol> iterationVariables, 1064LocalSymbol arrayVar = _factory.SynthesizedLocal(arrayType, syntax: forEachSyntax, kind: SynthesizedLocalKind.ForEachArray); 1078LocalSymbol[] upperVar = new LocalSymbol[rank]; 1100LocalSymbol[] positionVar = new LocalSymbol[rank]; 1223private static BoundLocal MakeBoundLocal(CSharpSyntaxNode syntax, LocalSymbol local, TypeSymbol type) 1231private BoundStatement MakeLocalDeclaration(CSharpSyntaxNode syntax, LocalSymbol local, BoundExpression rewrittenInitialValue)

Lowering\LocalRewriter\LocalRewriter_ForStatement.cs (1)

42ImmutableArray<LocalSymbol> outerLocals,

Lowering\LocalRewriter\LocalRewriter_FunctionPointerInvocation.cs (1)

25ArrayBuilder<LocalSymbol>? temps = null;

Lowering\LocalRewriter\LocalRewriter_Index.cs (2)

35ArrayBuilder<LocalSymbol> locals = ArrayBuilder<LocalSymbol>.GetInstance();

Lowering\LocalRewriter\LocalRewriter_IndexerAccess.cs (8)

Lowering\LocalRewriter\LocalRewriter_IsOperator.cs (1)

91locals: ImmutableArray<LocalSymbol>.Empty,

Lowering\LocalRewriter\LocalRewriter_IsPatternOperator.cs (2)

120LocalSymbol resultTemp = _factory.SynthesizedLocal(node.Type, node.Syntax, kind: SynthesizedLocalKind.LoweringTemp); 181test = _factory.Sequence(ImmutableArray<LocalSymbol>.Empty, _sideEffectBuilder.ToImmutable(), test);

Lowering\LocalRewriter\LocalRewriter_LocalDeclaration.cs (2)

19private BoundStatement? RewriteLocalDeclaration(BoundLocalDeclaration? originalOpt, SyntaxNode syntax, LocalSymbol localSymbol, BoundExpression? rewrittenInitializer, bool hasErrors = false) 72private BoundStatement InstrumentLocalDeclarationIfNecessary(BoundLocalDeclaration? originalOpt, LocalSymbol localSymbol, BoundStatement rewrittenLocalDeclaration)

Lowering\LocalRewriter\LocalRewriter_NullCoalescingAssignmentOperator.cs (2)

18var temps = ArrayBuilder<LocalSymbol>.GetInstance(); 142var alternative = _factory.Sequence(ImmutableArray<LocalSymbol>.Empty, ImmutableArray.Create(tmpAssignment, transformedLhsAssignment), tmp);

Lowering\LocalRewriter\LocalRewriter_ObjectCreationExpression.cs (5)

44ArrayBuilder<LocalSymbol>? tempsBuilder = null; 166var temps = ArrayBuilder<LocalSymbol>.GetInstance(); 200ArrayBuilder<BoundExpression> sideEffects, ArrayBuilder<LocalSymbol> temps) 270ArrayBuilder<LocalSymbol>? temps = null; 288ImmutableArray<LocalSymbol> locals;

Lowering\LocalRewriter\LocalRewriter_ObjectOrCollectionInitializerExpression.cs (14)

Lowering\LocalRewriter\LocalRewriter_PatternSwitchStatement.cs (1)

75var outerVariables = ArrayBuilder<LocalSymbol>.GetInstance();

Lowering\LocalRewriter\LocalRewriter_Range.cs (1)

85var locals = ArrayBuilder<LocalSymbol>.GetInstance();

Lowering\LocalRewriter\LocalRewriter_StackAlloc.cs (1)

54var locals = ArrayBuilder<LocalSymbol>.GetInstance();

Lowering\LocalRewriter\LocalRewriter_StringConcat.cs (1)

469var localsBuilder = ArrayBuilder<LocalSymbol>.GetInstance();

Lowering\LocalRewriter\LocalRewriter_StringInterpolation.cs (5)

34var builderTempSymbol = _factory.InterpolatedStringHandlerLocal(data.BuilderType, syntax); 59var outLocal = _factory.SynthesizedLocal(localType); 260private readonly LocalSymbol? _outTemp; 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_SwitchExpression.cs (2)

50var outerVariables = ArrayBuilder<LocalSymbol>.GetInstance(); 89LocalSymbol resultTemp = _factory.SynthesizedLocal(node.Type, node.Syntax, kind: SynthesizedLocalKind.LoweringTemp);

Lowering\LocalRewriter\LocalRewriter_TupleBinaryOperator.cs (14)

Lowering\LocalRewriter\LocalRewriter_UnaryOperator.cs (10)

237locals: ImmutableArray.Create<LocalSymbol>(boundTemp.LocalSymbol), 461ArrayBuilder<LocalSymbol> tempSymbols = ArrayBuilder<LocalSymbol>.GetInstance(); 578ArrayBuilder<LocalSymbol> tempSymbols = ArrayBuilder<LocalSymbol>.GetInstance(); 590LocalSymbol tempSymbol = _factory.SynthesizedLocal(operandType); 653ArrayBuilder<LocalSymbol> tempSymbols, 692ArrayBuilder<LocalSymbol> tempSymbols, 708ImmutableArray<LocalSymbol>.Empty, 871locals: ImmutableArray.Create<LocalSymbol>(boundTemp.LocalSymbol),

Lowering\LocalRewriter\LocalRewriter_UsingStatement.cs (6)

64ImmutableArray<LocalSymbol> locals, 92BoundBlock body = new BoundBlock(syntax, ImmutableArray<LocalSymbol>.Empty, statements); 96ImmutableArray<LocalSymbol>.Empty, 217LocalSymbol localSymbol = localDeclaration.LocalSymbol; 258locals: ImmutableArray.Create<LocalSymbol>(boundTemp.LocalSymbol), //localSymbol will be declared by an enclosing block 511ArrayBuilder<LocalSymbol>? temps = null;

Lowering\LocalRewriter\LocalRewriter_WhileStatement.cs (1)

108ImmutableArray<LocalSymbol> locals,

Lowering\LocalRewriter\LoweredDynamicOperation.cs (3)

25private readonly ImmutableArray<LocalSymbol> _temps; 29public LoweredDynamicOperation(SyntheticBoundNodeFactory? factory, BoundExpression? siteInitialization, BoundExpression siteInvocation, TypeSymbol resultType, ImmutableArray<LocalSymbol> temps) 56return new LoweredDynamicOperation(null, null, bad, resultType, default(ImmutableArray<LocalSymbol>));

Lowering\LocalRewriter\LoweredDynamicOperationFactory.cs (5)

641ImmutableArray<LocalSymbol> temps = MakeTempsForDiscardArguments(ref loweredArguments); 671private ImmutableArray<LocalSymbol> MakeTempsForDiscardArguments(ref ImmutableArray<BoundExpression> loweredArguments) 677return ImmutableArray<LocalSymbol>.Empty; 680ArrayBuilder<LocalSymbol> temporariesBuilder = ArrayBuilder<LocalSymbol>.GetInstance(discardCount);

Lowering\MethodToClassRewriter.cs (3)

55protected sealed override bool TryRewriteLocal(LocalSymbol local, [NotNullWhen(true)] out LocalSymbol? newLocal) 311ImmutableArray.Create<LocalSymbol>(tempLocal.LocalSymbol),

Lowering\SpillSequenceSpiller.cs (37)

22private readonly PooledDictionary<LocalSymbol, LocalSymbol> _tempSubstitution; 23private readonly PooledDictionary<LocalSymbol, BoundComplexConditionalReceiver> _receiverSubstitution; 27PooledDictionary<LocalSymbol, LocalSymbol> tempSubstitution, 28PooledDictionary<LocalSymbol, BoundComplexConditionalReceiver> receiverSubstitution, 41private ArrayBuilder<LocalSymbol> _locals; 67public ImmutableArray<LocalSymbol> GetLocals() 69return (_locals == null) ? ImmutableArray<LocalSymbol>.Empty : _locals.ToImmutable(); 122public void AddLocal(LocalSymbol local) 126_locals = ArrayBuilder<LocalSymbol>.GetInstance(); 132public void AddLocals(ImmutableArray<LocalSymbol> locals) 134foreach (var local in locals) 183private readonly PooledDictionary<LocalSymbol, LocalSymbol> _tempSubstitution; 184private readonly PooledDictionary<LocalSymbol, BoundComplexConditionalReceiver> _receiverSubstitution; 187PooledDictionary<LocalSymbol, LocalSymbol> tempSubstitution, 188PooledDictionary<LocalSymbol, BoundComplexConditionalReceiver> receiverSubstitution, 197PooledDictionary<LocalSymbol, LocalSymbol> tempSubstitution, 198PooledDictionary<LocalSymbol, BoundComplexConditionalReceiver> receiverSubstitution, 214LocalSymbol longLived; 234var tempSubstitution = PooledDictionary<LocalSymbol, LocalSymbol>.GetInstance(); 235var receiverSubstitution = PooledDictionary<LocalSymbol, BoundComplexConditionalReceiver>.GetInstance(); 357out LocalSymbol receiverRefLocal, 530out LocalSymbol outReceiverRefLocal, 1007var tmp = _F.SynthesizedLocal(node.Type, kind: SynthesizedLocalKind.Spill, syntax: _F.Syntax); 1146var tmp = _F.SynthesizedLocal(node.Type, kind: SynthesizedLocalKind.Spill, syntax: _F.Syntax); 1161var tmp = _F.SynthesizedLocal(condition.Type, kind: SynthesizedLocalKind.Spill, syntax: _F.Syntax); 1261var tmp = _F.SynthesizedLocal(node.Type, kind: SynthesizedLocalKind.Spill, syntax: _F.Syntax); 1317var clone = _F.SynthesizedLocal(receiver.Type, _F.Syntax, refKind: RefKind.None, kind: SynthesizedLocalKind.Spill); 1347var tmp = _F.SynthesizedLocal(node.Type, kind: SynthesizedLocalKind.Spill, syntax: _F.Syntax); 1498private void PromoteAndAddLocals(BoundSpillSequenceBuilder builder, ImmutableArray<LocalSymbol> locals) 1500foreach (var local in locals) 1508LocalSymbol longLived = local.WithSynthesizedLocalKindAndSyntax(SynthesizedLocalKind.Spill, _F.Syntax);

Lowering\StateMachineRewriter\IteratorAndAsyncCaptureWalker.cs (13)

44private readonly Dictionary<LocalSymbol, BoundExpression> _boundRefLocalInitializers = new Dictionary<LocalSymbol, BoundExpression>(); 87if (variable is LocalSymbol local) 150LocalSymbol { IsConst: false, IsPinned: false, IsRef: false } local => 169if (!((LocalSymbol)symbol).IsConst) 223case LocalSymbol { RefKind: RefKind.None }: 230var type = (variable.Kind == SymbolKind.Local) ? ((LocalSymbol)variable).Type : ((ParameterSymbol)variable).Type; 232(variable is LocalSymbol { RefKind: not RefKind.None } refLocal && !canRefLocalBeHoisted(refLocal))) 238if (_variablesToHoist.Add(variable) && variable is LocalSymbol local && _boundRefLocalInitializers.TryGetValue(local, out var variableInitializer)) 242static bool canRefLocalBeHoisted(LocalSymbol refLocal) 362if (node is { IsRef: true, Left: BoundLocal { LocalSymbol: LocalSymbol { IsCompilerGenerated: true } local } }) 394private void AddVariables(ImmutableArray<LocalSymbol> locals) 396foreach (var local in locals)

Lowering\StateMachineRewriter\MethodToStateMachineRewriter.cs (13)

36protected readonly LocalSymbol cachedState; 50protected readonly LocalSymbol? cachedThis; 286foreach (var local in node.Locals) 301private BoundStatement PossibleIteratorScope(ImmutableArray<LocalSymbol> locals, Func<BoundStatement> wrapped) 309foreach (var local in locals) 352foreach (var local in locals) 466private StateMachineFieldSymbol GetOrAllocateReusableHoistedField(TypeSymbol type, out bool reused, LocalSymbol? local = null) 541var newLocalsBuilder = ArrayBuilder<LocalSymbol>.GetInstance(); 544foreach (var local in node.Locals) 551LocalSymbol localToUse; 584ImmutableArray<LocalSymbol> newLocals; 625var leftLocal = ((BoundLocal)node.Left).LocalSymbol; 660static StateMachineFieldSymbol createHoistedSymbol(TypeSymbol type, MethodToStateMachineRewriter @this, LocalSymbol assignedLocal)

Lowering\StateMachineRewriter\RefInitializationHoister.cs (6)

59LocalSymbol local, 62Func<TypeSymbol, TArg, LocalSymbol, THoistedSymbol> createHoistedSymbol, 97var sacrificialTemp = _factory.SynthesizedLocal(type, refKind: RefKind.Ref); 110return _factory.Sequence(ImmutableArray<LocalSymbol>.Empty, sideEffects.ToImmutableAndFree(), last); 136LocalSymbol assignedLocal, 141Func<TypeSymbol, TArg, LocalSymbol, THoistedSymbol> createHoistedSymbol,

Lowering\StateMachineRewriter\StateMachineRewriter.cs (8)

81protected abstract void InitializeStateMachine(ArrayBuilder<BoundStatement> bodyBuilder, NamedTypeSymbol frameType, LocalSymbol stateMachineLocal); 86protected abstract BoundStatement GenerateStateMachineCreation(LocalSymbol stateMachineVariable, NamedTypeSymbol frameType, IReadOnlyDictionary<Symbol, CapturedSymbolReplacement> proxies); 157var local = (LocalSymbol)variable; 271private bool ShouldPreallocateNonReusableProxy(LocalSymbol local) 293LocalSymbol stateMachineVariable = F.SynthesizedLocal(frameType, null); 306protected BoundStatement GenerateParameterStorage(LocalSymbol stateMachineVariable, IReadOnlyDictionary<Symbol, CapturedSymbolReplacement> proxies) 427var resultVariable = F.SynthesizedLocal(stateMachineType, null);

Lowering\SyntheticBoundNodeFactory.cs (28)

Operations\CSharpOperationFactory.cs (1)

1966var local = boundForEachStatement.IterationVariables[0];

Symbols\LocalDeclarationKind.cs (1)

18/// Check the value of <see cref="LocalSymbol.SynthesizedKind"/> for the kind of synthesized variable.

Symbols\LocalSymbol.cs (2)

41internal abstract LocalSymbol WithSynthesizedLocalKindAndSyntax( 361internal abstract ConstantValue GetConstantValue(SyntaxNode node, LocalSymbol inProgress, BindingDiagnosticBag diagnostics = null);

Symbols\PublicModel\LocalSymbol.cs (2)

14private readonly Symbols.LocalSymbol _underlying; 17public LocalSymbol(Symbols.LocalSymbol underlying)

Symbols\Source\SourceComplexParameterSymbol.cs (1)

353ImmutableArray<LocalSymbol>.Empty,

Symbols\Source\SourceLocalSymbol.cs (5)

155internal static LocalSymbol MakeLocalSymbolWithEnclosingContext( 232internal override LocalSymbol WithSynthesizedLocalKindAndSyntax( 470internal override ConstantValue GetConstantValue(SyntaxNode node, LocalSymbol inProgress, BindingDiagnosticBag diagnostics) 575private void MakeConstantTuple(LocalSymbol inProgress, BoundExpression boundInitValue) 593internal override ConstantValue GetConstantValue(SyntaxNode node, LocalSymbol inProgress, BindingDiagnosticBag diagnostics = null)

Symbols\Symbol.cs (1)

1733if (((LocalSymbol)variable).IsConst)

Symbols\SymbolExtensions.cs (6)

504LocalSymbol local = (LocalSymbol)symbol; 586internal static ILocalSymbol? GetPublicSymbol(this LocalSymbol? symbol) 711internal static ImmutableArray<ILocalSymbol> GetPublicSymbols(this ImmutableArray<LocalSymbol> symbols) 783internal static LocalSymbol? GetSymbol(this ILocalSymbol? symbol) 785return symbol.GetSymbol<LocalSymbol>();

Symbols\SymbolVisitor.cs (1)

65public virtual void VisitLocal(LocalSymbol symbol)

Symbols\SymbolVisitor`1.cs (1)

65public virtual TResult VisitLocal(LocalSymbol symbol)

Symbols\SymbolVisitor`2.cs (2)

245/// Called when visiting a <see cref="LocalSymbol" />; Override this with specific 251public virtual TResult VisitLocal(LocalSymbol symbol, TArgument argument)

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

59var builderLocalSymbol = F.SynthesizedLocal(stringBuilder);

Symbols\Synthesized\SynthesizedEntryPointSymbol.cs (5)

405locals: ImmutableArray<LocalSymbol>.Empty, 428locals: ImmutableArray<LocalSymbol>.Empty, 500locals: ImmutableArray<LocalSymbol>.Empty, 506ImmutableArray.Create<LocalSymbol>(scriptLocal.LocalSymbol), 623ImmutableArray.Create<LocalSymbol>(submissionLocal.LocalSymbol),

Symbols\Synthesized\SynthesizedLocal.cs (2)

73internal sealed override LocalSymbol WithSynthesizedLocalKindAndSyntax( 190internal sealed override ConstantValue GetConstantValue(SyntaxNode node, LocalSymbol inProgress, BindingDiagnosticBag diagnostics)

Symbols\Synthesized\TypeSubstitutedLocalSymbol.cs (5)

16private readonly LocalSymbol _originalVariable; 20public TypeSubstitutedLocalSymbol(LocalSymbol originalVariable, TypeWithAnnotations type, Symbol containingSymbol) 124internal override ConstantValue GetConstantValue(SyntaxNode node, LocalSymbol inProgress, BindingDiagnosticBag diagnostics) 134internal LocalSymbol UnderlyingLocalSymbol => _originalVariable; 136internal override LocalSymbol WithSynthesizedLocalKindAndSyntax(

Symbols\UpdatedContainingSymbolLocal.cs (3)

50if (!(other is LocalSymbol otherLocal)) 93internal override ConstantValue GetConstantValue(SyntaxNode node, LocalSymbol inProgress, BindingDiagnosticBag? diagnostics = null) => 101internal override LocalSymbol WithSynthesizedLocalKindAndSyntax(