Tools/Castle.DynamicProxy2/Castle.DynamicProxy/Generators/BaseProxyGenerator.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 using System;
  16 using System.Collections;
  17 using System.Reflection;
  18 using System.Reflection.Emit;
  19 using System.Runtime.Serialization;
  20 using Castle.Core.Interceptor;
  21 using Castle.DynamicProxy.Generators.Emitters;
  22 using Castle.DynamicProxy.Generators.Emitters.CodeBuilders;
  23 using Castle.DynamicProxy.Generators.Emitters.SimpleAST;
  24 using Castle.DynamicProxy.Serialization;
  25
  26 namespace Castle.DynamicProxy.Generators
  27 {
  28 #if DOTNET2
  29         using System.Collections.Generic;
  30 #endif
  31
  32         public enum ConstructorVersion
  33         {
  34                 WithTargetMethod,
  35                 WithoutTargetMethod
  36         }
  37
  38         /// <summary>
  39         /// Base class that exposes the common functionalities
  40         /// to proxy generation.
  41         /// </summary>
  42         /// <remarks>
  43         /// TODO:
  44         /// - Use the interceptor selector if provided
  45         /// - Add tests and fixes for 'leaking this' problem
  46         /// - Mixin support
  47         /// </remarks>
  48         [CLSCompliant(false)]
  49         public abstract class BaseProxyGenerator
  50         {
  51                 private static MethodInfo invocation_getArgumentsMethod = typeof (AbstractInvocation).GetMethod("get_Arguments");
  52
  53                 private readonly ModuleScope scope;
  54                 private int nestedCounter, callbackCounter;
  55                 private int fieldCount = 1;
  56                 private FieldReference typeTokenField;
  57                 private Hashtable method2TokenField = new Hashtable();
  58                 private IList generateNewSlot = new ArrayList();
  59                 protected IList methodsToSkip = new ArrayList();
  60
  61                 protected readonly Type targetType;
  62                 protected IProxyGenerationHook generationHook;
  63                 protected ConstructorInfo serializationConstructor;
  64
  65                 protected BaseProxyGenerator(ModuleScope scope, Type targetType)
  66                 {
  67                         this.scope = scope;
  68                         this.targetType = targetType;
  69                 }
  70
  71                 protected ModuleScope Scope
  72                 {
  73                         get { return scope; }
  74                 }
  75
  76                 protected virtual ClassEmitter BuildClassEmitter(String typeName, Type parentType, IList interfaceList)
  77                 {
  78                         Type[] interfaces = new Type[interfaceList.Count];
  79
  80                         interfaceList.CopyTo(interfaces, 0);
  81
  82                         return BuildClassEmitter(typeName, parentType, interfaces);
  83                 }
  84
  85                 protected virtual ClassEmitter BuildClassEmitter(String typeName, Type parentType, Type[] interfaces)
  86                 {
  87                         if (interfaces == null)
  88                         {
  89                                 interfaces = new Type[0];
  90                         }
  91
  92                         return new ClassEmitter(Scope, typeName, parentType, interfaces, true);
  93                 }
  94
  95                 /// <summary>
  96                 /// Used by dinamically implement <see cref="Core.Interceptor.IProxyTargetAccessor"/>
  97                 /// </summary>
  98                 /// <returns></returns>
  99                 protected abstract Reference GetProxyTargetReference();
 100
 101                 protected abstract bool CanOnlyProxyVirtual();
 102
 103                 #region Cache related
 104
 105                 protected Type GetFromCache(CacheKey key)
 106                 {
 107                         return scope.GetFromCache(key);
 108                 }
 109
 110                 protected void AddToCache(CacheKey key, Type type)
 111                 {
 112                         scope.RegisterInCache(key, type);
 113                 }
 114
 115                 #endregion
 116
 117                 protected MethodEmitter CreateProxiedMethod(
 118                         Type targetType,
 119                         MethodInfo method,
 120                         ClassEmitter emitter,
 121                         NestedClassEmitter invocationImpl,
 122                         FieldReference interceptorsField,
 123                         Reference targetRef,
 124                         ConstructorVersion version,
 125                         MethodInfo methodOnTarget)
 126                 {
 127                         MethodAttributes atts = ObtainMethodAttributes(method);
 128                         MethodEmitter methodEmitter = emitter.CreateMethod(method.Name, atts);
 129
 130                         return
 131                                 ImplementProxiedMethod(targetType,
 132                                                        methodEmitter,
 133                                                        method,
 134                                                        emitter,
 135                                                        invocationImpl,
 136                                                        interceptorsField,
 137                                                        targetRef,
 138                                                        version,
 139                                                        methodOnTarget);
 140                 }
 141
 142                 protected void ImplementBlankInterface(
 143                         Type targetType,
 144                         Type _interface,
 145                         ClassEmitter emitter,
 146                         FieldReference interceptorsField,
 147                         ConstructorEmitter typeInitializerConstructor)
 148                 {
 149                         PropertyToGenerate[] propsToGenerate;
 150                         EventToGenerate[] eventsToGenerate;
 151                         MethodInfo[] methods = CollectMethodsAndProperties(emitter, _interface, false, out propsToGenerate, out eventsToGenerate);
 152
 153                         Dictionary<MethodInfo, NestedClassEmitter> method2Invocation = new Dictionary<MethodInfo, NestedClassEmitter>();
 154
 155                         foreach (MethodInfo method in methods)
 156                         {
 157                                 AddFieldToCacheMethodTokenAndStatementsToInitialize(method, typeInitializerConstructor, emitter);
 158
 159                                 method2Invocation[method] =
 160                                         BuildInvocationNestedType(emitter,
 161                                                                   targetType,
 162                                                                   emitter.TypeBuilder,
 163                                                                   method,
 164                                                                   null,
 165                                                                   ConstructorVersion.WithoutTargetMethod);
 166                         }
 167
 168                         foreach (MethodInfo method in methods)
 169                         {
 170                                 if (method.IsSpecialName && (method.Name.StartsWith("get_") || method.Name.StartsWith("set_")))
 171                                 {
 172                                         continue;
 173                                 }
 174
 175                                 NestedClassEmitter nestedClass = method2Invocation[method];
 176
 177                                 MethodEmitter newProxiedMethod =
 178                                         CreateProxiedMethod(targetType,
 179                                                             method,
 180                                                             emitter,
 181                                                             nestedClass,
 182                                                             interceptorsField,
 183                                                             SelfReference.Self,
 184                                                             ConstructorVersion.WithoutTargetMethod,
 185                                                             null);
 186
 187                                 ReplicateNonInheritableAttributes(method, newProxiedMethod);
 188                         }
 189
 190                         foreach (PropertyToGenerate propToGen in propsToGenerate)
 191                         {
 192                                 if (propToGen.CanRead)
 193                                 {
 194                                         NestedClassEmitter nestedClass = method2Invocation[propToGen.GetMethod];
 195
 196                                         MethodAttributes atts = ObtainMethodAttributes(propToGen.GetMethod);
 197
 198                                         MethodEmitter getEmitter = propToGen.Emitter.CreateGetMethod(atts);
 199
 200                                         ImplementProxiedMethod(targetType,
 201                                                                getEmitter,
 202                                                                propToGen.GetMethod,
 203                                                                emitter,
 204                                                                nestedClass,
 205                                                                interceptorsField,
 206                                                                SelfReference.Self,
 207                                                                ConstructorVersion.WithoutTargetMethod,
 208                                                                null);
 209
 210                                         ReplicateNonInheritableAttributes(propToGen.GetMethod, getEmitter);
 211                                 }
 212
 213                                 if (propToGen.CanWrite)
 214                                 {
 215                                         NestedClassEmitter nestedClass = method2Invocation[propToGen.SetMethod];
 216
 217                                         MethodAttributes atts = ObtainMethodAttributes(propToGen.SetMethod);
 218
 219                                         MethodEmitter setEmitter = propToGen.Emitter.CreateSetMethod(atts);
 220
 221                                         ImplementProxiedMethod(targetType,
 222                                                                setEmitter,
 223                                                                propToGen.SetMethod,
 224                                                                emitter,
 225                                                                nestedClass,
 226                                                                interceptorsField,
 227                                                                SelfReference.Self,
 228                                                                ConstructorVersion.WithoutTargetMethod,
 229                                                                null);
 230
 231                                         ReplicateNonInheritableAttributes(propToGen.SetMethod, setEmitter);
 232                                 }
 233                         }
 234
 235                         foreach (EventToGenerate eventToGenerate in eventsToGenerate)
 236                         {
 237                                 NestedClassEmitter add_nestedClass = method2Invocation[eventToGenerate.AddMethod];
 238
 239                                 MethodAttributes add_atts = ObtainMethodAttributes(eventToGenerate.AddMethod);
 240
 241                                 MethodEmitter addEmitter = eventToGenerate.Emitter.CreateAddMethod(add_atts);
 242
 243                                 ImplementProxiedMethod(targetType,
 244                                                        addEmitter,
 245                                                        eventToGenerate.AddMethod,
 246                                                        emitter,
 247                                                        add_nestedClass,
 248                                                        interceptorsField,
 249                                                        SelfReference.Self,
 250                                                        ConstructorVersion.WithoutTargetMethod,
 251                                                        null);
 252
 253                                 ReplicateNonInheritableAttributes(eventToGenerate.AddMethod, addEmitter);
 254
 255                                 NestedClassEmitter remove_nestedClass = method2Invocation[eventToGenerate.RemoveMethod];
 256
 257                                 MethodAttributes remove_atts = ObtainMethodAttributes(eventToGenerate.RemoveMethod);
 258
 259                                 MethodEmitter removeEmitter = eventToGenerate.Emitter.CreateRemoveMethod(remove_atts);
 260
 261                                 ImplementProxiedMethod(targetType,
 262                                                        removeEmitter,
 263                                                        eventToGenerate.RemoveMethod,
 264                                                        emitter,
 265                                                        remove_nestedClass,
 266                                                        interceptorsField,
 267                                                        SelfReference.Self,
 268                                                        ConstructorVersion.WithoutTargetMethod,
 269                                                        null);
 270
 271                                 ReplicateNonInheritableAttributes(eventToGenerate.RemoveMethod, removeEmitter);
 272                         }
 273                 }
 274
 275                 protected MethodEmitter ImplementProxiedMethod(
 276                         Type targetType,
 277                         MethodEmitter methodEmitter,
 278                         MethodInfo method,
 279                         ClassEmitter emitter,
 280                         NestedClassEmitter invocationImpl,
 281                         FieldReference interceptorsField,
 282                         Reference targetRef,
 283                         ConstructorVersion version,
 284                         MethodInfo methodOnTarget)
 285                 {
 286                         methodEmitter.CopyParametersAndReturnTypeFrom(method, emitter);
 287
 288                         TypeReference[] dereferencedArguments = IndirectReference.WrapIfByRef(methodEmitter.Arguments);
 289
 290                         Type iinvocation = invocationImpl.TypeBuilder;
 291
 292                         Type[] set1 = null;
 293                         Type[] set2 = null;
 294
 295                         if (iinvocation.IsGenericType)
 296                         {
 297                                 // get type generics
 298                                 set1 = targetType.GetGenericArguments();
 299                         }
 300
 301                         if (method.IsGenericMethod)
 302                         {
 303                                 // get method generics
 304                                 set2 = method.GetGenericArguments();
 305                         }
 306
 307                         bool isGenericInvocationClass = false;
 308
 309                         if (set1 != null || set2 != null)
 310                         {
 311                                 iinvocation = iinvocation.MakeGenericType(TypeUtil.Union(set1, set2));
 312
 313                                 isGenericInvocationClass = true;
 314                         }
 315
 316                         LocalReference invocationImplLocal = methodEmitter.CodeBuilder.DeclareLocal(iinvocation);
 317
 318                         // TODO: Initialize iinvocation instance
 319                         // with ordinary arguments and in and out arguments
 320
 321                         Expression interceptors;
 322
 323                         // if (useSelector)
 324                         {
 325                                 // TODO: Generate code that checks the return of selector
 326                                 // if no interceptors is returned, should we invoke the base.Method directly?
 327                         }
 328                         // else
 329                         {
 330                                 interceptors = interceptorsField.ToExpression();
 331                         }
 332
 333                         Expression typeTokenFieldExp = typeTokenField.ToExpression();
 334                         Expression methodInfoTokenExp;
 335
 336                         if (method2TokenField.ContainsKey(method)) // Token is in the cache
 337                         {
 338                                 methodInfoTokenExp = ((FieldReference) method2TokenField[method]).ToExpression();
 339                         }
 340                         else
 341                         {
 342                                 // Not in the cache: generic method
 343
 344                                 methodInfoTokenExp = new MethodTokenExpression(method);
 345                         }
 346
 347                         ConstructorInfo constructor = invocationImpl.Constructors[0].Builder;
 348
 349                         if (isGenericInvocationClass)
 350                         {
 351                                 constructor = TypeBuilder.GetConstructor(iinvocation, invocationImpl.Constructors[0].Builder);
 352                         }
 353
 354                         NewInstanceExpression newInvocImpl;
 355
 356                         if (version == ConstructorVersion.WithTargetMethod)
 357                         {
 358                                 Expression methodOnTargetTokenExp;
 359
 360                                 if (method2TokenField.ContainsKey(methodOnTarget)) // Token is in the cache
 361                                 {
 362                                         methodOnTargetTokenExp = ((FieldReference) method2TokenField[methodOnTarget]).ToExpression();
 363                                 }
 364                                 else
 365                                 {
 366                                         // Not in the cache: generic method
 367
 368                                         methodOnTargetTokenExp = new MethodTokenExpression(methodOnTarget);
 369                                 }
 370
 371                                 newInvocImpl =
 372                                         new NewInstanceExpression(constructor,
 373                                                                   targetRef.ToExpression(),
 374                                                                   interceptors,
 375                                                                   typeTokenFieldExp,
 376                                                                   methodOnTargetTokenExp,
 377                                                                   methodInfoTokenExp,
 378                                                                   new ReferencesToObjectArrayExpression(dereferencedArguments),
 379                                                                   SelfReference.Self.ToExpression());
 380                         }
 381                         else
 382                         {
 383                                 newInvocImpl =
 384                                         new NewInstanceExpression(constructor,
 385                                                                   targetRef.ToExpression(),
 386                                                                   interceptors,
 387                                                                   typeTokenFieldExp,
 388                                                                   methodInfoTokenExp,
 389                                                                   new ReferencesToObjectArrayExpression(dereferencedArguments),
 390                                                                   SelfReference.Self.ToExpression());
 391                         }
 392
 393                         methodEmitter.CodeBuilder.AddStatement(new AssignStatement(invocationImplLocal, newInvocImpl));
 394
 395                         methodEmitter.CodeBuilder.AddStatement(
 396                                 new ExpressionStatement(new MethodInvocationExpression(invocationImplLocal, Constants.AbstractInvocationProceed)));
 397
 398                         CopyOutAndRefParameters(dereferencedArguments, invocationImplLocal, method, methodEmitter);
 399
 400                         if (method.ReturnType != typeof (void))
 401                         {
 402                                 // Emit code to return with cast from ReturnValue
 403                                 MethodInvocationExpression getRetVal =
 404                                         new MethodInvocationExpression(invocationImplLocal, typeof (AbstractInvocation).GetMethod("get_ReturnValue"));
 405
 406                                 methodEmitter.CodeBuilder.AddStatement(new ReturnStatement(new ConvertExpression(method.ReturnType, getRetVal)));
 407                         }
 408                         else
 409                         {
 410                                 methodEmitter.CodeBuilder.AddStatement(new ReturnStatement());
 411                         }
 412
 413                         return methodEmitter;
 414                 }
 415
 416                 private static void CopyOutAndRefParameters(
 417                         TypeReference[] dereferencedArguments, LocalReference invocationImplLocal, MethodInfo method, MethodEmitter methodEmitter)
 418                 {
 419                         ParameterInfo[] parameters = method.GetParameters();
 420                         bool hasByRefParam = false;
 421                         for (int i = 0; i < parameters.Length; i++)
 422                         {
 423                                 if (parameters[i].ParameterType.IsByRef)
 424                                         hasByRefParam = true;
 425                         }
 426                         if (!hasByRefParam)
 427                                 return; //saving the need to create locals if there is no need
 428                         LocalReference invocationArgs = methodEmitter.CodeBuilder.DeclareLocal(typeof (object[]));
 429                         methodEmitter.CodeBuilder.AddStatement(
 430                                 new AssignStatement(invocationArgs,
 431                                                     new MethodInvocationExpression(invocationImplLocal, invocation_getArgumentsMethod)
 432                                         )
 433                                 );
 434                         for (int i = 0; i < parameters.Length; i++)
 435                         {
 436                                 if (parameters[i].ParameterType.IsByRef)
 437                                 {
 438                                         methodEmitter.CodeBuilder.AddStatement(
 439                                                 new AssignStatement(dereferencedArguments[i],
 440                                                                     new ConvertExpression(dereferencedArguments[i].Type,
 441                                                                                           new LoadRefArrayElementExpression(i, invocationArgs)
 442                                                                         )
 443                                                         ));
 444                                 }
 445                         }
 446                 }
 447
 448                 protected void GenerateConstructor(ClassEmitter emitter, params FieldReference[] fields)
 449                 {
 450                         GenerateConstructor(emitter, null, fields);
 451                 }
 452
 453                 protected void GenerateConstructor(
 454                         ClassEmitter emitter, ConstructorInfo baseConstructor, params FieldReference[] fields)
 455                 {
 456                         ArgumentReference[] args;
 457                         ParameterInfo[] baseConstructorParams = null;
 458
 459                         if (baseConstructor != null)
 460                         {
 461                                 baseConstructorParams = baseConstructor.GetParameters();
 462                         }
 463
 464                         if (baseConstructorParams != null && baseConstructorParams.Length != 0)
 465                         {
 466                                 args = new ArgumentReference[fields.Length + baseConstructorParams.Length];
 467
 468                                 int offset = fields.Length;
 469
 470                                 for (int i = offset; i < offset + baseConstructorParams.Length; i++)
 471                                 {
 472                                         ParameterInfo paramInfo = baseConstructorParams[i - offset];
 473                                         args[i] = new ArgumentReference(paramInfo.ParameterType);
 474                                 }
 475                         }
 476                         else
 477                         {
 478                                 args = new ArgumentReference[fields.Length];
 479                         }
 480
 481                         for (int i = 0; i < fields.Length; i++)
 482                         {
 483                                 args[i] = new ArgumentReference(fields[i].Reference.FieldType);
 484                         }
 485
 486                         ConstructorEmitter constructor = emitter.CreateConstructor(args);
 487
 488                         for (int i = 0; i < fields.Length; i++)
 489                         {
 490                                 constructor.CodeBuilder.AddStatement(new AssignStatement(fields[i], args[i].ToExpression()));
 491                         }
 492
 493                         // Invoke base constructor
 494
 495                         if (baseConstructor != null)
 496                         {
 497                                 ArgumentReference[] slice = new ArgumentReference[baseConstructorParams.Length];
 498                                 Array.Copy(args, fields.Length, slice, 0, baseConstructorParams.Length);
 499
 500                                 constructor.CodeBuilder.InvokeBaseConstructor(baseConstructor, slice);
 501                         }
 502                         else
 503                         {
 504                                 constructor.CodeBuilder.InvokeBaseConstructor();
 505                         }
 506
 507                         // Invoke initialize method
 508
 509                         // constructor.CodeBuilder.AddStatement(
 510                         //      new ExpressionStatement(new MethodInvocationExpression(SelfReference.Self, initCacheMethod)));
 511
 512                         constructor.CodeBuilder.AddStatement(new ReturnStatement());
 513                 }
 514
 515                 /// <summary>
 516                 /// Generates a parameters constructor that initializes the proxy
 517                 /// state with <see cref="StandardInterceptor"/> just to make it non-null.
 518                 /// <para>
 519                 /// This constructor is important to allow proxies to be XML serializable
 520                 /// </para>
 521                 /// </summary>
 522                 protected void GenerateParameterlessConstructor(ClassEmitter emitter, Type baseClass, FieldReference interceptorField)
 523                 {
 524                         // Check if the type actually has a default constructor
 525
 526                         ConstructorInfo defaultConstructor = baseClass.GetConstructor(BindingFlags.Public, null, Type.EmptyTypes, null);
 527
 528                         if (defaultConstructor == null)
 529                         {
 530                                 defaultConstructor = baseClass.GetConstructor(BindingFlags.NonPublic, null, Type.EmptyTypes, null);
 531
 532                                 if (defaultConstructor == null || defaultConstructor.IsPrivate)
 533                                 {
 534                                         return;
 535                                 }
 536                         }
 537
 538                         ConstructorEmitter constructor = emitter.CreateConstructor();
 539
 540                         // initialize fields with an empty interceptor
 541
 542                         constructor.CodeBuilder.AddStatement(
 543                                 new AssignStatement(interceptorField, new NewArrayExpression(1, typeof (IInterceptor))));
 544                         constructor.CodeBuilder.AddStatement(
 545                                 new AssignArrayStatement(interceptorField, 0, new NewInstanceExpression(typeof (StandardInterceptor), new Type[0])));
 546
 547                         // Invoke base constructor
 548
 549                         constructor.CodeBuilder.InvokeBaseConstructor(defaultConstructor);
 550
 551                         constructor.CodeBuilder.AddStatement(new ReturnStatement());
 552                 }
 553
 554                 #region First level attributes
 555
 556                 protected MethodAttributes ObtainMethodAttributes(MethodInfo method)
 557                 {
 558                         MethodAttributes atts = MethodAttributes.Virtual;
 559
 560                         if (ShouldCreateNewSlot(method))
 561                         {
 562                                 atts |= MethodAttributes.NewSlot;
 563                         }
 564
 565                         if (method.IsPublic)
 566                         {
 567                                 atts |= MethodAttributes.Public;
 568                         }
 569
 570                         if (method.IsHideBySig)
 571                         {
 572                                 atts |= MethodAttributes.HideBySig;
 573                         }
 574                         if (InternalsHelper.IsInternal(method) && InternalsHelper.IsInternalToDynamicProxy(method.DeclaringType.Assembly))
 575                         {
 576                                 atts |= MethodAttributes.Assembly;
 577                         }
 578                         if (method.IsFamilyAndAssembly)
 579                         {
 580                                 atts |= MethodAttributes.FamANDAssem;
 581                         }
 582                         else if (method.IsFamilyOrAssembly)
 583                         {
 584                                 atts |= MethodAttributes.FamORAssem;
 585                         }
 586                         else if (method.IsFamily)
 587                         {
 588                                 atts |= MethodAttributes.Family;
 589                         }
 590
 591                         if (method.Name.StartsWith("set_") || method.Name.StartsWith("get_"))
 592                         {
 593                                 atts |= MethodAttributes.SpecialName;
 594                         }
 595
 596                         return atts;
 597                 }
 598
 599                 private PropertyAttributes ObtainPropertyAttributes(PropertyInfo property)
 600                 {
 601                         PropertyAttributes atts = PropertyAttributes.None;
 602
 603                         return atts;
 604                 }
 605
 606                 #endregion
 607
 608                 protected MethodBuilder CreateCallbackMethod(ClassEmitter emitter, MethodInfo methodInfo, MethodInfo methodOnTarget)
 609                 {
 610                         MethodInfo targetMethod = methodOnTarget != null ? methodOnTarget : methodInfo;
 611
 612                         if (targetMethod.IsAbstract)
 613                                 return null;
 614
 615                         // MethodBuild creation
 616
 617                         MethodAttributes atts = MethodAttributes.Family;
 618
 619                         String name = methodInfo.Name + "_callback_" + ++callbackCounter;
 620
 621                         MethodEmitter callBackMethod = emitter.CreateMethod(name, atts);
 622
 623                         callBackMethod.CopyParametersAndReturnTypeFrom(targetMethod, emitter);
 624
 625                         // Generic definition
 626
 627                         if (targetMethod.IsGenericMethod)
 628                         {
 629                                 targetMethod = targetMethod.MakeGenericMethod(callBackMethod.GenericTypeParams);
 630                         }
 631
 632                         // Parameters exp
 633
 634                         Expression[] exps = new Expression[callBackMethod.Arguments.Length];
 635
 636                         for (int i = 0; i < callBackMethod.Arguments.Length; i++)
 637                         {
 638                                 exps[i] = callBackMethod.Arguments[i].ToExpression();
 639                         }
 640
 641                         // invocation on base class
 642
 643                         callBackMethod.CodeBuilder.AddStatement(
 644                                 new ReturnStatement(new MethodInvocationExpression(GetProxyTargetReference(), targetMethod, exps)));
 645
 646                         return callBackMethod.MethodBuilder;
 647                 }
 648
 649                 #region IInvocation related
 650
 651                 /// <summary>
 652                 /// If callbackMethod is null the InvokeOnTarget implementation
 653                 /// is just the code to throw an exception
 654                 /// </summary>
 655                 /// <param name="emitter"></param>
 656                 /// <param name="targetType"></param>
 657                 /// <param name="targetForInvocation"></param>
 658                 /// <param name="methodInfo"></param>
 659                 /// <param name="callbackMethod"></param>
 660                 /// <param name="version"></param>
 661                 /// <returns></returns>
 662                 protected NestedClassEmitter BuildInvocationNestedType(
 663                         ClassEmitter emitter,
 664                         Type targetType,
 665                         Type targetForInvocation,
 666                         MethodInfo methodInfo,
 667                         MethodInfo callbackMethod,
 668                         ConstructorVersion version)
 669                 {
 670                         return BuildInvocationNestedType(emitter, targetType, targetForInvocation, methodInfo, callbackMethod, version, false);
 671                 }
 672
 673                 /// <summary>
 674                 /// If callbackMethod is null the InvokeOnTarget implementation
 675                 /// is just the code to throw an exception
 676                 /// </summary>
 677                 /// <param name="emitter"></param>
 678                 /// <param name="targetType"></param>
 679                 /// <param name="targetForInvocation"></param>
 680                 /// <param name="methodInfo"></param>
 681                 /// <param name="callbackMethod"></param>
 682                 /// <param name="version"></param>
 683                 /// <param name="allowChangeTarget">If true the invocation will implement the IChangeProxyTarget interface</param>
 684                 /// <returns></returns>
 685                 protected NestedClassEmitter BuildInvocationNestedType(
 686                         ClassEmitter emitter,
 687                         Type targetType,
 688                         Type targetForInvocation,
 689                         MethodInfo methodInfo,
 690                         MethodInfo callbackMethod,
 691                         ConstructorVersion version,
 692                         bool allowChangeTarget)
 693                 {
 694                         nestedCounter++;
 695
 696                         Type[] interfaces = new Type[0];
 697                         if (allowChangeTarget)
 698                         {
 699                                 interfaces = new Type[] {typeof (IChangeProxyTarget)};
 700                         }
 701
 702                         NestedClassEmitter nested =
 703                                 new NestedClassEmitter(emitter,
 704                                                        "Invocation" + methodInfo.Name + "_" + nestedCounter.ToString(),
 705                                                        typeof (AbstractInvocation),
 706                                                        interfaces);
 707
 708                         Type[] genTypes = TypeUtil.Union(targetType.GetGenericArguments(), methodInfo.GetGenericArguments());
 709 #if DOTNET2
 710                         nested.CreateGenericParameters(genTypes);
 711 #endif
 712                         // Create the invocation fields
 713
 714                         FieldReference targetRef = nested.CreateField("target", targetForInvocation);
 715
 716                         // Create constructor
 717
 718                         CreateIInvocationConstructor(targetForInvocation, nested, targetRef, version);
 719
 720                         if (allowChangeTarget)
 721                         {
 722                                 ArgumentReference argument1 = new ArgumentReference(typeof (object));
 723                                 MethodEmitter methodEmitter =
 724                                         nested.CreateMethod("ChangeInvocationTarget", new ReturnReferenceExpression(typeof (void)), MethodAttributes.Public | MethodAttributes.Virtual, argument1);
 725                                 methodEmitter.CodeBuilder.AddStatement(
 726                                         new AssignStatement(targetRef,
 727                                                             new ConvertExpression(targetType, argument1.ToExpression())
 728                                                 )
 729                                         );
 730                                 methodEmitter.CodeBuilder.AddStatement(new ReturnStatement());
 731                         }
 732
 733                         // InvokeMethodOnTarget implementation
 734
 735                         if (callbackMethod != null)
 736                         {
 737                                 ParameterInfo[] parameters = methodInfo.GetParameters();
 738
 739                                 CreateIInvocationInvokeOnTarget(emitter, nested, parameters, targetRef, callbackMethod);
 740                         }
 741                         else
 742                         {
 743                                 CreateEmptyIInvocationInvokeOnTarget(nested);
 744                         }
 745
 746                         nested.DefineCustomAttribute(new SerializableAttribute());
 747
 748                         return nested;
 749                 }
 750
 751                 protected void CreateIInvocationInvokeOnTarget(
 752                         ClassEmitter targetTypeEmitter,
 753                         NestedClassEmitter nested,
 754                         ParameterInfo[] parameters,
 755                         FieldReference targetField,
 756                         MethodInfo callbackMethod)
 757                 {
 758                         const MethodAttributes methodAtts = MethodAttributes.Public | MethodAttributes.Final | MethodAttributes.Virtual;
 759
 760                         MethodEmitter method =
 761                                 nested.CreateMethod("InvokeMethodOnTarget", new ReturnReferenceExpression(typeof (void)), methodAtts);
 762
 763                         Expression[] args = new Expression[parameters.Length];
 764
 765                         // Idea: instead of grab parameters one by one
 766                         // we should grab an array
 767                         Hashtable byRefArguments = new Hashtable();
 768                         for (int i = 0; i < parameters.Length; i++)
 769                         {
 770                                 ParameterInfo param = parameters[i];
 771
 772                                 Type paramType = param.ParameterType;
 773
 774                                 if (HasGenericParameters(paramType))
 775                                 {
 776                                         paramType = paramType.GetGenericTypeDefinition().MakeGenericType(nested.GetGenericArgumentsFor(paramType));
 777                                 }
 778                                 else if (paramType.IsGenericParameter)
 779                                 {
 780                                         paramType = nested.GetGenericArgument(paramType.Name);
 781                                 }
 782
 783                                 if (paramType.IsByRef)
 784                                 {
 785                                         LocalReference localReference = method.CodeBuilder.DeclareLocal(paramType.GetElementType());
 786                                         method.CodeBuilder.AddStatement(
 787                                                 new AssignStatement(localReference,
 788                                                                     new ConvertExpression(paramType.GetElementType(),
 789                                                                                           new MethodInvocationExpression(SelfReference.Self,
 790                                                                                                                          typeof (AbstractInvocation).GetMethod("GetArgumentValue"),
 791                                                                                                                          new LiteralIntExpression(i)))));
 792                                         ByRefReference byRefReference = new ByRefReference(localReference);
 793                                         args[i] = new ReferenceExpression(byRefReference);
 794                                         byRefArguments[i] = localReference;
 795                                 }
 796                                 else
 797                                 {
 798                                         args[i] =
 799                                                 new ConvertExpression(paramType,
 800                                                                       new MethodInvocationExpression(SelfReference.Self,
 801                                                                                                      typeof (AbstractInvocation).GetMethod("GetArgumentValue"),
 802                                                                                                      new LiteralIntExpression(i)));
 803                                 }
 804                         }
 805
 806                         MethodInvocationExpression baseMethodInvExp;
 807
 808                         if (callbackMethod.IsGenericMethod)
 809                         {
 810                                 callbackMethod = callbackMethod.MakeGenericMethod(nested.GetGenericArgumentsFor(callbackMethod));
 811                         }
 812
 813                         baseMethodInvExp = new MethodInvocationExpression(targetField, callbackMethod, args);
 814
 815                         LocalReference ret_local = null;
 816
 817                         if (callbackMethod.ReturnType != typeof (void))
 818                         {
 819                                 if (callbackMethod.ReturnType.IsGenericParameter)
 820                                 {
 821                                         ret_local = method.CodeBuilder.DeclareLocal(nested.GetGenericArgument(callbackMethod.ReturnType.Name));
 822                                 }
 823                                 else if (HasGenericParameters(callbackMethod.ReturnType))
 824                                 {
 825                                         ret_local =
 826                                                 method.CodeBuilder.DeclareLocal(
 827                                                         callbackMethod.ReturnType.GetGenericTypeDefinition().MakeGenericType(
 828                                                                 nested.GetGenericArgumentsFor(callbackMethod.ReturnType)));
 829                                 }
 830                                 else
 831                                 {
 832                                         ret_local = method.CodeBuilder.DeclareLocal(callbackMethod.ReturnType);
 833                                 }
 834
 835                                 method.CodeBuilder.AddStatement(new AssignStatement(ret_local, baseMethodInvExp));
 836                         }
 837                         else
 838                         {
 839                                 method.CodeBuilder.AddStatement(new ExpressionStatement(baseMethodInvExp));
 840                         }
 841
 842                         foreach (DictionaryEntry byRefArgument in byRefArguments)
 843                         {
 844                                 int index = (int) byRefArgument.Key;
 845                                 LocalReference localReference = (LocalReference) byRefArgument.Value;
 846                                 method.CodeBuilder.AddStatement(
 847                                         new ExpressionStatement(
 848                                                 new MethodInvocationExpression(SelfReference.Self,
 849                                                                                typeof (AbstractInvocation).GetMethod("SetArgumentValue"),
 850                                                                                new LiteralIntExpression(index),
 851                                                                                                            new ConvertExpression(typeof(object),localReference.Type,new ReferenceExpression(localReference)))
 852                                                 ));
 853                         }
 854
 855                         if (callbackMethod.ReturnType != typeof (void))
 856                         {
 857                                 MethodInvocationExpression setRetVal =
 858                                         new MethodInvocationExpression(SelfReference.Self,
 859                                                                        typeof (AbstractInvocation).GetMethod("set_ReturnValue"),
 860                                                                        new ConvertExpression(typeof (object), ret_local.Type, ret_local.ToExpression()));
 861
 862                                 method.CodeBuilder.AddStatement(new ExpressionStatement(setRetVal));
 863                         }
 864
 865                         method.CodeBuilder.AddStatement(new ReturnStatement());
 866                 }
 867
 868                 protected void CreateEmptyIInvocationInvokeOnTarget(NestedClassEmitter nested)
 869                 {
 870                         const MethodAttributes methodAtts = MethodAttributes.Public | MethodAttributes.Final | MethodAttributes.Virtual;
 871
 872                         MethodEmitter method =
 873                                 nested.CreateMethod("InvokeMethodOnTarget", new ReturnReferenceExpression(typeof (void)), methodAtts);
 874
 875                         // TODO: throw exception
 876
 877                         String message =
 878                                 String.Format("This is a DynamicProxy2 error: the interceptor attempted " +
 879                                               "to 'Proceed' for a method without a target, for example, an interface method or an abstract method");
 880
 881                         method.CodeBuilder.AddStatement(new ThrowStatement(typeof (NotImplementedException), message));
 882
 883                         method.CodeBuilder.AddStatement(new ReturnStatement());
 884                 }
 885
 886                 /// <summary>
 887                 /// Generates the constructor for the nested class that extends
 888                 /// <see cref="AbstractInvocation"/>
 889                 /// </summary>
 890                 /// <param name="targetFieldType"></param>
 891                 /// <param name="nested"></param>
 892                 /// <param name="targetField"></param>
 893                 /// <param name="version"></param>
 894                 protected void CreateIInvocationConstructor(
 895                         Type targetFieldType, NestedClassEmitter nested, FieldReference targetField, ConstructorVersion version)
 896                 {
 897                         ArgumentReference cArg0 = new ArgumentReference(targetFieldType);
 898                         ArgumentReference cArg1 = new ArgumentReference(typeof (IInterceptor[]));
 899                         ArgumentReference cArg2 = new ArgumentReference(typeof (Type));
 900                         ArgumentReference cArg3 = new ArgumentReference(typeof (MethodInfo));
 901                         ArgumentReference cArg4 = null;
 902                         ArgumentReference cArg6 = new ArgumentReference(typeof (object));
 903
 904                         if (version == ConstructorVersion.WithTargetMethod)
 905                         {
 906                                 cArg4 = new ArgumentReference(typeof (MethodInfo));
 907                         }
 908
 909                         ArgumentReference cArg5 = new ArgumentReference(typeof (object[]));
 910
 911                         ConstructorEmitter constructor;
 912
 913                         if (cArg4 == null)
 914                         {
 915                                 constructor = nested.CreateConstructor(cArg0, cArg1, cArg2, cArg3, cArg5, cArg6);
 916                         }
 917                         else
 918                         {
 919                                 constructor = nested.CreateConstructor(cArg0, cArg1, cArg2, cArg3, cArg4, cArg5, cArg6);
 920                         }
 921
 922                         constructor.CodeBuilder.AddStatement(new AssignStatement(targetField, cArg0.ToExpression()));
 923
 924                         if (cArg4 == null)
 925                         {
 926                                 constructor.CodeBuilder.InvokeBaseConstructor(Constants.AbstractInvocationConstructorWithoutTargetMethod,
 927                                                                               cArg0,
 928                                                                               cArg6,
 929                                                                               cArg1,
 930                                                                               cArg2,
 931                                                                               cArg3,
 932                                                                               cArg5);
 933                         }
 934                         else
 935                         {
 936                                 constructor.CodeBuilder.InvokeBaseConstructor(Constants.AbstractInvocationConstructorWithTargetMethod,
 937                                                                               cArg0,
 938                                                                               cArg6,
 939                                                                               cArg1,
 940                                                                               cArg2,
 941                                                                               cArg3,
 942                                                                               cArg4,
 943                                                                               cArg5);
 944                         }
 945
 946                         constructor.CodeBuilder.AddStatement(new ReturnStatement());
 947                 }
 948
 949                 #endregion
 950
 951                 #region Custom Attribute handling
 952
 953                 protected void ReplicateNonInheritableAttributes(Type targetType, ClassEmitter emitter)
 954                 {
 955                         object[] attrs = targetType.GetCustomAttributes(false);
 956
 957                         foreach (Attribute attribute in attrs)
 958                         {
 959                                 if (IsInheritable(attribute)) continue;
 960
 961                                 emitter.DefineCustomAttribute(attribute);
 962                         }
 963                 }
 964
 965                 protected void ReplicateNonInheritableAttributes(MethodInfo method, MethodEmitter emitter)
 966                 {
 967                         object[] attrs = method.GetCustomAttributes(false);
 968
 969                         foreach (Attribute attribute in attrs)
 970                         {
 971                                 if (IsInheritable(attribute)) continue;
 972
 973                                 emitter.DefineCustomAttribute(attribute);
 974                         }
 975                 }
 976
 977                 #endregion
 978
 979                 #region Type tokens related operations
 980
 981                 protected void GenerateConstructors(ClassEmitter emitter, Type baseType, params FieldReference[] fields)
 982                 {
 983                         ConstructorInfo[] constructors =
 984                                 baseType.GetConstructors(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
 985
 986                         foreach (ConstructorInfo constructor in constructors)
 987                         {
 988                                 if (constructor.IsPrivate) continue;
 989
 990                                 GenerateConstructor(emitter, constructor, fields);
 991                         }
 992                 }
 993
 994                 protected ConstructorEmitter GenerateStaticConstructor(ClassEmitter emitter)
 995                 {
 996                         return emitter.CreateTypeConstructor();
 997                 }
 998
 999                 /// <summary>
1000                 /// Improvement: this cache should be static. We should generate a
1001                 /// type constructor instead
1002                 /// </summary>
1003                 protected void CreateInitializeCacheMethodBody(
1004                         Type targetType, MethodInfo[] methods, ClassEmitter classEmitter, ConstructorEmitter typeInitializerConstructor)
1005                 {
1006                         typeTokenField = classEmitter.CreateStaticField("typeTokenCache", typeof (Type));
1007
1008                         typeInitializerConstructor.CodeBuilder.AddStatement(
1009                                 new AssignStatement(typeTokenField, new TypeTokenExpression(targetType)));
1010
1011                         CacheMethodTokens(classEmitter, methods, typeInitializerConstructor);
1012                 }
1013
1014                 protected void CacheMethodTokens(
1015                         ClassEmitter classEmitter, MethodInfo[] methods, ConstructorEmitter typeInitializerConstructor)
1016                 {
1017                         foreach (MethodInfo method in methods)
1018                         {
1019                                 // Aparently we cannot cache generic methods
1020                                 if (method.IsGenericMethod) continue;
1021
1022                                 AddFieldToCacheMethodTokenAndStatementsToInitialize(method, typeInitializerConstructor, classEmitter);
1023                         }
1024                 }
1025
1026                 protected void AddFieldToCacheMethodTokenAndStatementsToInitialize(
1027                         MethodInfo method, ConstructorEmitter typeInitializerConstructor, ClassEmitter classEmitter)
1028                 {
1029                         if (!method2TokenField.ContainsKey(method))
1030                         {
1031                                 FieldReference fieldCache =
1032                                         classEmitter.CreateStaticField("tokenCache" + fieldCount++, typeof (MethodInfo));
1033
1034                                 method2TokenField.Add(method, fieldCache);
1035
1036                                 typeInitializerConstructor.CodeBuilder.AddStatement(
1037                                         new AssignStatement(fieldCache, new MethodTokenExpression(method)));
1038                         }
1039                 }
1040
1041                 protected void CompleteInitCacheMethod(ConstructorCodeBuilder constCodeBuilder)
1042                 {
1043                         constCodeBuilder.AddStatement(new ReturnStatement());
1044                 }
1045
1046                 protected void AddDefaultInterfaces(IList interfaceList)
1047                 {
1048                         if (!interfaceList.Contains(typeof (IProxyTargetAccessor)))
1049                         {
1050                                 interfaceList.Add(typeof (IProxyTargetAccessor));
1051                         }
1052                 }
1053
1054                 protected void ImplementProxyTargetAccessor(Type targetType, ClassEmitter emitter)
1055                 {
1056                         MethodAttributes attributes = MethodAttributes.Virtual | MethodAttributes.Public;
1057
1058                         MethodEmitter methodEmitter =
1059                                 emitter.CreateMethod("DynProxyGetTarget", attributes, new ReturnReferenceExpression(typeof (object)));
1060
1061                         methodEmitter.CodeBuilder.AddStatement(
1062                                 new ReturnStatement(new ConvertExpression(typeof (object), targetType, GetProxyTargetReference().ToExpression())));
1063                 }
1064
1065                 #endregion
1066
1067                 #region Utility methods
1068
1069                 protected void CollectMethodsToProxy(ArrayList methodList, Type type, bool onlyVirtuals)
1070                 {
1071                         CollectMethods(methodList, type, onlyVirtuals);
1072
1073                         if (type.IsInterface)
1074                         {
1075                                 Type[] typeChain = type.FindInterfaces(new TypeFilter(NoFilter), null);
1076
1077                                 foreach (Type interType in typeChain)
1078                                 {
1079                                         CollectMethods(methodList, interType, onlyVirtuals);
1080                                 }
1081                         }
1082                 }
1083
1084                 protected void CollectPropertyMethodsToProxy(
1085                         ArrayList methodList, Type type, bool onlyVirtuals, ClassEmitter emitter, out PropertyToGenerate[] propsToGenerate)
1086                 {
1087                         if (type.IsInterface)
1088                         {
1089                                 ArrayList toGenerateList = new ArrayList();
1090
1091                                 toGenerateList.AddRange(CollectProperties(methodList, type, onlyVirtuals, emitter));
1092
1093                                 Type[] typeChain = type.FindInterfaces(new TypeFilter(NoFilter), null);
1094
1095                                 foreach (Type interType in typeChain)
1096                                 {
1097                                         toGenerateList.AddRange(CollectProperties(methodList, interType, onlyVirtuals, emitter));
1098                                 }
1099
1100                                 propsToGenerate = (PropertyToGenerate[]) toGenerateList.ToArray(typeof (PropertyToGenerate));
1101                         }
1102                         else
1103                         {
1104                                 propsToGenerate = CollectProperties(methodList, type, onlyVirtuals, emitter);
1105                         }
1106                 }
1107
1108                 /// <summary>
1109                 /// Performs some basic screening and invokes the <see cref="IProxyGenerationHook"/>
1110                 /// to select methods.
1111                 /// </summary>
1112                 /// <param name="method"></param>
1113                 /// <param name="onlyVirtuals"></param>
1114                 /// <returns></returns>
1115                 protected bool AcceptMethod(MethodInfo method, bool onlyVirtuals)
1116                 {
1117                         // we can never intercept a sealed (final) method
1118                         if (method.IsFinal)
1119                                 return false;
1120
1121                         bool isInternalsAndNotVisibleToDynamicProxy = InternalsHelper.IsInternal(method)
1122                                                                       && InternalsHelper.IsInternalToDynamicProxy(method.DeclaringType.Assembly) == false;
1123                         if (isInternalsAndNotVisibleToDynamicProxy)
1124                                 return false;
1125
1126                         if (onlyVirtuals && !method.IsVirtual)
1127                         {
1128                                 if (method.DeclaringType != typeof (object) && method.DeclaringType != typeof (MarshalByRefObject))
1129                                 {
1130                                         generationHook.NonVirtualMemberNotification(targetType, method);
1131                                 }
1132
1133                                 return false;
1134                         }
1135
1136                         //can only proxy methods that are public or protected (or internals that have already been checked above)
1137                         if ((method.IsPublic || method.IsFamily || method.IsAssembly) == false)
1138                                 return false;
1139
1140                         if (method.DeclaringType == typeof (object))
1141                         {
1142                                 return false;
1143                         }
1144                         if (method.DeclaringType == typeof (MarshalByRefObject))
1145                         {
1146                                 return false;
1147                         }
1148
1149                         return generationHook.ShouldInterceptMethod(targetType, method);
1150                         ;
1151                 }
1152
1153                 protected MethodInfo[] CollectMethodsAndProperties(
1154                         ClassEmitter emitter,
1155                         Type targetType,
1156                         out PropertyToGenerate[] propsToGenerate,
1157                         out EventToGenerate[] eventsToGenerate)
1158                 {
1159                         bool onlyVirtuals = CanOnlyProxyVirtual();
1160
1161                         return CollectMethodsAndProperties(emitter, targetType, onlyVirtuals, out propsToGenerate, out eventsToGenerate);
1162                 }
1163
1164                 protected MethodInfo[] CollectMethodsAndProperties(
1165                         ClassEmitter emitter,
1166                         Type targetType,
1167                         bool onlyVirtuals,
1168                         out PropertyToGenerate[] propsToGenerate,
1169                         out EventToGenerate[] eventsToGenerate)
1170                 {
1171                         ArrayList methodsList = new ArrayList();
1172
1173                         CollectMethodsToProxy(methodsList, targetType, onlyVirtuals);
1174                         CollectPropertyMethodsToProxy(methodsList, targetType, onlyVirtuals, emitter, out propsToGenerate);
1175                         CollectEventMethodsToProxy(methodsList, targetType, onlyVirtuals, emitter, out eventsToGenerate);
1176                         return (MethodInfo[]) methodsList.ToArray(typeof (MethodInfo));
1177                 }
1178
1179                 private void CollectEventMethodsToProxy(
1180                         ArrayList methodList, Type type, bool onlyVirtuals, ClassEmitter emitter, out EventToGenerate[] eventsToGenerates)
1181                 {
1182                         if (type.IsInterface)
1183                         {
1184                                 ArrayList toGenerateList = new ArrayList();
1185
1186                                 toGenerateList.AddRange(CollectEvents(methodList, type, onlyVirtuals, emitter));
1187
1188                                 Type[] typeChain = type.FindInterfaces(new TypeFilter(NoFilter), null);
1189
1190                                 foreach (Type interType in typeChain)
1191                                 {
1192                                         toGenerateList.AddRange(CollectEvents(methodList, interType, onlyVirtuals, emitter));
1193                                 }
1194
1195                                 eventsToGenerates = (EventToGenerate[]) toGenerateList.ToArray(typeof (EventToGenerate));
1196                         }
1197                         else
1198                         {
1199                                 eventsToGenerates = CollectEvents(methodList, type, onlyVirtuals, emitter);
1200                         }
1201                 }
1202
1203                 /// <summary>
1204                 /// Checks if the method is public or protected.
1205                 /// </summary>
1206                 /// <param name="method"></param>
1207                 /// <returns></returns>
1208                 private bool IsAccessible(MethodInfo method)
1209                 {
1210                         return method.IsPublic || method.IsFamily || method.IsFamilyAndAssembly || method.IsFamilyOrAssembly;
1211                 }
1212
1213                 private bool HasGenericParameters(Type type)
1214                 {
1215                         if (type.IsGenericType)
1216                         {
1217                                 Type[] genTypes = type.GetGenericArguments();
1218
1219                                 foreach (Type genType in genTypes)
1220                                 {
1221                                         if (genType.IsGenericParameter)
1222                                         {
1223                                                 return true;
1224                                         }
1225                                 }
1226                         }
1227
1228                         return false;
1229                 }
1230
1231                 private bool NoFilter(Type type, object filterCriteria)
1232                 {
1233                         return true;
1234                 }
1235
1236                 private void CollectMethods(ArrayList methodsList, Type type, bool onlyVirtuals)
1237                 {
1238                         BindingFlags flags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
1239
1240                         MethodInfo[] methods = type.GetMethods(flags);
1241
1242                         foreach (MethodInfo method in methods)
1243                         {
1244                                 if (method.IsFinal)
1245                                 {
1246                                         AddMethodToGenerateNewSlot(method);
1247                                         continue;
1248                                 }
1249
1250                                 if (method.IsSpecialName)
1251                                 {
1252                                         continue;
1253                                 }
1254
1255                                 if (AcceptMethod(method, onlyVirtuals))
1256                                 {
1257                                         methodsList.Add(method);
1258                                 }
1259                         }
1260                 }
1261
1262                 private EventToGenerate[] CollectEvents(ArrayList methodList, Type type, bool onlyVirtuals, ClassEmitter emitter)
1263                 {
1264                         ArrayList toGenerateList = new ArrayList();
1265
1266                         BindingFlags flags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
1267
1268                         EventInfo[] events = type.GetEvents(flags);
1269
1270                         foreach (EventInfo eventInfo in events)
1271                         {
1272                                 MethodInfo addMethod = eventInfo.GetAddMethod(true);
1273                                 MethodInfo removeMethod = eventInfo.GetRemoveMethod(true);
1274                                 bool shouldGenerate = false;
1275
1276                                 if (addMethod != null && IsAccessible(addMethod) && AcceptMethod(addMethod, onlyVirtuals))
1277                                 {
1278                                         shouldGenerate = true;
1279                                         methodList.Add(addMethod);
1280                                 }
1281
1282                                 if (removeMethod != null && IsAccessible(removeMethod) && AcceptMethod(removeMethod, onlyVirtuals))
1283                                 {
1284                                         shouldGenerate = true;
1285                                         methodList.Add(removeMethod);
1286                                 }
1287
1288                                 if (shouldGenerate == false)
1289                                         continue;
1290
1291                                 EventAttributes atts = ObtainEventAttributes(eventInfo);
1292
1293                                 EventEmitter eventEmitter = emitter.CreateEvent(eventInfo.Name, atts, eventInfo.EventHandlerType);
1294
1295                                 EventToGenerate eventToGenerate = new EventToGenerate(eventEmitter, addMethod, removeMethod, atts);
1296
1297                                 toGenerateList.Add(eventToGenerate);
1298                         }
1299
1300                         return (EventToGenerate[]) toGenerateList.ToArray(typeof (EventToGenerate));
1301                 }
1302
1303                 private EventAttributes ObtainEventAttributes(EventInfo eventInfo)
1304                 {
1305                         return EventAttributes.None;
1306                 }
1307
1308                 private PropertyToGenerate[] CollectProperties(
1309                         ArrayList methodList, Type type, bool onlyVirtuals, ClassEmitter emitter)
1310                 {
1311                         ArrayList toGenerateList = new ArrayList();
1312
1313                         BindingFlags flags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
1314
1315                         PropertyInfo[] properties = type.GetProperties(flags);
1316
1317                         foreach (PropertyInfo propInfo in properties)
1318                         {
1319                                 bool generateReadable, generateWritable;
1320
1321                                 generateWritable = generateReadable = false;
1322
1323                                 MethodInfo setMethod, getMethod;
1324                                 setMethod = getMethod = null;
1325
1326                                 if (propInfo.CanRead)
1327                                 {
1328                                         getMethod = propInfo.GetGetMethod(true);
1329
1330                                         if (IsAccessible(getMethod) && AcceptMethod(getMethod, onlyVirtuals))
1331                                         {
1332                                                 methodList.Add(getMethod);
1333                                                 generateReadable = true;
1334                                         }
1335                                 }
1336
1337                                 if (propInfo.CanWrite)
1338                                 {
1339                                         setMethod = propInfo.GetSetMethod(true);
1340
1341                                         if (IsAccessible(setMethod) && AcceptMethod(setMethod, onlyVirtuals))
1342                                         {
1343                                                 methodList.Add(setMethod);
1344                                                 generateWritable = true;
1345                                         }
1346                                 }
1347
1348                                 if (!generateWritable && !generateReadable)
1349                                 {
1350                                         continue;
1351                                 }
1352
1353                                 PropertyAttributes atts = ObtainPropertyAttributes(propInfo);
1354
1355                                 PropertyEmitter propEmitter = emitter.CreateProperty(propInfo.Name, atts, propInfo.PropertyType);
1356
1357                                 PropertyToGenerate propToGenerate =
1358                                         new PropertyToGenerate(generateReadable, generateWritable, propEmitter, getMethod, setMethod);
1359
1360                                 toGenerateList.Add(propToGenerate);
1361                         }
1362
1363                         return (PropertyToGenerate[]) toGenerateList.ToArray(typeof (PropertyToGenerate));
1364                 }
1365
1366                 private bool IsInheritable(Attribute attribute)
1367                 {
1368                         object[] attrs = attribute.GetType().GetCustomAttributes(typeof (AttributeUsageAttribute), true);
1369
1370                         if (attrs.Length != 0)
1371                         {
1372                                 AttributeUsageAttribute usage = (AttributeUsageAttribute) attrs[0];
1373
1374                                 return usage.Inherited;
1375                         }
1376
1377                         return true;
1378                 }
1379
1380                 #endregion
1381
1382                 protected void AddMethodToGenerateNewSlot(MethodInfo method)
1383                 {
1384                         generateNewSlot.Add(method);
1385                 }
1386
1387                 /// <summary>
1388                 /// Checks if the method has the same signature as a method that was marked as
1389                 /// one that should generate a new vtable slot.
1390                 /// </summary>
1391                 protected bool ShouldCreateNewSlot(MethodInfo method)
1392                 {
1393                         string methodStr = method.ToString();
1394                         foreach (MethodInfo candidate in generateNewSlot)
1395                         {
1396                                 if (candidate.ToString() == methodStr)
1397                                         return true;
1398                         }
1399                         return false;
1400                 }
1401
1402                 protected virtual void ImplementGetObjectData(ClassEmitter emitter, FieldReference interceptorsField, Type[] interfaces)
1403                 {
1404                         /*// To prevent re-implementation of this interface.
1405                         _generated.Add(typeof(ISerializable));*/
1406
1407                         if (interfaces == null)
1408                                 interfaces = new Type[0];
1409
1410                         Type[] get_type_args = new Type[] {typeof (String), typeof (bool), typeof (bool)};
1411                         Type[] key_and_object = new Type[] {typeof (String), typeof (Object)};
1412                         MethodInfo addValueMethod = typeof (SerializationInfo).GetMethod("AddValue", key_and_object);
1413
1414                         ArgumentReference arg1 = new ArgumentReference(typeof (SerializationInfo));
1415                         ArgumentReference arg2 = new ArgumentReference(typeof (StreamingContext));
1416                         MethodEmitter getObjectData = emitter.CreateMethod("GetObjectData",
1417                                                                            new ReturnReferenceExpression(typeof (void)), arg1, arg2);
1418
1419                         LocalReference typeLocal = getObjectData.CodeBuilder.DeclareLocal(typeof (Type));
1420
1421                         getObjectData.CodeBuilder.AddStatement(new AssignStatement(
1422                                                                 typeLocal,
1423                                                                 new MethodInvocationExpression(null,
1424                                                                                                typeof (Type).GetMethod("GetType",
1425                                                                                                                        get_type_args),
1426                                                                                                new ConstReference(
1427                                                                                                 typeof (ProxyObjectReference).
1428                                                                                                         AssemblyQualifiedName).ToExpression(),
1429                                                                                                new ConstReference(1).ToExpression(),
1430                                                                                                new ConstReference(0).ToExpression())));
1431
1432                         getObjectData.CodeBuilder.AddStatement(new ExpressionStatement(
1433                                                                 new MethodInvocationExpression(
1434                                                                         arg1, typeof (SerializationInfo).GetMethod("SetType"),
1435                                                                         typeLocal.ToExpression())));
1436
1437                         getObjectData.CodeBuilder.AddStatement(new ExpressionStatement(
1438                                                                 new MethodInvocationExpression(arg1, addValueMethod,
1439                                                                                                new ConstReference("__interceptors").
1440                                                                                                 ToExpression(),
1441                                                                                                interceptorsField.ToExpression())));
1442
1443                         LocalReference interfacesLocal =
1444                                 getObjectData.CodeBuilder.DeclareLocal(typeof (String[]));
1445
1446                         getObjectData.CodeBuilder.AddStatement(
1447                                 new AssignStatement(interfacesLocal,
1448                                                     new NewArrayExpression(interfaces.Length, typeof (String))));
1449
1450                         for (int i = 0; i < interfaces.Length; i++)
1451                         {
1452                                 getObjectData.CodeBuilder.AddStatement(new AssignArrayStatement(
1453                                                                         interfacesLocal, i,
1454                                                                         new ConstReference(interfaces[i].AssemblyQualifiedName).ToExpression()));
1455                         }
1456
1457                         getObjectData.CodeBuilder.AddStatement(new ExpressionStatement(
1458                                                                 new MethodInvocationExpression(arg1, addValueMethod,
1459                                                                                                new ConstReference("__interfaces").
1460                                                                                                 ToExpression(),
1461                                                                                                interfacesLocal.ToExpression())));
1462
1463                         getObjectData.CodeBuilder.AddStatement(new ExpressionStatement(
1464                                                                 new MethodInvocationExpression(arg1, addValueMethod,
1465                                                                                                new ConstReference("__baseType").
1466                                                                                                 ToExpression(),
1467                                                                                                new TypeTokenExpression(emitter.BaseType))));
1468
1469                         CustomizeGetObjectData(getObjectData.CodeBuilder, arg1, arg2);
1470
1471                         getObjectData.CodeBuilder.AddStatement(new ReturnStatement());
1472                 }
1473
1474                 protected virtual void CustomizeGetObjectData(
1475                         AbstractCodeBuilder codebuilder, ArgumentReference arg1,
1476                         ArgumentReference arg2)
1477                 {
1478                 }
1479
1480
1481                 protected bool VerifyIfBaseImplementsGetObjectData(Type baseType)
1482                 {
1483                         // If base type implements ISerializable, we have to make sure
1484                         // the GetObjectData is marked as virtual
1485
1486                         if (typeof (ISerializable).IsAssignableFrom(baseType))
1487                         {
1488                                 MethodInfo getObjectDataMethod = baseType.GetMethod("GetObjectData",
1489                                                                                     new Type[] {typeof (SerializationInfo), typeof (StreamingContext)});
1490
1491                                 if (getObjectDataMethod == null) //explicit interface implementation
1492                                 {
1493                                         return false;
1494                                 }
1495
1496                                 if (!getObjectDataMethod.IsVirtual || getObjectDataMethod.IsFinal)
1497                                 {
1498                                         String message = String.Format("The type {0} implements ISerializable, but GetObjectData is not marked as virtual",
1499                                                                        baseType.FullName);
1500                                         throw new ArgumentException(message);
1501                                 }
1502
1503                                 methodsToSkip.Add(getObjectDataMethod);
1504
1505                                 serializationConstructor = baseType.GetConstructor(
1506                                         BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic,
1507                                         null,
1508                                         new Type[] {typeof (SerializationInfo), typeof (StreamingContext)},
1509                                         null);
1510
1511                                 if (serializationConstructor == null)
1512                                 {
1513                                         String message = String.Format("The type {0} implements ISerializable, but failed to provide a deserialization constructor", baseType.FullName);
1514                                         throw new ArgumentException(message);
1515                                 }
1516
1517                                 return true;
1518                         }
1519                         return false;
1520                 }
1521         }
1522 }