2006-03-04 Marek Safar <marek.safar@seznam.cz>

	A fix for #77353.

	* class.cs (SetMethod.DefineParameters): Uses new parameters type ctor.
	(Event.Define): ditto
	(SetIndexerMethod.DefineParameters): Uses Parameters.MergeGenerated.

	* delegate.cs (Delegate.Define): Uses Parameters.MergeGenerated.
	Removed redundant code and set NewSlot for Invoke method too.

	* parameter.cs (Parameters.ctor): Add custom, type ctor.
	(Parameters.MergeGenerated): New method. Use this method when you merge
	compiler generated argument with user arguments.

svn path=/trunk/mcs/; revision=57580

diff --git a/mcs/mcs/ChangeLog b/mcs/mcs/ChangeLog
index 55335d6fa7d91692aa49c8ea29daae082d3d63b8..c37cd38cf32a6a39f6ce3fe06aeeb2be41bf6d1b 100644 (file)
--- a/mcs/mcs/ChangeLog
+++ b/mcs/mcs/ChangeLog
@@ -1,3 +1,18 @@
+2006-03-04  Marek Safar  <marek.safar@seznam.cz>
+
+       A fix for #77353.
+
+       * class.cs (SetMethod.DefineParameters): Uses new parameters type ctor.
+       (Event.Define): ditto
+       (SetIndexerMethod.DefineParameters): Uses Parameters.MergeGenerated.
+
+       * delegate.cs (Delegate.Define): Uses Parameters.MergeGenerated.
+       Removed redundant code and set NewSlot for Invoke method too.
+
+       * parameter.cs (Parameters.ctor): Add custom, type ctor.
+       (Parameters.MergeGenerated): New method. Use this method when you merge
+       compiler generated argument with user arguments.
+
 2006-03-03  Marek Safar  <marek.safar@seznam.cz>
 
        * attribute.cs (ResolveAsTypeTerminal): Removed.

