public void CSharpComplexCollectionInitializer()
{
ObjectCreateExpression oce = ParseUtilCSharp.ParseExpression <ObjectCreateExpression>(
@"new List<Contact> {
new Contact {
Name = ""Chris"",
PhoneNumbers = { ""206-555-0101"" }
},
new Contact(additionalParameter) {
Name = ""Bob"",
PhoneNumbers = { ""650-555-0199"", ""425-882-8080"" }
}
}");
Assert.AreEqual(0, oce.Parameters.Count);
Assert.AreEqual(2, oce.ObjectInitializer.CreateExpressions.Count);
oce = (ObjectCreateExpression)oce.ObjectInitializer.CreateExpressions[1]; // look at Bob
Assert.AreEqual(1, oce.Parameters.Count);
Assert.IsInstanceOf(typeof(IdentifierExpression), oce.Parameters[0]);
Assert.IsInstanceOf(typeof(PrimitiveExpression), CheckPropertyInitializationExpression(oce.ObjectInitializer.CreateExpressions[0], "Name"));
CollectionInitializerExpression phoneNumbers = (CollectionInitializerExpression)CheckPropertyInitializationExpression(oce.ObjectInitializer.CreateExpressions[1], "PhoneNumbers");
Assert.AreEqual(2, phoneNumbers.CreateExpressions.Count);
}
private InvocationExpression CreateReflectionInvocation(InvocationExpression invocationExpression, bool staticMethod)
{
List <Expression> arguments = new List <Expression>();
FieldReferenceExpression fieldReferenceExpression = (FieldReferenceExpression)invocationExpression.TargetObject;
Expression invoker = fieldReferenceExpression.TargetObject;
TypeReferenceExpression helper = new TypeReferenceExpression("Helpers.ReflectionHelper");
FieldReferenceExpression call = new FieldReferenceExpression(helper, "CallInternalMethod");
string name = fieldReferenceExpression.FieldName;
PrimitiveExpression methodName = new PrimitiveExpression(name, '"' + name + '"');
arguments.Add(methodName);
if (staticMethod)
{
arguments.Add(new PrimitiveExpression(null, "null"));
}
else
{
arguments.Add(invoker);
}
CollectionInitializerExpression arrayInitializer = new CollectionInitializerExpression(invocationExpression.Arguments);
TypeReference reference = AstUtil.GetTypeReference("object", invocationExpression);
reference.RankSpecifier = new int[1];
ArrayCreateExpression argArray = new ArrayCreateExpression(reference, arrayInitializer);
arguments.Add(argArray);
return(new InvocationExpression(call, arguments));
}
public override object VisitCollectionInitializerExpression(CollectionInitializerExpression arrayInitializerExpression, object data)
{
foreach (INode node in arrayInitializerExpression.CreateExpressions)
{
node.Parent = arrayInitializerExpression;
}
return(base.VisitCollectionInitializerExpression(arrayInitializerExpression, data));
}
public override object VisitCollectionInitializerExpression(CollectionInitializerExpression collectionInitializerExpression, object data)
{
if (collectionInitializerExpression.CreateExpressions.Count == 0)
{
return(null);
}
DomReturnType type = (DomReturnType)ResolveType(collectionInitializerExpression.CreateExpressions[0]);
type.ArrayDimensions++;
return(CreateResult(type));
}
DefaultClass CreateAnonymousTypeClass(CollectionInitializerExpression initializer)
{
List <IReturnType> fieldTypes = new List <IReturnType>();
List <string> fieldNames = new List <string>();
foreach (Expression expr in initializer.CreateExpressions)
{
if (expr is NamedArgumentExpression)
{
// use right part only
fieldTypes.Add(ResolveType(((NamedArgumentExpression)expr).Expression));
}
else
{
fieldTypes.Add(ResolveType(expr));
}
fieldNames.Add(GetAnonymousTypeFieldName(expr));
}
StringBuilder nameBuilder = new StringBuilder();
nameBuilder.Append('{');
for (int i = 0; i < fieldTypes.Count; i++)
{
if (i > 0)
{
nameBuilder.Append(", ");
}
nameBuilder.Append(fieldNames[i]);
nameBuilder.Append(" : ");
if (fieldTypes[i] != null)
{
nameBuilder.Append(fieldTypes[i].DotNetName);
}
}
nameBuilder.Append('}');
DefaultClass c = new DefaultClass(new DefaultCompilationUnit(resolver.ProjectContent), nameBuilder.ToString());
c.Modifiers = ModifierEnum.Internal | ModifierEnum.Synthetic | ModifierEnum.Sealed;
for (int i = 0; i < fieldTypes.Count; i++)
{
DefaultProperty p = new DefaultProperty(fieldNames[i], fieldTypes[i], ModifierEnum.Public | ModifierEnum.Synthetic, DomRegion.Empty, DomRegion.Empty, c);
p.CanGet = true;
p.CanSet = false;
c.Properties.Add(p);
}
return(c);
}
public void CSharpNestedObjectInitializerForPreinitializedProperty()
{
ObjectCreateExpression oce = ParseUtilCSharp.ParseExpression <ObjectCreateExpression>(
"new Rectangle { P1 = { X = 0, Y = 1 }, P2 = { X = 2, Y = 3 } }"
);
Assert.AreEqual(0, oce.Parameters.Count);
Assert.AreEqual(2, oce.ObjectInitializer.CreateExpressions.Count);
CollectionInitializerExpression aie = (CollectionInitializerExpression)CheckPropertyInitializationExpression(oce.ObjectInitializer.CreateExpressions[0], "P1");
Assert.IsInstanceOf(typeof(PrimitiveExpression), CheckPropertyInitializationExpression(aie.CreateExpressions[0], "X"));
Assert.IsInstanceOf(typeof(PrimitiveExpression), CheckPropertyInitializationExpression(aie.CreateExpressions[1], "Y"));
aie = (CollectionInitializerExpression)CheckPropertyInitializationExpression(oce.ObjectInitializer.CreateExpressions[1], "P2");
Assert.IsInstanceOf(typeof(PrimitiveExpression), CheckPropertyInitializationExpression(aie.CreateExpressions[0], "X"));
Assert.IsInstanceOf(typeof(PrimitiveExpression), CheckPropertyInitializationExpression(aie.CreateExpressions[1], "Y"));
}
private Expression CreateReflectionInstance(ObjectCreateExpression objectCreateExpression)
{
TypeReferenceExpression helper = new TypeReferenceExpression("Helpers.ReflectionHelper");
FieldReferenceExpression target = new FieldReferenceExpression(helper, "InstantiateClass");
List <Expression> arguments = new List <Expression>();
TypeOfExpression typeofExpression = new TypeOfExpression(objectCreateExpression.CreateType);
CollectionInitializerExpression arrayInitializer = new CollectionInitializerExpression(objectCreateExpression.Parameters);
TypeReference reference = new TypeReference("object");
reference.RankSpecifier = new int[1];
ArrayCreateExpression arrayCreateExpression = new ArrayCreateExpression(reference, arrayInitializer);
arguments.Add(typeofExpression);
arguments.Add(arrayCreateExpression);
InvocationExpression invocation = new InvocationExpression(target, arguments);
CastExpression castExpression = new CastExpression(objectCreateExpression.CreateType, invocation, CastType.Cast);
return(castExpression);
}
public override object VisitCollectionInitializerExpression(CollectionInitializerExpression collectionInitializerExpression, object data)
{
// used for implicitly typed arrays
if (collectionInitializerExpression.CreateExpressions.Count == 0)
{
return(null);
}
IReturnType combinedRT = ResolveType(collectionInitializerExpression.CreateExpressions[0]);
for (int i = 1; i < collectionInitializerExpression.CreateExpressions.Count; i++)
{
IReturnType rt = ResolveType(collectionInitializerExpression.CreateExpressions[i]);
combinedRT = MemberLookupHelper.GetCommonType(resolver.ProjectContent, combinedRT, rt);
}
if (combinedRT == null)
{
return(null);
}
return(CreateResolveResult(new ArrayReturnType(resolver.ProjectContent, combinedRT, 1)));
}
private static AbstractExpression ReadCollectionInitializer(IObjectOrCollectionInitializerOperation op)
{
var context = CodeReaderContext.GetContextOrThrow();
var result = new CollectionInitializerExpression {
Items = op.Initializers.Select(readInitializer).ToList()
};
return(result);
CollectionInitializerExpression.ItemInitializer readInitializer(IOperation initOp)
{
if (initOp is IInvocationOperation invocation)
{
var item = new CollectionInitializerExpression.ItemInitializer();
item.ItemArguments.AddRange(invocation.Arguments.Select(arg => ReadExpression(arg.Value)));
return(item);
}
throw new CodeReadErrorException($"Unrecognized collection initializer: {initOp.Syntax}");
}
}
public override object VisitCollectionInitializerExpression(CollectionInitializerExpression collectionInitializerExpression, object data)
{
if (collectionInitializerExpression.CreateExpressions.Count == 0)
{
return(null);
}
DomReturnType type = null;
IType typeObject = null;
for (int i = 0; i < collectionInitializerExpression.CreateExpressions.Count; i++)
{
DomReturnType curType = (DomReturnType)ResolveType(collectionInitializerExpression.CreateExpressions[i]);
// if we found object or we have only one create expression we can stop
if (curType.DecoratedFullName == DomReturnType.Object.DecoratedFullName || collectionInitializerExpression.CreateExpressions.Count == 1)
{
type = curType;
break;
}
IType curTypeObject = resolver.Dom.GetType(curType);
if (curTypeObject == null)
{
continue;
}
if (type == null || resolver.Dom.GetInheritanceTree(typeObject).Any(t => t.DecoratedFullName == curTypeObject.DecoratedFullName))
{
type = curType;
typeObject = curTypeObject;
}
}
if (type != null)
{
type.ArrayDimensions++;
}
return(CreateResult(type));
}
IType CreateAnonymousClass(CollectionInitializerExpression initializer)
{
DomType result;
if (!anonymousTypes.TryGetValue(initializer, out result))
{
result = new AnonymousType();
result.SourceProjectDom = resolver.Dom;
foreach (Expression expr in initializer.CreateExpressions)
{
var oldPos = resolver.ResolvePosition;
if (!expr.StartLocation.IsEmpty)
{
resolver.resolvePosition = new DomLocation(expr.StartLocation.Line + resolver.CallingMember.Location.Line - 1, expr.StartLocation.Column - 1);
}
DomProperty newProperty = new DomProperty(GetAnonymousTypeFieldName(expr), MonoDevelop.Projects.Dom.Modifiers.Public, DomLocation.Empty, DomRegion.Empty, ResolveType(expr));
newProperty.DeclaringType = result;
result.Add(newProperty);
resolver.resolvePosition = oldPos;
}
anonymousTypes[initializer] = result;
}
return(result);
}
void ObjectCreateExpression(
#line 1935 "VBNET.ATG"
out Expression oce) {
#line 1937 "VBNET.ATG"
TypeReference type = null;
Expression initializer = null;
List<Expression> arguments = null;
ArrayList dimensions = null;
oce = null;
bool canBeNormal; bool canBeReDim;
Expect(148);
if (StartOf(7)) {
NonArrayTypeName(
#line 1945 "VBNET.ATG"
out type, false);
if (la.kind == 25) {
lexer.NextToken();
NormalOrReDimArgumentList(
#line 1946 "VBNET.ATG"
out arguments, out canBeNormal, out canBeReDim);
Expect(26);
if (la.kind == 23 ||
#line 1947 "VBNET.ATG"
la.kind == Tokens.OpenParenthesis) {
if (
#line 1947 "VBNET.ATG"
la.kind == Tokens.OpenParenthesis) {
ArrayTypeModifiers(
#line 1948 "VBNET.ATG"
out dimensions);
CollectionInitializer(
#line 1949 "VBNET.ATG"
out initializer);
} else {
CollectionInitializer(
#line 1950 "VBNET.ATG"
out initializer);
}
}
#line 1952 "VBNET.ATG"
if (canBeReDim && !canBeNormal && initializer == null) initializer = new CollectionInitializerExpression();
}
}
#line 1956 "VBNET.ATG"
if (initializer == null) {
oce = new ObjectCreateExpression(type, arguments);
} else {
if (dimensions == null) dimensions = new ArrayList();
dimensions.Insert(0, (arguments == null) ? 0 : Math.Max(arguments.Count - 1, 0));
type.RankSpecifier = (int[])dimensions.ToArray(typeof(int));
ArrayCreateExpression ace = new ArrayCreateExpression(type, initializer as CollectionInitializerExpression);
ace.Arguments = arguments;
oce = ace;
}
if (la.kind == 218) {
#line 1970 "VBNET.ATG"
NamedArgumentExpression memberInitializer = null;
lexer.NextToken();
#line 1974 "VBNET.ATG"
CollectionInitializerExpression memberInitializers = new CollectionInitializerExpression();
memberInitializers.StartLocation = la.Location;
Expect(23);
MemberInitializer(
#line 1978 "VBNET.ATG"
out memberInitializer);
#line 1979 "VBNET.ATG"
memberInitializers.CreateExpressions.Add(memberInitializer);
while (la.kind == 12) {
lexer.NextToken();
MemberInitializer(
#line 1981 "VBNET.ATG"
out memberInitializer);
#line 1982 "VBNET.ATG"
memberInitializers.CreateExpressions.Add(memberInitializer);
}
Expect(24);
#line 1986 "VBNET.ATG"
memberInitializers.EndLocation = t.Location;
if(oce is ObjectCreateExpression)
{
((ObjectCreateExpression)oce).ObjectInitializer = memberInitializers;
}
}
}
public virtual object VisitCollectionInitializerExpression(CollectionInitializerExpression collectionInitializerExpression, object data) {
Debug.Assert((collectionInitializerExpression != null));
Debug.Assert((collectionInitializerExpression.CreateExpressions != null));
for (int i = 0; i < collectionInitializerExpression.CreateExpressions.Count; i++) {
Expression o = collectionInitializerExpression.CreateExpressions[i];
Debug.Assert(o != null);
nodeStack.Push(o);
o.AcceptVisitor(this, data);
o = (Expression)nodeStack.Pop();
if (o == null)
collectionInitializerExpression.CreateExpressions.RemoveAt(i--);
else
collectionInitializerExpression.CreateExpressions[i] = o;
}
return null;
}
public virtual object VisitCollectionInitializerExpression(CollectionInitializerExpression collectionInitializerExpression, object data) {
throw new global::System.NotImplementedException("CollectionInitializerExpression");
}
private bool IsMatch(CollectionInitializerExpression left, CollectionInitializerExpression right)
{
return(true);
}
public object VisitCollectionInitializerExpression(CollectionInitializerExpression collectionInitializerExpression, object data)
{
throw new NotImplementedException();
}
public virtual object VisitCollectionInitializerExpression(CollectionInitializerExpression collectionInitializerExpression, object data) {
Debug.Assert((collectionInitializerExpression != null));
Debug.Assert((collectionInitializerExpression.CreateExpressions != null));
foreach (Expression o in collectionInitializerExpression.CreateExpressions) {
Debug.Assert(o != null);
o.AcceptVisitor(this, data);
}
return null;
}
public virtual object TrackedVisitCollectionInitializerExpression(CollectionInitializerExpression collectionInitializerExpression, object data) {
return base.VisitCollectionInitializerExpression(collectionInitializerExpression, data);
}
void CollectionInitializer(
#line 1403 "cs.ATG"
out Expression outExpr) {
#line 1405 "cs.ATG"
Expression expr = null;
CollectionInitializerExpression initializer = new CollectionInitializerExpression();
Expect(16);
#line 1409 "cs.ATG"
initializer.StartLocation = t.Location;
if (StartOf(31)) {
VariableInitializer(
#line 1410 "cs.ATG"
out expr);
#line 1411 "cs.ATG"
SafeAdd(initializer, initializer.CreateExpressions, expr);
while (
#line 1412 "cs.ATG"
NotFinalComma()) {
Expect(14);
VariableInitializer(
#line 1413 "cs.ATG"
out expr);
#line 1414 "cs.ATG"
SafeAdd(initializer, initializer.CreateExpressions, expr);
}
if (la.kind == 14) {
lexer.NextToken();
}
}
Expect(17);
#line 1418 "cs.ATG"
initializer.EndLocation = t.Location; outExpr = initializer;
}
B.ArrayLiteralExpression ConvertArrayLiteralExpression(CollectionInitializerExpression aie)
{
B.ArrayLiteralExpression dims = new B.ArrayLiteralExpression(GetLexicalInfo(aie));
ConvertExpressions(aie.CreateExpressions, dims.Items);
return(dims);
}
void CollectionOrObjectInitializer(
#line 1421 "cs.ATG"
out Expression outExpr) {
#line 1423 "cs.ATG"
Expression expr = null;
CollectionInitializerExpression initializer = new CollectionInitializerExpression();
Expect(16);
#line 1427 "cs.ATG"
initializer.StartLocation = t.Location;
if (StartOf(31)) {
ObjectPropertyInitializerOrVariableInitializer(
#line 1428 "cs.ATG"
out expr);
#line 1429 "cs.ATG"
SafeAdd(initializer, initializer.CreateExpressions, expr);
while (
#line 1430 "cs.ATG"
NotFinalComma()) {
Expect(14);
ObjectPropertyInitializerOrVariableInitializer(
#line 1431 "cs.ATG"
out expr);
#line 1432 "cs.ATG"
SafeAdd(initializer, initializer.CreateExpressions, expr);
}
if (la.kind == 14) {
lexer.NextToken();
}
}
Expect(17);
#line 1436 "cs.ATG"
initializer.EndLocation = t.Location; outExpr = initializer;
}
public virtual CollectionInitializerExpression RewriteCollectionInitializerExpression(CollectionInitializerExpression expression)
{
return(expression);
}
public override object VisitCollectionInitializerExpression(CollectionInitializerExpression collectionInitializerExpression, object data)
{
WriteLine("VisitCollectionInitializerExpression");
return(base.VisitCollectionInitializerExpression(collectionInitializerExpression, data));
}
public virtual void VisitCollectionInitializerExpression(CollectionInitializerExpression expression)
{
VisitAbstractExpression(expression);
}
public object VisitCollectionInitializerExpression(CollectionInitializerExpression aie, object data)
{
return(ConvertArrayLiteralExpression(aie));
}
void CollectionInitializer(
#line 1511 "VBNET.ATG"
out Expression outExpr) {
#line 1513 "VBNET.ATG"
Expression expr = null;
CollectionInitializerExpression initializer = new CollectionInitializerExpression();
Expect(23);
if (StartOf(30)) {
VariableInitializer(
#line 1518 "VBNET.ATG"
out expr);
#line 1520 "VBNET.ATG"
if (expr != null) { initializer.CreateExpressions.Add(expr); }
while (
#line 1523 "VBNET.ATG"
NotFinalComma()) {
Expect(12);
VariableInitializer(
#line 1523 "VBNET.ATG"
out expr);
#line 1524 "VBNET.ATG"
if (expr != null) { initializer.CreateExpressions.Add(expr); }
}
}
Expect(24);
#line 1527 "VBNET.ATG"
outExpr = initializer;
}
public virtual object VisitCollectionInitializerExpression(CollectionInitializerExpression collectionInitializerExpression, object data)
{
throw new global::System.NotImplementedException("CollectionInitializerExpression");
}
public sealed override object VisitCollectionInitializerExpression(CollectionInitializerExpression collectionInitializerExpression, object data) {
BeginVisit(collectionInitializerExpression);
object result = TrackedVisitCollectionInitializerExpression(collectionInitializerExpression, data);
EndVisit(collectionInitializerExpression);
return result;
}
