2007-07-03 Marek Safar <marek.safar@gmail.com>

	* lambda.cs: Simplified little bit.

	* parameter.cs: Introduced ImplicitLambdaParameter.
	(Parameters.CreateFullyResolved): New factory instead of ctor.

	* anonymous.cs,
	* class.cs,
	* delegate.cs: Updated parameter creation.

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

diff --git a/mcs/mcs/ChangeLog b/mcs/mcs/ChangeLog
index 9281b0ae175b3d61eae0d0b114b6aa925147d1ed..6cd3d353e7101a2f9b87498a4202ce58f4d06d8c 100644 (file)
--- a/mcs/mcs/ChangeLog
+++ b/mcs/mcs/ChangeLog
@@ -1,3 +1,14 @@
+2007-07-03  Marek Safar  <marek.safar@gmail.com>
+
+       * lambda.cs: Simplified little bit.
+       
+       * parameter.cs: Introduced ImplicitLambdaParameter.
+       (Parameters.CreateFullyResolved): New factory instead of ctor.
+       
+       * anonymous.cs,
+       * class.cs,
+       * delegate.cs: Updated parameter creation.
+       
 2007-07-03  Marek Safar  <marek.safar@gmail.com>
 
        *  ecore.cs (SimpleName.GetSignatureForError): Display correctly generic

diff --git a/mcs/mcs/anonymous.cs b/mcs/mcs/anonymous.cs
index f1326d8712d432113b7c2bfad5679cf80bcaa7d2..e0f937812e931a5e4fa3428ce2c7ffa840d976e3 100644 (file)
--- a/mcs/mcs/anonymous.cs
+++ b/mcs/mcs/anonymous.cs
@@ -118,7 +118,7 @@ namespace Mono.CSharp {
                                inflated_types [i] = it;
                                inflated_params [i] = new Parameter (it, p.Name, p.ModFlags, p.OptAttributes, p.Location);
                        }
-                       return new Parameters (inflated_params, inflated_types);
+                       return Parameters.CreateFullyResolved (inflated_params, inflated_types);
                }
 
                public TypeExpr InflateType (Type it)

