void CheckPointObjectCreation(ObjectCreateExpression oce)
{
Assert.AreEqual(0, oce.Parameters.Count);
Assert.AreEqual(2, oce.ObjectInitializer.CreateExpressions.Count);
Assert.IsInstanceOf(typeof(PrimitiveExpression), CheckPropertyInitializationExpression(oce.ObjectInitializer.CreateExpressions[0], "X"));
Assert.IsInstanceOf(typeof(PrimitiveExpression), CheckPropertyInitializationExpression(oce.ObjectInitializer.CreateExpressions[1], "Y"));
}
public override object TrackedVisitBlockStatement(BlockStatement blockStatement, object data)
{
blockStatement.Children.Clear();
TypeReference notImplmentedException = new TypeReference("System.NotImplementedException");
ObjectCreateExpression objectCreate = new ObjectCreateExpression(notImplmentedException, new List<Expression>());
blockStatement.Children.Add(new ThrowStatement(objectCreate));
return null;
}
public override object VisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression, object data)
{
if(objectCreateExpression.CreateType.GenericTypes.Count>0)
{
UnlockWith(objectCreateExpression);
}
return base.VisitObjectCreateExpression(objectCreateExpression, data);
}
public override object VisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression, object data)
{
var expr = objectCreateExpression.ObjectInitializer;
if (expr.CreateExpressions.Count > 0 && !objectCreateExpression.IsAnonymousType)
UnlockWith(objectCreateExpression.ObjectInitializer); //Handing over the ObjectInitializer will make it highlight that code region only.
return base.VisitObjectCreateExpression(objectCreateExpression, data);
}
void CheckSimpleObjectCreateExpression(ObjectCreateExpression oce)
{
Assert.AreEqual("MyObject", oce.CreateType.Type);
Assert.AreEqual(3, oce.Parameters.Count);
for (int i = 0; i < oce.Parameters.Count; ++i) {
Assert.IsTrue(oce.Parameters[i] is PrimitiveExpression);
}
}
private bool ContainsInternalConstructor(IList constructors, ObjectCreateExpression objectCreateExpression)
{
foreach (ConstructorDeclaration constructor in constructors)
{
if (constructor.Parameters.Count == objectCreateExpression.Parameters.Count
&& (AstUtil.ContainsModifier(constructor, Modifiers.Internal) || AstUtil.ContainsModifier(constructor, Modifiers.Protected)))
return true;
}
return false;
}
public override object VisitObjectCreateExpression(ICSharpCode.NRefactory.Ast.ObjectCreateExpression objectCreateExpression, object data)
{
foreach (var tuple in searchedMembers)
{
var searchedMember = tuple.Item1;
IMethod method = searchedMember as IMethod;
if (method != null && method.IsConstructor)
{
ResolveResult resolveResult = resolver.ResolveExpression(objectCreateExpression, ConvertLocation(objectCreateExpression.StartLocation));
if (resolveResult != null && resolveResult.ResolvedType != null)
{
IType resolvedType = resolver.Dom.GetType(resolveResult.ResolvedType);
int pCount = objectCreateExpression.Parameters != null ? objectCreateExpression.Parameters.Count : 0;
if (resolvedType != null && resolvedType.FullName == method.DeclaringType.FullName && pCount == method.Parameters.Count)
{
int line, column;
if (SearchText(SearchedMemberName, objectCreateExpression.StartLocation.Line, objectCreateExpression.StartLocation.Column, out line, out column))
{
AddUniqueReference(line, column, SearchedMemberName);
}
}
}
}
IProperty property = searchedMember as IProperty;
if (property != null && objectCreateExpression.ObjectInitializer != null)
{
ResolveResult resolveResult = resolver.ResolveExpression(objectCreateExpression, ConvertLocation(objectCreateExpression.StartLocation));
if (resolveResult != null && resolveResult.ResolvedType != null)
{
IType resolvedType = resolver.Dom.GetType(resolveResult.ResolvedType);
if (resolvedType != null && resolvedType.FullName == property.DeclaringType.FullName)
{
foreach (Expression expr in objectCreateExpression.ObjectInitializer.CreateExpressions)
{
NamedArgumentExpression namedArgumentExpression = expr as NamedArgumentExpression;
if (namedArgumentExpression == null)
{
continue;
}
if (namedArgumentExpression.Name == property.Name)
{
AddUniqueReference(namedArgumentExpression.StartLocation.Line, namedArgumentExpression.StartLocation.Column, SearchedMemberName);
}
}
}
}
}
}
return(base.VisitObjectCreateExpression(objectCreateExpression, data));
}
/// <summary>
/// Creates an expression which, when evaluated, creates a List<T> in the debugee
/// filled with contents of IEnumerable<T> from the debugee.
/// </summary>
/// <param name="iEnumerableVariable">Expression for IEnumerable variable in the debugee.</param>
/// <param name="itemType">
/// The generic argument of IEnumerable<T> that <paramref name="iEnumerableVariable"/> implements.</param>
public static Expression CreateDebugListExpression(Expression iEnumerableVariable, DebugType itemType, out DebugType listType)
{
// is using itemType.AppDomain ok?
listType = DebugType.CreateFromType(itemType.AppDomain, typeof(System.Collections.Generic.List<>), itemType);
var iEnumerableType = DebugType.CreateFromType(itemType.AppDomain, typeof(IEnumerable<>), itemType);
// explicitely cast the variable to IEnumerable<T>, where T is itemType
Expression iEnumerableVariableExplicitCast = new CastExpression { Expression = iEnumerableVariable.Clone() , Type = iEnumerableType.GetTypeReference() };
var obj = new ObjectCreateExpression() { Type = listType.GetTypeReference() };
obj.Arguments.Add(iEnumerableVariableExplicitCast);
return obj;
}
public override object TrackedVisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression, object data)
{
TypeDeclaration thisTypeDeclaration = (TypeDeclaration) AstUtil.GetParentOfType(objectCreateExpression, typeof(TypeDeclaration));
if (IsTestFixture(thisTypeDeclaration))
{
string fullName = GetFullName(objectCreateExpression.CreateType);
if (CodeBase.Types.Contains(fullName))
{
TypeDeclaration typeDeclaration = (TypeDeclaration) CodeBase.Types[fullName];
IList constructors = AstUtil.GetChildrenWithType(typeDeclaration, typeof(ConstructorDeclaration));
if (ContainsInternalConstructor(constructors, objectCreateExpression))
{
Expression replacedExpression;
replacedExpression = CreateReflectionInstance(objectCreateExpression);
ReplaceCurrentNode(replacedExpression);
}
}
}
return base.TrackedVisitObjectCreateExpression(objectCreateExpression, data);
}
public virtual object VisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression, object data) {
throw new global::System.NotImplementedException("ObjectCreateExpression");
}
public override object TrackedVisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression, object data)
{
if (data as bool? ?? false) {
#if DEBUG
LoggingService.Debug("ResourceToolkit: BclNRefactoryResourceResolver found object initialization: "+objectCreateExpression.ToString());
#endif
// Resolve the constructor.
// A type derived from the declaration type is also allowed.
MemberResolveResult mrr = this.Resolve(objectCreateExpression) as MemberResolveResult;
#if DEBUG
if (mrr != null) {
LoggingService.Debug("ResourceToolkit: BclNRefactoryResourceResolver: resolved constructor: "+mrr.ResolvedMember.ToString());
}
#endif
if (mrr != null &&
mrr.ResolvedMember is IMethod &&
(mrr.ResolvedMember.DeclaringType.CompareTo(this.resourceManagerMember.ReturnType.GetUnderlyingClass()) == 0 ||
mrr.ResolvedMember.DeclaringType.IsTypeInInheritanceTree(this.resourceManagerMember.ReturnType.GetUnderlyingClass()))
) {
#if DEBUG
LoggingService.Debug("ResourceToolkit: BclNRefactoryResourceResolver: This is the correct constructor.");
#endif
// This most probably is the resource manager initialization we are looking for.
// Find a parameter that indicates the resources being referenced.
foreach (Expression param in objectCreateExpression.Parameters) {
PrimitiveExpression p = param as PrimitiveExpression;
if (p != null) {
string pValue = p.Value as string;
if (!String.IsNullOrEmpty(pValue)) {
#if DEBUG
LoggingService.Debug("ResourceToolkit: BclNRefactoryResourceResolver found string parameter: '"+pValue+"'");
#endif
this.foundResourceSet = NRefactoryResourceResolver.GetResourceSetReference(this.resourceManagerMember.DeclaringType.CompilationUnit.FileName, pValue);
#if DEBUG
if (this.foundResourceSet.FileName != null) {
LoggingService.Debug("ResourceToolkit: BclNRefactoryResourceResolver found resource file: "+this.foundResourceSet.FileName);
}
#endif
break;
}
continue;
}
// Support typeof(...)
TypeOfExpression t = param as TypeOfExpression;
if (t != null && this.PositionAvailable) {
#if DEBUG
LoggingService.Debug("ResourceToolkit: BclNRefactoryResourceResolver: Found TypeOfExpression in constructor call: " + t.ToString());
#endif
ResolveResult rr = this.Resolve(new TypeReferenceExpression(t.TypeReference), ExpressionContext.Type);
#if DEBUG
if (rr == null) {
LoggingService.Debug("ResourceToolkit: BclNRefactoryResourceResolver: The TypeReference of the TypeOfExpression could not be resolved.");
} else {
LoggingService.Debug("ResourceToolkit: BclNRefactoryResourceResolver: The TypeReference resolved to: " + rr.ToString());
}
#endif
if (rr != null) {
#if DEBUG
LoggingService.Debug("ResourceToolkit: BclNRefactoryResourceResolver found typeof(...) parameter, type: '"+rr.ResolvedType.ToString()+"'");
#endif
this.foundResourceSet = NRefactoryResourceResolver.GetResourceSetReference(this.resourceManagerMember.DeclaringType.CompilationUnit.FileName, rr.ResolvedType.FullyQualifiedName);
#if DEBUG
if (this.foundResourceSet.FileName != null) {
LoggingService.Debug("ResourceToolkit: BclNRefactoryResourceResolver found resource file: "+this.foundResourceSet.FileName);
}
#endif
break;
}
}
}
}
}
return base.TrackedVisitObjectCreateExpression(objectCreateExpression, data);
}
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 override object TrackedVisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression, object data)
{
string fullName = GetFullName(objectCreateExpression.CreateType);
if (CodeBase.References.Contains("Cons:" + fullName))
{
objectCreateExpression.Parameters.Add(new ThisReferenceExpression());
}
return base.TrackedVisitObjectCreateExpression(objectCreateExpression, data);
}
void NewExpression(
#line 2065 "cs.ATG"
out Expression pexpr) {
#line 2066 "cs.ATG"
pexpr = null;
List<Expression> parameters = new List<Expression>();
TypeReference type = null;
Expression expr;
Expect(89);
if (StartOf(10)) {
NonArrayType(
#line 2073 "cs.ATG"
out type);
}
if (la.kind == 16 || la.kind == 20) {
if (la.kind == 20) {
#line 2079 "cs.ATG"
ObjectCreateExpression oce = new ObjectCreateExpression(type, parameters);
lexer.NextToken();
#line 2080 "cs.ATG"
if (type == null) Error("Cannot use an anonymous type with arguments for the constructor");
if (StartOf(25)) {
Argument(
#line 2081 "cs.ATG"
out expr);
#line 2081 "cs.ATG"
SafeAdd(oce, parameters, expr);
while (la.kind == 14) {
lexer.NextToken();
Argument(
#line 2082 "cs.ATG"
out expr);
#line 2082 "cs.ATG"
SafeAdd(oce, parameters, expr);
}
}
Expect(21);
#line 2084 "cs.ATG"
pexpr = oce;
if (la.kind == 16) {
CollectionOrObjectInitializer(
#line 2085 "cs.ATG"
out expr);
#line 2085 "cs.ATG"
oce.ObjectInitializer = (CollectionInitializerExpression)expr;
}
} else {
#line 2086 "cs.ATG"
ObjectCreateExpression oce = new ObjectCreateExpression(type, parameters);
CollectionOrObjectInitializer(
#line 2087 "cs.ATG"
out expr);
#line 2087 "cs.ATG"
oce.ObjectInitializer = (CollectionInitializerExpression)expr;
#line 2088 "cs.ATG"
pexpr = oce;
}
} else if (la.kind == 18) {
lexer.NextToken();
#line 2093 "cs.ATG"
ArrayCreateExpression ace = new ArrayCreateExpression(type);
/* we must not change RankSpecifier on the null type reference*/
if (ace.CreateType.IsNull) { ace.CreateType = new TypeReference(""); }
pexpr = ace;
int dims = 0; List<int> ranks = new List<int>();
if (la.kind == 14 || la.kind == 19) {
while (la.kind == 14) {
lexer.NextToken();
#line 2100 "cs.ATG"
dims += 1;
}
Expect(19);
#line 2101 "cs.ATG"
ranks.Add(dims); dims = 0;
while (la.kind == 18) {
lexer.NextToken();
while (la.kind == 14) {
lexer.NextToken();
#line 2102 "cs.ATG"
++dims;
}
Expect(19);
#line 2102 "cs.ATG"
ranks.Add(dims); dims = 0;
}
#line 2103 "cs.ATG"
ace.CreateType.RankSpecifier = ranks.ToArray();
CollectionInitializer(
#line 2104 "cs.ATG"
out expr);
#line 2104 "cs.ATG"
ace.ArrayInitializer = (CollectionInitializerExpression)expr;
} else if (StartOf(6)) {
Expr(
#line 2105 "cs.ATG"
out expr);
#line 2105 "cs.ATG"
if (expr != null) parameters.Add(expr);
while (la.kind == 14) {
lexer.NextToken();
#line 2106 "cs.ATG"
dims += 1;
Expr(
#line 2107 "cs.ATG"
out expr);
#line 2107 "cs.ATG"
if (expr != null) parameters.Add(expr);
}
Expect(19);
#line 2109 "cs.ATG"
ranks.Add(dims); ace.Arguments = parameters; dims = 0;
while (la.kind == 18) {
lexer.NextToken();
while (la.kind == 14) {
lexer.NextToken();
#line 2110 "cs.ATG"
++dims;
}
Expect(19);
#line 2110 "cs.ATG"
ranks.Add(dims); dims = 0;
}
#line 2111 "cs.ATG"
ace.CreateType.RankSpecifier = ranks.ToArray();
if (la.kind == 16) {
CollectionInitializer(
#line 2112 "cs.ATG"
out expr);
#line 2112 "cs.ATG"
ace.ArrayInitializer = (CollectionInitializerExpression)expr;
}
} else SynErr(211);
} else SynErr(212);
}
public override object TrackedVisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression, object data)
{
this.Append(objectCreateExpression.CreateType.Type);
if (NRefactoryToPythonConverter.IsGenericType(objectCreateExpression))
{
this.AppendGenericTypes(objectCreateExpression);
}
this.Append("(");
bool flag = true;
foreach (Expression parameter in objectCreateExpression.Parameters)
{
if (!flag)
{
this.Append(", ");
}
parameter.AcceptVisitor(this, data);
flag = false;
}
bool flag1 = true;
foreach (Expression createExpression in objectCreateExpression.ObjectInitializer.CreateExpressions)
{
if (!flag1)
{
this.Append(", ");
}
createExpression.AcceptVisitor(this, data);
flag1 = false;
}
this.Append(")");
return null;
}
/// <summary>
/// Appends the types used when creating a generic surrounded by square brackets.
/// </summary>
void AppendGenericTypes(ObjectCreateExpression expression)
{
Append("[");
List<TypeReference> typeRefs = expression.CreateType.GenericTypes;
for (int i = 0; i < typeRefs.Count; ++i) {
if (i != 0) {
Append(", ");
}
TypeReference typeRef = typeRefs[i];
if (typeRef.IsArrayType) {
Append("Array[" + GetTypeName(typeRef) + "]");
} else {
Append(GetTypeName(typeRef));
}
}
Append("]");
}
public override object VisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression, object data)
{
return new CodeObjectCreateExpression(ConvType(objectCreateExpression.CreateType),
objectCreateExpression.Parameters == null ? null : GetExpressionList(objectCreateExpression.Parameters));
}
public override object VisitObjectCreateExpression (ObjectCreateExpression objectCreateExpression, object data)
{
if (objectCreateExpression.IsAnonymousType) {
ResolveResult result = new AnonymousTypeResolveResult (CreateAnonymousClass (objectCreateExpression.ObjectInitializer));
result.CallingType = resolver.CallingType;
result.CallingMember = resolver.CallingMember;
return result;
}
return CreateResult (objectCreateExpression.CreateType);
}
private void AppendGenericTypes(ObjectCreateExpression expression)
{
this.Append("[");
List<TypeReference> genericTypes = expression.CreateType.GenericTypes;
for (int i = 0; i < genericTypes.Count; i++)
{
if (i != 0)
{
this.Append(", ");
}
TypeReference item = genericTypes[i];
if (!item.IsArrayType)
{
this.Append(this.GetTypeName(item));
}
else
{
this.Append(string.Concat("Array[", this.GetTypeName(item), "]"));
}
}
this.Append("]");
}
public virtual object VisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression, object data)
{
Debug.Assert((objectCreateExpression != null));
Debug.Assert((objectCreateExpression.CreateType != null));
Debug.Assert((objectCreateExpression.Parameters != null));
Debug.Assert((objectCreateExpression.ObjectInitializer != null));
objectCreateExpression.CreateType.AcceptVisitor(this, data);
foreach (Expression o in objectCreateExpression.Parameters) {
Debug.Assert(o != null);
o.AcceptVisitor(this, data);
}
return objectCreateExpression.ObjectInitializer.AcceptVisitor(this, data);
}
public override object VisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression, object data)
{
if (!objectCreateExpression.ObjectInitializer.IsNull)
throw new EvaluateException(objectCreateExpression.ObjectInitializer, "Object initializers not supported");
DebugType type = objectCreateExpression.CreateType.ResolveType(context.AppDomain);
List<TypedValue> ctorArgs = EvaluateAll(objectCreateExpression.Parameters);
ConstructorInfo ctor = type.GetConstructor(BindingFlags.Default, null, CallingConventions.Any, GetTypes(ctorArgs), null);
if (ctor == null)
throw new EvaluateException(objectCreateExpression, "Constructor not found");
Value val = (Value)ctor.Invoke(GetValues(ctorArgs));
return new TypedValue(val, type);
}
public virtual object VisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression, object data) {
Debug.Assert((objectCreateExpression != null));
Debug.Assert((objectCreateExpression.CreateType != null));
Debug.Assert((objectCreateExpression.Parameters != null));
Debug.Assert((objectCreateExpression.ObjectInitializer != null));
nodeStack.Push(objectCreateExpression.CreateType);
objectCreateExpression.CreateType.AcceptVisitor(this, data);
objectCreateExpression.CreateType = ((TypeReference)(nodeStack.Pop()));
for (int i = 0; i < objectCreateExpression.Parameters.Count; i++) {
Expression o = objectCreateExpression.Parameters[i];
Debug.Assert(o != null);
nodeStack.Push(o);
o.AcceptVisitor(this, data);
o = (Expression)nodeStack.Pop();
if (o == null)
objectCreateExpression.Parameters.RemoveAt(i--);
else
objectCreateExpression.Parameters[i] = o;
}
nodeStack.Push(objectCreateExpression.ObjectInitializer);
objectCreateExpression.ObjectInitializer.AcceptVisitor(this, data);
objectCreateExpression.ObjectInitializer = ((CollectionInitializerExpression)(nodeStack.Pop()));
return null;
}
/// <summary>
/// Converts an NRefactory's ObjectCreateExpression to a code dom's
/// CodeObjectCreateExpression.
/// </summary>
public override object TrackedVisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression, object data)
{
Append(objectCreateExpression.CreateType.Type);
if (IsGenericType(objectCreateExpression)) {
AppendGenericTypes(objectCreateExpression);
}
Append("(");
// Add parameters.
bool firstParameter = true;
foreach (Expression expression in objectCreateExpression.Parameters) {
if (!firstParameter) {
Append(", ");
}
expression.AcceptVisitor(this, data);
firstParameter = false;
}
// Add object initializers.
bool firstInitializer = true;
foreach (Expression expression in objectCreateExpression.ObjectInitializer.CreateExpressions) {
if (!firstInitializer) {
Append(", ");
}
expression.AcceptVisitor(this, data);
firstInitializer = false;
}
Append(")");
return null;
}
public virtual object TrackedVisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression, object data) {
return base.VisitObjectCreateExpression(objectCreateExpression, data);
}
public override object VisitQueryExpression(QueryExpression queryExpression, object data)
{
if (this.queryExpression != null) // prevent endloss loop: var n = from n select n; n.$ (doesn't make sense, but you can type this)
return null;
this.queryExpression = queryExpression;
IReturnType type = null;
QueryExpressionSelectClause selectClause = queryExpression.SelectOrGroupClause as QueryExpressionSelectClause;
if (selectClause != null) {
InvocationExpression selectInvocation = new InvocationExpression (new MemberReferenceExpression (queryExpression.FromClause.InExpression, "Select"));
LambdaExpression selectLambdaExpr = new LambdaExpression ();
selectLambdaExpr.Parent = selectInvocation;
selectLambdaExpr.Parameters.Add (new ParameterDeclarationExpression (null, "par"));
selectLambdaExpr.ExpressionBody = selectClause.Projection;
TypeReference typeRef = new TypeReference ("System.Func");
typeRef.GenericTypes.Add (TypeReference.Null);
ResolveResult result = resolver.ResolveExpression (selectLambdaExpr, resolver.ResolvePosition, false);
typeRef.GenericTypes.Add (result.ResolvedType.ConvertToTypeReference ());
ObjectCreateExpression createExpression = new ObjectCreateExpression (typeRef, new List<Expression> (new Expression [] {
null,
selectLambdaExpr
}));
selectInvocation.Arguments.Add (createExpression);
return CreateResult (ResolveType (selectInvocation));
}
QueryExpressionGroupClause groupClause = queryExpression.SelectOrGroupClause as QueryExpressionGroupClause;
if (groupClause != null) {
InvocationExpression groupInvocation = new InvocationExpression (new MemberReferenceExpression (queryExpression.FromClause.InExpression, "GroupBy"));
LambdaExpression keyLambdaExpr = new LambdaExpression ();
keyLambdaExpr.Parent = groupInvocation;
keyLambdaExpr.Parameters.Add (new ParameterDeclarationExpression (null, "par"));
keyLambdaExpr.ExpressionBody = groupClause.GroupBy;
groupInvocation.Arguments.Add (keyLambdaExpr);
LambdaExpression elementLambdaExpr = new LambdaExpression ();
elementLambdaExpr.Parent = groupInvocation;
elementLambdaExpr.Parameters.Add (new ParameterDeclarationExpression (null, "par"));
elementLambdaExpr.ExpressionBody = groupClause.Projection;
groupInvocation.Arguments.Add (elementLambdaExpr);
return CreateResult (ResolveType (groupInvocation));
}
if (type != null)
return CreateResult (new DomReturnType("System.Collections.Generic.IEnumerable", false, new List<IReturnType> (new IReturnType[] { type })));
return null;
}
public sealed override object VisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression, object data) {
this.BeginVisit(objectCreateExpression);
object result = this.TrackedVisitObjectCreateExpression(objectCreateExpression, data);
this.EndVisit(objectCreateExpression);
return result;
}
void ObjectCreateExpression(
#line 1860 "VBNET.ATG"
out Expression oce) {
#line 1862 "VBNET.ATG"
TypeReference type = null;
Expression initializer = null;
List<Expression> arguments = null;
ArrayList dimensions = null;
oce = null;
bool canBeNormal; bool canBeReDim;
Expect(127);
NonArrayTypeName(
#line 1869 "VBNET.ATG"
out type, false);
if (la.kind == 24) {
lexer.NextToken();
NormalOrReDimArgumentList(
#line 1870 "VBNET.ATG"
out arguments, out canBeNormal, out canBeReDim);
Expect(25);
if (la.kind == 22 ||
#line 1871 "VBNET.ATG"
la.kind == Tokens.OpenParenthesis) {
if (
#line 1871 "VBNET.ATG"
la.kind == Tokens.OpenParenthesis) {
ArrayTypeModifiers(
#line 1872 "VBNET.ATG"
out dimensions);
CollectionInitializer(
#line 1873 "VBNET.ATG"
out initializer);
} else {
CollectionInitializer(
#line 1874 "VBNET.ATG"
out initializer);
}
}
#line 1876 "VBNET.ATG"
if (canBeReDim && !canBeNormal && initializer == null) initializer = new CollectionInitializerExpression();
}
#line 1879 "VBNET.ATG"
if (type == null) type = new TypeReference("Object"); // fallback type on parser errors
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;
}
}
private static bool IsGenericType(ObjectCreateExpression expression)
{
return expression.CreateType.GenericTypes.Count > 0;
}
public virtual object VisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression, object data) {
throw CreateException(objectCreateExpression);
}
void ObjectCreateExpression(
//#line 2123 "VBNET.ATG"
out Expression oce) {
//#line 2125 "VBNET.ATG"
TypeReference type = null;
CollectionInitializerExpression initializer = null;
List<Expression> arguments = null;
ArrayList dimensions = null;
oce = null;
Location startLocation = la.Location;
bool canBeNormal; bool canBeReDim;
Expect(162);
if (StartOf(8)) {
NonArrayTypeName(
//#line 2134 "VBNET.ATG"
out type, false);
if (la.kind == 37) {
lexer.NextToken();
NormalOrReDimArgumentList(
//#line 2135 "VBNET.ATG"
out arguments, out canBeNormal, out canBeReDim);
Expect(38);
if (la.kind == 35 ||
//#line 2136 "VBNET.ATG"
la.kind == Tokens.OpenParenthesis) {
if (
//#line 2136 "VBNET.ATG"
la.kind == Tokens.OpenParenthesis) {
ArrayTypeModifiers(
//#line 2137 "VBNET.ATG"
out dimensions);
CollectionInitializer(
//#line 2138 "VBNET.ATG"
out initializer);
} else {
CollectionInitializer(
//#line 2139 "VBNET.ATG"
out initializer);
}
}
//#line 2141 "VBNET.ATG"
if (canBeReDim && !canBeNormal && initializer == null) initializer = new CollectionInitializerExpression();
}
}
//#line 2145 "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);
ace.Arguments = arguments;
oce = ace;
}
if (la.kind == 126 || la.kind == 233) {
if (la.kind == 233) {
//#line 2160 "VBNET.ATG"
MemberInitializerExpression memberInitializer = null;
Expression anonymousMember = null;
lexer.NextToken();
//#line 2165 "VBNET.ATG"
CollectionInitializerExpression memberInitializers = new CollectionInitializerExpression();
memberInitializers.StartLocation = la.Location;
Expect(35);
if (la.kind == 26 || la.kind == 147) {
MemberInitializer(
//#line 2170 "VBNET.ATG"
out memberInitializer);
//#line 2171 "VBNET.ATG"
memberInitializers.CreateExpressions.Add(memberInitializer);
} else if (StartOf(24)) {
Expr(
//#line 2172 "VBNET.ATG"
out anonymousMember);
//#line 2173 "VBNET.ATG"
memberInitializers.CreateExpressions.Add(anonymousMember);
} else SynErr(270);
while (la.kind == 22) {
lexer.NextToken();
if (la.kind == 26 || la.kind == 147) {
MemberInitializer(
//#line 2177 "VBNET.ATG"
out memberInitializer);
//#line 2178 "VBNET.ATG"
memberInitializers.CreateExpressions.Add(memberInitializer);
} else if (StartOf(24)) {
Expr(
//#line 2179 "VBNET.ATG"
out anonymousMember);
//#line 2180 "VBNET.ATG"
memberInitializers.CreateExpressions.Add(anonymousMember);
} else SynErr(271);
}
Expect(36);
//#line 2185 "VBNET.ATG"
memberInitializers.EndLocation = t.Location;
if(oce is ObjectCreateExpression)
{
((ObjectCreateExpression)oce).ObjectInitializer = memberInitializers;
}
} else {
lexer.NextToken();
CollectionInitializer(
//#line 2195 "VBNET.ATG"
out initializer);
//#line 2197 "VBNET.ATG"
if(oce is ObjectCreateExpression)
((ObjectCreateExpression)oce).ObjectInitializer = initializer;
}
}
//#line 2203 "VBNET.ATG"
if (oce != null) {
oce.StartLocation = startLocation;
oce.EndLocation = t.EndLocation;
}
}
public override object VisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression, object data)
{
if (objectCreateExpression.IsAnonymousType) {
return CreateResolveResult(CreateAnonymousTypeClass(objectCreateExpression.ObjectInitializer).DefaultReturnType);
} else {
IReturnType rt = TypeVisitor.CreateReturnType(objectCreateExpression.CreateType, resolver);
if (rt == null)
return new UnknownConstructorCallResolveResult(resolver.CallingClass, resolver.CallingMember, objectCreateExpression.CreateType.ToString());
return ResolveConstructorOverload(rt, objectCreateExpression.Parameters)
?? CreateResolveResult(rt);
}
}
