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);

                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 override object VisitQueryExpression(QueryExpression queryExpression, object data)
        {
            QueryExpressionSelectClause selectClause = queryExpression.SelectOrGroupClause as QueryExpressionSelectClause;
            QueryExpressionGroupClause  groupClause  = queryExpression.SelectOrGroupClause as QueryExpressionGroupClause;

            if (selectClause != null)
            {
                // Fake a call to 'Select'
                var fakeInvocation = new InvocationExpression(new MemberReferenceExpression(
                                                                  queryExpression.FromClause.InExpression, "Select"));

                var selector = new LambdaExpression();
                selector.Parameters.Add(new ParameterDeclarationExpression(null, "__rangeVariable"));
                selector.ExpressionBody = selectClause.Projection;
                selector.Parent         = fakeInvocation;

                fakeInvocation.Arguments.Add(selector);

                return(CreateResolveResult(ResolveType(fakeInvocation)));
            }
            else if (groupClause != null)
            {
                // Fake a call to 'GroupBy'
                var fakeInvocation = new InvocationExpression(new MemberReferenceExpression(
                                                                  queryExpression.FromClause.InExpression, "GroupBy"));

                var keySelector = new LambdaExpression();
                keySelector.Parameters.Add(new ParameterDeclarationExpression(null, "__rangeVariable"));
                keySelector.ExpressionBody = groupClause.GroupBy;
                keySelector.Parent         = fakeInvocation;

                var elementSelector = new LambdaExpression();
                elementSelector.Parameters.Add(new ParameterDeclarationExpression(null, "__rangeVariable"));
                elementSelector.ExpressionBody = groupClause.Projection;
                elementSelector.Parent         = fakeInvocation;

                fakeInvocation.Arguments.Add(keySelector);
                fakeInvocation.Arguments.Add(elementSelector);

                return(CreateResolveResult(ResolveType(fakeInvocation)));
            }
            else
            {
                return(null);
            }
        }
Example #3
0
			public override object Visit (Mono.CSharp.Linq.Select sel)
			{
				var result = new QueryExpressionSelectClause ();
				var location = LocationsBag.GetLocations (sel);
				result.AddChild (new CSharpTokenNode (Convert (location[0]), "select".Length), QueryExpressionWhereClause.Roles.Keyword);
				result.AddChild ((INode)sel.Expr.Accept (this), QueryExpressionWhereClause.Roles.Expression);
				return result;
			}
 public override object VisitQueryExpressionSelectClause(QueryExpressionSelectClause queryExpressionSelectClause,
                                                         object data)
 {
     ProcessQuery(queryExpressionSelectClause.Projection);
     return(base.VisitQueryExpressionSelectClause(queryExpressionSelectClause, data));
 }
Example #5
0
 public object VisitQueryExpressionSelectClause(QueryExpressionSelectClause queryExpressionSelectClause, object data)
 {
     AddError(queryExpressionSelectClause, "queryExpressionSelectClause is not supported.");
     return(null);
 }
 public virtual object VisitQueryExpressionSelectClause(QueryExpressionSelectClause queryExpressionSelectClause, object data)
 {
     throw new global::System.NotImplementedException("QueryExpressionSelectClause");
 }
Example #7
0
	void QueryExpressionSelectClause(
#line  2507 "cs.ATG" 
out QueryExpressionSelectClause sc) {

#line  2508 "cs.ATG" 
		Expression expr; sc = new QueryExpressionSelectClause(); sc.StartLocation = la.Location; 
		Expect(133);
		Expr(
#line  2511 "cs.ATG" 
out expr);

#line  2511 "cs.ATG" 
		sc.Projection = expr; 

#line  2512 "cs.ATG" 
		sc.EndLocation = t.EndLocation; 
	}
Example #8
0
 public override object VisitQueryExpressionSelectClause(QueryExpressionSelectClause queryExpressionSelectClause, object data)
 {
     return(base.VisitQueryExpressionSelectClause(queryExpressionSelectClause, data));
 }
 public object VisitQueryExpressionSelectClause(QueryExpressionSelectClause queryExpressionSelectClause, object data)
 {
     throw new NotImplementedException();
 }
		public virtual object VisitQueryExpressionSelectClause(QueryExpressionSelectClause queryExpressionSelectClause, object data) {
			Debug.Assert((queryExpressionSelectClause != null));
			Debug.Assert((queryExpressionSelectClause.Projection != null));
			return queryExpressionSelectClause.Projection.AcceptVisitor(this, data);
		}
 private bool IsMatch(QueryExpressionSelectClause left, QueryExpressionSelectClause right)
 {
     return(true);
 }
		public virtual object VisitQueryExpressionSelectClause(QueryExpressionSelectClause queryExpressionSelectClause, object data) {
			throw new global::System.NotImplementedException("QueryExpressionSelectClause");
		}
		public virtual object VisitQueryExpressionSelectClause(QueryExpressionSelectClause queryExpressionSelectClause, object data) {
			Debug.Assert((queryExpressionSelectClause != null));
			Debug.Assert((queryExpressionSelectClause.Projection != null));
			nodeStack.Push(queryExpressionSelectClause.Projection);
			queryExpressionSelectClause.Projection.AcceptVisitor(this, data);
			queryExpressionSelectClause.Projection = ((Expression)(nodeStack.Pop()));
			return null;
		}
		public sealed override object VisitQueryExpressionSelectClause(QueryExpressionSelectClause queryExpressionSelectClause, object data) {
			BeginVisit(queryExpressionSelectClause);
			object result = TrackedVisitQueryExpressionSelectClause(queryExpressionSelectClause, data);
			EndVisit(queryExpressionSelectClause);
			return result;
		}
		public virtual object TrackedVisitQueryExpressionSelectClause(QueryExpressionSelectClause queryExpressionSelectClause, object data) {
			return base.VisitQueryExpressionSelectClause(queryExpressionSelectClause, data);
		}