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