Change the way how using declarators statements are generated to handle await in...

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

diff --git a/mcs/mcs/parameter.cs b/mcs/mcs/parameter.cs
index cb768e1d82b8c1919f9fcebff986478f17445227..20fbfb1f2deb9ceb0c93f8d248a6cd21d98a63bf 100644 (file)
--- a/mcs/mcs/parameter.cs
+++ b/mcs/mcs/parameter.cs
@@ -430,7 +430,7 @@ namespace Mono.CSharp {
                                }
 
                                if (TypeSpecComparer.IsEqual (default_expr.Type, parameter_type) ||
-                                       (default_expr is NullConstant && TypeManager.IsReferenceType (parameter_type) && !parameter_type.IsGenericParameter) ||
+                                       (default_expr is NullConstant && TypeSpec.IsReferenceType (parameter_type) && !parameter_type.IsGenericParameter) ||
                                        parameter_type.BuiltinType == BuiltinTypeSpec.Type.Object) {
                                        return;
                                }
@@ -493,6 +493,11 @@ namespace Mono.CSharp {
                        }
                }
 
+               public void Error_DuplicateName (Report r)
+               {
+                       r.Error (100, Location, "The parameter name `{0}' is a duplicate", Name);
+               }
+
                public virtual string GetSignatureForError ()
                {
                        string type_name;
@@ -608,40 +613,20 @@ namespace Mono.CSharp {
 
                public void Emit (EmitContext ec)
                {
-                       int arg_idx = idx;
-                       if (!ec.IsStatic)
-                               arg_idx++;
-
-                       ParameterReference.EmitLdArg (ec, arg_idx);
+                       ec.EmitArgumentLoad (idx);
                }
 
                public void EmitAssign (EmitContext ec)
                {
-                       int arg_idx = idx;
-                       if (!ec.IsStatic)
-                               arg_idx++;
-
-                       if (arg_idx <= 255)
-                               ec.Emit (OpCodes.Starg_S, (byte) arg_idx);
-                       else
-                               ec.Emit (OpCodes.Starg, arg_idx);
+                       ec.EmitArgumentStore (idx);
                }
 
                public void EmitAddressOf (EmitContext ec)
                {
-                       int arg_idx = idx;
-
-                       if (!ec.IsStatic)
-                               arg_idx++;
-
-                       bool is_ref = (ModFlags & Modifier.ISBYREF) != 0;
-                       if (is_ref) {
-                               ParameterReference.EmitLdArg (ec, arg_idx);
+                       if ((ModFlags & Modifier.ISBYREF) != 0) {
+                               ec.EmitArgumentLoad (idx);
                        } else {
-                               if (arg_idx <= 255)
-                                       ec.Emit (OpCodes.Ldarga_S, (byte) arg_idx);
-                               else
-                                       ec.Emit (OpCodes.Ldarga, arg_idx);
+                               ec.EmitArgumentAddress (idx);
                        }
                }
 
@@ -1007,6 +992,17 @@ namespace Mono.CSharp {
                                null);
                }
 
+               public void CheckConstraints (IMemberContext mc)
+               {
+                       foreach (Parameter p in parameters) {
+                               //
+                               // It's null for compiler generated types or special types like __arglist
+                               //
+                               if (p.TypeExpression != null)
+                                       ConstraintChecker.Check (mc, p.Type, p.TypeExpression.Location);
+                       }
+               }
+
                //
                // Returns non-zero value for equal CLS parameter signatures
                //
@@ -1095,6 +1091,20 @@ namespace Mono.CSharp {
                        return parameters;
                }
 
+               //
+               // Parameters checks for members which don't have a block
+               //
+               public void CheckParameters (MemberCore member)
+               {
+                       for (int i = 0; i < parameters.Length; ++i) {
+                               var name = parameters[i].Name;
+                               for (int ii = i + 1; ii < parameters.Length; ++ii) {
+                                       if (parameters[ii].Name == name)
+                                               this[ii].Error_DuplicateName (member.Compiler.Report);
+                               }
+                       }
+               }
+
                public bool Resolve (IMemberContext ec)
                {
                        if (types != null)
@@ -1248,7 +1258,7 @@ namespace Mono.CSharp {
                                        }
                                }
 
-                               if (!expr.IsNull && TypeManager.IsReferenceType (parameter_type) && parameter_type.BuiltinType != BuiltinTypeSpec.Type.String) {
+                               if (!expr.IsNull && TypeSpec.IsReferenceType (parameter_type) && parameter_type.BuiltinType != BuiltinTypeSpec.Type.String) {
                                        rc.Report.Error (1763, Location,
                                                "Optional parameter `{0}' of type `{1}' can only be initialized with `null'",
                                                p.Name, parameter_type.GetSignatureForError ());