_factory

Lowering\LocalRewriter\LocalRewriter.cs (16)

63_factory.CurrentFunction = containingMethod; 157=> _factory; 166=> _factory.InstrumentationState!; 176get { return _factory.CompilationState.ModuleBuilderOpt; } 295var oldContainingSymbol = _factory.CurrentFunction; 302_factory.CurrentFunction = lambda; 312_factory.CurrentFunction = oldContainingSymbol; 325if (_factory.CompilationState.ModuleBuilderOpt is { } moduleBuilder) 342if (_factory.CompilationState.Compilation.ShouldEmitNullableAttributes(localFunction)) 357var oldContainingSymbol = _factory.CurrentFunction; 364_factory.CurrentFunction = localFunction; 376_dynamicFactory = new LoweredDynamicOperationFactory(_factory, _dynamicFactory.MethodOrdinal, localFunctionOrdinal); 383_factory.CurrentFunction = oldContainingSymbol; 647if (_factory.CurrentFunction?.IsStatic == false) 709var F = _factory; 1000_factory.CompilationState.ModuleBuilderOpt?.EnsureIsReadOnlyAttributeExists();

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

33_factory = localRewriter._factory;

Lowering\LocalRewriter\LocalRewriter_AssignmentOperator.cs (5)

226return _factory.AssignmentExpression( 264return _factory.AssignmentExpression( 298return _factory.AssignmentExpression( 299_factory.Field(rewrittenReceiver, backingField), 334LocalSymbol rhsTemp = _factory.SynthesizedLocal(exprType);

Lowering\LocalRewriter\LocalRewriter_Await.cs (1)

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

Lowering\LocalRewriter\LocalRewriter_BinaryOperator.cs (62)

Lowering\LocalRewriter\LocalRewriter_Call.cs (19)

54else if (hasImplicitReceiver && _factory.TopLevelMethod is { RequiresInstanceReceiver: false }) 57Debug.Assert(_factory.CurrentType is { }); 58loweredReceiver = new BoundTypeExpression(node.Syntax, null, _factory.CurrentType); 467_factory.CurrentFunction, 475receiverTemp = _factory.StoreToTemp(rewrittenReceiver, out assignmentToTemp, refKind); 503visitedArgumentsBuilder.Add(_factory.MakeTempForDiscard(discard, tempsOpt)); 564rewrittenReceiver = _factory.Sequence( 640local = _factory.StoreToTemp(visitedArgument, out var store, refKind: paramRefKind == RefKind.In ? RefKind.In : argRefKind); 642visitedArgumentsBuilder[argIndex] = _factory.Sequence(ImmutableArray<LocalSymbol>.Empty, ImmutableArray.Create<BoundExpression>(store), local); 702BoundLocal cache = _factory.Local(_factory.SynthesizedLocal(receiverType)); 709var intermediateRef = _factory.Local(_factory.SynthesizedLocal(receiverType, refKind: RefKind.Ref)); 722_factory.Sequence(new BoundExpression[] { _factory.AssignmentExpression(cache, intermediateRef) }, cache), 740_factory.Sequence(new BoundExpression[] { _factory.AssignmentExpression(cache, assignmentToTemp.Right) }, cache), 1111var temp = _factory.StoreToTemp( 1512BoundLocal boundTemp = _factory.StoreToTemp(argument, out boundAssignmentToTemp);

Lowering\LocalRewriter\LocalRewriter_CompoundAssignmentOperator.cs (19)

Lowering\LocalRewriter\LocalRewriter_ConditionalAccess.cs (13)

50return _factory.Default(node.Type); 96temp = _factory.SynthesizedLocal(receiverType); 97_currentConditionalAccessTarget = _factory.Local(temp); 136loweredAccessExpression = _factory.New((NamedTypeSymbol)nodeType, loweredAccessExpression); 168loweredReceiver = _factory.MakeSequence( 169_factory.AssignmentExpression(_factory.Local(temp), loweredReceiver), 170_factory.Local(temp)); 177var condition = _factory.ObjectNotEqual( 178_factory.Convert(objectType, loweredReceiver), 179_factory.Null(objectType)); 186_factory.Default(nodeType), 193result = _factory.MakeSequence(temp, result);

Lowering\LocalRewriter\LocalRewriter_Conversion.cs (23)

92var save_Syntax = _factory.Syntax; 93_factory.Syntax = node.Syntax; 108result = new BoundObjectCreationExpression(node.Syntax, ctor.AsMember((NamedTypeSymbol)node.Type), utf8Bytes, _factory.Literal(0), _factory.Literal(length)); 111_factory.Syntax = save_Syntax; 143builder.Add(_factory.Literal(b)); 149builder.Add(_factory.Literal((byte)0)); 153ImmutableArray.Create<BoundExpression>(_factory.Literal(builder.Count)), 445return _factory.ThrowExpression(operand.Expression, rewrittenType); 559var oldSyntax = _factory.Syntax; 560_factory.Syntax = (mg.ReceiverOpt ?? mg).Syntax; 561var receiver = (!method.RequiresInstanceReceiver && !oldNodeOpt.IsExtensionMethod && !method.IsAbstract && !method.IsVirtual) ? _factory.Type(method.ContainingType) : mg.ReceiverOpt; 563_factory.Syntax = oldSyntax; 568Debug.Assert(_factory.TopLevelMethod is { }); 570if (_factory.Compilation.LanguageVersion >= MessageID.IDS_FeatureCacheStaticMethodGroupConversion.RequiredVersion() 572&& _factory.TopLevelMethod.MethodKind != MethodKind.StaticConstructor // Avoid caching twice if people do it manually. 575var rewriter = _lazyDelegateCacheRewriter ??= new DelegateCacheRewriter(_factory, _topLevelMethodOrdinal); 650return _factory.NullOrDefault(rewrittenType); 821var savedTuple = _factory.StoreToTemp(rewrittenOperand, out assignmentToTemp); 833return _factory.MakeSequence(savedTuple.LocalSymbol, assignmentToTemp, result); 1024var boundTemp = _factory.StoreToTemp(operand, out tempAssignment); 1282BoundLocal boundTemp = _factory.StoreToTemp(rewrittenOperand, out tempAssignment); 1286BoundExpression condition = _factory.MakeNullableHasValue(syntax, boundTemp);

Lowering\LocalRewriter\LocalRewriter_DeconstructionAssignmentOperator.cs (6)

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

Lowering\LocalRewriter\LocalRewriter_DelegateCreationExpression.cs (4)

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

Lowering\LocalRewriter\LocalRewriter_DoStatement.cs (1)

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

Lowering\LocalRewriter\LocalRewriter_Event.cs (18)

83boundTemp = _factory.StoreToTemp(rewrittenReceiverOpt!, out tempAssignment); 86NamedTypeSymbol tokenType = _factory.WellKnownType(WellKnownType.System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken); 87NamedTypeSymbol marshalType = _factory.WellKnownType(WellKnownType.System_Runtime_InteropServices_WindowsRuntime_WindowsRuntimeMarshal); 89NamedTypeSymbol actionType = _factory.WellKnownType(WellKnownType.System_Action_T).Construct(tokenType); 93BoundExpression delegateCreationArgument = boundTemp ?? rewrittenReceiverOpt ?? _factory.Type(eventType); 131NamedTypeSymbol func2Type = _factory.WellKnownType(WellKnownType.System_Func_T2).Construct(eventType, tokenType); 273return _factory.Call(getOrCreateCall, invocationListAccessor); 288SyntaxNode oldSyntax = _factory.Syntax; 289_factory.Syntax = node.Syntax; 291var ctor = _factory.WellKnownMethod(WellKnownMember.System_Runtime_InteropServices_ComAwareEventInfo__ctor); 295var addRemove = _factory.WellKnownMethod(node.IsAddition ? WellKnownMember.System_Runtime_InteropServices_ComAwareEventInfo__AddEventHandler : 300BoundExpression eventInfo = _factory.New(ctor, _factory.Typeof(node.Event.ContainingType), _factory.Literal(node.Event.MetadataName)); 301result = _factory.Call(eventInfo, addRemove, 302_factory.Convert(addRemove.Parameters[0].Type, rewrittenReceiver), 303_factory.Convert(addRemove.Parameters[1].Type, rewrittenArgument)); 307_factory.Syntax = oldSyntax;

Lowering\LocalRewriter\LocalRewriter_Field.cs (4)

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

Lowering\LocalRewriter\LocalRewriter_FixedStatement.cs (15)

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

Lowering\LocalRewriter\LocalRewriter_ForEachStatement.cs (21)

Lowering\LocalRewriter\LocalRewriter_ForStatement.cs (1)

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

Lowering\LocalRewriter\LocalRewriter_HostObjectMemberReference.cs (3)

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

Lowering\LocalRewriter\LocalRewriter_IfStatement.cs (1)

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

Lowering\LocalRewriter\LocalRewriter_IndexerAccess.cs (6)

236return _factory.Sequence( 257var F = _factory; 393return _factory.Literal(0); 409return _factory.IntSubtract(lengthAccess, loweredExpr); 424return _factory.Call( 516var F = _factory;

Lowering\LocalRewriter\LocalRewriter_IsOperator.cs (1)

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

Lowering\LocalRewriter\LocalRewriter_IsPatternOperator.cs (2)

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

Lowering\LocalRewriter\LocalRewriter_Literal.cs (1)

70var curMethod = _factory.CurrentFunction;

Lowering\LocalRewriter\LocalRewriter_LocalDeclaration.cs (1)

57_factory.AssignmentExpression(

Lowering\LocalRewriter\LocalRewriter_LockStatement.cs (2)

56BoundLocal boundLockTemp = _factory.StoreToTemp(rewrittenArgument, out assignmentToLockTemp, syntaxOpt: lockSyntax, kind: SynthesizedLocalKind.Lock); 99BoundLocal boundLockTakenTemp = _factory.StoreToTemp(

Lowering\LocalRewriter\LocalRewriter_NullCoalescingAssignmentOperator.cs (5)

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

Lowering\LocalRewriter\LocalRewriter_NullCoalescingOperator.cs (2)

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

Lowering\LocalRewriter\LocalRewriter_ObjectCreationExpression.cs (19)

160BoundLocal oldValue = _factory.StoreToTemp(rewrittenReceiver, out BoundAssignmentOperator boundAssignmentToTemp); 164BoundExpression value = _factory.New(anonymousType, getAnonymousTypeValues(withExpr, oldValue, anonymousType, sideEffects, temps)); 179expression = _factory.Convert( 181_factory.Call( 206BoundLocal valueTemp = _factory.StoreToTemp(rewrittenRight, out BoundAssignmentOperator boundAssignmentToTemp); 225builder.Add(_factory.Property(oldValue, property)); 259BoundLocal value = _factory.StoreToTemp(rewrittenExpression, out boundAssignmentToTemp, isKnownToReferToTempIfReferenceType: true); 366SyntaxNode oldSyntax = _factory.Syntax; 367_factory.Syntax = node.Syntax; 369var ctor = _factory.WellKnownMethod(WellKnownMember.System_Guid__ctor); 375newGuid = _factory.New(ctor, _factory.Literal(node.GuidString)); 382var getTypeFromCLSID = _factory.WellKnownMethod(WellKnownMember.System_Runtime_InteropServices_Marshal__GetTypeFromCLSID, isOptional: true); 386getTypeFromCLSID = _factory.WellKnownMethod(WellKnownMember.System_Type__GetTypeFromCLSID); 393callGetTypeFromCLSID = _factory.Call(null, getTypeFromCLSID, newGuid); 400var createInstance = _factory.WellKnownMethod(WellKnownMember.System_Activator__CreateInstance); 405rewrittenObjectCreation = _factory.Convert(node.Type, _factory.Call(null, createInstance, callGetTypeFromCLSID)); 412_factory.Syntax = oldSyntax;

Lowering\LocalRewriter\LocalRewriter_ObjectOrCollectionInitializerExpression.cs (2)

422var temp = _factory.StoreToTemp(rewrittenIndex, out store); 476var temp = _factory.StoreToTemp(arg, out store, refKind);

Lowering\LocalRewriter\LocalRewriter_PreviousSubmissionReference.cs (3)

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

Lowering\LocalRewriter\LocalRewriter_Range.cs (2)

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

Lowering\LocalRewriter\LocalRewriter_ReturnStatement.cs (2)

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

Lowering\LocalRewriter\LocalRewriter_StackAlloc.cs (11)

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

Lowering\LocalRewriter\LocalRewriter_StringConcat.cs (10)

87result = _factory.StringLiteral(string.Empty); 229return _factory.StringLiteral(concatenated); 238return _factory.Literal(string.Empty); 296return _factory.Coalesce(loweredOperand, _factory.Literal("")); 344var array = _factory.ArrayOrEmpty(_factory.SpecialType(SpecialType.System_String), loweredArgs); 392return _factory.StringLiteral(cv.CharValue.ToString()); 472var temp = _factory.StoreToTemp(expr, out var store); 473return _factory.Sequence(

Lowering\LocalRewriter\LocalRewriter_StringInterpolation.cs (22)

23var stringFactory = _factory.WellKnownType(WellKnownType.System_Runtime_CompilerServices_FormattableStringFactory); 29var result = _factory.StaticCall(stringFactory, "Create", expressions.ToImmutableAndFree(), 60return _factory.NullOrDefault(rewrittenType); 78var builderTempSymbol = _factory.InterpolatedStringHandlerLocal(data.BuilderType, syntax); 79BoundLocal builderTemp = _factory.Local(builderTempSymbol); 103var outLocal = _factory.SynthesizedLocal(localType); 104appendShouldProceedLocal = _factory.Local(outLocal); 109var handlerConstructionAssignment = _factory.AssignmentExpression(builderTemp, (BoundExpression)VisitObjectCreationExpression(construction)); 159: _factory.LogicalAnd(currentExpression, actualCall); 171var appendCallsStatements = resultExpressions.SelectAsArray(static (appendCall, @this) => (BoundStatement)@this._factory.ExpressionStatement(appendCall), this); 175var resultIf = _factory.If(appendShouldProceedLocal, _factory.StatementList(appendCallsStatements)); 177return new InterpolationHandlerResult(ImmutableArray.Create(_factory.ExpressionStatement(handlerConstructionAssignment), resultIf), builderTemp, appendShouldProceedLocal.LocalSymbol, this); 210_factory.Syntax = node.Syntax; 251format = _factory.StringLiteral(formatString.ToStringAndFree()); 298return _factory.StringLiteral(""); 314part = _factory.StringLiteral(part.ConstantValueOpt.StringValue); 319_factory.Binary(BinaryOperatorKind.StringConcatenation, node.Type, result, part); 331result = new BoundNullCoalescingOperator(result.Syntax, result, _factory.StringLiteral(""), leftPlaceholder: placeholder, leftConversion: placeholder, BoundNullCoalescingOperatorResultKind.LeftType, @checked: false, result.Type) { WasCompilerGenerated = true }; 354result = _factory.StaticCall(stringType, "Format", expressions.ToImmutableAndFree(), 440return _rewriter._factory.Sequence(locals, _expressions, result); 445return _rewriter._factory.SpillSequence(locals, _statements, result);

Lowering\LocalRewriter\LocalRewriter_TryStatement.cs (1)

101_factory);

Lowering\LocalRewriter\LocalRewriter_TupleBinaryOperator.cs (16)

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

Lowering\LocalRewriter\LocalRewriter_TupleCreationExpression.cs (2)

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

Lowering\LocalRewriter\LocalRewriter_UnaryOperator.cs (8)

95return _factory.Literal(constant.BooleanValue); 97return MakeConversionNode(_factory.Literal(!constant.BooleanValue), type, @checked: false); 198BoundLocal boundTemp = _factory.StoreToTemp(loweredOperand, out tempAssignment); 202BoundExpression condition = _factory.MakeNullableHasValue(syntax, boundTemp); 438LocalSymbol tempSymbol = _factory.SynthesizedLocal(operandType); 657BoundLocal boundTemp = _factory.StoreToTemp(rewrittenArgument, out tempAssignment); 663BoundExpression condition = _factory.MakeNullableHasValue(node.Syntax, boundTemp); 824BoundExpression condition = _factory.MakeNullableHasValue(syntax, operand);

Lowering\LocalRewriter\LocalRewriter_UsingStatement.cs (5)

175boundTemp = _factory.StoreToTemp(tempInit, out tempAssignment, kind: SynthesizedLocalKind.Using); 180boundTemp = _factory.StoreToTemp(rewrittenExpression, out tempAssignment, syntaxOpt: usingSyntax, kind: SynthesizedLocalKind.Using); 251BoundLocal boundTemp = _factory.StoreToTemp(tempInit, out tempAssignment, kind: SynthesizedLocalKind.Using); 382ifCondition = _factory.MakeNullableHasValue(resourceSyntax, local); 391ifCondition = _factory.MakeNullCheck(resourceSyntax, local, BinaryOperatorKind.NotEqual);

Lowering\LocalRewriter\LocalRewriter_WhileStatement.cs (1)

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

Lowering\LocalRewriter\LocalRewriter_Yield.cs (1)

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