//
//
- public class QueryExpression : ARangeVariableQueryClause
+ public class QueryExpression : AQueryClause
{
- public QueryExpression (Block block, AQueryClause query)
- : base (block, null, query.Location)
+ LocatedToken variable;
+
+ public QueryExpression (LocatedToken variable, AQueryClause query)
+ : base (null, query.Location)
{
+ this.variable = variable;
this.next = query;
}
+ public override Expression BuildQueryClause (EmitContext ec, Expression lSide, Parameter parentParameter, TransparentIdentifiersScope ti)
+ {
+ Parameter p = CreateBlockParameter (variable);
+ return next.BuildQueryClause (ec, lSide, p, ti);
+ }
+
public override Expression DoResolve (EmitContext ec)
{
Expression e = BuildQueryClause (ec, null, null, null);
}
}
- class QueryExpressionInvocation : Invocation
+ class QueryExpressionInvocation : Invocation, MethodGroupExpr.IErrorHandler
{
public QueryExpressionInvocation (QueryExpressionAccess expr, ArrayList arguments)
: base (expr, arguments)
protected override MethodGroupExpr DoResolveOverload (EmitContext ec)
{
- int errors = Report.Errors;
- MethodGroupExpr rmg = mg.OverloadResolve (ec, Arguments, true, loc);
- if (rmg == null && errors == Report.Errors) {
- // TODO: investigate whether would be better to re-use extension methods error handling
- Report.Error (1936, loc, "An implementation of `{0}' query expression pattern for source type `{1}' could not be found",
- mg.Name, TypeManager.CSharpName (mg.Type));
+ MethodGroupExpr.CustomErrorHandler = this;
+ MethodGroupExpr rmg = mg.OverloadResolve (ec, Arguments, false, loc);
+ MethodGroupExpr.CustomErrorHandler = null;
+ return rmg;
+ }
+
+ public bool NoExactMatch (EmitContext ec, MethodBase method)
+ {
+ ParameterData pd = TypeManager.GetParameterData (method);
+ Type source_type = pd.ExtensionMethodType;
+ if (source_type != null) {
+ Argument a = (Argument) Arguments [0];
+
+ if (source_type.IsGenericType && source_type.ContainsGenericParameters) {
+ TypeInferenceContext tic = new TypeInferenceContext (source_type.GetGenericArguments ());
+ tic.OutputTypeInference (ec, a.Expr, source_type);
+ if (tic.FixAllTypes ()) {
+ source_type = source_type.GetGenericTypeDefinition ().MakeGenericType (tic.InferredTypeArguments);
+ }
+ }
+
+ if (!Convert.ImplicitConversionExists (ec, a.Expr, source_type)) {
+ Report.Error (1936, loc, "An implementation of `{0}' query expression pattern for source type `{1}' could not be found",
+ mg.Name, TypeManager.CSharpName (a.Type));
+ return true;
+ }
}
- return rmg;
+ if (!method.IsGenericMethod)
+ return false;
+
+ Report.Error (1942, loc, "Type inference failed to infer type argument for `{0}' clause. " +
+ "Try specifying the type argument explicitly",
+ mg.Name.ToLower ());
+ return true;
}
}
this.expr = expr;
this.loc = loc;
}
+
+ protected override void CloneTo (CloneContext clonectx, Expression target)
+ {
+ AQueryClause t = (AQueryClause) target;
+ if (expr != null)
+ t.expr = expr.Clone (clonectx);
+
+ if (next != null)
+ t.next = (AQueryClause)next.Clone (clonectx);
+ }
public override Expression DoResolve (EmitContext ec)
{
public virtual Expression BuildQueryClause (EmitContext ec, Expression lSide, Parameter parameter, TransparentIdentifiersScope ti)
{
ArrayList args = new ArrayList (1);
- args.Add (new Argument (CreateSelector (ec, expr, parameter, ti)));
+ args.Add (CreateSelectorArgument (ec, expr, parameter, ti));
lSide = CreateQueryExpression (lSide, args);
if (next != null) {
Select s = next as Select;
if (s == null || s.IsRequired (parameter))
return next.BuildQueryClause (ec, lSide, parameter, ti);
+
+ // Skip transparent select clause if any clause follows
+ if (next.next != null)
+ return next.next.BuildQueryClause (ec, lSide, parameter, ti);
}
return lSide;
}
+ protected static Parameter CreateBlockParameter (LocatedToken li)
+ {
+ return new ImplicitQueryParameter (li);
+ }
+
protected Invocation CreateQueryExpression (Expression lSide, ArrayList arguments)
{
return new QueryExpressionInvocation (
new QueryExpressionAccess (lSide, MethodName, typeArguments, loc), arguments);
}
- protected LambdaExpression CreateSelector (EmitContext ec, Expression expr, Parameter parameter, TransparentIdentifiersScope ti)
+ protected Argument CreateSelectorArgument (EmitContext ec, Expression expr, Parameter parameter, TransparentIdentifiersScope ti)
{
- return CreateSelector (ec, expr, new Parameter [] { parameter }, ti);
+ return CreateSelectorArgument (ec, expr, new Parameter [] { parameter }, ti);
}
- protected LambdaExpression CreateSelector (EmitContext ec, Expression expr, Parameter[] parameters, TransparentIdentifiersScope ti)
+ protected Argument CreateSelectorArgument (EmitContext ec, Expression expr, Parameter[] parameters, TransparentIdentifiersScope ti)
{
Parameters p = new Parameters (parameters);
LambdaExpression selector = new LambdaExpression (
- null, null, (TypeContainer) ec.DeclContainer, p, ec.CurrentBlock, loc);
+ null, null, (TypeContainer)ec.TypeContainer, p, ec.CurrentBlock, loc);
selector.Block = new SelectorBlock (ec.CurrentBlock, p, ti, loc);
selector.Block.AddStatement (new Return (expr, loc));
- selector.CreateAnonymousHelpers ();
- selector.RootScope.DefineType ();
+ if (!ec.IsInProbingMode) {
+ selector.CreateAnonymousHelpers ();
- return selector;
+ // TODO: I am not sure where this should be done to work
+ // correctly with anonymous containerss and was called only once
+ // FIXME: selector.RootScope == null for nested anonymous
+ // methods only ?
+ if (selector.RootScope != null)
+ selector.RootScope.DefineType ();
+ }
+
+ return new Argument (selector);
}
public override void Emit (EmitContext ec)
//
public abstract class ARangeVariableQueryClause : AQueryClause
{
- public readonly Block block;
+ LocatedToken variable;
protected Expression element_selector;
- protected ARangeVariableQueryClause (Block block, Expression expr, Location loc)
+ protected ARangeVariableQueryClause (LocatedToken variable, Expression expr, Location loc)
: base (expr, loc)
{
- this.block = block;
+ this.variable = variable;
}
protected virtual void AddSelectorArguments (EmitContext ec, ArrayList args, Parameter parentParameter,
- Parameter parameter, TransparentIdentifiersScope ti)
+ ref Parameter parameter, TransparentIdentifiersScope ti)
{
- args.Add (new Argument (CreateSelector (ec, expr, parentParameter, null)));
- args.Add (new Argument (CreateSelector (ec, element_selector,
- new Parameter [] { parentParameter, parameter }, ti)));
+ args.Add (CreateSelectorArgument (ec, expr, parentParameter, ti));
+ args.Add (CreateSelectorArgument (ec, element_selector,
+ new Parameter [] { parentParameter, parameter }, ti));
}
//
//
public override Expression BuildQueryClause (EmitContext ec, Expression lSide, Parameter parentParameter, TransparentIdentifiersScope ti)
{
- ICollection values = block.Variables.Values;
- if (values.Count != 1)
- throw new NotImplementedException ("Count != 1");
-
- IEnumerator enumerator = values.GetEnumerator ();
- enumerator.MoveNext ();
- LocalInfo li = (LocalInfo) enumerator.Current;
-
- Parameter parameter;
- if (li.Type == ImplicitQueryParameter.ImplicitType.Instance) {
- parameter = new ImplicitQueryParameter (li);
- } else {
- parameter = new Parameter (li.Type, li.Name, Parameter.Modifier.NONE, null, li.Location);
- }
-
- if (parentParameter == null)
- return next.BuildQueryClause (ec, expr, parameter, ti);
+ Parameter parameter = CreateBlockParameter (variable);
if (next != null) {
//
ArrayList transp_args = new ArrayList (2);
transp_args.Add (new AnonymousTypeParameter (parentParameter));
transp_args.Add (CreateAnonymousTypeVariable (parameter));
- element_selector = new AnonymousTypeDeclaration (transp_args, (TypeContainer) ec.DeclContainer, loc);
+ element_selector = new AnonymousTypeDeclaration (transp_args, (TypeContainer) ec.TypeContainer, loc);
}
- ArrayList args = new ArrayList (2);
- AddSelectorArguments (ec, args, parentParameter, parameter, ti);
+ ArrayList args = new ArrayList ();
+ AddSelectorArguments (ec, args, parentParameter, ref parameter, ti);
lSide = CreateQueryExpression (lSide, args);
if (next != null) {
//
- // Parameter indentifiers goes to the scope
+ // Parameter identifiers go to the scope
//
string[] identifiers;
if (ti == null) {
return lSide;
}
-
+
+ protected override void CloneTo (CloneContext clonectx, Expression target)
+ {
+ ARangeVariableQueryClause t = (ARangeVariableQueryClause) target;
+ if (element_selector != null)
+ t.element_selector = element_selector.Clone (clonectx);
+ base.CloneTo (clonectx, t);
+ }
+
//
// For transparent identifiers, creates an instance of variable expression
//
public class Cast : QueryStartClause
{
+ // We don't have to clone cast type
readonly Expression type_expr;
public Cast (Expression type, Expression expr)
this.type_expr = type;
}
- protected override void CloneTo (CloneContext clonectx, Expression target)
- {
- // We don't have to clone cast type
- Cast t = (Cast) target;
- t.expr = expr.Clone (clonectx);
- }
-
public override Expression BuildQueryClause (EmitContext ec, Expression lSide, Parameter parameter, TransparentIdentifiersScope ti)
{
lSide = CreateQueryExpression (expr, new TypeArguments (loc, type_expr), null);
public class GroupBy : AQueryClause
{
- readonly Expression element_selector;
+ Expression element_selector;
public GroupBy (Expression elementSelector, Expression keySelector, Location loc)
: base (keySelector, loc)
public override Expression BuildQueryClause (EmitContext ec, Expression lSide, Parameter parameter, TransparentIdentifiersScope ti)
{
ArrayList args = new ArrayList (2);
- args.Add (new Argument (CreateSelector (ec, expr, parameter, ti)));
+ args.Add (CreateSelectorArgument (ec, expr, parameter, ti));
// A query can be optimized when selector is not group by specific
if (!element_selector.Equals (lSide))
- args.Add (new Argument (CreateSelector (ec, element_selector, parameter, ti)));
+ args.Add (CreateSelectorArgument (ec, element_selector, parameter, ti));
lSide = CreateQueryExpression (lSide, args);
if (next != null)
return lSide;
}
+
+ protected override void CloneTo (CloneContext clonectx, Expression target)
+ {
+ GroupBy t = (GroupBy) target;
+ t.element_selector = element_selector.Clone (clonectx);
+ base.CloneTo (clonectx, t);
+ }
protected override string MethodName {
get { return "GroupBy"; }
}
}
+ public class Join : ARangeVariableQueryClause
+ {
+ Expression projection;
+ Expression inner_selector, outer_selector;
+
+ public Join (LocatedToken variable, Expression inner, Expression outerSelector, Expression innerSelector, Location loc)
+ : base (variable, inner, loc)
+ {
+ this.outer_selector = outerSelector;
+ this.inner_selector = innerSelector;
+ }
+
+ protected override void AddSelectorArguments (EmitContext ec, ArrayList args, Parameter parentParameter,
+ ref Parameter parameter, TransparentIdentifiersScope ti)
+ {
+ args.Add (new Argument (expr));
+ args.Add (CreateSelectorArgument (ec, outer_selector, parentParameter, ti));
+ args.Add (CreateSelectorArgument (ec, inner_selector, parameter, ti));
+
+ parameter = CreateResultSelectorParameter (parameter);
+ if (projection == null) {
+ ArrayList join_args = new ArrayList (2);
+ join_args.Add (new AnonymousTypeParameter (parentParameter));
+ join_args.Add (new AnonymousTypeParameter (parameter));
+ projection = new AnonymousTypeDeclaration (join_args, (TypeContainer) ec.TypeContainer, loc);
+ }
+
+ args.Add (CreateSelectorArgument (ec, projection,
+ new Parameter [] { parentParameter, parameter }, ti));
+ }
+
+ protected override void CloneTo (CloneContext clonectx, Expression target)
+ {
+ Join t = (Join) target;
+ t.projection = projection.Clone (clonectx);
+ t.inner_selector = inner_selector.Clone (clonectx);
+ t.outer_selector = outer_selector.Clone (clonectx);
+ base.CloneTo (clonectx, t);
+ }
+
+ protected virtual Parameter CreateResultSelectorParameter (Parameter parameter)
+ {
+ return parameter;
+ }
+
+ public override AQueryClause Next {
+ set {
+ // Use select as join projection
+ if (value is Select) {
+ projection = value.expr;
+ next = value.next;
+ return;
+ }
+
+ base.Next = value;
+ }
+ }
+
+ protected override string MethodName {
+ get { return "Join"; }
+ }
+ }
+
+ public class GroupJoin : Join
+ {
+ readonly LocatedToken into_variable;
+
+ public GroupJoin (LocatedToken variable, Expression inner, Expression outerSelector, Expression innerSelector,
+ LocatedToken into, Location loc)
+ : base (variable, inner, outerSelector, innerSelector, loc)
+ {
+ this.into_variable = into;
+ }
+
+ protected override Parameter CreateResultSelectorParameter (Parameter parameter)
+ {
+ //
+ // into variable is used as result selector and it's passed as
+ // transparent identifiers to the next clause
+ //
+ return CreateBlockParameter (into_variable);
+ }
+
+ protected override string MethodName {
+ get { return "GroupJoin"; }
+ }
+ }
+
public class Let : ARangeVariableQueryClause
{
class RangeAnonymousTypeParameter : AnonymousTypeParameter
return e;
}
+
+ protected override void Error_InvalidInitializer (Expression initializer)
+ {
+ Report.Error (1932, loc, "A range variable `{0}' cannot be initialized with `{1}'",
+ Name, initializer.GetSignatureForError ());
+ }
}
- public Let (Block block, Expression expr)
- : base (block, expr, expr.Location)
+ public Let (LocatedToken variable, Expression expr, Location loc)
+ : base (variable, expr, loc)
{
}
- protected override void AddSelectorArguments (EmitContext ec, ArrayList args, Parameter parentParameter, Parameter parameter,
- TransparentIdentifiersScope ti)
+ protected override void AddSelectorArguments (EmitContext ec, ArrayList args, Parameter parentParameter,
+ ref Parameter parameter, TransparentIdentifiersScope ti)
{
- args.Add (new Argument (CreateSelector (ec, element_selector, parentParameter, ti)));
+ args.Add (CreateSelectorArgument (ec, element_selector, parentParameter, ti));
}
protected override AnonymousTypeParameter CreateAnonymousTypeVariable (Parameter parameter)
public class SelectMany : ARangeVariableQueryClause
{
- public SelectMany (Block block, Expression expr)
- : base (block, expr, expr.Location)
+ public SelectMany (LocatedToken variable, Expression expr)
+ : base (variable, expr, expr.Location)
{
}
}
}
- readonly LocalInfo variable;
-
- public ImplicitQueryParameter (LocalInfo variable)
- : base (variable.Name, variable.Location)
+ public ImplicitQueryParameter (LocatedToken variable)
+ : base (variable.Value, variable.Location)
{
- this.variable = variable;
- }
-
- public override bool Resolve (IResolveContext ec)
- {
- if (!base.Resolve (ec))
- return false;
-
- variable.VariableType = parameter_type;
- return true;
}
}
if (ident == null)
return null;
- return new MemberAccess (CreateIndentifierNestingExpression (ident), name);
+ return new MemberAccess (CreateIdentifierNestingExpression (ident), name);
}
TransparentIdentifiersScope FindIdentifier (string name)
return parent.FindIdentifier (name);
}
- Expression CreateIndentifierNestingExpression (TransparentIdentifiersScope end)
+ Expression CreateIdentifierNestingExpression (TransparentIdentifiersScope end)
{
Expression expr = new SimpleName (parameter.Name, parameter.Location);
TransparentIdentifiersScope current = this;
public override Expression GetTransparentIdentifier (string name)
{
- if (transparent_identifiers == null)
- return null;
+ Expression expr = null;
+ if (transparent_identifiers != null)
+ expr = transparent_identifiers.GetIdentifier (name);
+
+ if (expr != null || Container == null)
+ return expr;
+
+ return Container.GetTransparentIdentifier (name);
+ }
+ }
- return transparent_identifiers.GetIdentifier (name);
+ //
+ // This block is actually never used, it is used by parser only
+ //
+ public class QueryBlock : Block
+ {
+ Hashtable range_variables = new Hashtable ();
+
+ public QueryBlock (Block parent, Location start)
+ : base (parent, start, Location.Null)
+ {
+ }
+
+ protected override void AddVariable (LocalInfo li)
+ {
+ string name = li.Name;
+ if (range_variables.Contains (name)) {
+ Location conflict = (Location)range_variables [name];
+ Report.SymbolRelatedToPreviousError (conflict, name);
+ Error_AlreadyDeclared (li.Location, name);
+ return;
+ }
+
+ range_variables.Add (name, li.Location);
+ }
+
+ protected override void Error_AlreadyDeclared (Location loc, string var, string reason)
+ {
+ Report.Error (1931, loc, "A range variable `{0}' conflicts with a previous declaration of `{0}'",
+ var);
+ }
+
+ protected override void Error_AlreadyDeclared (Location loc, string var)
+ {
+ Report.Error (1930, loc, "A range variable `{0}' has already been declared in this scope",
+ var);
+ }
+
+ protected override void Error_AlreadyDeclaredTypeParameter (Location loc, string name)
+ {
+ Report.Error (1948, loc, "A range variable `{0}' conflicts with a method type parameter",
+ name);
}
}
}