return next.BuildQueryClause (ec, lSide);
}
- public override Expression DoResolve (ResolveContext ec)
+ protected override Expression DoResolve (ResolveContext ec)
{
int counter = QueryBlock.TransparentParameter.Counter;
Expression e = BuildQueryClause (ec, null);
- e = e.Resolve (ec);
+ if (e != null)
+ e = e.Resolve (ec);
//
// Reset counter in probing mode to ensure that all transparent
}
}
- abstract class AQueryClause : Expression
+ abstract class AQueryClause : ShimExpression
{
class QueryExpressionAccess : MemberAccess
{
Argument a = arguments [0];
if (TypeManager.IsGenericType (source_type) && TypeManager.ContainsGenericParameters (source_type)) {
-#if GMCS_SOURCE
TypeInferenceContext tic = new TypeInferenceContext (TypeManager.GetTypeArguments (source_type));
tic.OutputTypeInference (ec, a.Expr, source_type);
if (tic.FixAllTypes (ec)) {
source_type = TypeManager.DropGenericTypeArguments (source_type).MakeGenericType (tic.InferredTypeArguments);
}
-#else
- throw new NotSupportedException ();
-#endif
}
if (!Convert.ImplicitConversionExists (ec, a.Expr, source_type)) {
// TODO: protected
public AQueryClause next;
- public Expression expr;
protected ToplevelBlock block;
protected AQueryClause (ToplevelBlock block, Expression expr, Location loc)
+ : base (expr)
{
this.block = block;
- this.expr = expr;
this.loc = loc;
}
protected override void CloneTo (CloneContext clonectx, Expression target)
{
+ base.CloneTo (clonectx, target);
+
AQueryClause t = (AQueryClause) target;
- if (expr != null)
- t.expr = expr.Clone (clonectx);
if (block != null)
t.block = (ToplevelBlock) block.Clone (clonectx);
t.next = (AQueryClause) next.Clone (clonectx);
}
- public override Expression CreateExpressionTree (ResolveContext ec)
- {
- // Should not be reached
- throw new NotSupportedException ("ET");
- }
-
- public override Expression DoResolve (ResolveContext ec)
+ protected override Expression DoResolve (ResolveContext ec)
{
- return expr.DoResolve (ec);
+ return expr.Resolve (ec);
}
public virtual Expression BuildQueryClause (ResolveContext ec, Expression lSide)
new QueryExpressionAccess (lSide, MethodName, typeArguments, loc), arguments);
}
- public override void Emit (EmitContext ec)
- {
- throw new NotSupportedException ();
- }
-
protected abstract string MethodName { get; }
- public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
- {
- // Nothing to mutate
- }
-
public virtual AQueryClause Next {
set {
next = value;
{
sealed class RangeAnonymousTypeParameter : AnonymousTypeParameter
{
- public RangeAnonymousTypeParameter (Expression initializer, LocatedToken parameter)
+ public RangeAnonymousTypeParameter (Expression initializer, SimpleMemberName parameter)
: base (initializer, parameter.Value, parameter.Location)
{
}
{
}
- protected static Expression CreateRangeVariableType (ToplevelBlock block, IMemberContext context, LocatedToken name, Expression init)
+ protected static Expression CreateRangeVariableType (ToplevelBlock block, IMemberContext context, SimpleMemberName name, Expression init)
{
ArrayList args = new ArrayList (2);
args.Add (new AnonymousTypeParameter (block.Parameters [0]));
args.Add (new RangeAnonymousTypeParameter (init, name));
- return new AnonymousTypeDeclaration (args, context.CurrentTypeDefinition, name.Location);
+ return new NewAnonymousType (args, context.CurrentTypeDefinition, name.Location);
}
}
public override Expression BuildQueryClause (ResolveContext ec, Expression lSide)
{
+ expr = expr.Resolve (ec);
+ if (expr == null)
+ return null;
+
+ if (TypeManager.IsDynamicType (expr.Type) || expr.Type == TypeManager.void_type) {
+ ec.Report.Error (1979, expr.Location,
+ "Query expression with a source or join sequence of type `{0}' is not allowed",
+ TypeManager.CSharpName (expr.Type));
+ return null;
+ }
+
return next.BuildQueryClause (ec, expr);
}
- public override Expression DoResolve (ResolveContext ec)
+ protected override Expression DoResolve (ResolveContext ec)
{
Expression e = BuildQueryClause (ec, null);
return e.Resolve (ec);
class Join : ARangeVariableQueryClause
{
- readonly LocatedToken lt;
+ readonly SimpleMemberName lt;
ToplevelBlock inner_selector, outer_selector;
- public Join (ToplevelBlock block, LocatedToken lt, Expression inner, ToplevelBlock outerSelector, ToplevelBlock innerSelector, Location loc)
+ public Join (ToplevelBlock block, SimpleMemberName lt, Expression inner, ToplevelBlock outerSelector, ToplevelBlock innerSelector, Location loc)
: base (block, inner)
{
this.lt = lt;
args.Add (new Argument (lambda));
Expression result_selector_expr;
- LocatedToken into_variable = GetIntoVariable ();
+ SimpleMemberName into_variable = GetIntoVariable ();
//
// When select follows use is as result selector
//
if (next is Select) {
- result_selector_expr = next.expr;
+ result_selector_expr = next.Expr;
next = next.next;
} else {
result_selector_expr = CreateRangeVariableType (block, ec.MemberContext, into_variable,
args.Add (new Argument (result_selector));
}
- protected virtual LocatedToken GetIntoVariable ()
+ protected virtual SimpleMemberName GetIntoVariable ()
{
return lt;
}
class GroupJoin : Join
{
- readonly LocatedToken into;
+ readonly SimpleMemberName into;
- public GroupJoin (ToplevelBlock block, LocatedToken lt, Expression inner,
- ToplevelBlock outerSelector, ToplevelBlock innerSelector, LocatedToken into, Location loc)
+ public GroupJoin (ToplevelBlock block, SimpleMemberName lt, Expression inner,
+ ToplevelBlock outerSelector, ToplevelBlock innerSelector, SimpleMemberName into, Location loc)
: base (block, lt, inner, outerSelector, innerSelector, loc)
{
this.into = into;
}
- protected override LocatedToken GetIntoVariable ()
+ protected override SimpleMemberName GetIntoVariable ()
{
return into;
}
class Let : ARangeVariableQueryClause
{
- public Let (ToplevelBlock block, TypeContainer container, LocatedToken identifier, Expression expr)
+ public Let (ToplevelBlock block, TypeContainer container, SimpleMemberName identifier, Expression expr)
: base (block, CreateRangeVariableType (block, container, identifier, expr))
{
}
class SelectMany : ARangeVariableQueryClause
{
- LocatedToken lt;
+ SimpleMemberName lt;
- public SelectMany (ToplevelBlock block, LocatedToken lt, Expression expr)
+ public SelectMany (ToplevelBlock block, SimpleMemberName lt, Expression expr)
: base (block, expr)
{
this.lt = lt;
// When select follow use is as result selector
//
if (next is Select) {
- result_selector_expr = next.expr;
+ result_selector_expr = next.Expr;
next = next.next;
} else {
result_selector_expr = CreateRangeVariableType (block, ec.MemberContext, lt, new SimpleName (lt.Value, lt.Location));
class Where : AQueryClause
{
- public Where (ToplevelBlock block, Expression expr, Location loc)
+ public Where (ToplevelBlock block, BooleanExpression expr, Location loc)
: base (block, expr, loc)
{
}
public readonly ParametersCompiled Parent;
public readonly string Identifier;
- public TransparentParameter (ParametersCompiled parent, LocatedToken identifier)
+ public TransparentParameter (ParametersCompiled parent, SimpleMemberName identifier)
: base (ParameterNamePrefix + Counter++, identifier.Location)
{
Parent = parent;
}
}
- public QueryBlock (CompilerContext ctx, Block parent, LocatedToken lt, Location start)
- : base (ctx, parent, new ParametersCompiled (new ImplicitQueryParameter (lt.Value, lt.Location)), start)
+ public QueryBlock (CompilerContext ctx, Block parent, SimpleMemberName lt, Location start)
+ : base (ctx, parent, new ParametersCompiled (ctx, new ImplicitQueryParameter (lt.Value, lt.Location)), start)
{
if (parent != null)
base.CheckParentConflictName (parent.Toplevel, lt.Value, lt.Location);
}
- public QueryBlock (CompilerContext ctx, Block parent, ParametersCompiled parameters, LocatedToken lt, Location start)
- : base (ctx, parent, new ParametersCompiled (parameters [0].Clone (), new ImplicitQueryParameter (lt.Value, lt.Location)), start)
+ public QueryBlock (CompilerContext ctx, Block parent, ParametersCompiled parameters, SimpleMemberName lt, Location start)
+ : base (ctx, parent, new ParametersCompiled (ctx, parameters [0].Clone (), new ImplicitQueryParameter (lt.Value, lt.Location)), start)
{
}
{
}
- public void AddTransparentParameter (LocatedToken name)
+ public void AddTransparentParameter (CompilerContext ctx, SimpleMemberName name)
{
base.CheckParentConflictName (this, name.Value, name.Location);
- parameters = new ParametersCompiled (new TransparentParameter (parameters, name));
+ parameters = new ParametersCompiled (ctx, new TransparentParameter (parameters, name));
}
protected override bool CheckParentConflictName (ToplevelBlock block, string name, Location l)
projects / mono.git / blobdiff