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