mcs/class/Mono.CSharp/monotouch.cs

   1 //
   2 // monotouch.cs: iOS System.Reflection.Emit API needed to simplify mcs compilation
   3 //
   4 // Authors:
   5 //      Marek Safar  <marek.safar@gmail.com>
   6 //
   7 // Copyright (C) 2014 Xamarin Inc (http://www.xamarin.com)
   8 //
   9 // Permission is hereby granted, free of charge, to any person obtaining
  10 // a copy of this software and associated documentation files (the
  11 // "Software"), to deal in the Software without restriction, including
  12 // without limitation the rights to use, copy, modify, merge, publish,
  13 // distribute, sublicense, and/or sell copies of the Software, and to
  14 // permit persons to whom the Software is furnished to do so, subject to
  15 // the following conditions:
  16 //
  17 // The above copyright notice and this permission notice shall be
  18 // included in all copies or substantial portions of the Software.
  19 //
  20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  23 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  24 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  25 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  26 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27 //
  28
  29 namespace System.Reflection.Emit
  30 {
  31         public class ILGenerator
  32         {
  33                 public void BeginCatchBlock (Type exceptionType)
  34                 {
  35                         throw new NotSupportedException ();
  36                 }
  37
  38                 public Label BeginExceptionBlock ()
  39                 {
  40                         throw new NotSupportedException ();
  41                 }
  42
  43                 public void BeginExceptFilterBlock ()
  44                 {
  45                         throw new NotSupportedException ();
  46                 }
  47
  48                 public void BeginFinallyBlock ()
  49                 {
  50                         throw new NotSupportedException ();
  51                 }
  52
  53                 public LocalBuilder DeclareLocal (params object[] args)
  54                 {
  55                         throw new NotSupportedException ();
  56                 }
  57
  58                 public Label DefineLabel ()
  59                 {
  60                         throw new NotSupportedException ();
  61                 }
  62
  63                 public void Emit (OpCode opcode)
  64                 {
  65                         throw new NotSupportedException ();
  66                 }
  67
  68                 public void Emit (OpCode opcode, object args)
  69                 {
  70                         throw new NotSupportedException ();
  71                 }
  72
  73                 public  void EmitCall (OpCode opcode, params object[] args)
  74                 {
  75                         throw new NotSupportedException ();
  76                 }
  77
  78                 public void EndExceptionBlock ()
  79                 {
  80                         throw new NotSupportedException ();
  81                 }
  82
  83                 public void MarkLabel (Label loc)
  84                 {
  85                         throw new NotSupportedException ();
  86                 }
  87
  88                 public int ILOffset { get; set; }
  89         }
  90
  91         public class TypeBuilder : Type
  92         {
  93                 #region implemented abstract members of MemberInfo
  94
  95                 public override bool IsDefined (Type attributeType, bool inherit)
  96                 {
  97                         throw new NotSupportedException ();
  98                 }
  99
 100                 public override object[] GetCustomAttributes (bool inherit)
 101                 {
 102                         throw new NotSupportedException ();
 103                 }
 104
 105                 public override object[] GetCustomAttributes (Type attributeType, bool inherit)
 106                 {
 107                         throw new NotSupportedException ();
 108                 }
 109
 110                 public override string Name {
 111                         get {
 112                                 throw new NotSupportedException ();
 113                         }
 114                 }
 115
 116                 #endregion
 117
 118                 #region implemented abstract members of Type
 119
 120                 public override Type GetInterface (string name, bool ignoreCase)
 121                 {
 122                         throw new NotSupportedException ();
 123                 }
 124
 125                 public override Type[] GetInterfaces ()
 126                 {
 127                         throw new NotSupportedException ();
 128                 }
 129
 130                 public override Type GetElementType ()
 131                 {
 132                         throw new NotSupportedException ();
 133                 }
 134
 135                 public override EventInfo GetEvent (string name, BindingFlags bindingAttr)
 136                 {
 137                         throw new NotSupportedException ();
 138                 }
 139
 140                 public override EventInfo[] GetEvents (BindingFlags bindingAttr)
 141                 {
 142                         throw new NotSupportedException ();
 143                 }
 144
 145                 public override FieldInfo GetField (string name, BindingFlags bindingAttr)
 146                 {
 147                         throw new NotSupportedException ();
 148                 }
 149
 150                 public override FieldInfo[] GetFields (BindingFlags bindingAttr)
 151                 {
 152                         throw new NotSupportedException ();
 153                 }
 154
 155                 public override MemberInfo[] GetMembers (BindingFlags bindingAttr)
 156                 {
 157                         throw new NotSupportedException ();
 158                 }
 159
 160                 protected override MethodInfo GetMethodImpl (string name, BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)
 161                 {
 162                         throw new NotSupportedException ();
 163                 }
 164
 165                 public override MethodInfo[] GetMethods (BindingFlags bindingAttr)
 166                 {
 167                         throw new NotSupportedException ();
 168                 }
 169
 170                 public override Type GetNestedType (string name, BindingFlags bindingAttr)
 171                 {
 172                         throw new NotSupportedException ();
 173                 }
 174
 175                 public override Type[] GetNestedTypes (BindingFlags bindingAttr)
 176                 {
 177                         throw new NotSupportedException ();
 178                 }
 179
 180                 public override PropertyInfo[] GetProperties (BindingFlags bindingAttr)
 181                 {
 182                         throw new NotSupportedException ();
 183                 }
 184
 185                 protected override PropertyInfo GetPropertyImpl (string name, BindingFlags bindingAttr, Binder binder, Type returnType, Type[] types, ParameterModifier[] modifiers)
 186                 {
 187                         throw new NotSupportedException ();
 188                 }
 189
 190                 protected override ConstructorInfo GetConstructorImpl (BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)
 191                 {
 192                         throw new NotSupportedException ();
 193                 }
 194
 195                 protected override TypeAttributes GetAttributeFlagsImpl ()
 196                 {
 197                         throw new NotSupportedException ();
 198                 }
 199
 200                 protected override bool HasElementTypeImpl ()
 201                 {
 202                         throw new NotSupportedException ();
 203                 }
 204
 205                 protected override bool IsArrayImpl ()
 206                 {
 207                         throw new NotSupportedException ();
 208                 }
 209
 210                 protected override bool IsByRefImpl ()
 211                 {
 212                         throw new NotSupportedException ();
 213                 }
 214
 215                 protected override bool IsCOMObjectImpl ()
 216                 {
 217                         throw new NotSupportedException ();
 218                 }
 219
 220                 protected override bool IsPointerImpl ()
 221                 {
 222                         throw new NotSupportedException ();
 223                 }
 224
 225                 protected override bool IsPrimitiveImpl ()
 226                 {
 227                         throw new NotSupportedException ();
 228                 }
 229
 230                 public override ConstructorInfo[] GetConstructors (BindingFlags bindingAttr)
 231                 {
 232                         throw new NotSupportedException ();
 233                 }
 234
 235                 public override object InvokeMember (string name, BindingFlags invokeAttr, Binder binder, object target, object[] args, ParameterModifier[] modifiers, System.Globalization.CultureInfo culture, string[] namedParameters)
 236                 {
 237                         throw new NotSupportedException ();
 238                 }
 239
 240                 public override Assembly Assembly {
 241                         get {
 242                                 throw new NotSupportedException ();
 243                         }
 244                 }
 245
 246                 public override string AssemblyQualifiedName {
 247                         get {
 248                                 throw new NotSupportedException ();
 249                         }
 250                 }
 251
 252                 public override Type BaseType {
 253                         get {
 254                                 throw new NotSupportedException ();
 255                         }
 256                 }
 257
 258                 public override string FullName {
 259                         get {
 260                                 throw new NotSupportedException ();
 261                         }
 262                 }
 263
 264                 public override Guid GUID {
 265                         get {
 266                                 throw new NotSupportedException ();
 267                         }
 268                 }
 269
 270                 public override Module Module {
 271                         get {
 272                                 throw new NotSupportedException ();
 273                         }
 274                 }
 275
 276                 public override string Namespace {
 277                         get {
 278                                 throw new NotSupportedException ();
 279                         }
 280                 }
 281
 282                 public override Type UnderlyingSystemType {
 283                         get {
 284                                 throw new NotSupportedException ();
 285                         }
 286                 }
 287
 288                 #endregion
 289
 290                 public void AddInterfaceImplementation (Type interfaceType)
 291                 {
 292                         throw new NotSupportedException ();
 293                 }
 294
 295                 public void AddDeclarativeSecurity (params object[] args)
 296                 {
 297                         throw new NotSupportedException ();
 298                 }
 299
 300                 public void SetParent (object arg)
 301                 {
 302                         throw new NotSupportedException ();
 303                 }
 304
 305                 public Type CreateType()
 306                 {
 307                         throw new NotSupportedException ();
 308                 }
 309
 310                 public ConstructorBuilder DefineConstructor (params object[] args)
 311                 {
 312                         throw new NotSupportedException ();
 313                 }
 314
 315                 public MethodBuilder DefineMethod (params object[] args)
 316                 {
 317                         throw new NotSupportedException ();
 318                 }
 319
 320                 public TypeBuilder DefineNestedType (params object[] args)
 321                 {
 322                         throw new NotSupportedException ();
 323                 }
 324
 325                 public PropertyBuilder DefineProperty (params object[] args)
 326                 {
 327                         throw new NotSupportedException ();
 328                 }
 329
 330                 public EventBuilder DefineEvent (params object[] args)
 331                 {
 332                         throw new NotSupportedException ();
 333                 }
 334
 335                 public FieldBuilder DefineField (params object[] args)
 336                 {
 337                         throw new NotSupportedException ();
 338                 }
 339
 340                 public GenericTypeParameterBuilder[] DefineGenericParameters (params string[] names)
 341                 {
 342                         throw new NotSupportedException ();
 343                 }
 344
 345                 public MethodBuilder DefineMethodOverride (params object[] args)
 346                 {
 347                         throw new NotSupportedException ();
 348                 }
 349
 350                 public static ConstructorInfo GetConstructor (Type type, ConstructorInfo constructor)
 351                 {
 352                         throw new NotSupportedException ();
 353                 }
 354
 355                 public static FieldInfo GetField (Type type, FieldInfo field)
 356                 {
 357                         throw new NotSupportedException ();
 358                 }
 359
 360                 public static MethodInfo GetMethod (Type type, MethodInfo method)
 361                 {
 362                         throw new NotSupportedException ();
 363                 }
 364
 365                 public void SetCustomAttribute (params object[] args)
 366                 {
 367                         throw new NotSupportedException ();
 368                 }
 369         }
 370
 371         public class MethodBuilder : MethodBase
 372         {
 373                 #region implemented abstract members of MemberInfo
 374
 375                 public override bool IsDefined (Type attributeType, bool inherit)
 376                 {
 377                         throw new NotSupportedException ();
 378                 }
 379
 380                 public override object[] GetCustomAttributes (bool inherit)
 381                 {
 382                         throw new NotSupportedException ();
 383                 }
 384
 385                 public override object[] GetCustomAttributes (Type attributeType, bool inherit)
 386                 {
 387                         throw new NotSupportedException ();
 388                 }
 389
 390                 public override Type DeclaringType {
 391                         get {
 392                                 throw new NotSupportedException ();
 393                         }
 394                 }
 395
 396                 public override MemberTypes MemberType {
 397                         get {
 398                                 throw new NotSupportedException ();
 399                         }
 400                 }
 401
 402                 public override string Name {
 403                         get {
 404                                 throw new NotSupportedException ();
 405                         }
 406                 }
 407
 408                 public override Type ReflectedType {
 409                         get {
 410                                 throw new NotSupportedException ();
 411                         }
 412                 }
 413
 414                 #endregion
 415
 416                 #region implemented abstract members of MethodBase
 417
 418                 public override MethodImplAttributes GetMethodImplementationFlags ()
 419                 {
 420                         throw new NotSupportedException ();
 421                 }
 422
 423                 public override ParameterInfo[] GetParameters ()
 424                 {
 425                         throw new NotSupportedException ();
 426                 }
 427
 428                 public override object Invoke (object obj, BindingFlags invokeAttr, Binder binder, object[] parameters, System.Globalization.CultureInfo culture)
 429                 {
 430                         throw new NotSupportedException ();
 431                 }
 432
 433                 public override RuntimeMethodHandle MethodHandle {
 434                         get {
 435                                 throw new NotSupportedException ();
 436                         }
 437                 }
 438
 439                 public override MethodAttributes Attributes {
 440                         get {
 441                                 throw new NotSupportedException ();
 442                         }
 443                 }
 444
 445                 #endregion
 446
 447                 public void AddDeclarativeSecurity (params object[] args)
 448                 {
 449                         throw new NotSupportedException ();
 450                 }
 451
 452                 public ParameterBuilder DefineParameter (params object[] args)
 453                 {
 454                         throw new NotSupportedException ();
 455                 }
 456
 457                 public GenericTypeParameterBuilder[] DefineGenericParameters (params string[] names)
 458                 {
 459                         throw new NotSupportedException ();
 460                 }
 461
 462                 public MethodToken GetToken()
 463                 {
 464                         throw new NotSupportedException ();
 465                 }
 466
 467                 public ILGenerator GetILGenerator ()
 468                 {
 469                         throw new NotSupportedException ();
 470                 }
 471
 472                 public void SetCustomAttribute (params object[] args)
 473                 {
 474                         throw new NotSupportedException ();
 475                 }
 476
 477                 public void SetImplementationFlags (MethodImplAttributes attributes)
 478                 {
 479                         throw new NotSupportedException ();
 480                 }
 481
 482                 public void SetParameters (params Type[] parameterTypes)
 483                 {
 484                         throw new NotSupportedException ();
 485                 }
 486
 487                 public void SetReturnType (object arg)
 488                 {
 489                         throw new NotSupportedException ();
 490                 }
 491         }
 492
 493         public class AssemblyBuilder : Assembly
 494         {
 495                 public void AddResourceFile (params object[] args)
 496                 {
 497                         throw new NotSupportedException ();
 498                 }
 499
 500                 public void DefineVersionInfoResource (params object[] args)
 501                 {
 502                         throw new NotSupportedException ();
 503                 }
 504
 505                 public ModuleBuilder DefineDynamicModule (params object[] args)
 506                 {
 507                         throw new NotSupportedException ();
 508                 }
 509
 510                 public void DefineUnmanagedResource (params object[] args)
 511                 {
 512                         throw new NotSupportedException ();
 513                 }
 514
 515                 public void Save (params object[] args)
 516                 {
 517                         throw new NotSupportedException ();
 518                 }
 519
 520                 public void SetEntryPoint (params object[] args)
 521                 {
 522                         throw new NotSupportedException ();
 523                 }
 524
 525                 public void SetCustomAttribute (params object[] args)
 526                 {
 527                         throw new NotSupportedException ();
 528                 }
 529         }
 530
 531         public class LocalBuilder : LocalVariableInfo
 532         {
 533         }
 534
 535         public class GenericTypeParameterBuilder : Type
 536         {
 537                 #region implemented abstract members of MemberInfo
 538
 539                 public override bool IsDefined (Type attributeType, bool inherit)
 540                 {
 541                         throw new NotSupportedException ();
 542                 }
 543
 544                 public override object[] GetCustomAttributes (bool inherit)
 545                 {
 546                         throw new NotSupportedException ();
 547                 }
 548
 549                 public override object[] GetCustomAttributes (Type attributeType, bool inherit)
 550                 {
 551                         throw new NotSupportedException ();
 552                 }
 553
 554                 public override string Name {
 555                         get {
 556                                 throw new NotSupportedException ();
 557                         }
 558                 }
 559
 560                 #endregion
 561
 562                 #region implemented abstract members of Type
 563
 564                 public override Type GetInterface (string name, bool ignoreCase)
 565                 {
 566                         throw new NotSupportedException ();
 567                 }
 568
 569                 public override Type[] GetInterfaces ()
 570                 {
 571                         throw new NotSupportedException ();
 572                 }
 573
 574                 public override Type GetElementType ()
 575                 {
 576                         throw new NotSupportedException ();
 577                 }
 578
 579                 public override EventInfo GetEvent (string name, BindingFlags bindingAttr)
 580                 {
 581                         throw new NotSupportedException ();
 582                 }
 583
 584                 public override EventInfo[] GetEvents (BindingFlags bindingAttr)
 585                 {
 586                         throw new NotSupportedException ();
 587                 }
 588
 589                 public override FieldInfo GetField (string name, BindingFlags bindingAttr)
 590                 {
 591                         throw new NotSupportedException ();
 592                 }
 593
 594                 public override FieldInfo[] GetFields (BindingFlags bindingAttr)
 595                 {
 596                         throw new NotSupportedException ();
 597                 }
 598
 599                 public override MemberInfo[] GetMembers (BindingFlags bindingAttr)
 600                 {
 601                         throw new NotSupportedException ();
 602                 }
 603
 604                 protected override MethodInfo GetMethodImpl (string name, BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)
 605                 {
 606                         throw new NotSupportedException ();
 607                 }
 608
 609                 public override MethodInfo[] GetMethods (BindingFlags bindingAttr)
 610                 {
 611                         throw new NotSupportedException ();
 612                 }
 613
 614                 public override Type GetNestedType (string name, BindingFlags bindingAttr)
 615                 {
 616                         throw new NotSupportedException ();
 617                 }
 618
 619                 public override Type[] GetNestedTypes (BindingFlags bindingAttr)
 620                 {
 621                         throw new NotSupportedException ();
 622                 }
 623
 624                 public override PropertyInfo[] GetProperties (BindingFlags bindingAttr)
 625                 {
 626                         throw new NotSupportedException ();
 627                 }
 628
 629                 protected override PropertyInfo GetPropertyImpl (string name, BindingFlags bindingAttr, Binder binder, Type returnType, Type[] types, ParameterModifier[] modifiers)
 630                 {
 631                         throw new NotSupportedException ();
 632                 }
 633
 634                 protected override ConstructorInfo GetConstructorImpl (BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)
 635                 {
 636                         throw new NotSupportedException ();
 637                 }
 638
 639                 protected override TypeAttributes GetAttributeFlagsImpl ()
 640                 {
 641                         throw new NotSupportedException ();
 642                 }
 643
 644                 protected override bool HasElementTypeImpl ()
 645                 {
 646                         throw new NotSupportedException ();
 647                 }
 648
 649                 protected override bool IsArrayImpl ()
 650                 {
 651                         throw new NotSupportedException ();
 652                 }
 653
 654                 protected override bool IsByRefImpl ()
 655                 {
 656                         throw new NotSupportedException ();
 657                 }
 658
 659                 protected override bool IsCOMObjectImpl ()
 660                 {
 661                         throw new NotSupportedException ();
 662                 }
 663
 664                 protected override bool IsPointerImpl ()
 665                 {
 666                         throw new NotSupportedException ();
 667                 }
 668
 669                 protected override bool IsPrimitiveImpl ()
 670                 {
 671                         throw new NotSupportedException ();
 672                 }
 673
 674                 public override ConstructorInfo[] GetConstructors (BindingFlags bindingAttr)
 675                 {
 676                         throw new NotSupportedException ();
 677                 }
 678
 679                 public override object InvokeMember (string name, BindingFlags invokeAttr, Binder binder, object target, object[] args, ParameterModifier[] modifiers, System.Globalization.CultureInfo culture, string[] namedParameters)
 680                 {
 681                         throw new NotSupportedException ();
 682                 }
 683
 684                 public override Assembly Assembly {
 685                         get {
 686                                 throw new NotSupportedException ();
 687                         }
 688                 }
 689
 690                 public override string AssemblyQualifiedName {
 691                         get {
 692                                 throw new NotSupportedException ();
 693                         }
 694                 }
 695
 696                 public override Type BaseType {
 697                         get {
 698                                 throw new NotSupportedException ();
 699                         }
 700                 }
 701
 702                 public override string FullName {
 703                         get {
 704                                 throw new NotSupportedException ();
 705                         }
 706                 }
 707
 708                 public override Guid GUID {
 709                         get {
 710                                 throw new NotSupportedException ();
 711                         }
 712                 }
 713
 714                 public override Module Module {
 715                         get {
 716                                 throw new NotSupportedException ();
 717                         }
 718                 }
 719
 720                 public override string Namespace {
 721                         get {
 722                                 throw new NotSupportedException ();
 723                         }
 724                 }
 725
 726                 public override Type UnderlyingSystemType {
 727                         get {
 728                                 throw new NotSupportedException ();
 729                         }
 730                 }
 731
 732                 #endregion
 733
 734                 public void SetCustomAttribute (params object[] args)
 735                 {
 736                         throw new NotSupportedException ();
 737                 }
 738
 739                 public void SetGenericParameterAttributes (GenericParameterAttributes genericParameterAttributes)
 740                 {
 741                         throw new NotSupportedException ();
 742                 }
 743
 744                 public void SetInterfaceConstraints (params Type[] interfaceConstraints)
 745                 {
 746                         throw new NotSupportedException ();
 747                 }
 748
 749                 public void SetBaseTypeConstraint (Type baseTypeConstraint)
 750                 {
 751                         throw new NotSupportedException ();
 752                 }
 753         }
 754
 755         public class ConstructorBuilder : MethodBase
 756         {
 757                 #region implemented abstract members of MemberInfo
 758
 759                 public override bool IsDefined (Type attributeType, bool inherit)
 760                 {
 761                         throw new NotSupportedException ();
 762                 }
 763
 764                 public override object[] GetCustomAttributes (bool inherit)
 765                 {
 766                         throw new NotSupportedException ();
 767                 }
 768
 769                 public override object[] GetCustomAttributes (Type attributeType, bool inherit)
 770                 {
 771                         throw new NotSupportedException ();
 772                 }
 773
 774                 public override Type DeclaringType {
 775                         get {
 776                                 throw new NotSupportedException ();
 777                         }
 778                 }
 779
 780                 public override MemberTypes MemberType {
 781                         get {
 782                                 throw new NotSupportedException ();
 783                         }
 784                 }
 785
 786                 public override string Name {
 787                         get {
 788                                 throw new NotSupportedException ();
 789                         }
 790                 }
 791
 792                 public override Type ReflectedType {
 793                         get {
 794                                 throw new NotSupportedException ();
 795                         }
 796                 }
 797
 798                 #endregion
 799
 800                 #region implemented abstract members of MethodBase
 801
 802                 public override MethodImplAttributes GetMethodImplementationFlags ()
 803                 {
 804                         throw new NotSupportedException ();
 805                 }
 806
 807                 public override ParameterInfo[] GetParameters ()
 808                 {
 809                         throw new NotSupportedException ();
 810                 }
 811
 812                 public override object Invoke (object obj, BindingFlags invokeAttr, Binder binder, object[] parameters, System.Globalization.CultureInfo culture)
 813                 {
 814                         throw new NotSupportedException ();
 815                 }
 816
 817                 public override RuntimeMethodHandle MethodHandle {
 818                         get {
 819                                 throw new NotSupportedException ();
 820                         }
 821                 }
 822
 823                 public override MethodAttributes Attributes {
 824                         get {
 825                                 throw new NotSupportedException ();
 826                         }
 827                 }
 828
 829                 #endregion
 830
 831                 public void AddDeclarativeSecurity (params object[] args)
 832                 {
 833                         throw new NotSupportedException ();
 834                 }
 835
 836                 public ParameterBuilder DefineParameter (params object[] args)
 837                 {
 838                         throw new NotSupportedException ();
 839                 }
 840
 841                 public MethodToken GetToken()
 842                 {
 843                         throw new NotSupportedException ();
 844                 }
 845
 846                 public ILGenerator GetILGenerator ()
 847                 {
 848                         throw new NotSupportedException ();
 849                 }
 850
 851                 public void SetCustomAttribute (params object[] args)
 852                 {
 853                         throw new NotSupportedException ();
 854                 }
 855
 856                 public void SetImplementationFlags (MethodImplAttributes attributes)
 857                 {
 858                         throw new NotSupportedException ();
 859                 }
 860         }
 861
 862         public class ModuleBuilder : Module
 863         {
 864                 public void DefineManifestResource (params object[] args)
 865                 {
 866                         throw new NotSupportedException ();
 867                 }
 868
 869                 public TypeBuilder DefineType (params object[] args)
 870                 {
 871                         throw new NotSupportedException ();
 872                 }
 873
 874                 public MethodToken GetToken()
 875                 {
 876                         throw new NotSupportedException ();
 877                 }
 878
 879                 public MethodInfo GetArrayMethod (params object[] args)
 880                 {
 881                         throw new NotSupportedException ();
 882                 }
 883
 884                 public void SetCustomAttribute (params object[] args)
 885                 {
 886                         throw new NotSupportedException ();
 887                 }
 888         }
 889
 890         public class PropertyBuilder : PropertyInfo
 891         {
 892                 #region implemented abstract members of MemberInfo
 893
 894                 public override bool IsDefined (Type attributeType, bool inherit)
 895                 {
 896                         throw new NotSupportedException ();
 897                 }
 898
 899                 public override object[] GetCustomAttributes (bool inherit)
 900                 {
 901                         throw new NotSupportedException ();
 902                 }
 903
 904                 public override object[] GetCustomAttributes (Type attributeType, bool inherit)
 905                 {
 906                         throw new NotSupportedException ();
 907                 }
 908
 909                 public override Type DeclaringType {
 910                         get {
 911                                 throw new NotSupportedException ();
 912                         }
 913                 }
 914
 915                 public override string Name {
 916                         get {
 917                                 throw new NotSupportedException ();
 918                         }
 919                 }
 920
 921                 public override Type ReflectedType {
 922                         get {
 923                                 throw new NotSupportedException ();
 924                         }
 925                 }
 926
 927                 #endregion
 928
 929                 #region implemented abstract members of PropertyInfo
 930
 931                 public override MethodInfo[] GetAccessors (bool nonPublic)
 932                 {
 933                         throw new NotSupportedException ();
 934                 }
 935
 936                 public override MethodInfo GetGetMethod (bool nonPublic)
 937                 {
 938                         throw new NotSupportedException ();
 939                 }
 940
 941                 public override ParameterInfo[] GetIndexParameters ()
 942                 {
 943                         throw new NotSupportedException ();
 944                 }
 945
 946                 public override MethodInfo GetSetMethod (bool nonPublic)
 947                 {
 948                         throw new NotSupportedException ();
 949                 }
 950
 951                 public override object GetValue (object obj, BindingFlags invokeAttr, Binder binder, object[] index, System.Globalization.CultureInfo culture)
 952                 {
 953                         throw new NotSupportedException ();
 954                 }
 955
 956                 public override void SetValue (object obj, object value, BindingFlags invokeAttr, Binder binder, object[] index, System.Globalization.CultureInfo culture)
 957                 {
 958                         throw new NotSupportedException ();
 959                 }
 960
 961                 public override PropertyAttributes Attributes {
 962                         get {
 963                                 throw new NotSupportedException ();
 964                         }
 965                 }
 966
 967                 public override bool CanRead {
 968                         get {
 969                                 throw new NotSupportedException ();
 970                         }
 971                 }
 972
 973                 public override bool CanWrite {
 974                         get {
 975                                 throw new NotSupportedException ();
 976                         }
 977                 }
 978
 979                 public override Type PropertyType {
 980                         get {
 981                                 throw new NotSupportedException ();
 982                         }
 983                 }
 984
 985                 #endregion
 986
 987                 public MethodToken GetToken()
 988                 {
 989                         throw new NotSupportedException ();
 990                 }
 991
 992                 public void SetGetMethod (object arg)
 993                 {
 994                         throw new NotSupportedException ();
 995                 }
 996
 997                 public void SetSetMethod (object arg)
 998                 {
 999                         throw new NotSupportedException ();
1000                 }
1001
1002                 public void SetCustomAttribute (params object[] args)
1003                 {
1004                         throw new NotSupportedException ();
1005                 }
1006         }
1007
1008         public class FieldBuilder : FieldInfo
1009         {
1010                 #region implemented abstract members of MemberInfo
1011
1012                 public override bool IsDefined (Type attributeType, bool inherit)
1013                 {
1014                         throw new NotSupportedException ();
1015                 }
1016
1017                 public override object[] GetCustomAttributes (bool inherit)
1018                 {
1019                         throw new NotSupportedException ();
1020                 }
1021
1022                 public override object[] GetCustomAttributes (Type attributeType, bool inherit)
1023                 {
1024                         throw new NotSupportedException ();
1025                 }
1026
1027                 public override Type DeclaringType {
1028                         get {
1029                                 throw new NotSupportedException ();
1030                         }
1031                 }
1032
1033                 public override string Name {
1034                         get {
1035                                 throw new NotSupportedException ();
1036                         }
1037                 }
1038
1039                 public override Type ReflectedType {
1040                         get {
1041                                 throw new NotSupportedException ();
1042                         }
1043                 }
1044
1045                 #endregion
1046
1047                 #region implemented abstract members of FieldInfo
1048
1049                 public override object GetValue (object obj)
1050                 {
1051                         throw new NotSupportedException ();
1052                 }
1053
1054                 public override void SetValue (object obj, object value, BindingFlags invokeAttr, Binder binder, System.Globalization.CultureInfo culture)
1055                 {
1056                         throw new NotSupportedException ();
1057                 }
1058
1059                 public override FieldAttributes Attributes {
1060                         get {
1061                                 throw new NotSupportedException ();
1062                         }
1063                 }
1064
1065                 public override RuntimeFieldHandle FieldHandle {
1066                         get {
1067                                 throw new NotSupportedException ();
1068                         }
1069                 }
1070
1071                 public override Type FieldType {
1072                         get {
1073                                 throw new NotSupportedException ();
1074                         }
1075                 }
1076
1077                 #endregion
1078
1079                 public void SetConstant (object arg)
1080                 {
1081                         throw new NotSupportedException ();
1082                 }
1083
1084                 public void SetCustomAttribute (params object[] args)
1085                 {
1086                         throw new NotSupportedException ();
1087                 }
1088         }
1089
1090         public class ParameterBuilder : ParameterInfo
1091         {
1092                 public void SetConstant (object arg)
1093                 {
1094                         throw new NotSupportedException ();
1095                 }
1096
1097                 public void SetCustomAttribute (params object[] args)
1098                 {
1099                         throw new NotSupportedException ();
1100                 }
1101         }
1102
1103         public class EventBuilder
1104         {
1105                 public void SetAddOnMethod (MethodBuilder mdBuilder)
1106                 {
1107                         throw new NotSupportedException ();
1108                 }
1109
1110                 public void SetRemoveOnMethod (MethodBuilder mdBuilder)
1111                 {
1112                         throw new NotSupportedException ();
1113                 }
1114
1115                 public void SetCustomAttribute (params object[] args)
1116                 {
1117                         throw new NotSupportedException ();
1118                 }
1119         }
1120
1121         public class CustomAttributeBuilder
1122         {
1123                 public CustomAttributeBuilder (params object[] args)
1124                 {
1125                         throw new NotSupportedException ();
1126                 }
1127         }
1128 }