mcs/class/System.Core/System.Linq/QueryableTransformer.cs

   1 //
   2 // QueryableTransformer.cs
   3 //
   4 // Authors:
   5 //      Roei Erez (roeie@mainsoft.com)
   6 //      Jb Evain (jbevain@novell.com)
   7 //
   8 // Copyright (C) 2008 Novell, Inc (http://www.novell.com)
   9 //
  10 // Permission is hereby granted, free of charge, to any person obtaining
  11 // a copy of this software and associated documentation files (the
  12 // "Software"), to deal in the Software without restriction, including
  13 // without limitation the rights to use, copy, modify, merge, publish,
  14 // distribute, sublicense, and/or sell copies of the Software, and to
  15 // permit persons to whom the Software is furnished to do so, subject to
  16 // the following conditions:
  17 //
  18 // The above copyright notice and this permission notice shall be
  19 // included in all copies or substantial portions of the Software.
  20 //
  21 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  22 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  24 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  25 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  26 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  27 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28 //
  29
  30 using System;
  31 using System.Collections;
  32 using System.Collections.Generic;
  33 using System.Collections.ObjectModel;
  34 using System.Linq;
  35 using System.Linq.Expressions;
  36 using System.Reflection;
  37 using System.Runtime.CompilerServices;
  38
  39 namespace System.Linq {
  40
  41         class QueryableTransformer : ExpressionTransformer {
  42
  43                 protected override MethodCallExpression VisitMethodCall (MethodCallExpression methodCall)
  44                 {
  45                         if (IsQueryableExtension (methodCall.Method))
  46                                 return ReplaceQueryableMethod (methodCall);
  47
  48                         return base.VisitMethodCall (methodCall);
  49                 }
  50
  51                 protected override LambdaExpression VisitLambda (LambdaExpression lambda)
  52                 {
  53                         return lambda;
  54                 }
  55
  56                 protected override ConstantExpression VisitConstant (ConstantExpression constant)
  57                 {
  58                         var qe = constant.Value as IQueryableEnumerable;
  59                         if (qe == null)
  60                                 return constant;
  61
  62                         return Expression.Constant (qe.GetEnumerable ());
  63                 }
  64
  65                 static bool IsQueryableExtension (MethodInfo method)
  66                 {
  67                         return HasExtensionAttribute (method) &&
  68                                 method.GetParameters () [0].ParameterType.IsAssignableTo (typeof (IQueryable));
  69                 }
  70
  71                 static bool HasExtensionAttribute (MethodInfo method)
  72                 {
  73                         return method.GetCustomAttributes (typeof (ExtensionAttribute), false).Length > 0;
  74                 }
  75
  76                 MethodCallExpression ReplaceQueryableMethod (MethodCallExpression old)
  77                 {
  78                         Expression target = null;
  79                         if (old.Object != null)
  80                                 target = Visit (old.Object);
  81
  82                         var method = ReplaceQueryableMethod (old.Method);
  83                         var parameters = method.GetParameters ();
  84                         var arguments = new Expression [old.Arguments.Count];
  85
  86                         for (int i = 0; i < arguments.Length; i++) {
  87                                 arguments [i] = UnquoteIfNeeded (
  88                                         Visit (old.Arguments [i]),
  89                                         parameters [i].ParameterType);
  90                         }
  91
  92                         return new MethodCallExpression (target, method, arguments.ToReadOnlyCollection ());
  93                 }
  94
  95                 static Expression UnquoteIfNeeded (Expression expression, Type delegateType)
  96                 {
  97                         if (expression.NodeType != ExpressionType.Quote)
  98                                 return expression;
  99
 100                         var lambda = (LambdaExpression) ((UnaryExpression) expression).Operand;
 101                         if (lambda.Type == delegateType)
 102                                 return lambda;
 103
 104                         return expression;
 105                 }
 106
 107                 static Type GetTargetDeclaringType (MethodInfo method)
 108                 {
 109                         return method.DeclaringType == typeof (Queryable) ? typeof (Enumerable) : method.DeclaringType;
 110                 }
 111
 112                 static MethodInfo ReplaceQueryableMethod (MethodInfo method)
 113                 {
 114                         var result = GetMatchingMethod (method, GetTargetDeclaringType (method));
 115
 116                         if (result != null)
 117                                 return result;
 118
 119                         throw new InvalidOperationException (
 120                                 string.Format (
 121                                         "There is no method {0} on type {1} that matches the specified arguments",
 122                                         method.Name,
 123                                         method.DeclaringType.FullName));
 124                 }
 125
 126                 static MethodInfo GetMatchingMethod (MethodInfo method, Type declaring)
 127                 {
 128                         foreach (var candidate in declaring.GetMethods ()) {
 129                                 if (!MethodMatch (candidate, method))
 130                                         continue;
 131
 132                                 if (method.IsGenericMethod)
 133                                         return candidate.MakeGenericMethodFrom (method);
 134
 135                                 return candidate;
 136                         }
 137
 138                         return null;
 139                 }
 140
 141                 static bool MethodMatch (MethodInfo candidate, MethodInfo method)
 142                 {
 143                         if (candidate.Name != method.Name)
 144                                 return false;
 145
 146                         if (!HasExtensionAttribute (candidate))
 147                                 return false;
 148
 149                         var parameters = method.GetParameterTypes ();
 150
 151                         if (parameters.Length != candidate.GetParameters ().Length)
 152                                 return false;
 153
 154                         if (method.IsGenericMethod) {
 155                                 if (!candidate.IsGenericMethod)
 156                                         return false;
 157
 158                                 if (candidate.GetGenericArguments ().Length != method.GetGenericArguments ().Length)
 159                                         return false;
 160
 161                                 candidate = candidate.MakeGenericMethodFrom (method);
 162                         }
 163
 164                         if (!TypeMatch (candidate.ReturnType, method.ReturnType))
 165                                 return false;
 166
 167                         var candidate_parameters = candidate.GetParameterTypes ();
 168
 169                         if (candidate_parameters [0] != GetComparableType (parameters [0]))
 170                                 return false;
 171
 172                         for (int i = 1; i < candidate_parameters.Length; ++i)
 173                                 if (!TypeMatch (candidate_parameters [i], parameters [i]))
 174                                         return false;
 175
 176                         return true;
 177                 }
 178
 179                 static bool TypeMatch (Type candidate, Type type)
 180                 {
 181                         if (candidate == type)
 182                                 return true;
 183
 184                         return candidate == GetComparableType (type);
 185                 }
 186
 187                 static Type GetComparableType (Type type)
 188                 {
 189                         if (type.IsGenericInstanceOf (typeof (IQueryable<>)))
 190                                 type = typeof (IEnumerable<>).MakeGenericTypeFrom (type);
 191                         else if (type.IsGenericInstanceOf (typeof (IOrderedQueryable<>)))
 192                                 type = typeof (IOrderedEnumerable<>).MakeGenericTypeFrom (type);
 193                         else if (type.IsGenericInstanceOf (typeof (Expression<>)))
 194                                 type = type.GetFirstGenericArgument ();
 195                         else if (type == typeof (IQueryable))
 196                                 type = typeof (IEnumerable);
 197
 198                         return type;
 199                 }
 200         }
 201 }