Tools/Castle.DynamicProxy2/Castle.DynamicProxy/Generators/Emitters/GenericUtil.cs

   1 // Copyright 2004-2007 Castle Project - http://www.castleproject.org/
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 namespace Castle.DynamicProxy.Generators.Emitters
  16 {
  17         using System;
  18         using System.Collections.Generic;
  19         using System.Reflection;
  20         using System.Reflection.Emit;
  21
  22         internal delegate GenericTypeParameterBuilder[] ApplyGenArgs(String[] argumentNames);
  23
  24         internal class GenericUtil
  25         {
  26                 public static void PopulateGenericArguments(
  27                         AbstractTypeEmitter parentEmitter,
  28                         Dictionary<String, GenericTypeParameterBuilder> name2GenericType)
  29                 {
  30                         if (parentEmitter.GenericTypeParams == null) return;
  31
  32                         foreach(GenericTypeParameterBuilder genType in parentEmitter.GenericTypeParams)
  33                         {
  34                                 name2GenericType.Add(genType.Name, genType);
  35                         }
  36                 }
  37
  38                 public static GenericTypeParameterBuilder[] DefineGenericArguments(
  39                         Type[] genericArguments, TypeBuilder builder,
  40                         Dictionary<String, GenericTypeParameterBuilder> name2GenericType)
  41                 {
  42                         return
  43                                 DefineGenericArguments(genericArguments, name2GenericType,
  44                                                        delegate(String[] args) { return builder.DefineGenericParameters(args); });
  45                 }
  46
  47                 public static GenericTypeParameterBuilder[] DefineGenericArguments(
  48                         Type[] genericArguments,
  49                         MethodBuilder builder,
  50                         Dictionary<String, GenericTypeParameterBuilder>
  51                                 name2GenericType)
  52                 {
  53                         return
  54                                 DefineGenericArguments(genericArguments, name2GenericType,
  55                                                        delegate(String[] args) { return builder.DefineGenericParameters(args); });
  56                 }
  57
  58                 private static GenericTypeParameterBuilder[] DefineGenericArguments(
  59                         Type[] genericArguments,
  60                         Dictionary<String, GenericTypeParameterBuilder>
  61                                 name2GenericType,
  62                         ApplyGenArgs gen)
  63                 {
  64                         GenericTypeParameterBuilder[] genericTypeParams = null;
  65
  66                         String[] argumentNames = new String[genericArguments.Length];
  67
  68                         for(int i = 0; i < argumentNames.Length; i++)
  69                         {
  70                                 argumentNames[i] = genericArguments[i].Name;
  71                         }
  72
  73                         if (argumentNames.Length != 0)
  74                         {
  75                                 genericTypeParams = gen(argumentNames);
  76
  77                                 for(int i = 0; i < genericTypeParams.Length; i++)
  78                                 {
  79                                         try
  80                                         {
  81                                                 GenericParameterAttributes attributes = genericArguments[i].GenericParameterAttributes;
  82                                                 Type[] types = genericArguments[i].GetGenericParameterConstraints();
  83
  84                                                 genericTypeParams[i].SetGenericParameterAttributes(attributes);
  85
  86                                                 Type[] interfacesConstraints = Array.FindAll(types, delegate(Type type) { return type.IsInterface; });
  87
  88                                                 Type baseClassConstraint = Array.Find(types, delegate(Type type) { return type.IsClass; });
  89
  90                                                 if (interfacesConstraints.Length != 0)
  91                                                 {
  92                                                         for(int j = 0; j < interfacesConstraints.Length; ++j)
  93                                                         {
  94                                                                 interfacesConstraints[j] =
  95                                                                         SubstituteGenericArguments(interfacesConstraints[j], genericArguments, genericTypeParams);
  96                                                         }
  97                                                         genericTypeParams[i].SetInterfaceConstraints(interfacesConstraints);
  98                                                 }
  99
 100                                                 if (baseClassConstraint != null)
 101                                                 {
 102                                                         baseClassConstraint = SubstituteGenericArguments(baseClassConstraint, genericArguments, genericTypeParams);
 103                                                         genericTypeParams[i].SetBaseTypeConstraint(baseClassConstraint);
 104                                                 }
 105                                         }
 106                                         catch(NotSupportedException)
 107                                         {
 108                                                 // Doesnt matter
 109
 110                                                 genericTypeParams[i].SetGenericParameterAttributes(GenericParameterAttributes.None);
 111                                         }
 112
 113                                         if (name2GenericType.ContainsKey(argumentNames[i]))
 114                                         {
 115                                                 name2GenericType.Remove(argumentNames[i]);
 116                                         }
 117
 118                                         name2GenericType.Add(argumentNames[i], genericTypeParams[i]);
 119                                 }
 120                         }
 121
 122                         return genericTypeParams;
 123                 }
 124
 125                 private static Type SubstituteGenericArguments(
 126                         Type type, Type[] argumentsToSubstitute, GenericTypeParameterBuilder[] substitutes)
 127                 {
 128                         if (type.IsGenericType)
 129                         {
 130                                 Type[] genericArguments = type.GetGenericArguments();
 131                                 type = type.GetGenericTypeDefinition();
 132
 133                                 for(int i = 0; i < genericArguments.Length; ++i)
 134                                 {
 135                                         int substitutionIndex = Array.IndexOf(argumentsToSubstitute, genericArguments[i]);
 136                                         if (substitutionIndex != -1)
 137                                         {
 138                                                 genericArguments[i] = substitutes[substitutionIndex];
 139                                         }
 140                                 }
 141                                 return type.MakeGenericType(genericArguments);
 142                         }
 143                         else
 144                         {
 145                                 return type;
 146                         }
 147                 }
 148
 149                 public static Type[] ExtractParametersTypes(
 150                         ParameterInfo[] baseMethodParameters,
 151                         Dictionary<String, GenericTypeParameterBuilder> name2GenericType)
 152                 {
 153                         Type[] newParameters = new Type[baseMethodParameters.Length];
 154
 155                         for(int i = 0; i < baseMethodParameters.Length; i++)
 156                         {
 157                                 ParameterInfo param = baseMethodParameters[i];
 158                                 Type paramType = param.ParameterType;
 159
 160                                 newParameters[i] = ExtractCorrectType(paramType, name2GenericType);
 161                         }
 162
 163                         return newParameters;
 164                 }
 165
 166                 public static Type ExtractCorrectType(
 167                         Type paramType,
 168                         Dictionary<string, GenericTypeParameterBuilder> name2GenericType)
 169                 {
 170                         if (paramType.IsArray)
 171                         {
 172                                 int rank = paramType.GetArrayRank();
 173
 174                                 Type underlyingType = paramType.GetElementType();
 175
 176                                 if (underlyingType.IsGenericParameter)
 177                                 {
 178                                         GenericTypeParameterBuilder genericType = name2GenericType[underlyingType.Name];
 179
 180                                         if (rank == 1)
 181                                         {
 182                                                 return genericType.MakeArrayType();
 183                                         }
 184                                         else
 185                                         {
 186                                                 return genericType.MakeArrayType(rank);
 187                                         }
 188                                 }
 189                                 else
 190                                 {
 191                                         if (rank == 1)
 192                                         {
 193                                                 return underlyingType.MakeArrayType();
 194                                         }
 195                                         else
 196                                         {
 197                                                 return underlyingType.MakeArrayType(rank);
 198                                         }
 199                                 }
 200                         }
 201
 202                         if (paramType.IsGenericParameter)
 203                         {
 204                                 return name2GenericType[paramType.Name];
 205                         }
 206
 207                         return paramType;
 208                 }
 209
 210                 public static Type[] ExtractParameterTypes(ParameterInfo[] baseMethodParameters)
 211                 {
 212                         Type[] newParameters = new Type[baseMethodParameters.Length];
 213
 214                         for(int i = 0; i < baseMethodParameters.Length; i++)
 215                         {
 216                                 ParameterInfo param = baseMethodParameters[i];
 217                                 Type paramType = param.ParameterType;
 218
 219                                 newParameters[i] = paramType;
 220                         }
 221
 222                         return newParameters;
 223                 }
 224         }
 225 }