diff --git a/mcs/mcs/class.cs b/mcs/mcs/class.cs
index 25dcf72ce063ce4ea6dba2255abeb2a207a9edc7..77d13ef23d471906dd1d1863bded1ce05858d627 100644 (file)
--- a/mcs/mcs/class.cs
+++ b/mcs/mcs/class.cs
@@ -6457,9 +6457,8 @@ namespace Mono.CSharp {
 
                        protected virtual void DefineParameters ()
                        {
-                               parameters = new Parameters (
-                                       new Parameter[] { new Parameter (method.MemberType, "value", Parameter.Modifier.NONE, null, Location) },
-                                       new Type[] { method.MemberType });
+                               parameters = Parameters.CreateFullyResolved (
+                                       new Parameter (method.MemberType, "value", Parameter.Modifier.NONE, null, Location));
                        }
 
                        public override MethodBuilder Define (DeclSpace parent)
@@ -7558,9 +7557,8 @@ namespace Mono.CSharp {
                                return false;
                        }
 
-                       parameters = new Parameters (
-                               new Parameter[] { new Parameter (MemberType, "value", Parameter.Modifier.NONE, null, Location) },
-                               new Type[] { MemberType } );
+                       parameters = Parameters.CreateFullyResolved (
+                               new Parameter (MemberType, "value", Parameter.Modifier.NONE, null, Location));
 
                        if (!CheckBase ())
                                return false;

diff --git a/mcs/mcs/delegate.cs b/mcs/mcs/delegate.cs
index a0efd9a7d1f4c719b795ad6aaddf39642974a287..358e750801f32ff8d6c279ad7549af88c96470f6 100644 (file)
--- a/mcs/mcs/delegate.cs
+++ b/mcs/mcs/delegate.cs
@@ -297,7 +297,7 @@ namespace Mono.CSharp {
                                        end_params [param] = p;
                                        ++param;
                                }
-                               end_parameters = new Parameters (end_params, end_param_types);
+                               end_parameters = Parameters.CreateFullyResolved (end_params, end_param_types);
                        }
                        else {
                                end_parameters = Parameters.EmptyReadOnlyParameters;

diff --git a/mcs/mcs/lambda.cs b/mcs/mcs/lambda.cs
index bf2eff261ba448cae3aba41edb3cacf972de5c5b..a8c61489f009d5624c83509437d9761d89c82d78 100644 (file)
--- a/mcs/mcs/lambda.cs
+++ b/mcs/mcs/lambda.cs
@@ -18,10 +18,9 @@ namespace Mono.CSharp {
                bool explicit_parameters;
 
                //
-               // The parameter list can either be:
-               //    null: no parameters
-               //    arraylist of Parameter (explicitly typed parameters)
-               //    arraylist of strings (implicitly typed parameters)
+               // The parameters can either be:
+               //    A list of Parameters (explicitly typed parameters)
+               //    An ImplicitLambdaParameter
                //
                public LambdaExpression (AnonymousMethodExpression parent,
                                         GenericMethod generic, TypeContainer host,
@@ -29,15 +28,7 @@ namespace Mono.CSharp {
                                         Location loc)
                        : base (parent, generic, host, parameters, container, loc)
                {
-                       explicit_parameters = (parameters != null && parameters.Count > 0 && parameters [0].TypeName != null);
-                       if (parameters == null)
-                               Parameters = Parameters.EmptyReadOnlyParameters;
-               }
-
-               public bool HasImplicitParameters {
-                       get {
-                               return !explicit_parameters;
-                       }
+                       explicit_parameters = parameters.FixedParameters [0].TypeName != null;
                }
 
                public bool HasExplicitParameters {
@@ -48,23 +39,17 @@ namespace Mono.CSharp {
                
                public override Expression DoResolve (EmitContext ec)
                {
-                       eclass = ExprClass.Value;
-                       type = TypeManager.anonymous_method_type;
-
-                       if (explicit_parameters){
+                       //
+                       // Only explicit parameters can be resolved at this point
+                       //
+                       if (explicit_parameters) {
                                if (!Parameters.Resolve (ec))
                                        return null;
                        }
-                       
-                       // We will resolve parameters later, we do not
-                       // have information at this point.
-                       
-                       return this;
-               }
 
-               public override void Emit (EmitContext ec)
-               {
-                       base.Emit (ec);
+                       eclass = ExprClass.Value;
+                       type = TypeManager.anonymous_method_type;                                               
+                       return this;
                }
 
                public override bool ImplicitStandardConversionExists (Type delegate_type)

diff --git a/mcs/mcs/parameter.cs b/mcs/mcs/parameter.cs
index 6c50851b114f925c714e28fb8bac53d4914a69f9..71838a6f549d0411d74c3edd5999e5831de85349 100644 (file)
--- a/mcs/mcs/parameter.cs
+++ b/mcs/mcs/parameter.cs
@@ -139,6 +139,14 @@ namespace Mono.CSharp {
                }
        }
 
+       public class ImplicitLambdaParameter : Parameter
+       {
+               public ImplicitLambdaParameter (string name, Location loc)
+                       : base ((Type)null, name, Modifier.NONE, null, loc)
+               {
+               }
+       }
+
        public class ParamsParameter : Parameter {
                public ParamsParameter (Expression type, string name, Attributes attrs, Location loc):
                        base (type, name, Parameter.Modifier.PARAMS, attrs, loc)
@@ -312,7 +320,7 @@ namespace Mono.CSharp {
 
                        base.ApplyAttributeBuilder (a, cb);
                }
-
+               
                public virtual bool CheckAccessibility (InterfaceMemberBase member)
                {
                        if (IsTypeParameter)
@@ -614,7 +622,7 @@ namespace Mono.CSharp {
                        types = new Type [0];
                }
 
-               public Parameters (Parameter[] parameters, Type[] types)
+               private Parameters (Parameter[] parameters, Type[] types)
                {
                        FixedParameters = parameters;
                        this.types = types;
@@ -635,6 +643,16 @@ namespace Mono.CSharp {
                {
                        HasArglist = has_arglist;
                }
+               
+               public static Parameters CreateFullyResolved (Parameter p)
+               {
+                       return new Parameters (new Parameter [] { p }, new Type [] { p.ParameterType });
+               }
+               
+               public static Parameters CreateFullyResolved (Parameter[] parameters, Type[] types)
+               {
+                       return new Parameters (parameters, types);
+               }
 
                /// <summary>
                /// Use this method when you merge compiler generated argument with user arguments