private BoundDynamicIndexerAccess TransformDynamicIndexerAccess(BoundDynamicIndexerAccess indexerAccess, ArrayBuilder <BoundExpression> stores, ArrayBuilder <LocalSymbol> temps)
{
BoundExpression loweredReceiver;
if (CanChangeValueBetweenReads(indexerAccess.ReceiverOpt))
{
BoundAssignmentOperator assignmentToTemp;
var temp = _factory.StoreToTemp(VisitExpression(indexerAccess.ReceiverOpt), out assignmentToTemp);
stores.Add(assignmentToTemp);
temps.Add(temp.LocalSymbol);
loweredReceiver = temp;
}
else
{
loweredReceiver = indexerAccess.ReceiverOpt;
}
var arguments = indexerAccess.Arguments;
var loweredArguments = new BoundExpression[arguments.Length];
for (int i = 0; i < arguments.Length; i++)
{
if (CanChangeValueBetweenReads(arguments[i]))
{
BoundAssignmentOperator assignmentToTemp;
var temp = _factory.StoreToTemp(VisitExpression(arguments[i]), out assignmentToTemp, indexerAccess.ArgumentRefKindsOpt.RefKinds(i) != RefKind.None ? RefKind.Ref : RefKind.None);
stores.Add(assignmentToTemp);
temps.Add(temp.LocalSymbol);
loweredArguments[i] = temp;
}
else
{
loweredArguments[i] = arguments[i];
}
}
return(new BoundDynamicIndexerAccess(
indexerAccess.Syntax,
loweredReceiver,
loweredArguments.AsImmutableOrNull(),
indexerAccess.ArgumentNamesOpt,
indexerAccess.ArgumentRefKindsOpt,
indexerAccess.ApplicableIndexers,
indexerAccess.Type));
}
internal static ImmutableArray <BoundExpression> GetCallSiteArguments(BoundExpression callSiteFieldAccess, BoundExpression receiver, ImmutableArray <BoundExpression> arguments, BoundExpression right)
{
var result = new BoundExpression[1 + (receiver != null ? 1 : 0) + arguments.Length + (right != null ? 1 : 0)];
int j = 0;
result[j++] = callSiteFieldAccess;
if (receiver != null)
{
result[j++] = receiver;
}
arguments.CopyTo(result, j);
j += arguments.Length;
if (right != null)
{
result[j++] = right;
}
return(result.AsImmutableOrNull());
}
private BoundIndexerAccess TransformIndexerAccess(BoundIndexerAccess indexerAccess, ArrayBuilder <BoundExpression> stores, ArrayBuilder <LocalSymbol> temps)
{
var receiverOpt = indexerAccess.ReceiverOpt;
Debug.Assert(receiverOpt != null);
BoundExpression transformedReceiver;
if (CanChangeValueBetweenReads(receiverOpt))
{
BoundExpression rewrittenReceiver = VisitExpression(receiverOpt);
BoundAssignmentOperator assignmentToTemp;
// SPEC VIOLATION: It is not very clear when receiver of constrained callvirt is dereferenced - when pushed (in lexical order),
// SPEC VIOLATION: or when actual call is executed. The actual behavior seems to be implementation specific in different JITs.
// SPEC VIOLATION: To not depend on that, the right thing to do here is to store the value of the variable
// SPEC VIOLATION: when variable has reference type (regular temp), and store variable's location when it has a value type. (ref temp)
// SPEC VIOLATION: in a case of unconstrained generic type parameter a runtime test (default(T) == null) would be needed
// SPEC VIOLATION: However, for compatibility with Dev12 we will continue treating all generic type parameters, constrained or not,
// SPEC VIOLATION: as value types.
var variableRepresentsLocation = rewrittenReceiver.Type.IsValueType || rewrittenReceiver.Type.Kind == SymbolKind.TypeParameter;
var receiverTemp = _factory.StoreToTemp(rewrittenReceiver, out assignmentToTemp, refKind: variableRepresentsLocation ? RefKind.Ref : RefKind.None);
transformedReceiver = receiverTemp;
stores.Add(assignmentToTemp);
temps.Add(receiverTemp.LocalSymbol);
}
else
{
transformedReceiver = VisitExpression(receiverOpt);
}
// Dealing with the arguments is a bit tricky because they can be named out-of-order arguments;
// we have to preserve both the source-code order of the side effects and the side effects
// only being executed once.
//
// This is a subtly different problem than the problem faced by the conventional call
// rewriter; with the conventional call rewriter we already know that the side effects
// will only be executed once because the arguments are only being pushed on the stack once.
// In a compound equality operator on an indexer the indices are placed on the stack twice.
// That is to say, if you have:
//
// C().M(z : Z(), x : X(), y : Y())
//
// then we can rewrite that into
//
// tempc = C()
// tempz = Z()
// tempc.M(X(), Y(), tempz)
//
// See, we can optimize away two of the temporaries, for x and y. But we cannot optimize away any of the
// temporaries in
//
// C().Collection[z : Z(), x : X(), y : Y()] += 1;
//
// because we have to ensure not just that Z() happens first, but in addition that X() and Y() are only
// called once. We have to generate this as
//
// tempc = C().Collection
// tempz = Z()
// tempx = X()
// tempy = Y()
// tempc[tempx, tempy, tempz] = tempc[tempx, tempy, tempz] + 1;
//
// Fortunately arguments to indexers are never ref or out, so we don't need to worry about that.
// However, we can still do the optimization where constants are not stored in
// temporaries; if we have
//
// C().Collection[z : 123, y : Y(), x : X()] += 1;
//
// Then we can generate that as
//
// tempc = C().Collection
// tempx = X()
// tempy = Y()
// tempc[tempx, tempy, 123] = tempc[tempx, tempy, 123] + 1;
ImmutableArray <BoundExpression> rewrittenArguments = VisitList(indexerAccess.Arguments);
SyntaxNode syntax = indexerAccess.Syntax;
PropertySymbol indexer = indexerAccess.Indexer;
ImmutableArray <RefKind> argumentRefKinds = indexerAccess.ArgumentRefKindsOpt;
bool expanded = indexerAccess.Expanded;
ImmutableArray <int> argsToParamsOpt = indexerAccess.ArgsToParamsOpt;
ImmutableArray <ParameterSymbol> parameters = indexer.Parameters;
BoundExpression[] actualArguments = new BoundExpression[parameters.Length]; // The actual arguments that will be passed; one actual argument per formal parameter.
ArrayBuilder <BoundAssignmentOperator> storesToTemps = ArrayBuilder <BoundAssignmentOperator> .GetInstance(rewrittenArguments.Length);
ArrayBuilder <RefKind> refKinds = ArrayBuilder <RefKind> .GetInstance(parameters.Length, RefKind.None);
// Step one: Store everything that is non-trivial into a temporary; record the
// stores in storesToTemps and make the actual argument a reference to the temp.
// Do not yet attempt to deal with params arrays or optional arguments.
BuildStoresToTemps(
expanded,
argsToParamsOpt,
parameters,
argumentRefKinds,
rewrittenArguments,
forceLambdaSpilling: true, // lambdas must produce exactly one delegate so they must be spilled into a temp
actualArguments,
refKinds,
storesToTemps);
// Step two: If we have a params array, build the array and fill in the argument.
if (expanded)
{
BoundExpression array = BuildParamsArray(syntax, indexer, argsToParamsOpt, rewrittenArguments, parameters, actualArguments[actualArguments.Length - 1]);
BoundAssignmentOperator storeToTemp;
var boundTemp = _factory.StoreToTemp(array, out storeToTemp);
stores.Add(storeToTemp);
temps.Add(boundTemp.LocalSymbol);
actualArguments[actualArguments.Length - 1] = boundTemp;
}
// Step three: Now fill in the optional arguments. (Dev11 uses the getter for optional arguments in
// compound assignments, but for deconstructions we use the setter if the getter is missing.)
var accessor = indexer.GetOwnOrInheritedGetMethod() ?? indexer.GetOwnOrInheritedSetMethod();
InsertMissingOptionalArguments(syntax, accessor.Parameters, actualArguments, refKinds);
// For a call, step four would be to optimize away some of the temps. However, we need them all to prevent
// duplicate side-effects, so we'll skip that step.
if (indexer.ContainingType.IsComImport)
{
RewriteArgumentsForComCall(parameters, actualArguments, refKinds, temps);
}
rewrittenArguments = actualArguments.AsImmutableOrNull();
foreach (BoundAssignmentOperator tempAssignment in storesToTemps)
{
temps.Add(((BoundLocal)tempAssignment.Left).LocalSymbol);
stores.Add(tempAssignment);
}
storesToTemps.Free();
argumentRefKinds = GetRefKindsOrNull(refKinds);
refKinds.Free();
// This is a temporary object that will be rewritten away before the lowering completes.
return(new BoundIndexerAccess(
syntax,
transformedReceiver,
indexer,
rewrittenArguments,
default(ImmutableArray <string>),
argumentRefKinds,
false,
default(ImmutableArray <int>),
null,
indexerAccess.UseSetterForDefaultArgumentGeneration,
indexerAccess.Type));
}
private BoundExpression BindAnonymousObjectCreation(AnonymousObjectCreationExpressionSyntax node, DiagnosticBag diagnostics)
{
// prepare
var initializers = node.Initializers;
int fieldCount = initializers.Count;
bool hasError = false;
// bind field initializers
BoundExpression[] boundExpressions = new BoundExpression[fieldCount];
AnonymousTypeField[] fields = new AnonymousTypeField[fieldCount];
CSharpSyntaxNode[] fieldSyntaxNodes = new CSharpSyntaxNode[fieldCount];
// WARNING: Note that SemanticModel.GetDeclaredSymbol for field initializer node relies on
// the fact that the order of properties in anonymous type template corresponds
// 1-to-1 to the appropriate filed initializer syntax nodes; This means such
// correspondence must be preserved all the time including erroneous scenarios
// set of names already used
var uniqueFieldNames = PooledHashSet <string> .GetInstance();
for (int i = 0; i < fieldCount; i++)
{
AnonymousObjectMemberDeclaratorSyntax fieldInitializer = initializers[i];
NameEqualsSyntax nameEquals = fieldInitializer.NameEquals;
ExpressionSyntax expression = fieldInitializer.Expression;
SyntaxToken nameToken = default(SyntaxToken);
if (nameEquals != null)
{
nameToken = nameEquals.Name.Identifier;
}
else
{
if (!IsAnonymousTypeMemberExpression(expression))
{
hasError = true;
diagnostics.Add(ErrorCode.ERR_InvalidAnonymousTypeMemberDeclarator, expression.GetLocation());
}
nameToken = expression.ExtractAnonymousTypeMemberName();
}
hasError |= expression.HasErrors;
boundExpressions[i] = this.BindValue(expression, diagnostics, BindValueKind.RValue);
// check the name to be unique
string fieldName = null;
if (nameToken.Kind() == SyntaxKind.IdentifierToken)
{
fieldName = nameToken.ValueText;
if (!uniqueFieldNames.Add(fieldName))
{
// name duplication
Error(diagnostics, ErrorCode.ERR_AnonymousTypeDuplicatePropertyName, fieldInitializer);
hasError = true;
fieldName = null;
}
}
else
{
// there is something wrong with field's name
hasError = true;
}
// calculate the expression's type and report errors if needed
TypeSymbol fieldType = GetAnonymousTypeFieldType(boundExpressions[i], fieldInitializer, diagnostics, ref hasError);
// build anonymous type field descriptor
fieldSyntaxNodes[i] = (nameToken.Kind() == SyntaxKind.IdentifierToken) ? (CSharpSyntaxNode)nameToken.Parent : fieldInitializer;
// https://github.com/dotnet/roslyn/issues/24018: Initial binding should set NullableAnnotation.Unknown
NullableAnnotation nullableAnnotation;
switch (((CSharpParseOptions)node.SyntaxTree?.Options)?.IsFeatureEnabled(MessageID.IDS_FeatureNullableReferenceTypes))
{
case true:
nullableAnnotation = fieldType.IsReferenceType ? NullableAnnotation.Annotated : NullableAnnotation.NotAnnotated;
break;
case false:
nullableAnnotation = NullableAnnotation.NotAnnotated;
break;
default:
nullableAnnotation = NullableAnnotation.Unknown;
break;
}
fields[i] = new AnonymousTypeField(
fieldName == null ? "$" + i.ToString() : fieldName,
fieldSyntaxNodes[i].Location,
TypeSymbolWithAnnotations.Create(fieldType, nullableAnnotation));
// NOTE: ERR_InvalidAnonymousTypeMemberDeclarator (CS0746) would be generated by parser if needed
}
uniqueFieldNames.Free();
// Create anonymous type
AnonymousTypeManager manager = this.Compilation.AnonymousTypeManager;
AnonymousTypeDescriptor descriptor = new AnonymousTypeDescriptor(fields.AsImmutableOrNull(), node.NewKeyword.GetLocation());
NamedTypeSymbol anonymousType = manager.ConstructAnonymousTypeSymbol(descriptor);
// declarators - bound nodes created for providing semantic info
// on anonymous type fields having explicitly specified name
ArrayBuilder <BoundAnonymousPropertyDeclaration> declarators =
ArrayBuilder <BoundAnonymousPropertyDeclaration> .GetInstance();
for (int i = 0; i < fieldCount; i++)
{
NameEqualsSyntax explicitName = initializers[i].NameEquals;
if (explicitName != null)
{
AnonymousTypeField field = fields[i];
if (field.Name != null)
{
// get property symbol and create a bound property declaration node
foreach (var symbol in anonymousType.GetMembers(field.Name))
{
if (symbol.Kind == SymbolKind.Property)
{
declarators.Add(new BoundAnonymousPropertyDeclaration(fieldSyntaxNodes[i], (PropertySymbol)symbol, field.Type.TypeSymbol));
break;
}
}
}
}
}
// check if anonymous object creation is allowed in this context
if (!this.IsAnonymousTypesAllowed())
{
Error(diagnostics, ErrorCode.ERR_AnonymousTypeNotAvailable, node.NewKeyword);
hasError = true;
}
// Finally create a bound node
return(new BoundAnonymousObjectCreationExpression(
node,
anonymousType.InstanceConstructors[0],
boundExpressions.AsImmutableOrNull(),
declarators.ToImmutableAndFree(),
anonymousType,
hasError));
}