diff --git a/mcs/mcs/class.cs b/mcs/mcs/class.cs
index 68a79798a33484f6e6df0206b5f674dfbf4d0a8b..927ffca4e073d1df0726d5b71300acd8543eb898 100644 (file)
--- a/mcs/mcs/class.cs
+++ b/mcs/mcs/class.cs
@@ -5736,10 +5736,9 @@ namespace Mono.CSharp {
 
                        protected virtual void DefineParameters ()
                        {
-                               Parameter [] parms = new Parameter [1];
-                               parms [0] = new Parameter (method.MemberType, "value", Parameter.Modifier.NONE, null, Location);
-                               parameters = new Parameters (parms);
-                               parameters.Resolve (null);
+                               parameters = new Parameters (
+                                       new Parameter[] { new Parameter (method.MemberType, "value", Parameter.Modifier.NONE, null, Location) },
+                                       new Type[] { method.MemberType });
                        }
 
                        public override MethodBuilder Define (TypeContainer container)
@@ -6655,10 +6654,9 @@ namespace Mono.CSharp {
                                return false;
                        }
 
-                       Parameter [] parms = new Parameter [1];
-                       parms [0] = new Parameter (MemberType, "value", Parameter.Modifier.NONE, null, Location);
-                       parameters = new Parameters (parms);
-                       parameters.Resolve (this);
+                       parameters = new Parameters (
+                               new Parameter[] { new Parameter (MemberType, "value", Parameter.Modifier.NONE, null, Location) },
+                               new Type[] { MemberType } );
 
                        if (!CheckBase ())
                                return false;
@@ -6770,15 +6768,8 @@ namespace Mono.CSharp {
 
                        protected override void DefineParameters ()
                        {
-                               Parameter [] fixed_parms = method.Parameters.FixedParameters;
-                               Parameter [] tmp = new Parameter [fixed_parms.Length + 1];
-
-                               fixed_parms.CopyTo (tmp, 0);
-                               tmp [fixed_parms.Length] = new Parameter (
-                                       method.MemberType, "value", Parameter.Modifier.NONE, null, method.Location);
-
-                               parameters = new Parameters (tmp);
-                               parameters.Resolve (null);
+                               parameters = Parameters.MergeGenerated (method.Parameters,
+                                       new Parameter (method.MemberType, "value", Parameter.Modifier.NONE, null, method.Location));
                        }
                }
 

diff --git a/mcs/mcs/delegate.cs b/mcs/mcs/delegate.cs
index cd2fed0677d80928efa27e92640de88f7f6448d0..e242626a16fa729a046668e1968dbbea52a1f9bc 100644 (file)
--- a/mcs/mcs/delegate.cs
+++ b/mcs/mcs/delegate.cs
@@ -110,19 +110,16 @@ namespace Mono.CSharp {
 
                public override bool Define ()
                {
-                       MethodAttributes mattr;
-                       int i;
-
                        // FIXME: POSSIBLY make this static, as it is always constant
                        //
                        Type [] const_arg_types = new Type [2];
                        const_arg_types [0] = TypeManager.object_type;
                        const_arg_types [1] = TypeManager.intptr_type;
 
-                       mattr = MethodAttributes.RTSpecialName | MethodAttributes.SpecialName |
+                       const MethodAttributes ctor_mattr = MethodAttributes.RTSpecialName | MethodAttributes.SpecialName |
                                MethodAttributes.HideBySig | MethodAttributes.Public;
 
-                       ConstructorBuilder = TypeBuilder.DefineConstructor (mattr,
+                       ConstructorBuilder = TypeBuilder.DefineConstructor (ctor_mattr,
                                                                            CallingConventions.Standard,
                                                                            const_arg_types);
 
@@ -171,11 +168,9 @@ namespace Mono.CSharp {
                        ReturnType = ReturnType.ResolveAsTypeTerminal (this, false);
                        if (ReturnType == null)
                                return false;
-                        
-                       ret_type = ReturnType.Type;
-                       if (ret_type == null)
-                               return false;
 
+                       ret_type = ReturnType.Type;
+            
                        if (!Parent.AsAccessible (ret_type, ModFlags)) {
                                Report.Error (58, Location,
                                              "Inconsistent accessibility: return type `" +
@@ -196,22 +191,13 @@ namespace Mono.CSharp {
                        
                        CallingConventions cc = Parameters.CallingConvention;
 
-                       mattr = MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.Virtual;
+                       const MethodAttributes mattr = MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.Virtual | MethodAttributes.NewSlot;
 
                        InvokeBuilder = TypeBuilder.DefineMethod ("Invoke", 
                                                                  mattr,                     
                                                                  cc,
                                                                  ret_type,                  
                                                                  Parameters.Types);
-
-                       //
-                       // Define parameters, and count out/ref parameters
-                       //
-                       int out_params = 0;
-                       foreach (Parameter p in Parameters.FixedParameters) {
-                               if ((p.ModFlags & Parameter.Modifier.ISBYREF) != 0)
-                                       out_params++;
-                       }
                        
                        InvokeBuilder.SetImplementationFlags (MethodImplAttributes.Runtime);
 
@@ -220,86 +206,64 @@ namespace Mono.CSharp {
                        //
                        // BeginInvoke
                        //
-                       int params_num = Parameters.Count;
-                       Type [] async_param_types = new Type [params_num + 2];
-
-                       Parameters.Types.CopyTo (async_param_types, 0);
-
-                       async_param_types [params_num] = TypeManager.asynccallback_type;
-                       async_param_types [params_num + 1] = TypeManager.object_type;
-
-                       mattr = MethodAttributes.Public | MethodAttributes.HideBySig |
-                               MethodAttributes.Virtual | MethodAttributes.NewSlot;
+                       
+                       Parameters async_parameters = Parameters.MergeGenerated (Parameters, 
+                               new Parameter (TypeManager.asynccallback_type, "callback", Parameter.Modifier.NONE, null, Location),
+                               new Parameter (TypeManager.object_type, "object", Parameter.Modifier.NONE, null, Location));
                        
                        BeginInvokeBuilder = TypeBuilder.DefineMethod ("BeginInvoke",
-                                                                      mattr,
-                                                                      cc,
-                                                                      TypeManager.iasyncresult_type,
-                                                                      async_param_types);
+                               mattr, cc, TypeManager.iasyncresult_type, async_parameters.Types);
 
-                       i = Parameters.Count;
-                       Parameters.ApplyAttributes (BeginInvokeBuilder);
-                       BeginInvokeBuilder.DefineParameter (i + 1, ParameterAttributes.None, "callback");
-                       BeginInvokeBuilder.DefineParameter (i + 2, ParameterAttributes.None, "object");
-                       
                        BeginInvokeBuilder.SetImplementationFlags (MethodImplAttributes.Runtime);
-
-                       Parameter [] async_params = new Parameter [params_num + 2];
-                       Parameters.FixedParameters.CopyTo (async_params, 0);
-                       
-                       async_params [params_num] = new Parameter (
-                               TypeManager.asynccallback_type, "callback",
-                                                                  Parameter.Modifier.NONE, null, Location);
-                       async_params [params_num + 1] = new Parameter (
-                               TypeManager.object_type, "object",
-                                                                  Parameter.Modifier.NONE, null, Location);
-
-                       Parameters async_parameters = new Parameters (async_params);
-                       async_parameters.Resolve (this);
                        async_parameters.ApplyAttributes (BeginInvokeBuilder);
-
                        TypeManager.RegisterMethod (BeginInvokeBuilder, async_parameters);
 
                        //
                        // EndInvoke is a bit more interesting, all the parameters labeled as
                        // out or ref have to be duplicated here.
                        //
-                       
-                       Type [] end_param_types = new Type [out_params + 1];
-                       Parameter [] end_params = new Parameter [out_params + 1];
-                       int param = 0; 
-                       if (out_params > 0){
-                               int top = Parameters.FixedParameters.Length;
-                               for (i = 0; i < top; i++){
+
+                       //
+                       // Define parameters, and count out/ref parameters
+                       //
+                       Parameters end_parameters;
+                       int out_params = 0;
+
+                       foreach (Parameter p in Parameters.FixedParameters) {
+                               if ((p.ModFlags & Parameter.Modifier.ISBYREF) != 0)
+                                       ++out_params;
+                       }
+
+                       if (out_params > 0) {
+                               Type [] end_param_types = new Type [out_params];
+                               Parameter [] end_params = new Parameter [out_params ];
+
+                               int param = 0; 
+                               for (int i = 0; i < Parameters.FixedParameters.Length; ++i) {
                                        Parameter p = Parameters.FixedParameters [i];
                                        if ((p.ModFlags & Parameter.Modifier.ISBYREF) == 0)
                                                continue;
 
-                                       end_param_types [param] = Parameters.Types [i];
+                                       end_param_types [param] = p.ExternalType();
                                        end_params [param] = p;
-                                       param++;
+                                       ++param;
                                }
+                               end_parameters = new Parameters (end_params, end_param_types);
+                       }
+                       else {
+                               end_parameters = Parameters.EmptyReadOnlyParameters;
                        }
-                       end_param_types [out_params] = TypeManager.iasyncresult_type;
-                       end_params [out_params] = new Parameter (TypeManager.system_iasyncresult_expr, "result", Parameter.Modifier.NONE, null, Location);
 
+                       end_parameters = Parameters.MergeGenerated (end_parameters,
+                               new Parameter (TypeManager.iasyncresult_type, "result", Parameter.Modifier.NONE, null, Location));
+                       
                        //
                        // Create method, define parameters, register parameters with type system
                        //
-                       EndInvokeBuilder = TypeBuilder.DefineMethod ("EndInvoke", mattr, cc, ret_type, end_param_types);
+                       EndInvokeBuilder = TypeBuilder.DefineMethod ("EndInvoke", mattr, cc, ret_type, end_parameters.Types);
                        EndInvokeBuilder.SetImplementationFlags (MethodImplAttributes.Runtime);
 
-                       //
-                       // EndInvoke: Label the parameters
-                       //
-                       EndInvokeBuilder.DefineParameter (out_params + 1, ParameterAttributes.None, "result");
-                       for (i = 0; i < end_params.Length-1; i++){
-                               EndInvokeBuilder.DefineParameter (i + 1, end_params [i].Attributes, end_params [i].Name);
-                       }
-
-                       Parameters end_parameters = new Parameters (end_params);
-                       end_parameters.Resolve (this);
-
+                       end_parameters.ApplyAttributes (EndInvokeBuilder);
                        TypeManager.RegisterMethod (EndInvokeBuilder, end_parameters);
 
                        return true;

diff --git a/mcs/mcs/parameter.cs b/mcs/mcs/parameter.cs
index c454d4e5c786b0969f910fa3d844c8e1db9ae245..8d441b138d754a282b9592f876a5f7b39c22e253 100644 (file)
--- a/mcs/mcs/parameter.cs
+++ b/mcs/mcs/parameter.cs
@@ -207,7 +207,7 @@ namespace Mono.CSharp {
 
                public Expression TypeName;
                public readonly Modifier ModFlags;
-               public readonly string Name;
+               public string Name;
                protected Type parameter_type;
                public readonly Location Location;
 
@@ -413,8 +413,15 @@ namespace Mono.CSharp {
                        FixedParameters = new Parameter[0];
                        types = new Type [0];
                }
+
+               public Parameters (Parameter[] parameters, Type[] types)
+               {
+                       FixedParameters = parameters;
+                       this.types = types;
+                       count = types.Length;
+               }
                
-               public Parameters (Parameter [] parameters)
+               public Parameters (Parameter[] parameters)
                {
                        if (parameters == null)
                                throw new ArgumentException ("Use EmptyReadOnlyPatameters");
@@ -429,6 +436,31 @@ namespace Mono.CSharp {
                        HasArglist = has_arglist;
                }
 
+               /// <summary>
+               /// Use this method when you merge compiler generated argument with user arguments
+               /// </summary>
+               public static Parameters MergeGenerated (Parameters userParams, params Parameter[] compilerParams)
+               {
+                       Parameter[] all_params = new Parameter [userParams.count + compilerParams.Length];
+                       Type[] all_types = new Type[all_params.Length];
+                       userParams.FixedParameters.CopyTo(all_params, 0);
+                       userParams.Types.CopyTo (all_types, 0);
+
+                       int last_filled = userParams.Count;
+                       foreach (Parameter p in compilerParams) {
+                               for (int i = 0; i < last_filled; ++i) {
+                                       while (p.Name == all_params [i].Name) {
+                                               p.Name = '_' + p.Name;
+                                       }
+                               }
+                               all_params [last_filled] = p;
+                               all_types [last_filled] = p.ParameterType;
+                               ++last_filled;
+                       }
+                       
+                       return new Parameters (all_params, all_types);
+               }
+
                public bool Empty {
                        get {
                                return count == 0;
@@ -497,9 +529,8 @@ namespace Mono.CSharp {
 
                        types = new Type [count];
                        
-                       if (ec != null && !VerifyArgs ()){
+                       if (!VerifyArgs ())
                                return false;
-                       }
 
                        bool ok = true;
                        Parameter p;