src/Boo.Lang/Runtime/MethodResolver.cs

   1 #region license
   2 // Copyright (c) 2003, 2004, 2005 Rodrigo B. de Oliveira (rbo@acm.org)
   3 // All rights reserved.
   4 //
   5 // Redistribution and use in source and binary forms, with or without modification,
   6 // are permitted provided that the following conditions are met:
   7 //
   8 //         * Redistributions of source code must retain the above copyright notice,
   9 //         this list of conditions and the following disclaimer.
  10 //         * Redistributions in binary form must reproduce the above copyright notice,
  11 //         this list of conditions and the following disclaimer in the documentation
  12 //         and/or other materials provided with the distribution.
  13 //         * Neither the name of Rodrigo B. de Oliveira nor the names of its
  14 //         contributors may be used to endorse or promote products derived from this
  15 //         software without specific prior written permission.
  16 //
  17 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  18 // ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  19 // WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  20 // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
  21 // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  23 // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  24 // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  25 // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26 // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27 #endregion
  28
  29
  30 using System;
  31 using System.Collections.Generic;
  32 using System.Reflection;
  33
  34 namespace Boo.Lang.Runtime
  35 {
  36         public class MethodResolver
  37         {
  38                 public static Type[] GetArgumentTypes(object[] arguments)
  39                 {
  40                         if (arguments.Length == 0) return DispatcherKey.NoArguments;
  41
  42                         Type[] types = new Type[arguments.Length];
  43                         for (int i = 0; i < types.Length; ++i)
  44                         {
  45                                 types[i] = GetObjectTypeOrNull(arguments[i]);
  46                         }
  47                         return types;
  48                 }
  49
  50                 private static Type GetObjectTypeOrNull(object arg)
  51                 {
  52                         if (null == arg) return null;
  53                         return arg.GetType();
  54                 }
  55
  56                 private readonly Type[] _arguments;
  57
  58                 public MethodResolver(params Type[] argumentTypes)
  59                 {
  60                         _arguments = argumentTypes;
  61                 }
  62
  63                 public CandidateMethod ResolveMethod(IEnumerable<MethodInfo> candidates)
  64                 {
  65                         List<CandidateMethod> applicable = FindApplicableMethods(candidates);
  66                         if (applicable.Count == 0) return null;
  67                         if (applicable.Count == 1) return applicable[0];
  68
  69                         List<CandidateMethod> dataPreserving = applicable.FindAll(DoesNotRequireConversions);
  70                         if (dataPreserving.Count > 0) return BestMethod(dataPreserving);
  71                         return BestMethod(applicable);
  72                 }
  73
  74                 private static bool DoesNotRequireConversions(CandidateMethod candidate)
  75                 {
  76                         return candidate.DoesNotRequireConversions;
  77                 }
  78
  79                 private CandidateMethod BestMethod(List<CandidateMethod> applicable)
  80                 {
  81                         applicable.Sort(BetterCandidate);
  82                         return applicable[applicable.Count - 1];
  83                 }
  84
  85                 private static int TotalScore(CandidateMethod c1)
  86                 {
  87                         int total = 0;
  88                         foreach (int score in c1.ArgumentScores)
  89                         {
  90                                 total += score;
  91                         }
  92                         return total;
  93                 }
  94
  95                 private int BetterCandidate(CandidateMethod c1, CandidateMethod c2)
  96                 {
  97                         int result = Math.Sign(TotalScore(c1) - TotalScore(c2));
  98                         if (result != 0) return result;
  99                         if (c1.VarArgs && !c2.VarArgs) return -1;
 100                         if (c2.VarArgs && !c1.VarArgs) return 1;
 101
 102                         int minArgumentCount = Math.Min(c1.MinimumArgumentCount, c2.MinimumArgumentCount);
 103                         for (int i = 0; i < minArgumentCount; ++i)
 104                         {
 105                                 result += MoreSpecificType(c1.GetParameterType(i), c2.GetParameterType(i));
 106                         }
 107                         if (result != 0) return result;
 108
 109                         if (c1.VarArgs && c2.VarArgs)
 110                         {
 111                                 return MoreSpecificType(c1.VarArgsParameterType, c2.VarArgsParameterType);
 112                         }
 113                         return 0;
 114                 }
 115
 116                 private static int MoreSpecificType(Type t1, Type t2)
 117                 {
 118                         // The less-generic type is more specific
 119                         int result = GetTypeGenerity(t2) - GetTypeGenerity(t1);
 120                         if (result != 0) return result;
 121
 122                         // If both types have the same generity, the deeper-nested type is more specific
 123                         return GetLogicalTypeDepth(t1) - GetLogicalTypeDepth(t2);
 124                 }
 125
 126                 private static int GetTypeGenerity(Type type)
 127                 {
 128                         if (!type.ContainsGenericParameters) return 0;
 129                         return type.GetGenericArguments().Length;
 130                 }
 131
 132                 private static int GetLogicalTypeDepth(Type type)
 133                 {
 134                         int depth = GetTypeDepth(type);
 135                         return (type.IsValueType) ? depth - 1 : depth;
 136                 }
 137
 138                 private static int GetTypeDepth(Type type)
 139                 {
 140                         if (type.IsByRef)
 141                         {
 142                                 return GetTypeDepth(type.GetElementType());
 143                         }
 144                         else if (type.IsInterface)
 145                         {
 146                                 return GetInterfaceDepth(type);
 147                         }
 148                         return GetClassDepth(type);
 149                 }
 150
 151                 private static int GetClassDepth(Type type)
 152                 {
 153                         int depth = 0;
 154                         Type objectType = typeof(object);
 155                         while (type != objectType)
 156                         {
 157                                 type = type.BaseType;
 158                                 ++depth;
 159                         }
 160                         return depth;
 161                 }
 162
 163                 private static int GetInterfaceDepth(Type type)
 164                 {
 165                         Type[] interfaces = type.GetInterfaces();
 166                         if (interfaces.Length > 0)
 167                         {
 168                                 int current = 0;
 169                                 foreach (Type i in interfaces)
 170                                 {
 171                                         int depth = GetInterfaceDepth(i);
 172                                         if (depth > current) current = depth;
 173                                 }
 174                                 return 1+current;
 175                         }
 176                         return 1;
 177                 }
 178
 179                 private List<CandidateMethod> FindApplicableMethods(IEnumerable<MethodInfo> candidates)
 180                 {
 181                         List<CandidateMethod> applicable = new List<CandidateMethod>();
 182                         foreach (MethodInfo method in candidates)
 183                         {
 184                                 CandidateMethod candidateMethod = IsApplicableMethod(method);
 185                                 if (null == candidateMethod) continue;
 186                                 applicable.Add(candidateMethod);
 187                         }
 188                         return applicable;
 189                 }
 190
 191                 private CandidateMethod IsApplicableMethod(MethodInfo method)
 192                 {
 193                         ParameterInfo[] parameters = method.GetParameters();
 194                         bool varargs = IsVarArgs(parameters);
 195                         if (!ValidArgumentCount(parameters, varargs)) return null;
 196
 197                         CandidateMethod candidateMethod = new CandidateMethod(method, _arguments.Length, varargs);
 198                         if (CalculateCandidateScore(candidateMethod)) return candidateMethod;
 199
 200                         return null;
 201                 }
 202
 203                 private bool ValidArgumentCount(ParameterInfo[] parameters, bool varargs)
 204                 {
 205                         if (varargs)
 206                         {
 207                                 int minArgumentCount = parameters.Length - 1;
 208                                 return _arguments.Length >= minArgumentCount;
 209                         }
 210                         return _arguments.Length == parameters.Length;
 211                 }
 212
 213                 private bool IsVarArgs(ParameterInfo[] parameters)
 214                 {
 215                         if (parameters.Length == 0) return false;
 216                         return HasParamArrayAttribute(parameters[parameters.Length - 1]);
 217                 }
 218
 219                 private bool HasParamArrayAttribute(ParameterInfo info)
 220                 {
 221                         return info.IsDefined(typeof(ParamArrayAttribute), true);
 222                 }
 223
 224                 private bool CalculateCandidateScore(CandidateMethod candidateMethod)
 225                 {
 226                         ParameterInfo[] parameters = candidateMethod.Parameters;
 227                         for (int i = 0; i < candidateMethod.MinimumArgumentCount; ++i)
 228                         {
 229                                 if (parameters[i].IsOut) return false;
 230
 231                                 if (!CalculateCandidateArgumentScore(candidateMethod, i, parameters[i].ParameterType))
 232                                 {
 233                                         return false;
 234                                 }
 235                         }
 236
 237                         if (candidateMethod.VarArgs)
 238                         {
 239                                 Type varArgItemType = candidateMethod.VarArgsParameterType;
 240                                 for (int i = candidateMethod.MinimumArgumentCount; i < _arguments.Length; ++i)
 241                                 {
 242                                         if (!CalculateCandidateArgumentScore(candidateMethod, i, varArgItemType))
 243                                         {
 244                                                 return false;
 245                                         }
 246                                 }
 247                         }
 248                         return true;
 249                 }
 250
 251                 private bool CalculateCandidateArgumentScore(CandidateMethod candidateMethod, int argumentIndex, Type paramType)
 252                 {
 253                         int score = CandidateMethod.CalculateArgumentScore(paramType, _arguments[argumentIndex]);
 254                         if (score < 0) return false;
 255
 256                         candidateMethod.ArgumentScores[argumentIndex] = score;
 257                         return true;
 258                 }
 259         }
 260 }