public override BoundNode VisitCollectionElementInitializer(BoundCollectionElementInitializer node)
{
if (_inExpressionLambda && node.AddMethod.IsStatic)
{
Error(ErrorCode.ERR_ExtensionCollectionElementInitializerInExpressionTree, node);
}
VisitCall(node.AddMethod, null, node.Arguments, default(ImmutableArray <RefKind>), default(ImmutableArray <string>), node.Expanded, node);
return(base.VisitCollectionElementInitializer(node));
}
public override BoundNode VisitCollectionElementInitializer(BoundCollectionElementInitializer node)
{
if (_inExpressionLambda && node.AddMethod.IsStatic)
{
Error(ErrorCode.ERR_ExtensionCollectionElementInitializerInExpressionTree, node);
}
VisitCall(node.AddMethod, null, node.Arguments, default(ImmutableArray<RefKind>), default(ImmutableArray<string>), node.Expanded, node);
return base.VisitCollectionElementInitializer(node);
}
// Rewrite collection initializer element Add method call:
// new List<int> { 1, 2, 3 }; OR new List<int> { { 1, 2 }, 3 };
// ~ ~~~~~~~~
private BoundExpression MakeCollectionInitializer(BoundExpression rewrittenReceiver, BoundCollectionElementInitializer initializer)
{
Debug.Assert(initializer.AddMethod.Name == "Add");
Debug.Assert(initializer.Arguments.Any());
Debug.Assert(rewrittenReceiver != null || _inExpressionLambda);
var syntax = initializer.Syntax;
MethodSymbol addMethod = initializer.AddMethod;
if (_allowOmissionOfConditionalCalls)
{
// NOTE: Calls cannot be omitted within an expression tree (CS0765); this should already
// have been checked.
if (addMethod.CallsAreOmitted(initializer.SyntaxTree))
{
return(null);
}
}
var rewrittenArguments = VisitList(initializer.Arguments);
var rewrittenType = VisitType(initializer.Type);
// 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;
var argumentRefKindsOpt = default(ImmutableArray <RefKind>);
rewrittenArguments = MakeArguments(syntax, rewrittenArguments, addMethod, addMethod, initializer.Expanded, initializer.ArgsToParamsOpt, ref argumentRefKindsOpt, out temps, enableCallerInfo: ThreeState.True);
if (initializer.InvokedAsExtensionMethod)
{
// the add method was found as an extension method. Replace the implicit receiver (first argument) with the rewritten receiver.
Debug.Assert(addMethod.IsStatic && addMethod.IsExtensionMethod);
Debug.Assert(rewrittenArguments[0].Kind == BoundKind.ImplicitReceiver);
Debug.Assert(!_inExpressionLambda, "Expression trees do not support extension Add");
rewrittenArguments = rewrittenArguments.SetItem(0, rewrittenReceiver);
rewrittenReceiver = null;
}
if (_inExpressionLambda)
{
return(initializer.Update(addMethod, rewrittenArguments, rewrittenReceiver, expanded: false, argsToParamsOpt: default, initializer.InvokedAsExtensionMethod, initializer.ResultKind, initializer.BinderOpt, rewrittenType));
// Rewrite collection initializer element Add method call:
// new List<int> { 1, 2, 3 }; OR new List<int> { { 1, 2 }, 3 };
// ~ ~~~~~~~~
private BoundExpression MakeCollectionInitializer(BoundExpression rewrittenReceiver, BoundCollectionElementInitializer initializer)
{
Debug.Assert(initializer.AddMethod.Name == "Add");
Debug.Assert(initializer.Arguments.Any());
Debug.Assert(rewrittenReceiver != null || inExpressionLambda);
var syntax = initializer.Syntax;
MethodSymbol addMethod = initializer.AddMethod;
// NOTE: Calls cannot be omitted within an expression tree (CS0765); this should already
// have been checked.
if (addMethod.CallsAreOmitted(initializer.SyntaxTree))
{
return(null);
}
var rewrittenArguments = VisitList(initializer.Arguments);
var rewrittenType = VisitType(initializer.Type);
// 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;
var argumentRefKindsOpt = default(ImmutableArray <RefKind>);
rewrittenArguments = MakeArguments(syntax, rewrittenArguments, addMethod, addMethod, initializer.Expanded, initializer.ArgsToParamsOpt, ref argumentRefKindsOpt, out temps);
Debug.Assert(argumentRefKindsOpt.IsDefault);
if (initializer.InvokedAsExtensionMethod)
{
// the add method was found as an extension method. Replace the implicit receiver (first argument) with the rewritten receiver.
Debug.Assert(addMethod.IsStatic && addMethod.IsExtensionMethod);
Debug.Assert(rewrittenArguments[0].Kind == BoundKind.ImplicitReceiver);
var newArgs = ArrayBuilder <BoundExpression> .GetInstance();
newArgs.AddRange(rewrittenArguments);
newArgs[0] = rewrittenReceiver;
rewrittenArguments = newArgs.ToImmutableAndFree();
rewrittenReceiver = null;
}
if (inExpressionLambda)
{
return(initializer.Update(addMethod, rewrittenArguments, false, default(ImmutableArray <int>), initializer.InvokedAsExtensionMethod, initializer.ResultKind, rewrittenType));
}
return(MakeCall(null, syntax, rewrittenReceiver, addMethod, rewrittenArguments, default(ImmutableArray <RefKind>), initializer.InvokedAsExtensionMethod, initializer.ResultKind, addMethod.ReturnType, temps));
}
public override BoundNode VisitCollectionElementInitializer(BoundCollectionElementInitializer node)
{
VisitCall(node.AddMethod, null, node.Arguments, default(ImmutableArray<RefKind>), default(ImmutableArray<string>), node.Expanded, node);
return base.VisitCollectionElementInitializer(node);
}
// Rewrite collection initializer element Add method call:
// new List<int> { 1, 2, 3 }; OR new List<int> { { 1, 2 }, 3 };
// ~ ~~~~~~~~
private BoundExpression MakeCollectionInitializer(BoundExpression rewrittenReceiver, BoundCollectionElementInitializer initializer)
{
MethodSymbol addMethod = initializer.AddMethod;
Debug.Assert(addMethod.Name == "Add");
Debug.Assert(addMethod.Parameters
.Skip(addMethod.IsExtensionMethod ? 1 : 0)
.All(p => p.RefKind == RefKind.None || p.RefKind == RefKind.In));
Debug.Assert(initializer.Arguments.Any());
Debug.Assert(rewrittenReceiver != null || _inExpressionLambda);
var syntax = initializer.Syntax;
if (_allowOmissionOfConditionalCalls)
{
// NOTE: Calls cannot be omitted within an expression tree (CS0765); this should already
// have been checked.
if (addMethod.CallsAreOmitted(initializer.SyntaxTree))
{
return(null);
}
}
var rewrittenArguments = VisitList(initializer.Arguments);
var rewrittenType = VisitType(initializer.Type);
// 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;
var argumentRefKindsOpt = default(ImmutableArray <RefKind>);
if (addMethod.Parameters[0].RefKind == RefKind.Ref)
{
// If the Add method is an extension which takes a `ref this` as the first parameter, implicitly add a `ref` to the argument
// Initializer element syntax cannot have `ref`, `in`, or `out` keywords.
// Arguments to `in` parameters will be converted to have RefKind.In later on.
var builder = ArrayBuilder <RefKind> .GetInstance(addMethod.Parameters.Length, RefKind.None);
builder[0] = RefKind.Ref;
argumentRefKindsOpt = builder.ToImmutableAndFree();
}
rewrittenArguments = MakeArguments(syntax, rewrittenArguments, addMethod, addMethod, initializer.Expanded, initializer.ArgsToParamsOpt, ref argumentRefKindsOpt, out temps, enableCallerInfo: ThreeState.True);
if (initializer.InvokedAsExtensionMethod)
{
Debug.Assert(addMethod.IsStatic);
Debug.Assert(addMethod.IsExtensionMethod);
Debug.Assert(!_inExpressionLambda, "Expression trees do not support extension Add");
rewrittenReceiver = null;
}
if (_inExpressionLambda)
{
return(initializer.Update(addMethod, rewrittenArguments, rewrittenReceiver, expanded: false, argsToParamsOpt: default, initializer.InvokedAsExtensionMethod, initializer.ResultKind, initializer.BinderOpt, rewrittenType));
public override BoundNode VisitCollectionElementInitializer(BoundCollectionElementInitializer node)
{
VisitCall(node.AddMethod, null, node.Arguments, default(ImmutableArray <RefKind>), default(ImmutableArray <string>), node.Expanded, node);
return(base.VisitCollectionElementInitializer(node));
}
// Rewrite collection initializer element Add method call:
// new List<int> { 1, 2, 3 }; OR new List<int> { { 1, 2 }, 3 };
// ~ ~~~~~~~~
private BoundExpression MakeCollectionInitializer(BoundExpression rewrittenReceiver, BoundCollectionElementInitializer initializer)
{
Debug.Assert(initializer.AddMethod.Name == "Add");
Debug.Assert(initializer.Arguments.Any());
Debug.Assert(rewrittenReceiver != null || _inExpressionLambda);
var syntax = initializer.Syntax;
MethodSymbol addMethod = initializer.AddMethod;
if (_allowOmissionOfConditionalCalls)
{
// NOTE: Calls cannot be omitted within an expression tree (CS0765); this should already
// have been checked.
if (addMethod.CallsAreOmitted(initializer.SyntaxTree))
{
return null;
}
}
var rewrittenArguments = VisitList(initializer.Arguments);
var rewrittenType = VisitType(initializer.Type);
// 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;
var argumentRefKindsOpt = default(ImmutableArray<RefKind>);
rewrittenArguments = MakeArguments(syntax, rewrittenArguments, addMethod, addMethod, initializer.Expanded, initializer.ArgsToParamsOpt, ref argumentRefKindsOpt, out temps, enableCallerInfo: ThreeState.True);
Debug.Assert(argumentRefKindsOpt.IsDefault);
if (initializer.InvokedAsExtensionMethod)
{
// the add method was found as an extension method. Replace the implicit receiver (first argument) with the rewritten receiver.
Debug.Assert(addMethod.IsStatic && addMethod.IsExtensionMethod);
Debug.Assert(rewrittenArguments[0].Kind == BoundKind.ImplicitReceiver);
Debug.Assert(!_inExpressionLambda, "Expression trees do not support extension Add");
rewrittenArguments = rewrittenArguments.SetItem(0, rewrittenReceiver);
rewrittenReceiver = null;
}
if (_inExpressionLambda)
{
return initializer.Update(addMethod, rewrittenArguments, false, default(ImmutableArray<int>), initializer.InvokedAsExtensionMethod, initializer.ResultKind, rewrittenType);
}
return MakeCall(null, syntax, rewrittenReceiver, addMethod, rewrittenArguments, default(ImmutableArray<RefKind>), initializer.InvokedAsExtensionMethod, initializer.ResultKind, addMethod.ReturnType, temps);
}
