private BoundExpression VisitObjectCreationExpressionInternal(BoundObjectCreationExpression node)
{
if (node.ConstantValue != null)
{
// typically a decimal constant.
return(Constant(node));
}
if ((object)node.Constructor == null ||
(node.Arguments.Length == 0 && !node.Type.IsStructType()) ||
node.Constructor.IsDefaultValueTypeConstructor())
{
return(ExprFactory("New", _bound.Typeof(node.Type)));
}
var ctor = _bound.ConstructorInfo(node.Constructor);
var args = _bound.Convert(_IEnumerableType.Construct(ExpressionType), Expressions(node.Arguments));
if (node.Type.IsAnonymousType && node.Arguments.Length != 0)
{
var anonType = (NamedTypeSymbol)node.Type;
var membersBuilder = ArrayBuilder <BoundExpression> .GetInstance();
for (int i = 0; i < node.Arguments.Length; i++)
{
membersBuilder.Add(_bound.MethodInfo(AnonymousTypeManager.GetAnonymousTypeProperty(anonType, i).GetMethod));
}
return(ExprFactory("New", ctor, args, _bound.ArrayOrEmpty(MemberInfoType, membersBuilder.ToImmutableAndFree())));
}
else
{
return(ExprFactory("New", ctor, args));
}
}
private static BoundStatement ConstructDirectNullCheck(ParameterSymbol parameter, SyntheticBoundNodeFactory factory)
{
BoundExpression paramIsNullCondition;
var loweredLeft = factory.Parameter(parameter);
if (loweredLeft.Type.IsNullableType())
{
paramIsNullCondition = factory.Not(factory.MakeNullableHasValue(loweredLeft.Syntax, loweredLeft));
}
else
{
// Examples of how we might get here:
// int*
// delegate*<...>
// T where T : int? (via some indirection)
Debug.Assert(parameter.Type.IsPointerOrFunctionPointer() ||
(parameter.Type.IsNullableTypeOrTypeParameter() && !parameter.Type.IsNullableType()));
paramIsNullCondition = factory.MakeNullCheck(loweredLeft.Syntax, loweredLeft, BinaryOperatorKind.Equal);
}
var argumentName = ImmutableArray.Create <BoundExpression>(factory.StringLiteral(parameter.Name));
BoundObjectCreationExpression ex = factory.New(factory.WellKnownMethod(WellKnownMember.System_ArgumentNullException__ctorString), argumentName);
BoundThrowStatement throwArgNullStatement = factory.Throw(ex);
return(factory.HiddenSequencePoint(factory.If(paramIsNullCondition, throwArgNullStatement)));
}
/// <summary>
/// Converts the expression for creating a tuple instance into an expression creating a ValueTuple (if short) or nested ValueTuples (if longer).
///
/// For instance, for a long tuple we'll generate:
/// creationExpression(ctor=largestCtor, args=firstArgs+(nested creationExpression for remainder, with smaller ctor and next few args))
/// </summary>
private BoundNode RewriteTupleCreationExpression(BoundTupleExpression node, ImmutableArray<BoundExpression> rewrittenArguments)
{
NamedTypeSymbol underlyingTupleType = node.Type.TupleUnderlyingType;
ArrayBuilder<NamedTypeSymbol> underlyingTupleTypeChain = ArrayBuilder<NamedTypeSymbol>.GetInstance();
TupleTypeSymbol.GetUnderlyingTypeChain(underlyingTupleType, underlyingTupleTypeChain);
try
{
// make a creation expression for the smallest type
NamedTypeSymbol smallestType = underlyingTupleTypeChain.Pop();
ImmutableArray<BoundExpression> smallestCtorArguments = ImmutableArray.Create(rewrittenArguments,
underlyingTupleTypeChain.Count * (TupleTypeSymbol.RestPosition - 1),
smallestType.Arity);
var smallestCtor = (MethodSymbol)TupleTypeSymbol.GetWellKnownMemberInType(smallestType.OriginalDefinition,
TupleTypeSymbol.GetTupleCtor(smallestType.Arity),
_diagnostics,
node.Syntax);
if ((object)smallestCtor == null)
{
return node;
}
MethodSymbol smallestConstructor = smallestCtor.AsMember(smallestType);
BoundObjectCreationExpression currentCreation = new BoundObjectCreationExpression(node.Syntax, smallestConstructor, smallestCtorArguments);
if (underlyingTupleTypeChain.Count > 0)
{
NamedTypeSymbol tuple8Type = underlyingTupleTypeChain.Peek();
var tuple8Ctor = (MethodSymbol)TupleTypeSymbol.GetWellKnownMemberInType(tuple8Type.OriginalDefinition,
TupleTypeSymbol.GetTupleCtor(TupleTypeSymbol.RestPosition),
_diagnostics,
node.Syntax);
if ((object)tuple8Ctor == null)
{
return node;
}
// make successively larger creation expressions containing the previous one
do
{
ImmutableArray<BoundExpression> ctorArguments = ImmutableArray.Create(rewrittenArguments,
(underlyingTupleTypeChain.Count - 1) * (TupleTypeSymbol.RestPosition - 1),
TupleTypeSymbol.RestPosition - 1)
.Add(currentCreation);
MethodSymbol constructor = tuple8Ctor.AsMember(underlyingTupleTypeChain.Pop());
currentCreation = new BoundObjectCreationExpression(node.Syntax, constructor, ctorArguments);
}
while (underlyingTupleTypeChain.Count > 0);
}
return currentCreation;
}
finally
{
underlyingTupleTypeChain.Free();
}
}
/// <summary>
/// Converts the expression for creating a tuple instance into an expression creating a ValueTuple (if short) or nested ValueTuples (if longer).
///
/// For instance, for a long tuple we'll generate:
/// creationExpression(ctor=largestCtor, args=firstArgs+(nested creationExpression for remainder, with smaller ctor and next few args))
/// </summary>
private BoundNode RewriteTupleCreationExpression(BoundTupleExpression node, ImmutableArray <BoundExpression> rewrittenArguments)
{
NamedTypeSymbol underlyingTupleType = node.Type.TupleUnderlyingType;
ArrayBuilder <NamedTypeSymbol> underlyingTupleTypeChain = ArrayBuilder <NamedTypeSymbol> .GetInstance();
TupleTypeSymbol.GetUnderlyingTypeChain(underlyingTupleType, underlyingTupleTypeChain);
try
{
// make a creation expression for the smallest type
NamedTypeSymbol smallestType = underlyingTupleTypeChain.Pop();
ImmutableArray <BoundExpression> smallestCtorArguments = ImmutableArray.Create(rewrittenArguments,
underlyingTupleTypeChain.Count * (TupleTypeSymbol.RestPosition - 1),
smallestType.Arity);
var smallestCtor = (MethodSymbol)TupleTypeSymbol.GetWellKnownMemberInType(smallestType.OriginalDefinition,
TupleTypeSymbol.GetTupleCtor(smallestType.Arity),
_diagnostics,
node.Syntax);
if ((object)smallestCtor == null)
{
return(node);
}
MethodSymbol smallestConstructor = smallestCtor.AsMember(smallestType);
BoundObjectCreationExpression currentCreation = new BoundObjectCreationExpression(node.Syntax, smallestConstructor, smallestCtorArguments);
if (underlyingTupleTypeChain.Count > 0)
{
NamedTypeSymbol tuple8Type = underlyingTupleTypeChain.Peek();
var tuple8Ctor = (MethodSymbol)TupleTypeSymbol.GetWellKnownMemberInType(tuple8Type.OriginalDefinition,
TupleTypeSymbol.GetTupleCtor(TupleTypeSymbol.RestPosition),
_diagnostics,
node.Syntax);
if ((object)tuple8Ctor == null)
{
return(node);
}
// make successively larger creation expressions containing the previous one
do
{
ImmutableArray <BoundExpression> ctorArguments = ImmutableArray.Create(rewrittenArguments,
(underlyingTupleTypeChain.Count - 1) * (TupleTypeSymbol.RestPosition - 1),
TupleTypeSymbol.RestPosition - 1)
.Add(currentCreation);
MethodSymbol constructor = tuple8Ctor.AsMember(underlyingTupleTypeChain.Pop());
currentCreation = new BoundObjectCreationExpression(node.Syntax, constructor, ctorArguments);
}while (underlyingTupleTypeChain.Count > 0);
}
return(currentCreation);
}
finally
{
underlyingTupleTypeChain.Free();
}
}
public override BoundNode VisitObjectCreationExpression(BoundObjectCreationExpression node)
{
Debug.Assert(node.InitializerExpressionOpt == null);
BoundSpillSequenceBuilder builder = null;
var arguments = this.VisitExpressionList(ref builder, node.Arguments, node.ArgumentRefKindsOpt);
return(UpdateExpression(builder, node.Update(node.Constructor, arguments, node.ArgumentNamesOpt, node.ArgumentRefKindsOpt, node.Expanded, node.ArgsToParamsOpt, node.ConstantValueOpt, node.InitializerExpressionOpt, node.BinderOpt, node.Type)));
}
public override BoundNode VisitFromEndIndexExpression(BoundFromEndIndexExpression node)
{
Debug.Assert(node.MethodOpt != null);
NamedTypeSymbol booleanType = _compilation.GetSpecialType(SpecialType.System_Boolean);
BoundExpression fromEnd = MakeLiteral(node.Syntax, ConstantValue.Create(true), booleanType);
BoundExpression operand = VisitExpression(node.Operand);
if (NullableNeverHasValue(operand))
{
operand = new BoundDefaultExpression(operand.Syntax, operand.Type !.GetNullableUnderlyingType());
}
operand = NullableAlwaysHasValue(operand) ?? operand;
if (!node.Type.IsNullableType())
{
return(new BoundObjectCreationExpression(node.Syntax, node.MethodOpt, operand, fromEnd));
}
ArrayBuilder <BoundExpression> sideeffects = ArrayBuilder <BoundExpression> .GetInstance();
ArrayBuilder <LocalSymbol> locals = ArrayBuilder <LocalSymbol> .GetInstance();
// operand.HasValue
operand = CaptureExpressionInTempIfNeeded(operand, sideeffects, locals);
BoundExpression condition = MakeOptimizedHasValue(operand.Syntax, operand);
// new Index(operand, fromEnd: true)
BoundExpression boundOperandGetValueOrDefault = MakeOptimizedGetValueOrDefault(operand.Syntax, operand);
BoundExpression indexCreation = new BoundObjectCreationExpression(node.Syntax, node.MethodOpt, boundOperandGetValueOrDefault, fromEnd);
// new Nullable(new Index(operand, fromEnd: true))
BoundExpression consequence = ConvertToNullable(node.Syntax, node.Type, indexCreation);
// default
BoundExpression alternative = new BoundDefaultExpression(node.Syntax, node.Type);
// operand.HasValue ? new Nullable(new Index(operand, fromEnd: true)) : default
BoundExpression conditionalExpression = RewriteConditionalOperator(
syntax: node.Syntax,
rewrittenCondition: condition,
rewrittenConsequence: consequence,
rewrittenAlternative: alternative,
constantValueOpt: null,
rewrittenType: node.Type,
isRef: false);
return(new BoundSequence(
syntax: node.Syntax,
locals: locals.ToImmutableAndFree(),
sideEffects: sideeffects.ToImmutableAndFree(),
value: conditionalExpression,
type: node.Type));
}
public override BoundNode?VisitObjectCreationExpression(BoundObjectCreationExpression node)
{
// perhaps we are passing a variable by ref and mutating it that way
if (!node.ArgumentRefKindsOpt.IsDefault)
{
_mightAssignSomething = true;
}
else
{
base.VisitObjectCreationExpression(node);
}
return(null);
}
public override BoundNode VisitObjectCreationExpression(BoundObjectCreationExpression node)
{
base.VisitObjectCreationExpression(node);
HashSet <DiagnosticInfo> useSiteDiagnostics = null;
if (Conversions.IsBaseInterface(IDisposableType, node.Type, ref useSiteDiagnostics))
{
if (!this.State.possiblyUndisposedCreations.Add(node) && reported.Add(node.Syntax))
{
Diagnostics.Add(ErrorCode.WRN_CA2000_DisposeObjectsBeforeLosingScope1, node.Syntax.Location, node.Type);
}
return(node);
}
return(null);
}
private BoundExpression GetDefaultParameterSpecial(CSharpSyntaxNode syntax, ParameterSymbol parameter)
{
// We have a call to a method M([Optional] object x) which omits the argument. The value we generate
// for the argument depends on the presence or absence of other attributes. The rules are:
//
// * If the parameter is marked as [MarshalAs(Interface)], [MarshalAs(IUnknown)] or [MarshalAs(IDispatch)]
// then the argument is null.
// * Otherwise, if the parameter is marked as [IUnknownConstant] then the argument is
// new UnknownWrapper(null)
// * Otherwise, if the parameter is marked as [IDispatchConstant] then the argument is
// new DispatchWrapper(null)
// * Otherwise, the argument is Type.Missing.
BoundExpression defaultValue;
if (parameter.IsMarshalAsObject)
{
// default(object)
defaultValue = new BoundDefaultOperator(syntax, parameter.Type);
}
else if (parameter.IsIUnknownConstant)
{
// new UnknownWrapper(default(object))
var methodSymbol = (MethodSymbol)this.compilation.GetWellKnownTypeMember(WellKnownMember.System_Runtime_InteropServices_UnknownWrapper__ctor);
var argument = new BoundDefaultOperator(syntax, parameter.Type);
defaultValue = new BoundObjectCreationExpression(syntax, methodSymbol, argument);
}
else if (parameter.IsIDispatchConstant)
{
// new DispatchWrapper(default(object))
var methodSymbol = (MethodSymbol)this.compilation.GetWellKnownTypeMember(WellKnownMember.System_Runtime_InteropServices_DispatchWrapper__ctor);
var argument = new BoundDefaultOperator(syntax, parameter.Type);
defaultValue = new BoundObjectCreationExpression(syntax, methodSymbol, argument);
}
else
{
// Type.Missing
var fieldSymbol = (FieldSymbol)compilation.GetWellKnownTypeMember(WellKnownMember.System_Type__Missing);
defaultValue = new BoundFieldAccess(syntax, null, fieldSymbol, ConstantValue.NotAvailable);
}
defaultValue = MakeConversion(defaultValue, parameter.Type, @checked: false);
return(defaultValue);
}
private BoundExpression GetLiftedUnaryOperatorConsequence(UnaryOperatorKind kind, SyntaxNode syntax, MethodSymbol method, TypeSymbol type, BoundExpression nonNullOperand)
{
MethodSymbol ctor = UnsafeGetNullableMethod(syntax, type, SpecialMember.System_Nullable_T__ctor);
// OP(temp.GetValueOrDefault())
BoundExpression unliftedOp = MakeUnaryOperator(
oldNode: null,
kind: kind.Unlifted(),
syntax: syntax,
method: method,
loweredOperand: nonNullOperand,
type: type.GetNullableUnderlyingType());
// new R?(OP(temp.GetValueOrDefault()))
BoundExpression consequence = new BoundObjectCreationExpression(
syntax,
ctor,
unliftedOp);
return(consequence);
}
public override BoundNode VisitObjectCreationExpression(BoundObjectCreationExpression node)
{
ReadOnlyArray <BoundExpression> arguments = (ReadOnlyArray <BoundExpression>) this.VisitList(node.Arguments);
BoundExpression initializerExpressionOpt = (BoundExpression)this.Visit(node.InitializerExpressionOpt);
TypeSymbol type = this.VisitType(node.Type);
if (!RequiresSpill(arguments) && (initializerExpressionOpt == null || initializerExpressionOpt.Kind != BoundKind.SpillSequence))
{
return(node.Update(node.Constructor, arguments, node.ArgumentNamesOpt, node.ArgumentRefKindsOpt, node.Expanded, node.ArgsToParamsOpt, node.ConstantValueOpt, initializerExpressionOpt, type));
}
var spillBuilder = new SpillBuilder();
ReadOnlyArray <BoundExpression> newArguments = SpillExpressionList(spillBuilder, arguments);
BoundExpression newInitializerExpressionOpt;
if (initializerExpressionOpt != null && initializerExpressionOpt.Kind == BoundKind.SpillSequence)
{
var spill = (BoundSpillSequence)initializerExpressionOpt;
spillBuilder.AddSpill(spill);
newInitializerExpressionOpt = spill.Value;
}
else
{
newInitializerExpressionOpt = initializerExpressionOpt;
}
BoundObjectCreationExpression newObjectCreation = node.Update(
node.Constructor,
newArguments,
node.ArgumentNamesOpt,
node.ArgumentRefKindsOpt,
node.Expanded,
node.ArgsToParamsOpt,
node.ConstantValueOpt,
newInitializerExpressionOpt,
type);
return(spillBuilder.BuildSequenceAndFree(F, newObjectCreation));
}
private BoundExpression MakeLiftedDecimalIncDecOperator(SyntaxNode syntax, BinaryOperatorKind oper, BoundExpression operand)
{
Debug.Assert(operand.Type.IsNullableType() && operand.Type.GetNullableUnderlyingType().SpecialType == SpecialType.System_Decimal);
// This method assumes that operand is already a temporary and so there is no need to copy it again.
MethodSymbol method = GetDecimalIncDecOperator(oper);
MethodSymbol getValueOrDefault = UnsafeGetNullableMethod(syntax, operand.Type, SpecialMember.System_Nullable_T_GetValueOrDefault);
MethodSymbol ctor = UnsafeGetNullableMethod(syntax, operand.Type, SpecialMember.System_Nullable_T__ctor);
// x.HasValue
BoundExpression condition = MakeNullableHasValue(syntax, operand);
// x.GetValueOrDefault()
BoundExpression getValueCall = BoundCall.Synthesized(syntax, operand, getValueOrDefault);
// op_Inc(x.GetValueOrDefault())
BoundExpression methodCall = BoundCall.Synthesized(syntax, null, method, getValueCall);
// new decimal?(op_Inc(x.GetValueOrDefault()))
BoundExpression consequence = new BoundObjectCreationExpression(syntax, ctor, methodCall);
// default(decimal?)
BoundExpression alternative = new BoundDefaultOperator(syntax, null, operand.Type);
// x.HasValue ? new decimal?(op_Inc(x.GetValueOrDefault())) : default(decimal?)
return(RewriteConditionalOperator(syntax, condition, consequence, alternative, ConstantValue.NotAvailable, operand.Type));
}
public override BoundNode VisitRangeExpression(BoundRangeExpression node)
{
Debug.Assert(node != null && node.MethodOpt != null);
bool needLifting = false;
var F = _factory;
var left = node.LeftOperand;
if (left != null)
{
left = tryOptimizeOperand(left);
}
else
{
left = newIndexZero(fromEnd: false);
}
var right = node.RightOperand;
if (right != null)
{
right = tryOptimizeOperand(right);
}
else
{
right = newIndexZero(fromEnd: true);
}
var operands = ImmutableArray.Create(left, right);
if (needLifting)
{
return(LiftRangeExpression(node, operands));
}
else
{
BoundExpression rangeCreation = new BoundObjectCreationExpression(
node.Syntax,
node.MethodOpt,
binderOpt: null,
operands);
if (node.Type.IsNullableType())
{
if (!TryGetNullableMethod(node.Syntax, node.Type, SpecialMember.System_Nullable_T__ctor, out MethodSymbol nullableCtor))
{
return(BadExpression(node.Syntax, node.Type, node));
}
return(new BoundObjectCreationExpression(node.Syntax, nullableCtor, binderOpt: null, rangeCreation));
}
return(rangeCreation);
}
BoundExpression newIndexZero(bool fromEnd) =>
// new Index(0, fromEnd: fromEnd)
F.New(
WellKnownMember.System_Index__ctor,
ImmutableArray.Create <BoundExpression>(F.Literal(0), F.Literal(fromEnd)));
BoundExpression tryOptimizeOperand(BoundExpression operand)
{
Debug.Assert(operand != null);
operand = VisitExpression(operand);
if (NullableNeverHasValue(operand))
{
operand = new BoundDefaultExpression(operand.Syntax, operand.Type.GetNullableUnderlyingType());
}
else
{
operand = NullableAlwaysHasValue(operand) ?? operand;
if (operand.Type.IsNullableType())
{
needLifting = true;
}
}
return(operand);
}
}
public override BoundNode VisitObjectCreationExpression(BoundObjectCreationExpression node)
{
Debug.Assert(node != null);
// Rewrite the arguments.
// NOTE: We may need additional argument rewriting such as generating a params array,
// re-ordering arguments based on argsToParamsOpt map, inserting arguments for optional parameters, etc.
// NOTE: This is done later by MakeArguments, for now we just lower each argument.
var rewrittenArguments = VisitList(node.Arguments);
// We have already lowered each argument, but we may need some additional rewriting for the arguments,
// such as generating a params array, re-ordering arguments based on argsToParamsOpt map, inserting arguments for optional parameters, etc.
ImmutableArray<LocalSymbol> temps;
ImmutableArray<RefKind> argumentRefKindsOpt = node.ArgumentRefKindsOpt;
rewrittenArguments = MakeArguments(node.Syntax, rewrittenArguments, node.Constructor, node.Constructor, node.Expanded, node.ArgsToParamsOpt, ref argumentRefKindsOpt, out temps);
BoundExpression rewrittenObjectCreation;
if (_inExpressionLambda)
{
if (!temps.IsDefaultOrEmpty)
{
throw ExceptionUtilities.UnexpectedValue(temps.Length);
}
rewrittenObjectCreation = node.UpdateArgumentsAndInitializer(rewrittenArguments, MakeObjectCreationInitializerForExpressionTree(node.InitializerExpressionOpt), changeTypeOpt: node.Constructor.ContainingType);
if (node.Type.IsInterfaceType())
{
Debug.Assert(rewrittenObjectCreation.Type == ((NamedTypeSymbol)node.Type).ComImportCoClass);
rewrittenObjectCreation = MakeConversion(rewrittenObjectCreation, node.Type, false, false);
}
return rewrittenObjectCreation;
}
rewrittenObjectCreation = node.UpdateArgumentsAndInitializer(rewrittenArguments, newInitializerExpression: null, changeTypeOpt: node.Constructor.ContainingType);
// replace "new S()" with a default struct ctor with "default(S)"
if (node.Constructor.IsDefaultValueTypeConstructor())
{
rewrittenObjectCreation = new BoundDefaultOperator(rewrittenObjectCreation.Syntax, rewrittenObjectCreation.Type);
}
if (!temps.IsDefaultOrEmpty)
{
rewrittenObjectCreation = new BoundSequence(
node.Syntax,
temps,
ImmutableArray<BoundExpression>.Empty,
rewrittenObjectCreation,
node.Type);
}
if (node.Type.IsInterfaceType())
{
Debug.Assert(rewrittenObjectCreation.Type == ((NamedTypeSymbol)node.Type).ComImportCoClass);
rewrittenObjectCreation = MakeConversion(rewrittenObjectCreation, node.Type, false, false);
}
if (node.InitializerExpressionOpt == null || node.InitializerExpressionOpt.HasErrors)
{
return rewrittenObjectCreation;
}
return MakeObjectCreationWithInitializer(node.Syntax, rewrittenObjectCreation, node.InitializerExpressionOpt, node.Type);
}
private BoundExpression VisitObjectCreationExpression(BoundObjectCreationExpression node)
{
return(VisitObjectCreationContinued(VisitObjectCreationExpressionInternal(node), node.InitializerExpressionOpt));
}
private BoundExpression MakeTupleCreationExpression(SyntaxNode syntax, NamedTypeSymbol type, ImmutableArray<BoundExpression> rewrittenArguments)
{
NamedTypeSymbol underlyingTupleType = type.TupleUnderlyingType ?? type;
Debug.Assert(underlyingTupleType.IsTupleCompatible());
ArrayBuilder<NamedTypeSymbol> underlyingTupleTypeChain = ArrayBuilder<NamedTypeSymbol>.GetInstance();
TupleTypeSymbol.GetUnderlyingTypeChain(underlyingTupleType, underlyingTupleTypeChain);
try
{
// make a creation expression for the smallest type
NamedTypeSymbol smallestType = underlyingTupleTypeChain.Pop();
ImmutableArray<BoundExpression> smallestCtorArguments = ImmutableArray.Create(rewrittenArguments,
underlyingTupleTypeChain.Count * (TupleTypeSymbol.RestPosition - 1),
smallestType.Arity);
var smallestCtor = (MethodSymbol)TupleTypeSymbol.GetWellKnownMemberInType(smallestType.OriginalDefinition,
TupleTypeSymbol.GetTupleCtor(smallestType.Arity),
_diagnostics,
syntax);
if ((object)smallestCtor == null)
{
return _factory.BadExpression(type);
}
MethodSymbol smallestConstructor = smallestCtor.AsMember(smallestType);
BoundObjectCreationExpression currentCreation = new BoundObjectCreationExpression(syntax, smallestConstructor, smallestCtorArguments);
if (underlyingTupleTypeChain.Count > 0)
{
NamedTypeSymbol tuple8Type = underlyingTupleTypeChain.Peek();
var tuple8Ctor = (MethodSymbol)TupleTypeSymbol.GetWellKnownMemberInType(tuple8Type.OriginalDefinition,
TupleTypeSymbol.GetTupleCtor(TupleTypeSymbol.RestPosition),
_diagnostics,
syntax);
if ((object)tuple8Ctor == null)
{
return _factory.BadExpression(type);
}
// make successively larger creation expressions containing the previous one
do
{
ImmutableArray<BoundExpression> ctorArguments = ImmutableArray.Create(rewrittenArguments,
(underlyingTupleTypeChain.Count - 1) * (TupleTypeSymbol.RestPosition - 1),
TupleTypeSymbol.RestPosition - 1)
.Add(currentCreation);
MethodSymbol constructor = tuple8Ctor.AsMember(underlyingTupleTypeChain.Pop());
currentCreation = new BoundObjectCreationExpression(syntax, constructor, ctorArguments);
}
while (underlyingTupleTypeChain.Count > 0);
}
currentCreation = currentCreation.Update(
currentCreation.Constructor,
currentCreation.Arguments,
currentCreation.ArgumentNamesOpt,
currentCreation.ArgumentRefKindsOpt,
currentCreation.Expanded,
currentCreation.ArgsToParamsOpt,
currentCreation.ConstantValue,
currentCreation.InitializerExpressionOpt,
type);
return currentCreation;
}
finally
{
underlyingTupleTypeChain.Free();
}
}
private BoundExpression MakeBuiltInIncrementOperator(BoundIncrementOperator node, BoundExpression rewrittenValueToIncrement)
{
BoundExpression result;
// If we have a built-in increment or decrement then things get a bit trickier. Suppose for example we have
// a user-defined conversion from X to short and from short to X, but no user-defined increment operator on
// X. The increment portion of "++x" is then: (X)(short)((int)(short)x + 1). That is, first x must be
// converted to short via an implicit user- defined conversion, then to int via an implicit numeric
// conversion, then the addition is performed in integers. The resulting integer is converted back to short,
// and then the short is converted to X.
// This is the input and output type of the unary increment operator we're going to call.
// That is, "short" in the example above.
TypeSymbol unaryOperandType = GetUnaryOperatorType(node);
// This is the kind of binary operator that we're going to realize the unary operator
// as. That is, "int + int --> int" in the example above.
BinaryOperatorKind binaryOperatorKind = GetCorrespondingBinaryOperator(node);
binaryOperatorKind |= IsIncrement(node) ? BinaryOperatorKind.Addition : BinaryOperatorKind.Subtraction;
// The "1" in the example above.
ConstantValue constantOne = GetConstantOneForBinOp(binaryOperatorKind);
Debug.Assert(constantOne != null);
Debug.Assert(constantOne.SpecialType != SpecialType.None);
Debug.Assert(binaryOperatorKind.OperandTypes() != 0);
// The input/output type of the binary operand. "int" in the example.
TypeSymbol binaryOperandType = _compilation.GetSpecialType(constantOne.SpecialType);
// 1
BoundExpression boundOne = MakeLiteral(
syntax: node.Syntax,
constantValue: constantOne,
type: binaryOperandType);
if (binaryOperatorKind.IsLifted())
{
binaryOperandType = _compilation.GetSpecialType(SpecialType.System_Nullable_T).Construct(binaryOperandType);
MethodSymbol ctor = UnsafeGetNullableMethod(node.Syntax, binaryOperandType, SpecialMember.System_Nullable_T__ctor);
boundOne = new BoundObjectCreationExpression(node.Syntax, ctor, boundOne);
}
// Now we construct the other operand to the binary addition. We start with just plain "x".
BoundExpression binaryOperand = rewrittenValueToIncrement;
bool @checked = node.OperatorKind.IsChecked();
// If we need to make a conversion from the original operand type to the operand type of the
// underlying increment operation, do it now.
if (!node.OperandConversion.IsIdentity)
{
// (short)x
binaryOperand = MakeConversionNode(
syntax: node.Syntax,
rewrittenOperand: binaryOperand,
conversion: node.OperandConversion,
rewrittenType: unaryOperandType,
@checked: @checked);
}
// Early-out for pointer increment - we don't need to convert the operands to a common type.
if (node.OperatorKind.OperandTypes() == UnaryOperatorKind.Pointer)
{
Debug.Assert(binaryOperatorKind.OperandTypes() == BinaryOperatorKind.PointerAndInt);
Debug.Assert(binaryOperand.Type.IsPointerType());
Debug.Assert(boundOne.Type.SpecialType == SpecialType.System_Int32);
return(MakeBinaryOperator(node.Syntax, binaryOperatorKind, binaryOperand, boundOne, binaryOperand.Type, method: null));
}
// If we need to make a conversion from the unary operator type to the binary operator type,
// do it now.
// (int)(short)x
binaryOperand = MakeConversionNode(binaryOperand, binaryOperandType, @checked);
// Perform the addition.
// (int)(short)x + 1
BoundExpression binOp;
if (unaryOperandType.SpecialType == SpecialType.System_Decimal)
{
binOp = MakeDecimalIncDecOperator(node.Syntax, binaryOperatorKind, binaryOperand);
}
else if (unaryOperandType.IsNullableType() && unaryOperandType.GetNullableUnderlyingType().SpecialType == SpecialType.System_Decimal)
{
binOp = MakeLiftedDecimalIncDecOperator(node.Syntax, binaryOperatorKind, binaryOperand);
}
else
{
binOp = MakeBinaryOperator(node.Syntax, binaryOperatorKind, binaryOperand, boundOne, binaryOperandType, method: null);
}
// Generate the conversion back to the type of the unary operator.
// (short)((int)(short)x + 1)
result = MakeConversionNode(binOp, unaryOperandType, @checked);
return(result);
}
private BoundExpression GetDefaultParameterValue(CSharpSyntaxNode syntax, ParameterSymbol parameter)
{
TypeSymbol parameterType = parameter.Type;
ConstantValue defaultConstantValue = parameter.ExplicitDefaultConstantValue;
BoundExpression defaultValue;
SourceLocation callerSourceLocation;
if (parameter.IsCallerLineNumber && ((callerSourceLocation = GetCallerLocation(syntax)) != null))
{
int line = callerSourceLocation.SourceTree.GetDisplayLineNumber(callerSourceLocation.SourceSpan);
BoundExpression lineLiteral = MakeLiteral(syntax, ConstantValue.Create(line), compilation.GetSpecialType(SpecialType.System_Int32));
if (parameterType.IsNullableType())
{
defaultValue = MakeConversion(lineLiteral, parameterType.GetNullableUnderlyingType(), false);
// wrap it in a nullable ctor.
defaultValue = new BoundObjectCreationExpression(
syntax,
GetNullableMethod(syntax, parameterType, SpecialMember.System_Nullable_T__ctor),
defaultValue);
}
else
{
defaultValue = MakeConversion(lineLiteral, parameterType, false);
}
}
else if (parameter.IsCallerFilePath && ((callerSourceLocation = GetCallerLocation(syntax)) != null))
{
string path = callerSourceLocation.SourceTree.GetDisplayPath(callerSourceLocation.SourceSpan, compilation.Options.SourceReferenceResolver);
BoundExpression memberNameLiteral = MakeLiteral(syntax, ConstantValue.Create(path), compilation.GetSpecialType(SpecialType.System_String));
defaultValue = MakeConversion(memberNameLiteral, parameterType, false);
}
else if (parameter.IsCallerMemberName && ((callerSourceLocation = GetCallerLocation(syntax)) != null))
{
string memberName = this.factory.TopLevelMethod.GetMemberCallerName();
BoundExpression memberNameLiteral = MakeLiteral(syntax, ConstantValue.Create(memberName), compilation.GetSpecialType(SpecialType.System_String));
defaultValue = MakeConversion(memberNameLiteral, parameterType, false);
}
else if (defaultConstantValue == ConstantValue.NotAvailable)
{
// There is no constant value given for the parameter in source/metadata.
if (parameterType.IsDynamic() || parameterType.SpecialType == SpecialType.System_Object)
{
// We have something like M([Optional] object x). We have special handling for such situations.
defaultValue = GetDefaultParameterSpecial(syntax, parameter);
}
else
{
// The argument to M([Optional] int x) becomes default(int)
defaultValue = new BoundDefaultOperator(syntax, parameterType);
}
}
else if (defaultConstantValue.IsNull && parameterType.IsValueType)
{
// We have something like M(int? x = null) or M(S x = default(S)),
// so replace the argument with default(int?).
defaultValue = new BoundDefaultOperator(syntax, parameterType);
}
else if (parameterType.IsNullableType())
{
// We have something like M(double? x = 1.23), so replace the argument
// with new double?(1.23).
TypeSymbol constantType = compilation.GetSpecialType(defaultConstantValue.SpecialType);
defaultValue = MakeLiteral(syntax, defaultConstantValue, constantType);
// The parameter's underlying type might not match the constant type. For example, we might have
// a default value of 5 (an integer) but a parameter type of decimal?.
defaultValue = MakeConversion(defaultValue, parameterType.GetNullableUnderlyingType(), @checked: false, acceptFailingConversion: true);
// Finally, wrap it in a nullable ctor.
defaultValue = new BoundObjectCreationExpression(
syntax,
GetNullableMethod(syntax, parameterType, SpecialMember.System_Nullable_T__ctor),
defaultValue);
}
else if (defaultConstantValue.IsNull || defaultConstantValue.IsBad)
{
defaultValue = MakeLiteral(syntax, defaultConstantValue, parameterType);
}
else
{
// We have something like M(double = 1.23), so replace the argument with 1.23.
TypeSymbol constantType = compilation.GetSpecialType(defaultConstantValue.SpecialType);
defaultValue = MakeLiteral(syntax, defaultConstantValue, constantType);
// The parameter type might not match the constant type.
defaultValue = MakeConversion(defaultValue, parameterType, @checked: false, acceptFailingConversion: true);
}
return(defaultValue);
}
private BoundExpression VisitObjectCreationExpression(BoundObjectCreationExpression node)
{
return VisitObjectCreationContinued(VisitObjectCreationExpressionInternal(node), node.InitializerExpressionOpt);
}
private BoundExpression GetDefaultParameterValue(CSharpSyntaxNode syntax, ParameterSymbol parameter)
{
TypeSymbol parameterType = parameter.Type;
ConstantValue defaultConstantValue = parameter.ExplicitDefaultConstantValue;
BoundExpression defaultValue;
SourceLocation callerSourceLocation;
if (parameter.IsCallerLineNumber && ((callerSourceLocation = GetCallerLocation(syntax)) != null))
{
int line = callerSourceLocation.SourceTree.GetDisplayLineNumber(callerSourceLocation.SourceSpan);
BoundExpression lineLiteral = MakeLiteral(syntax, ConstantValue.Create(line), compilation.GetSpecialType(SpecialType.System_Int32));
if (parameterType.IsNullableType())
{
defaultValue = MakeConversion(lineLiteral, parameterType.GetNullableUnderlyingType(), false);
// wrap it in a nullable ctor.
defaultValue = new BoundObjectCreationExpression(
syntax,
GetNullableMethod(syntax, parameterType, SpecialMember.System_Nullable_T__ctor),
defaultValue);
}
else
{
defaultValue = MakeConversion(lineLiteral, parameterType, false);
}
}
else if (parameter.IsCallerFilePath && ((callerSourceLocation = GetCallerLocation(syntax)) != null))
{
string path = callerSourceLocation.SourceTree.GetDisplayPath(callerSourceLocation.SourceSpan, compilation.Options.SourceReferenceResolver);
BoundExpression memberNameLiteral = MakeLiteral(syntax, ConstantValue.Create(path), compilation.GetSpecialType(SpecialType.System_String));
defaultValue = MakeConversion(memberNameLiteral, parameterType, false);
}
else if (parameter.IsCallerMemberName && ((callerSourceLocation = GetCallerLocation(syntax)) != null))
{
string memberName = this.factory.TopLevelMethod.GetMemberCallerName();
BoundExpression memberNameLiteral = MakeLiteral(syntax, ConstantValue.Create(memberName), compilation.GetSpecialType(SpecialType.System_String));
defaultValue = MakeConversion(memberNameLiteral, parameterType, false);
}
else if (defaultConstantValue == ConstantValue.NotAvailable)
{
// There is no constant value given for the parameter in source/metadata.
if (parameterType.IsDynamic() || parameterType.SpecialType == SpecialType.System_Object)
{
// We have something like M([Optional] object x). We have special handling for such situations.
defaultValue = GetDefaultParameterSpecial(syntax, parameter);
}
else
{
// The argument to M([Optional] int x) becomes default(int)
defaultValue = new BoundDefaultOperator(syntax, parameterType);
}
}
else if (defaultConstantValue.IsNull && parameterType.IsValueType)
{
// We have something like M(int? x = null) or M(S x = default(S)),
// so replace the argument with default(int?).
defaultValue = new BoundDefaultOperator(syntax, parameterType);
}
else if (parameterType.IsNullableType())
{
// We have something like M(double? x = 1.23), so replace the argument
// with new double?(1.23).
TypeSymbol constantType = compilation.GetSpecialType(defaultConstantValue.SpecialType);
defaultValue = MakeLiteral(syntax, defaultConstantValue, constantType);
// The parameter's underlying type might not match the constant type. For example, we might have
// a default value of 5 (an integer) but a parameter type of decimal?.
defaultValue = MakeConversion(defaultValue, parameterType.GetNullableUnderlyingType(), @checked: false, acceptFailingConversion: true);
// Finally, wrap it in a nullable ctor.
defaultValue = new BoundObjectCreationExpression(
syntax,
GetNullableMethod(syntax, parameterType, SpecialMember.System_Nullable_T__ctor),
defaultValue);
}
else if (defaultConstantValue.IsNull || defaultConstantValue.IsBad)
{
defaultValue = MakeLiteral(syntax, defaultConstantValue, parameterType);
}
else
{
// We have something like M(double = 1.23), so replace the argument with 1.23.
TypeSymbol constantType = compilation.GetSpecialType(defaultConstantValue.SpecialType);
defaultValue = MakeLiteral(syntax, defaultConstantValue, constantType);
// The parameter type might not match the constant type.
defaultValue = MakeConversion(defaultValue, parameterType, @checked: false, acceptFailingConversion: true);
}
return defaultValue;
}
private BoundExpression MakeTupleCreationExpression(SyntaxNode syntax, NamedTypeSymbol type, ImmutableArray <BoundExpression> rewrittenArguments)
{
NamedTypeSymbol underlyingTupleType = type.TupleUnderlyingType ?? type;
Debug.Assert(underlyingTupleType.IsTupleCompatible());
ArrayBuilder <NamedTypeSymbol> underlyingTupleTypeChain = ArrayBuilder <NamedTypeSymbol> .GetInstance();
TupleTypeSymbol.GetUnderlyingTypeChain(underlyingTupleType, underlyingTupleTypeChain);
try
{
// make a creation expression for the smallest type
NamedTypeSymbol smallestType = underlyingTupleTypeChain.Pop();
ImmutableArray <BoundExpression> smallestCtorArguments = ImmutableArray.Create(rewrittenArguments,
underlyingTupleTypeChain.Count * (TupleTypeSymbol.RestPosition - 1),
smallestType.Arity);
var smallestCtor = (MethodSymbol)TupleTypeSymbol.GetWellKnownMemberInType(smallestType.OriginalDefinition,
TupleTypeSymbol.GetTupleCtor(smallestType.Arity),
_diagnostics,
syntax);
if ((object)smallestCtor == null)
{
return(_factory.BadExpression(type));
}
MethodSymbol smallestConstructor = smallestCtor.AsMember(smallestType);
BoundObjectCreationExpression currentCreation = new BoundObjectCreationExpression(syntax, smallestConstructor, null, smallestCtorArguments);
if (underlyingTupleTypeChain.Count > 0)
{
NamedTypeSymbol tuple8Type = underlyingTupleTypeChain.Peek();
var tuple8Ctor = (MethodSymbol)TupleTypeSymbol.GetWellKnownMemberInType(tuple8Type.OriginalDefinition,
TupleTypeSymbol.GetTupleCtor(TupleTypeSymbol.RestPosition),
_diagnostics,
syntax);
if ((object)tuple8Ctor == null)
{
return(_factory.BadExpression(type));
}
// make successively larger creation expressions containing the previous one
do
{
ImmutableArray <BoundExpression> ctorArguments = ImmutableArray.Create(rewrittenArguments,
(underlyingTupleTypeChain.Count - 1) * (TupleTypeSymbol.RestPosition - 1),
TupleTypeSymbol.RestPosition - 1)
.Add(currentCreation);
MethodSymbol constructor = tuple8Ctor.AsMember(underlyingTupleTypeChain.Pop());
currentCreation = new BoundObjectCreationExpression(syntax, constructor, null, ctorArguments);
}while (underlyingTupleTypeChain.Count > 0);
}
currentCreation = currentCreation.Update(
currentCreation.Constructor,
currentCreation.Arguments,
currentCreation.ArgumentNamesOpt,
currentCreation.ArgumentRefKindsOpt,
currentCreation.Expanded,
currentCreation.ArgsToParamsOpt,
currentCreation.ConstantValue,
currentCreation.InitializerExpressionOpt,
currentCreation.BinderOpt,
type);
return(currentCreation);
}
finally
{
underlyingTupleTypeChain.Free();
}
}
private BoundExpression LiftRangeExpression(BoundRangeExpression node, BoundExpression left, BoundExpression right)
{
Debug.Assert(node.Type.IsNullableType());
Debug.Assert(left?.Type.IsNullableType() == true || right?.Type.IsNullableType() == true);
Debug.Assert(!(left is null && right is null));
var sideeffects = ArrayBuilder <BoundExpression> .GetInstance();
var locals = ArrayBuilder <LocalSymbol> .GetInstance();
// makeRange(left.GetValueOrDefault(), right.GetValueOrDefault())
BoundExpression condition = null;
left = getIndexFromPossibleNullable(left);
right = getIndexFromPossibleNullable(right);
var rangeExpr = MakeRangeExpression(node.MethodOpt, left, right);
Debug.Assert(condition != null);
if (!TryGetNullableMethod(node.Syntax, node.Type, SpecialMember.System_Nullable_T__ctor, out MethodSymbol nullableCtor))
{
return(BadExpression(node.Syntax, node.Type, node));
}
// new Nullable(makeRange(left.GetValueOrDefault(), right.GetValueOrDefault()))
BoundExpression consequence = new BoundObjectCreationExpression(node.Syntax, nullableCtor, binderOpt: null, rangeExpr);
// default
BoundExpression alternative = new BoundDefaultExpression(node.Syntax, node.Type);
// left.HasValue && right.HasValue
// ? new Nullable(makeRange(left.GetValueOrDefault(), right.GetValueOrDefault()))
// : default
BoundExpression conditionalExpression = RewriteConditionalOperator(
syntax: node.Syntax,
rewrittenCondition: condition,
rewrittenConsequence: consequence,
rewrittenAlternative: alternative,
constantValueOpt: null,
rewrittenType: node.Type,
isRef: false);
return(new BoundSequence(
syntax: node.Syntax,
locals: locals.ToImmutableAndFree(),
sideEffects: sideeffects.ToImmutableAndFree(),
value: conditionalExpression,
type: node.Type));
BoundExpression getIndexFromPossibleNullable(BoundExpression arg)
{
if (arg is null)
{
return(null);
}
BoundExpression tempOperand = CaptureExpressionInTempIfNeeded(arg, sideeffects, locals);
if (tempOperand.Type.IsNullableType())
{
BoundExpression operandHasValue = MakeOptimizedHasValue(tempOperand.Syntax, tempOperand);
if (condition is null)
{
condition = operandHasValue;
}
else
{
TypeSymbol boolType = _compilation.GetSpecialType(SpecialType.System_Boolean);
condition = MakeBinaryOperator(node.Syntax, BinaryOperatorKind.BoolAnd, condition, operandHasValue, boolType, method: null);
}
return(MakeOptimizedGetValueOrDefault(tempOperand.Syntax, tempOperand));
}
else
{
return(tempOperand);
}
}
}
public override BoundNode VisitObjectCreationExpression(BoundObjectCreationExpression node)
{
VisitCall(node.Constructor, null, node.Arguments, node.ArgumentRefKindsOpt, node.ArgumentNamesOpt, node.Expanded, node);
return base.VisitObjectCreationExpression(node);
}
/// <summary>
/// Gets the default value for the <paramref name="parameter"/>.
/// </summary>
/// <param name="syntax">
/// A syntax node corresponding to the invocation.
/// </param>
/// <param name="parameter">
/// A parameter to get the default value for.
/// </param>
/// <param name="enableCallerInfo">
/// Indicates if caller info is to be enabled when processing this optional parameter.
/// The value <see cref="ThreeState.Unknown"/> means the decision is to be made based on the shape of the <paramref name="syntax"/> node.
/// </param>
/// <remarks>
/// DELIBERATE SPEC VIOLATION: When processing an implicit invocation of an <c>Add</c> method generated
/// for an element-initializer in a collection-initializer, the parameter <paramref name="enableCallerInfo"/>
/// is set to <see cref="ThreeState.True"/>. It means that if the optional parameter is annotated with <see cref="CallerLineNumberAttribute"/>,
/// <see cref="CallerFilePathAttribute"/> or <see cref="CallerMemberNameAttribute"/>, and there is no explicit argument corresponding to it,
/// we will provide caller information as a value of this parameter.
/// This is done to match the native compiler behavior and user requests (see http://roslyn.codeplex.com/workitem/171). This behavior
/// does not match the C# spec that currently requires to provide caller information only in explicit invocations and query expressions.
/// </remarks>
private BoundExpression GetDefaultParameterValue(SyntaxNode syntax, ParameterSymbol parameter, ThreeState enableCallerInfo)
{
// TODO: Ideally, the enableCallerInfo parameter would be of just bool type with only 'true' and 'false' values, and all callers
// explicitly provided one of those values, so that we do not rely on shape of syntax nodes in the rewriter. There are not many immediate callers,
// but often the immediate caller does not have the required information, so all possible call chains should be analyzed and possibly updated
// to pass this information, and this might be a big task. We should consider doing this when the time permits.
TypeSymbol parameterType = parameter.Type;
Debug.Assert(parameter.IsOptional);
ConstantValue defaultConstantValue = parameter.ExplicitDefaultConstantValue;
BoundExpression defaultValue;
SourceLocation callerSourceLocation;
// For compatibility with the native compiler we treat all bad imported constant
// values as default(T).
if (defaultConstantValue != null && defaultConstantValue.IsBad)
{
defaultConstantValue = ConstantValue.Null;
}
if (parameter.IsCallerLineNumber && ((callerSourceLocation = GetCallerLocation(syntax, enableCallerInfo)) != null))
{
int line = callerSourceLocation.SourceTree.GetDisplayLineNumber(callerSourceLocation.SourceSpan);
BoundExpression lineLiteral = MakeLiteral(syntax, ConstantValue.Create(line), _compilation.GetSpecialType(SpecialType.System_Int32));
if (parameterType.IsNullableType())
{
defaultValue = MakeConversionNode(lineLiteral, parameterType.GetNullableUnderlyingType(), false);
// wrap it in a nullable ctor.
defaultValue = new BoundObjectCreationExpression(
syntax,
GetNullableMethod(syntax, parameterType, SpecialMember.System_Nullable_T__ctor),
defaultValue);
}
else
{
defaultValue = MakeConversionNode(lineLiteral, parameterType, false);
}
}
else if (parameter.IsCallerFilePath && ((callerSourceLocation = GetCallerLocation(syntax, enableCallerInfo)) != null))
{
string path = callerSourceLocation.SourceTree.GetDisplayPath(callerSourceLocation.SourceSpan, _compilation.Options.SourceReferenceResolver);
BoundExpression memberNameLiteral = MakeLiteral(syntax, ConstantValue.Create(path), _compilation.GetSpecialType(SpecialType.System_String));
defaultValue = MakeConversionNode(memberNameLiteral, parameterType, false);
}
else if (parameter.IsCallerMemberName && ((callerSourceLocation = GetCallerLocation(syntax, enableCallerInfo)) != null))
{
string memberName;
switch (_factory.TopLevelMethod.MethodKind)
{
case MethodKind.Constructor:
case MethodKind.StaticConstructor:
// See if the code is actually part of a field, field-like event or property initializer and return the name of the corresponding member.
var memberDecl = syntax.Ancestors().OfType<MemberDeclarationSyntax>().FirstOrDefault();
if (memberDecl != null)
{
BaseFieldDeclarationSyntax fieldDecl;
if (memberDecl.Kind() == SyntaxKind.PropertyDeclaration)
{
var propDecl = (PropertyDeclarationSyntax)memberDecl;
EqualsValueClauseSyntax initializer = propDecl.Initializer;
if (initializer != null && initializer.Span.Contains(syntax.Span))
{
memberName = propDecl.Identifier.ValueText;
break;
}
}
else if ((fieldDecl = memberDecl as BaseFieldDeclarationSyntax) != null)
{
memberName = null;
foreach (VariableDeclaratorSyntax varDecl in fieldDecl.Declaration.Variables)
{
EqualsValueClauseSyntax initializer = varDecl.Initializer;
if (initializer != null && initializer.Span.Contains(syntax.Span))
{
memberName = varDecl.Identifier.ValueText;
break;
}
}
if (memberName != null)
{
break;
}
}
}
goto default;
default:
memberName = _factory.TopLevelMethod.GetMemberCallerName();
break;
}
BoundExpression memberNameLiteral = MakeLiteral(syntax, ConstantValue.Create(memberName), _compilation.GetSpecialType(SpecialType.System_String));
defaultValue = MakeConversionNode(memberNameLiteral, parameterType, false);
}
else if (defaultConstantValue == ConstantValue.NotAvailable)
{
// There is no constant value given for the parameter in source/metadata.
if (parameterType.IsDynamic() || parameterType.SpecialType == SpecialType.System_Object)
{
// We have something like M([Optional] object x). We have special handling for such situations.
defaultValue = GetDefaultParameterSpecial(syntax, parameter);
}
else
{
// The argument to M([Optional] int x) becomes default(int)
defaultValue = new BoundDefaultOperator(syntax, parameterType);
}
}
else if (defaultConstantValue.IsNull && parameterType.IsValueType)
{
// We have something like M(int? x = null) or M(S x = default(S)),
// so replace the argument with default(int?).
defaultValue = new BoundDefaultOperator(syntax, parameterType);
}
else if (parameterType.IsNullableType())
{
// We have something like M(double? x = 1.23), so replace the argument
// with new double?(1.23).
TypeSymbol constantType = _compilation.GetSpecialType(defaultConstantValue.SpecialType);
defaultValue = MakeLiteral(syntax, defaultConstantValue, constantType);
// The parameter's underlying type might not match the constant type. For example, we might have
// a default value of 5 (an integer) but a parameter type of decimal?.
defaultValue = MakeConversionNode(defaultValue, parameterType.GetNullableUnderlyingType(), @checked: false, acceptFailingConversion: true);
// Finally, wrap it in a nullable ctor.
defaultValue = new BoundObjectCreationExpression(
syntax,
GetNullableMethod(syntax, parameterType, SpecialMember.System_Nullable_T__ctor),
defaultValue);
}
else if (defaultConstantValue.IsNull || defaultConstantValue.IsBad)
{
defaultValue = MakeLiteral(syntax, defaultConstantValue, parameterType);
}
else
{
// We have something like M(double x = 1.23), so replace the argument with 1.23.
TypeSymbol constantType = _compilation.GetSpecialType(defaultConstantValue.SpecialType);
defaultValue = MakeLiteral(syntax, defaultConstantValue, constantType);
// The parameter type might not match the constant type.
defaultValue = MakeConversionNode(defaultValue, parameterType, @checked: false, acceptFailingConversion: true);
}
return defaultValue;
}
private BoundExpression GetDefaultParameterSpecial(SyntaxNode syntax, ParameterSymbol parameter)
{
// We have a call to a method M([Optional] object x) which omits the argument. The value we generate
// for the argument depends on the presence or absence of other attributes. The rules are:
//
// * If the parameter is marked as [MarshalAs(Interface)], [MarshalAs(IUnknown)] or [MarshalAs(IDispatch)]
// then the argument is null.
// * Otherwise, if the parameter is marked as [IUnknownConstant] then the argument is
// new UnknownWrapper(null)
// * Otherwise, if the parameter is marked as [IDispatchConstant] then the argument is
// new DispatchWrapper(null)
// * Otherwise, the argument is Type.Missing.
BoundExpression defaultValue;
if (parameter.IsMarshalAsObject)
{
// default(object)
defaultValue = new BoundDefaultOperator(syntax, parameter.Type);
}
else if (parameter.IsIUnknownConstant)
{
// new UnknownWrapper(default(object))
var methodSymbol = (MethodSymbol)_compilation.GetWellKnownTypeMember(WellKnownMember.System_Runtime_InteropServices_UnknownWrapper__ctor);
var argument = new BoundDefaultOperator(syntax, parameter.Type);
defaultValue = new BoundObjectCreationExpression(syntax, methodSymbol, argument);
}
else if (parameter.IsIDispatchConstant)
{
// new DispatchWrapper(default(object))
var methodSymbol = (MethodSymbol)_compilation.GetWellKnownTypeMember(WellKnownMember.System_Runtime_InteropServices_DispatchWrapper__ctor);
var argument = new BoundDefaultOperator(syntax, parameter.Type);
defaultValue = new BoundObjectCreationExpression(syntax, methodSymbol, argument);
}
else
{
// Type.Missing
var fieldSymbol = (FieldSymbol)_compilation.GetWellKnownTypeMember(WellKnownMember.System_Type__Missing);
defaultValue = new BoundFieldAccess(syntax, null, fieldSymbol, ConstantValue.NotAvailable);
}
defaultValue = MakeConversionNode(defaultValue, parameter.Type, @checked: false);
return defaultValue;
}
public override BoundNode VisitObjectCreationExpression(BoundObjectCreationExpression node)
{
ReadOnlyArray<BoundExpression> arguments = (ReadOnlyArray<BoundExpression>)this.VisitList(node.Arguments);
BoundExpression initializerExpressionOpt = (BoundExpression)this.Visit(node.InitializerExpressionOpt);
TypeSymbol type = this.VisitType(node.Type);
if (!RequiresSpill(arguments) && (initializerExpressionOpt == null || initializerExpressionOpt.Kind != BoundKind.SpillSequence))
{
return node.Update(node.Constructor, arguments, node.ArgumentNamesOpt, node.ArgumentRefKindsOpt, node.Expanded, node.ArgsToParamsOpt, node.ConstantValueOpt, initializerExpressionOpt, type);
}
var spillBuilder = new SpillBuilder();
ReadOnlyArray<BoundExpression> newArguments = SpillExpressionList(spillBuilder, arguments);
BoundExpression newInitializerExpressionOpt;
if (initializerExpressionOpt != null && initializerExpressionOpt.Kind == BoundKind.SpillSequence)
{
var spill = (BoundSpillSequence)initializerExpressionOpt;
spillBuilder.AddSpill(spill);
newInitializerExpressionOpt = spill.Value;
}
else
{
newInitializerExpressionOpt = initializerExpressionOpt;
}
BoundObjectCreationExpression newObjectCreation = node.Update(
node.Constructor,
newArguments,
node.ArgumentNamesOpt,
node.ArgumentRefKindsOpt,
node.Expanded,
node.ArgsToParamsOpt,
node.ConstantValueOpt,
newInitializerExpressionOpt,
type);
return spillBuilder.BuildSequenceAndFree(F, newObjectCreation);
}
public override BoundNode VisitObjectCreationExpression(BoundObjectCreationExpression node)
{
Debug.Assert(node != null);
// Rewrite the arguments.
// NOTE: We may need additional argument rewriting such as generating a params array,
// re-ordering arguments based on argsToParamsOpt map, inserting arguments for optional parameters, etc.
// NOTE: This is done later by MakeArguments, for now we just lower each argument.
var rewrittenArguments = VisitList(node.Arguments);
// We have already lowered each argument, but we may need some additional rewriting for the arguments,
// such as generating a params array, re-ordering arguments based on argsToParamsOpt map, inserting arguments for optional parameters, etc.
ImmutableArray <LocalSymbol> temps;
ImmutableArray <RefKind> argumentRefKindsOpt = node.ArgumentRefKindsOpt;
rewrittenArguments = MakeArguments(
node.Syntax,
rewrittenArguments,
node.Constructor,
node.Constructor,
node.Expanded,
node.ArgsToParamsOpt,
ref argumentRefKindsOpt,
out temps);
BoundExpression rewrittenObjectCreation;
if (_inExpressionLambda)
{
if (!temps.IsDefaultOrEmpty)
{
throw ExceptionUtilities.UnexpectedValue(temps.Length);
}
rewrittenObjectCreation = node.UpdateArgumentsAndInitializer(rewrittenArguments, argumentRefKindsOpt, MakeObjectCreationInitializerForExpressionTree(node.InitializerExpressionOpt), changeTypeOpt: node.Constructor.ContainingType);
if (node.Type.IsInterfaceType())
{
Debug.Assert(TypeSymbol.Equals(rewrittenObjectCreation.Type, ((NamedTypeSymbol)node.Type).ComImportCoClass, TypeCompareKind.ConsiderEverything2));
rewrittenObjectCreation = MakeConversionNode(rewrittenObjectCreation, node.Type, false, false);
}
return(rewrittenObjectCreation);
}
rewrittenObjectCreation = node.UpdateArgumentsAndInitializer(rewrittenArguments, argumentRefKindsOpt, newInitializerExpression: null, changeTypeOpt: node.Constructor.ContainingType);
// replace "new S()" with a default struct ctor with "default(S)"
if (node.Constructor.IsDefaultValueTypeConstructor())
{
rewrittenObjectCreation = new BoundDefaultExpression(rewrittenObjectCreation.Syntax, rewrittenObjectCreation.Type !);
}
if (!temps.IsDefaultOrEmpty)
{
rewrittenObjectCreation = new BoundSequence(
node.Syntax,
temps,
ImmutableArray <BoundExpression> .Empty,
rewrittenObjectCreation,
node.Type);
}
if (node.Type.IsInterfaceType())
{
Debug.Assert(TypeSymbol.Equals(rewrittenObjectCreation.Type, ((NamedTypeSymbol)node.Type).ComImportCoClass, TypeCompareKind.ConsiderEverything2));
rewrittenObjectCreation = MakeConversionNode(rewrittenObjectCreation, node.Type, false, false);
}
if (node.InitializerExpressionOpt == null || node.InitializerExpressionOpt.HasErrors)
{
return(rewrittenObjectCreation);
}
return(MakeExpressionWithInitializer(node.Syntax, rewrittenObjectCreation, node.InitializerExpressionOpt, node.Type));
}
/// <summary>
/// Introduce a frame around the translation of the given node.
/// </summary>
/// <param name="node">The node whose translation should be translated to contain a frame</param>
/// <param name="frame">The frame for the translated node</param>
/// <param name="F">A function that computes the translation of the node. It receives lists of added statements and added symbols</param>
/// <returns>The translated statement, as returned from F</returns>
private T IntroduceFrame <T>(BoundNode node, LambdaFrame frame, Func <ArrayBuilder <BoundExpression>, ArrayBuilder <LocalSymbol>, T> F)
{
NamedTypeSymbol frameType = frame.ConstructIfGeneric(StaticCast <TypeSymbol> .From(currentTypeParameters));
LocalSymbol framePointer = new LambdaFrameLocalSymbol(this.topLevelMethod, frameType, CompilationState);
CSharpSyntaxNode syntax = node.Syntax;
// assign new frame to the frame variable
CompilationState.AddSynthesizedMethod(frame.Constructor, FlowAnalysisPass.AppendImplicitReturn(MethodCompiler.BindMethodBody(frame.Constructor, CompilationState, null), frame.Constructor));
var prologue = ArrayBuilder <BoundExpression> .GetInstance();
MethodSymbol constructor = frame.Constructor.AsMember(frameType);
Debug.Assert(frameType == constructor.ContainingType);
var newFrame = new BoundObjectCreationExpression(
syntax: syntax,
constructor: constructor);
prologue.Add(new BoundAssignmentOperator(syntax,
new BoundLocal(syntax, framePointer, null, frameType),
newFrame,
frameType));
CapturedSymbolReplacement oldInnermostFrameProxy = null;
if ((object)innermostFramePointer != null)
{
proxies.TryGetValue(innermostFramePointer, out oldInnermostFrameProxy);
if (analysis.needsParentFrame.Contains(node))
{
var capturedFrame = new LambdaCapturedVariable(frame, innermostFramePointer);
FieldSymbol frameParent = capturedFrame.AsMember(frameType);
BoundExpression left = new BoundFieldAccess(syntax, new BoundLocal(syntax, framePointer, null, frameType), frameParent, null);
BoundExpression right = FrameOfType(syntax, frameParent.Type as NamedTypeSymbol);
BoundExpression assignment = new BoundAssignmentOperator(syntax, left, right, left.Type);
if (this.currentMethod.MethodKind == MethodKind.Constructor && capturedFrame.Type == this.currentMethod.ContainingType && !this.seenBaseCall)
{
// Containing method is a constructor
// Initialization statement for the "this" proxy must be inserted
// after the constructor initializer statement block
// This insertion will be done by the delegate F
Debug.Assert(thisProxyInitDeferred == null);
thisProxyInitDeferred = assignment;
}
else
{
prologue.Add(assignment);
}
if (CompilationState.Emitting)
{
CompilationState.ModuleBuilderOpt.AddSynthesizedDefinition(frame, capturedFrame);
}
proxies[innermostFramePointer] = new CapturedToFrameSymbolReplacement(capturedFrame);
}
}
// Capture any parameters of this block. This would typically occur
// at the top level of a method or lambda with captured parameters.
// TODO: speed up the following by computing it in analysis.
foreach (var v in analysis.variablesCaptured)
{
BoundNode varNode;
if (!analysis.variableBlock.TryGetValue(v, out varNode) ||
varNode != node ||
analysis.declaredInsideExpressionLambda.Contains(v))
{
continue;
}
InitVariableProxy(syntax, v, framePointer, prologue);
}
Symbol oldInnermostFramePointer = innermostFramePointer;
innermostFramePointer = framePointer;
var addedLocals = ArrayBuilder <LocalSymbol> .GetInstance();
addedLocals.Add(framePointer);
framePointers.Add(frame, framePointer);
var result = F(prologue, addedLocals);
framePointers.Remove(frame);
innermostFramePointer = oldInnermostFramePointer;
if ((object)innermostFramePointer != null)
{
if (oldInnermostFrameProxy != null)
{
proxies[innermostFramePointer] = oldInnermostFrameProxy;
}
else
{
proxies.Remove(innermostFramePointer);
}
}
return(result);
}
public override BoundNode VisitObjectCreationExpression(BoundObjectCreationExpression node)
{
VisitCall(node.Constructor, null, node.Arguments, node.ArgumentRefKindsOpt, node.ArgumentNamesOpt, node.Expanded, node);
return(base.VisitObjectCreationExpression(node));
}
private BoundExpression GetLiftedUnaryOperatorConsequence(UnaryOperatorKind kind, CSharpSyntaxNode syntax, MethodSymbol method, TypeSymbol type, BoundExpression nonNullOperand)
{
MethodSymbol ctor = GetNullableMethod(syntax, type, SpecialMember.System_Nullable_T__ctor);
// OP(temp.GetValueOrDefault())
BoundExpression unliftedOp = MakeUnaryOperator(
oldNode: null,
kind: kind.Unlifted(),
syntax: syntax,
method: method,
loweredOperand: nonNullOperand,
type: type.GetNullableUnderlyingType());
// new R?(OP(temp.GetValueOrDefault()))
BoundExpression consequence = new BoundObjectCreationExpression(
syntax,
ctor,
unliftedOp);
return consequence;
}
public override BoundNode VisitObjectCreationExpression(BoundObjectCreationExpression node)
{
Debug.Assert(node.InitializerExpressionOpt == null);
BoundSpillSequence2 ss = null;
var arguments = this.VisitExpressionList(ref ss, node.Arguments, node.ArgumentRefKindsOpt);
return UpdateExpression(ss, node.Update(node.Constructor, arguments, node.ArgumentNamesOpt, node.ArgumentRefKindsOpt, node.Expanded, node.ArgsToParamsOpt, node.ConstantValueOpt, node.InitializerExpressionOpt, node.Type));
}
private BoundExpression MakeUserDefinedIncrementOperator(BoundIncrementOperator node, BoundExpression rewrittenValueToIncrement)
{
Debug.Assert((object)node.MethodOpt != null);
Debug.Assert(node.MethodOpt.ParameterCount == 1);
bool isLifted = node.OperatorKind.IsLifted();
bool @checked = node.OperatorKind.IsChecked();
BoundExpression rewrittenArgument = rewrittenValueToIncrement;
CSharpSyntaxNode syntax = node.Syntax;
TypeSymbol type = node.MethodOpt.ParameterTypes[0];
if (isLifted)
{
type = _compilation.GetSpecialType(SpecialType.System_Nullable_T).Construct(type);
Debug.Assert(node.MethodOpt.ParameterTypes[0] == node.MethodOpt.ReturnType);
}
if (!node.OperandConversion.IsIdentity)
{
rewrittenArgument = MakeConversionNode(
syntax: syntax,
rewrittenOperand: rewrittenValueToIncrement,
conversion: node.OperandConversion,
rewrittenType: type,
@checked: @checked);
}
if (!isLifted)
{
return BoundCall.Synthesized(syntax, null, node.MethodOpt, rewrittenArgument);
}
// S? temp = operand;
// S? r = temp.HasValue ?
// new S?(op_Increment(temp.GetValueOrDefault())) :
// default(S?);
// Unlike the other unary operators, we do not attempt to optimize nullable user-defined
// increment or decrement. The operand is a variable (or property), and so we do not know if
// it is always null/never null.
BoundAssignmentOperator tempAssignment;
BoundLocal boundTemp = _factory.StoreToTemp(rewrittenArgument, out tempAssignment);
MethodSymbol getValueOrDefault = GetNullableMethod(syntax, type, SpecialMember.System_Nullable_T_GetValueOrDefault);
MethodSymbol ctor = GetNullableMethod(syntax, type, SpecialMember.System_Nullable_T__ctor);
// temp.HasValue
BoundExpression condition = MakeNullableHasValue(node.Syntax, boundTemp);
// temp.GetValueOrDefault()
BoundExpression call_GetValueOrDefault = BoundCall.Synthesized(syntax, boundTemp, getValueOrDefault);
// op_Increment(temp.GetValueOrDefault())
BoundExpression userDefinedCall = BoundCall.Synthesized(syntax, null, node.MethodOpt, call_GetValueOrDefault);
// new S?(op_Increment(temp.GetValueOrDefault()))
BoundExpression consequence = new BoundObjectCreationExpression(syntax, ctor, userDefinedCall);
// default(S?)
BoundExpression alternative = new BoundDefaultOperator(syntax, null, type);
// temp.HasValue ?
// new S?(op_Increment(temp.GetValueOrDefault())) :
// default(S?);
BoundExpression conditionalExpression = RewriteConditionalOperator(
syntax: syntax,
rewrittenCondition: condition,
rewrittenConsequence: consequence,
rewrittenAlternative: alternative,
constantValueOpt: null,
rewrittenType: type);
// temp = operand;
// temp.HasValue ?
// new S?(op_Increment(temp.GetValueOrDefault())) :
// default(S?);
return new BoundSequence(
syntax: syntax,
locals: ImmutableArray.Create<LocalSymbol>(boundTemp.LocalSymbol),
sideEffects: ImmutableArray.Create<BoundExpression>(tempAssignment),
value: conditionalExpression,
type: type);
}
private BoundExpression VisitObjectCreationExpressionInternal(BoundObjectCreationExpression node)
{
if (node.ConstantValue != null)
{
// typically a decimal constant.
return Constant(node);
}
if ((object)node.Constructor == null ||
(node.Arguments.Length == 0 && !node.Type.IsStructType()) ||
node.Constructor.IsDefaultValueTypeConstructor())
{
return ExprFactory("New", _bound.Typeof(node.Type));
}
var ctor = _bound.ConstructorInfo(node.Constructor);
var args = _bound.Convert(_IEnumerableType.Construct(ExpressionType), Expressions(node.Arguments));
if (node.Type.IsAnonymousType && node.Arguments.Length != 0)
{
var anonType = (NamedTypeSymbol)node.Type;
var membersBuilder = ArrayBuilder<BoundExpression>.GetInstance();
for (int i = 0; i < node.Arguments.Length; i++)
{
membersBuilder.Add(_bound.MethodInfo(AnonymousTypeManager.GetAnonymousTypeProperty(anonType, i).GetMethod));
}
return ExprFactory("New", ctor, args, _bound.Array(MemberInfoType, membersBuilder.ToImmutableAndFree()));
}
else
{
return ExprFactory("New", ctor, args);
}
}
private BoundExpression MakeBuiltInIncrementOperator(BoundIncrementOperator node, BoundExpression rewrittenValueToIncrement)
{
BoundExpression result;
// If we have a built-in increment or decrement then things get a bit trickier. Suppose for example we have
// a user-defined conversion from X to short and from short to X, but no user-defined increment operator on
// X. The increment portion of "++x" is then: (X)(short)((int)(short)x + 1). That is, first x must be
// converted to short via an implicit user- defined conversion, then to int via an implicit numeric
// conversion, then the addition is performed in integers. The resulting integer is converted back to short,
// and then the short is converted to X.
// This is the input and output type of the unary increment operator we're going to call.
// That is, "short" in the example above.
TypeSymbol unaryOperandType = GetUnaryOperatorType(node);
// This is the kind of binary operator that we're going to realize the unary operator
// as. That is, "int + int --> int" in the example above.
BinaryOperatorKind binaryOperatorKind = GetCorrespondingBinaryOperator(node);
binaryOperatorKind |= IsIncrement(node) ? BinaryOperatorKind.Addition : BinaryOperatorKind.Subtraction;
// The "1" in the example above.
ConstantValue constantOne = GetConstantOneForBinOp(binaryOperatorKind);
Debug.Assert(constantOne != null);
Debug.Assert(constantOne.SpecialType != SpecialType.None);
Debug.Assert(binaryOperatorKind.OperandTypes() != 0);
// The input/output type of the binary operand. "int" in the example.
TypeSymbol binaryOperandType = _compilation.GetSpecialType(constantOne.SpecialType);
// 1
BoundExpression boundOne = MakeLiteral(
syntax: node.Syntax,
constantValue: constantOne,
type: binaryOperandType);
if (binaryOperatorKind.IsLifted())
{
binaryOperandType = _compilation.GetSpecialType(SpecialType.System_Nullable_T).Construct(binaryOperandType);
MethodSymbol ctor = GetNullableMethod(node.Syntax, binaryOperandType, SpecialMember.System_Nullable_T__ctor);
boundOne = new BoundObjectCreationExpression(node.Syntax, ctor, boundOne);
}
// Now we construct the other operand to the binary addition. We start with just plain "x".
BoundExpression binaryOperand = rewrittenValueToIncrement;
bool @checked = node.OperatorKind.IsChecked();
// If we need to make a conversion from the original operand type to the operand type of the
// underlying increment operation, do it now.
if (!node.OperandConversion.IsIdentity)
{
// (short)x
binaryOperand = MakeConversionNode(
syntax: node.Syntax,
rewrittenOperand: binaryOperand,
conversion: node.OperandConversion,
rewrittenType: unaryOperandType,
@checked: @checked);
}
// Early-out for pointer increment - we don't need to convert the operands to a common type.
if (node.OperatorKind.OperandTypes() == UnaryOperatorKind.Pointer)
{
Debug.Assert(binaryOperatorKind.OperandTypes() == BinaryOperatorKind.PointerAndInt);
Debug.Assert(binaryOperand.Type.IsPointerType());
Debug.Assert(boundOne.Type.SpecialType == SpecialType.System_Int32);
return MakeBinaryOperator(node.Syntax, binaryOperatorKind, binaryOperand, boundOne, binaryOperand.Type, method: null);
}
// If we need to make a conversion from the unary operator type to the binary operator type,
// do it now.
// (int)(short)x
binaryOperand = MakeConversionNode(binaryOperand, binaryOperandType, @checked);
// Perform the addition.
// (int)(short)x + 1
BoundExpression binOp;
if (unaryOperandType.SpecialType == SpecialType.System_Decimal)
{
binOp = MakeDecimalIncDecOperator(node.Syntax, binaryOperatorKind, binaryOperand);
}
else if (unaryOperandType.IsNullableType() && unaryOperandType.GetNullableUnderlyingType().SpecialType == SpecialType.System_Decimal)
{
binOp = MakeLiftedDecimalIncDecOperator(node.Syntax, binaryOperatorKind, binaryOperand);
}
else
{
binOp = MakeBinaryOperator(node.Syntax, binaryOperatorKind, binaryOperand, boundOne, binaryOperandType, method: null);
}
// Generate the conversion back to the type of the unary operator.
// (short)((int)(short)x + 1)
result = MakeConversionNode(binOp, unaryOperandType, @checked);
return result;
}
private BoundExpression MakeUserDefinedIncrementOperator(BoundIncrementOperator node, BoundExpression rewrittenValueToIncrement)
{
Debug.Assert((object)node.MethodOpt != null);
Debug.Assert(node.MethodOpt.ParameterCount == 1);
bool isLifted = node.OperatorKind.IsLifted();
bool @checked = node.OperatorKind.IsChecked();
BoundExpression rewrittenArgument = rewrittenValueToIncrement;
SyntaxNode syntax = node.Syntax;
TypeSymbol type = node.MethodOpt.ParameterTypes[0];
if (isLifted)
{
type = _compilation.GetSpecialType(SpecialType.System_Nullable_T).Construct(type);
Debug.Assert(node.MethodOpt.ParameterTypes[0] == node.MethodOpt.ReturnType);
}
if (!node.OperandConversion.IsIdentity)
{
rewrittenArgument = MakeConversionNode(
syntax: syntax,
rewrittenOperand: rewrittenValueToIncrement,
conversion: node.OperandConversion,
rewrittenType: type,
@checked: @checked);
}
if (!isLifted)
{
return(BoundCall.Synthesized(syntax, null, node.MethodOpt, rewrittenArgument));
}
// S? temp = operand;
// S? r = temp.HasValue ?
// new S?(op_Increment(temp.GetValueOrDefault())) :
// default(S?);
// Unlike the other unary operators, we do not attempt to optimize nullable user-defined
// increment or decrement. The operand is a variable (or property), and so we do not know if
// it is always null/never null.
BoundAssignmentOperator tempAssignment;
BoundLocal boundTemp = _factory.StoreToTemp(rewrittenArgument, out tempAssignment);
MethodSymbol getValueOrDefault = UnsafeGetNullableMethod(syntax, type, SpecialMember.System_Nullable_T_GetValueOrDefault);
MethodSymbol ctor = UnsafeGetNullableMethod(syntax, type, SpecialMember.System_Nullable_T__ctor);
// temp.HasValue
BoundExpression condition = MakeNullableHasValue(node.Syntax, boundTemp);
// temp.GetValueOrDefault()
BoundExpression call_GetValueOrDefault = BoundCall.Synthesized(syntax, boundTemp, getValueOrDefault);
// op_Increment(temp.GetValueOrDefault())
BoundExpression userDefinedCall = BoundCall.Synthesized(syntax, null, node.MethodOpt, call_GetValueOrDefault);
// new S?(op_Increment(temp.GetValueOrDefault()))
BoundExpression consequence = new BoundObjectCreationExpression(syntax, ctor, userDefinedCall);
// default(S?)
BoundExpression alternative = new BoundDefaultOperator(syntax, null, type);
// temp.HasValue ?
// new S?(op_Increment(temp.GetValueOrDefault())) :
// default(S?);
BoundExpression conditionalExpression = RewriteConditionalOperator(
syntax: syntax,
rewrittenCondition: condition,
rewrittenConsequence: consequence,
rewrittenAlternative: alternative,
constantValueOpt: null,
rewrittenType: type);
// temp = operand;
// temp.HasValue ?
// new S?(op_Increment(temp.GetValueOrDefault())) :
// default(S?);
return(new BoundSequence(
syntax: syntax,
locals: ImmutableArray.Create <LocalSymbol>(boundTemp.LocalSymbol),
sideEffects: ImmutableArray.Create <BoundExpression>(tempAssignment),
value: conditionalExpression,
type: type));
}
private BoundExpression MakeLiftedDecimalIncDecOperator(CSharpSyntaxNode syntax, BinaryOperatorKind oper, BoundExpression operand)
{
Debug.Assert(operand.Type.IsNullableType() && operand.Type.GetNullableUnderlyingType().SpecialType == SpecialType.System_Decimal);
// This method assumes that operand is already a temporary and so there is no need to copy it again.
MethodSymbol method = GetDecimalIncDecOperator(oper);
MethodSymbol getValueOrDefault = GetNullableMethod(syntax, operand.Type, SpecialMember.System_Nullable_T_GetValueOrDefault);
MethodSymbol ctor = GetNullableMethod(syntax, operand.Type, SpecialMember.System_Nullable_T__ctor);
// x.HasValue
BoundExpression condition = MakeNullableHasValue(syntax, operand);
// x.GetValueOrDefault()
BoundExpression getValueCall = BoundCall.Synthesized(syntax, operand, getValueOrDefault);
// op_Inc(x.GetValueOrDefault())
BoundExpression methodCall = BoundCall.Synthesized(syntax, null, method, getValueCall);
// new decimal?(op_Inc(x.GetValueOrDefault()))
BoundExpression consequence = new BoundObjectCreationExpression(syntax, ctor, methodCall);
// default(decimal?)
BoundExpression alternative = new BoundDefaultOperator(syntax, null, operand.Type);
// x.HasValue ? new decimal?(op_Inc(x.GetValueOrDefault())) : default(decimal?)
return RewriteConditionalOperator(syntax, condition, consequence, alternative, ConstantValue.NotAvailable, operand.Type);
}
private BoundExpression RewriteFullyLiftedBuiltInConversion(
CSharpSyntaxNode syntax,
BoundExpression operand,
ConversionKind kind,
bool @checked,
TypeSymbol type)
{
// SPEC: If the nullable conversion is from S? to T?:
// SPEC: * If the source HasValue property is false the result
// SPEC: is a null value of type T?.
// SPEC: * Otherwise the conversion is evaluated as an unwrapping
// SPEC: from S? to S, followed by the underlying conversion from
// SPEC: S to T, followed by a wrapping from T to T?
BoundExpression optimized = OptimizeLiftedBuiltInConversion(syntax, operand, kind, @checked, type);
if (optimized != null)
{
return optimized;
}
// We are unable to optimize the conversion. "(T?)s" is generated as:
// S? temp = s;
// temp.HasValue ? new T?((T)temp.GetValueOrDefault()) : default(T?)
BoundAssignmentOperator tempAssignment;
var boundTemp = factory.StoreToTemp(operand, out tempAssignment);
MethodSymbol get_HasValue = GetNullableMethod(syntax, boundTemp.Type, SpecialMember.System_Nullable_T_get_HasValue);
MethodSymbol getValueOrDefault = GetNullableMethod(syntax, boundTemp.Type, SpecialMember.System_Nullable_T_GetValueOrDefault);
BoundExpression condition = BoundCall.Synthesized(syntax, boundTemp, get_HasValue);
BoundExpression consequence = new BoundObjectCreationExpression(
syntax,
GetNullableMethod(syntax, type, SpecialMember.System_Nullable_T__ctor),
MakeConversion(
BoundCall.Synthesized(syntax, boundTemp, getValueOrDefault),
type.GetNullableUnderlyingType(),
@checked));
BoundExpression alternative = new BoundDefaultOperator(syntax, null, type);
BoundExpression conditionalExpression = RewriteConditionalOperator(
syntax: syntax,
rewrittenCondition: condition,
rewrittenConsequence: consequence,
rewrittenAlternative: alternative,
constantValueOpt: null,
rewrittenType: type);
return new BoundSequence(
syntax: syntax,
locals: ImmutableArray.Create(boundTemp.LocalSymbol),
sideEffects: ImmutableArray.Create<BoundExpression>(tempAssignment),
value: conditionalExpression,
type: type);
}
private BoundExpression LiftRangeExpression(BoundRangeExpression node, ImmutableArray <BoundExpression> operands)
{
Debug.Assert(node.Type.IsNullableType());
Debug.Assert(operands.Any(operand => operand.Type.IsNullableType()));
Debug.Assert(operands.Length == 1 || operands.Length == 2);
ArrayBuilder <BoundExpression> sideeffects = ArrayBuilder <BoundExpression> .GetInstance();
ArrayBuilder <LocalSymbol> locals = ArrayBuilder <LocalSymbol> .GetInstance();
ArrayBuilder <BoundExpression> arguments = ArrayBuilder <BoundExpression> .GetInstance();
// left.HasValue && right.HasValue
BoundExpression condition = null;
foreach (var operand in operands)
{
BoundExpression tempOperand = CaptureExpressionInTempIfNeeded(operand, sideeffects, locals);
if (tempOperand.Type.IsNullableType())
{
BoundExpression operandHasValue = MakeOptimizedHasValue(tempOperand.Syntax, tempOperand);
if (condition is null)
{
condition = operandHasValue;
}
else
{
TypeSymbol boolType = _compilation.GetSpecialType(SpecialType.System_Boolean);
condition = MakeBinaryOperator(node.Syntax, BinaryOperatorKind.BoolAnd, condition, operandHasValue, boolType, method: null);
}
arguments.Add(MakeOptimizedGetValueOrDefault(tempOperand.Syntax, tempOperand));
}
else
{
arguments.Add(tempOperand);
}
}
Debug.Assert(condition != null);
// method(left.GetValueOrDefault(), right.GetValueOrDefault())
BoundExpression rangeCall = MakeCall(
node.Syntax,
rewrittenReceiver: null,
node.MethodOpt,
arguments.ToImmutableArray(),
node.MethodOpt.ReturnType.TypeSymbol);
if (!TryGetNullableMethod(node.Syntax, node.Type, SpecialMember.System_Nullable_T__ctor, out MethodSymbol nullableCtor))
{
return(BadExpression(node.Syntax, node.Type, node));
}
// new Nullable(method(left.GetValueOrDefault(), right.GetValueOrDefault()))
BoundExpression consequence = new BoundObjectCreationExpression(node.Syntax, nullableCtor, binderOpt: null, rangeCall);
// default
BoundExpression alternative = new BoundDefaultExpression(node.Syntax, constantValueOpt: null, node.Type);
// left.HasValue && right.HasValue ? new Nullable(method(left.GetValueOrDefault(), right.GetValueOrDefault())) : default
BoundExpression conditionalExpression = RewriteConditionalOperator(
syntax: node.Syntax,
rewrittenCondition: condition,
rewrittenConsequence: consequence,
rewrittenAlternative: alternative,
constantValueOpt: null,
rewrittenType: node.Type,
isRef: false);
return(new BoundSequence(
syntax: node.Syntax,
locals: locals.ToImmutableAndFree(),
sideEffects: sideeffects.ToImmutableAndFree(),
value: conditionalExpression,
type: node.Type));
}
