Merge pull request #1898 from alexanderkyte/debugger_variable_reflection

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

diff --git a/mcs/class/corlib/System.Reflection.Emit/ConstructorOnTypeBuilderInst.cs b/mcs/class/corlib/System.Reflection.Emit/ConstructorOnTypeBuilderInst.cs
index 1e807d9f218316a6a642e3a2b6bcae8b5d7f3798..149e5dbd6633d1a5d6940d761cfcc18be4a8e37f 100644 (file)
--- a/mcs/class/corlib/System.Reflection.Emit/ConstructorOnTypeBuilderInst.cs
+++ b/mcs/class/corlib/System.Reflection.Emit/ConstructorOnTypeBuilderInst.cs
@@ -27,25 +27,27 @@
 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 //
 
+#if !FULL_AOT_RUNTIME
 using System;
 using System.Globalization;
 using System.Reflection;
-
-#if NET_2_0
+using System.Runtime.InteropServices;
 
 namespace System.Reflection.Emit
 {
        /*
         * This class represents a ctor of an instantiation of a generic type builder.
         */
+       [StructLayout (LayoutKind.Sequential)]
        internal class ConstructorOnTypeBuilderInst : ConstructorInfo
        {
                #region Keep in sync with object-internals.h
                MonoGenericClass instantiation;
-               ConstructorBuilder cb;
+               ConstructorInfo cb;
                #endregion
 
-               public ConstructorOnTypeBuilderInst (MonoGenericClass instantiation, ConstructorBuilder cb) {
+               public ConstructorOnTypeBuilderInst (MonoGenericClass instantiation, ConstructorInfo cb)
+               {
                        this.instantiation = instantiation;
                        this.cb = cb;
                }
@@ -72,41 +74,86 @@ namespace System.Reflection.Emit
                        }
                }
 
-               public override bool IsDefined (Type attributeType, bool inherit) {
-                       throw new NotSupportedException ();
+               public override Module Module {
+                       get {
+                               return cb.Module;
+                       }
+               }
+
+               public override bool IsDefined (Type attributeType, bool inherit)
+               {
+                       return cb.IsDefined (attributeType, inherit);
                }
 
-               public override object [] GetCustomAttributes (bool inherit) {
-                       throw new NotSupportedException ();
+               public override object [] GetCustomAttributes (bool inherit)
+               {
+                       return cb.GetCustomAttributes (inherit);
                }
 
-               public override object [] GetCustomAttributes (Type attributeType, bool inherit) {
-                       throw new NotSupportedException ();
+               public override object [] GetCustomAttributes (Type attributeType, bool inherit)
+               {
+                       return cb.GetCustomAttributes (attributeType, inherit);
                }
 
                //
                // MethodBase members
                //
 
-               public override MethodImplAttributes GetMethodImplementationFlags() {
+               public override MethodImplAttributes GetMethodImplementationFlags ()
+               {
                        return cb.GetMethodImplementationFlags ();
                }
 
-               public override ParameterInfo[] GetParameters() {
-                       throw new NotImplementedException ();
+               public override ParameterInfo[] GetParameters ()
+               {
+                       /*FIXME, maybe the right thing to do when the type is creates is to retrieve from the inflated type*/
+                       if (!instantiation.IsCreated)
+                               throw new NotSupportedException ();
+
+                       return GetParametersInternal ();
+               }
+
+               internal override ParameterInfo[] GetParametersInternal ()
+               {
+                       ParameterInfo [] res;
+                       if (cb is ConstructorBuilder) {
+                               ConstructorBuilder cbuilder = (ConstructorBuilder)cb;
+                               res = new ParameterInfo [cbuilder.parameters.Length];
+                               for (int i = 0; i < cbuilder.parameters.Length; i++) {
+                                       Type type = instantiation.InflateType (cbuilder.parameters [i]);
+                                       res [i] = ParameterInfo.New (cbuilder.pinfo == null ? null : cbuilder.pinfo [i], type, this, i + 1);
+                               }
+                       } else {
+                               ParameterInfo[] parms = cb.GetParameters ();
+                               res = new ParameterInfo [parms.Length];
+                               for (int i = 0; i < parms.Length; i++) {
+                                       Type type = instantiation.InflateType (parms [i].ParameterType);
+                                       res [i] = ParameterInfo.New (parms [i], type, this, i + 1);
+                               }
+                       }
+                       return res;
+               }
+
+               public override int MetadataToken {
+                       get {
+                               return base.MetadataToken;
+                       }
                }
 
-               internal override int GetParameterCount () {
-                       return cb.GetParameterCount ();
+               internal override int GetParametersCount ()
+               {
+                       return cb.GetParametersCount ();
                }
 
-               public override Object Invoke(Object obj, BindingFlags invokeAttr, Binder binder, Object[] parameters, CultureInfo culture) {
-                       throw new NotImplementedException ();
+               public override Object Invoke (Object obj, BindingFlags invokeAttr, Binder binder, Object[] parameters, CultureInfo culture)
+               {
+                       return cb.Invoke (obj, invokeAttr, binder, parameters,
+                               culture);
                }
 
                public override RuntimeMethodHandle MethodHandle {
                        get {
-                               throw new NotImplementedException ();
+                               return cb.MethodHandle;
                        }
                }
 
@@ -122,14 +169,14 @@ namespace System.Reflection.Emit
                        }
                }
 
-               public override Type [] GetGenericArguments () {
-                       throw new NotImplementedException ();
+               public override Type [] GetGenericArguments ()
+               {
+                       return cb.GetGenericArguments ();
                }
 
                public override bool ContainsGenericParameters {
                        get {
-                               // FIXME:
-                               throw new NotImplementedException ();
+                               return false;
                        }
                }
 
@@ -141,7 +188,7 @@ namespace System.Reflection.Emit
 
                public override bool IsGenericMethod {
                        get {
-                               return true;
+                               return false;
                        }
                }
 
@@ -150,8 +197,9 @@ namespace System.Reflection.Emit
                //
 
                public override object Invoke (BindingFlags invokeAttr, Binder binder, object[] parameters,
-                                                                          CultureInfo culture) {
-                       throw new NotImplementedException ();
+                                                                          CultureInfo culture)
+               {
+                       throw new InvalidOperationException ();
                }
        }
 }