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 Expression VisitMethodCall (MethodCallExpression methodCall)
  44                 {
  45                         if (IsQueryableExtension (methodCall.Method))
  46                                 return ReplaceQueryableMethod (methodCall);
  47
  48                         return base.VisitMethodCall (methodCall);
  49                 }
  50
  51                 protected override Expression VisitLambda (LambdaExpression lambda)
  52                 {
  53                         return lambda;
  54                 }
  55
  56                 protected override Expression 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 target_type = GetTargetDeclaringType (method);
 115                         var result = GetMatchingMethod (method, target_type);
 116
 117                         if (result != null)
 118                                 return result;
 119
 120                         throw new InvalidOperationException (
 121                                 string.Format (
 122                                         "There is no method {0} on type {1} that matches the specified arguments",
 123                                         method.Name,
 124                                         target_type.FullName));
 125                 }
 126
 127                 static MethodInfo GetMatchingMethod (MethodInfo method, Type declaring)
 128                 {
 129                         foreach (var candidate in declaring.GetMethods ()) {
 130                                 if (!MethodMatch (candidate, method))
 131                                         continue;
 132
 133                                 if (method.IsGenericMethod)
 134                                         return candidate.MakeGenericMethodFrom (method);
 135
 136                                 return candidate;
 137                         }
 138
 139                         return null;
 140                 }
 141
 142                 static bool MethodMatch (MethodInfo candidate, MethodInfo method)
 143                 {
 144                         if (candidate.Name != method.Name)
 145                                 return false;
 146
 147                         if (!HasExtensionAttribute (candidate))
 148                                 return false;
 149
 150                         var parameters = method.GetParameterTypes ();
 151
 152                         if (parameters.Length != candidate.GetParameters ().Length)
 153                                 return false;
 154
 155                         if (method.IsGenericMethod) {
 156                                 if (!candidate.IsGenericMethod)
 157                                         return false;
 158
 159                                 if (candidate.GetGenericArguments ().Length != method.GetGenericArguments ().Length)
 160                                         return false;
 161
 162                                 candidate = candidate.MakeGenericMethodFrom (method);
 163                         }
 164
 165                         if (!TypeMatch (candidate.ReturnType, method.ReturnType))
 166                                 return false;
 167
 168                         var candidate_parameters = candidate.GetParameterTypes ();
 169
 170                         if (candidate_parameters [0] != GetComparableType (parameters [0]))
 171                                 return false;
 172
 173                         for (int i = 1; i < candidate_parameters.Length; ++i)
 174                                 if (!TypeMatch (candidate_parameters [i], parameters [i]))
 175                                         return false;
 176
 177                         return true;
 178                 }
 179
 180                 static bool TypeMatch (Type candidate, Type type)
 181                 {
 182                         if (candidate == type)
 183                                 return true;
 184
 185                         return candidate == GetComparableType (type);
 186                 }
 187
 188                 static Type GetComparableType (Type type)
 189                 {
 190                         if (type.IsGenericInstanceOf (typeof (IQueryable<>)))
 191                                 type = typeof (IEnumerable<>).MakeGenericTypeFrom (type);
 192                         else if (type.IsGenericInstanceOf (typeof (IOrderedQueryable<>)))
 193                                 type = typeof (IOrderedEnumerable<>).MakeGenericTypeFrom (type);
 194                         else if (type.IsGenericInstanceOf (typeof (Expression<>)))
 195                                 type = type.GetFirstGenericArgument ();
 196                         else if (type == typeof (IQueryable))
 197                                 type = typeof (IEnumerable);
 198
 199                         return type;
 200                 }
 201         }
 202 }