2007-08-18 Marek Safar <marek.safar@gmail.com>

[mono.git] / mcs / mcs / parameter.cs

diff --git a/mcs/mcs/parameter.cs b/mcs/mcs/parameter.cs
index 6c50851b114f925c714e28fb8bac53d4914a69f9..a8d6b6f7d3ef553a6a45209fd45b198fa04c48c8 100644 (file)
--- a/mcs/mcs/parameter.cs
+++ b/mcs/mcs/parameter.cs
@@ -139,6 +139,22 @@ namespace Mono.CSharp {
                }
        }
 
+       public class ImplicitLambdaParameter : Parameter
+       {
+               public ImplicitLambdaParameter (string name, Location loc)
+                       : base ((Type)null, name, Modifier.NONE, null, loc)
+               {
+               }
+
+               public override bool Resolve (IResolveContext ec)
+               {
+                       if (parameter_type == null)
+                               throw new InternalErrorException ("Implicit lambda parameter type is not set");
+
+                       return true;
+               }
+       }
+
        public class ParamsParameter : Parameter {
                public ParamsParameter (Expression type, string name, Attributes attrs, Location loc):
                        base (type, name, Parameter.Modifier.PARAMS, attrs, loc)
@@ -211,7 +227,7 @@ namespace Mono.CSharp {
 
                static string[] attribute_targets = new string [] { "param" };
 
-               public Expression TypeName;
+               Expression TypeName;
                public Modifier modFlags;
                public string Name;
                public bool IsCaptured;
@@ -312,7 +328,7 @@ namespace Mono.CSharp {
 
                        base.ApplyAttributeBuilder (a, cb);
                }
-
+               
                public virtual bool CheckAccessibility (InterfaceMemberBase member)
                {
                        if (IsTypeParameter)
@@ -614,7 +630,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 +651,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
@@ -803,26 +829,34 @@ namespace Mono.CSharp {
                }
 
 #if MS_COMPATIBLE
-               public void InflateTypes (Type[] genArguments, Type[] argTypes)
+               public ParameterData InflateTypes (Type[] genArguments, Type[] argTypes)
                {
+                       Parameters p = Clone ();
                        for (int i = 0; i < count; ++i) {
-                               if (FixedParameters[i].IsTypeParameter) {
-                                       for (int ii = 0; ii < genArguments.Length; ++ii) {
-                                               if (types[i] != genArguments[ii])
-                                                       continue;
-
-                                               types[i] = argTypes[ii];
-                                               FixedParameters[i].ParameterType = types[i];
-                                               break;
+                               if (types[i].IsGenericType) {
+                                       Type[] gen_arguments_open = new Type [types[i].GetGenericTypeDefinition ().GetGenericArguments ().Length];
+                                       Type[] gen_arguments = types[i].GetGenericArguments ();
+                                       for (int ii = 0; ii < gen_arguments_open.Length; ++ii) {
+                                               if (gen_arguments[ii].IsGenericParameter) {
+                                                       Type t = argTypes[gen_arguments[ii].GenericParameterPosition];
+                                                       gen_arguments_open[ii] = t;
+                                               } else
+                                                       gen_arguments_open[ii] = gen_arguments[ii];
                                        }
+
+                                       p.FixedParameters [i].ParameterType = p.types[i] =
+                                               types[i].GetGenericTypeDefinition ().MakeGenericType (gen_arguments_open);
                                        continue;
                                }
 
-                               if (types[i].IsGenericType) {
-                                       types[i] = types[i].GetGenericTypeDefinition().MakeGenericType (argTypes[0]); // FIXME: The order can be different
-                                       FixedParameters[i].ParameterType = types[i];
+                               if (types[i].IsGenericParameter) {
+                                       Type gen_argument = argTypes[types[i].GenericParameterPosition];
+                                       p.FixedParameters[i].ParameterType = p.types[i] = gen_argument;
+                                       continue;
                                }
                        }
+
+                       return p;
                }
 #endif
 
@@ -857,6 +891,13 @@ namespace Mono.CSharp {
                        get {
                                return types;
                        }
+                       //
+                       // Dangerous, used by implicit lambda parameters
+                       // only to workaround bad design
+                       //
+                       set {
+                               types = value;
+                       }
                }
 
                public Parameter this [int pos]