Avoid random failure in CountdownEvent unit test

[mono.git] / mcs / class / corlib / System.Reflection.Emit / PropertyBuilder.cs

diff --git a/mcs/class/corlib/System.Reflection.Emit/PropertyBuilder.cs b/mcs/class/corlib/System.Reflection.Emit/PropertyBuilder.cs
old mode 100755 (executable)
new mode 100644 (file)
index 0e2a427..6bbfff1
--- a/mcs/class/corlib/System.Reflection.Emit/PropertyBuilder.cs
+++ b/mcs/class/corlib/System.Reflection.Emit/PropertyBuilder.cs
@@ -36,9 +36,16 @@ using System.Reflection;
 using System.Reflection.Emit;
 using System.Globalization;
 using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
 
 namespace System.Reflection.Emit {
-       public sealed class PropertyBuilder : PropertyInfo {
+       [ComVisible (true)]
+       [ComDefaultInterface (typeof (_PropertyBuilder))]
+       [ClassInterface (ClassInterfaceType.None)]
+       public sealed class PropertyBuilder : PropertyInfo, _PropertyBuilder {
+
+// Managed version of MonoReflectionPropertyBuilder
+#pragma warning disable 169, 414
                private PropertyAttributes attrs;
                private string name;
                private Type type;
@@ -49,11 +56,23 @@ namespace System.Reflection.Emit {
                private MethodBuilder get_method;
                private int table_idx = 0;
                internal TypeBuilder typeb;
+               private Type[] returnModReq;
+               private Type[] returnModOpt;
+               private Type[][] paramModReq;
+               private Type[][] paramModOpt;
+               CallingConventions callingConvention;           
+#pragma warning restore 169, 414
                
-               internal PropertyBuilder (TypeBuilder tb, string name, PropertyAttributes attributes, Type returnType, Type[] parameterTypes) {
+               internal PropertyBuilder (TypeBuilder tb, string name, PropertyAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] returnModReq, Type[] returnModOpt, Type[] parameterTypes, Type[][] paramModReq, Type[][] paramModOpt)
+               {
                        this.name = name;
                        this.attrs = attributes;
+                       this.callingConvention = callingConvention;
                        this.type = returnType;
+                       this.returnModReq = returnModReq;
+                       this.returnModOpt = returnModOpt;
+                       this.paramModReq = paramModReq;
+                       this.paramModOpt = paramModOpt;
                        if (parameterTypes != null) {
                                this.parameters = new Type [parameterTypes.Length];
                                System.Array.Copy (parameterTypes, this.parameters, this.parameters.Length);
@@ -92,16 +111,16 @@ namespace System.Reflection.Emit {
                        return null;
                }
                public override object[] GetCustomAttributes(bool inherit) {
-                       return null;
+                       throw not_supported ();
                }
                public override object[] GetCustomAttributes(Type attributeType, bool inherit) {
-                       return null;
+                       throw not_supported ();
                }
                public override MethodInfo GetGetMethod( bool nonPublic) {
                        return get_method;
                }
                public override ParameterInfo[] GetIndexParameters() {
-                       return null;
+                       throw not_supported ();
                }
                public override MethodInfo GetSetMethod( bool nonPublic) {
                        return set_method;
@@ -110,15 +129,21 @@ namespace System.Reflection.Emit {
                        return null;
                }
                public override object GetValue( object obj, BindingFlags invokeAttr, Binder binder, object[] index, CultureInfo culture) {
-                       return null;
+                       throw not_supported ();
                }
                public override bool IsDefined( Type attributeType, bool inherit) {
-                       return false;
+                       throw not_supported ();
                }
                public void SetConstant( object defaultValue) {
                        def_value = defaultValue;
                }
                public void SetCustomAttribute( CustomAttributeBuilder customBuilder) {
+                       string attrname = customBuilder.Ctor.ReflectedType.FullName;
+                       if (attrname == "System.Runtime.CompilerServices.SpecialNameAttribute") {
+                               attrs |= PropertyAttributes.SpecialName;
+                               return;
+                       }
+
                        if (cattrs != null) {
                                CustomAttributeBuilder[] new_array = new CustomAttributeBuilder [cattrs.Length + 1];
                                cattrs.CopyTo (new_array, 0);
@@ -129,6 +154,8 @@ namespace System.Reflection.Emit {
                                cattrs [0] = customBuilder;
                        }
                }
+
+               [ComVisible (true)]
                public void SetCustomAttribute( ConstructorInfo con, byte[] binaryAttribute) {
                        SetCustomAttribute (new CustomAttributeBuilder (con, binaryAttribute));
                }
@@ -142,6 +169,37 @@ namespace System.Reflection.Emit {
                }
                public override void SetValue( object obj, object value, BindingFlags invokeAttr, Binder binder, object[] index, CultureInfo culture) {
                }
+
+               public override Module Module {
+                       get {
+                               return base.Module;
+                       }
+               }
+
+                void _PropertyBuilder.GetIDsOfNames([In] ref Guid riid, IntPtr rgszNames, uint cNames, uint lcid, IntPtr rgDispId)
+                {
+                        throw new NotImplementedException ();
+                }
+
+                void _PropertyBuilder.GetTypeInfo (uint iTInfo, uint lcid, IntPtr ppTInfo)
+                {
+                        throw new NotImplementedException ();
+                }
+
+                void _PropertyBuilder.GetTypeInfoCount (out uint pcTInfo)
+                {
+                        throw new NotImplementedException ();
+                }
+
+                void _PropertyBuilder.Invoke (uint dispIdMember, [In] ref Guid riid, uint lcid, short wFlags, IntPtr pDispParams, IntPtr pVarResult, IntPtr pExcepInfo, IntPtr puArgErr)
+                {
+                        throw new NotImplementedException ();
+                }
+
+               private Exception not_supported ()
+               {
+                       return new NotSupportedException ("The invoked member is not supported in a dynamic module.");
+               }
        }
 }