mcs/argument.cs

   1 //
   2 // argument.cs: Argument expressions
   3 //
   4 // Author:
   5 //   Miguel de Icaza (miguel@ximain.com)
   6 //   Marek Safar (marek.safar@gmail.com)
   7 //
   8 // Dual licensed under the terms of the MIT X11 or GNU GPL
   9 // Copyright 2003-2008 Novell, Inc.
  10 //
  11
  12 using System;
  13 using System.Collections;
  14 using System.Reflection;
  15 using System.Reflection.Emit;
  16
  17 namespace Mono.CSharp
  18 {
  19         //
  20         // Argument expression used for invocation
  21         //
  22         public class Argument
  23         {
  24                 public enum AType : byte
  25                 {
  26                         None = 0,
  27                         Ref = 1,                        // ref modifier used
  28                         Out = 2,                        // out modifier used
  29                         Default = 3,            // argument created from default parameter value
  30                         DynamicTypeName = 4     // System.Type argument for dynamic binding
  31                 }
  32
  33                 public readonly AType ArgType;
  34                 public Expression Expr;
  35
  36                 public Argument (Expression expr, AType type)
  37                 {
  38                         this.Expr = expr;
  39                         this.ArgType = type;
  40                 }
  41
  42                 public Argument (Expression expr)
  43                 {
  44                         if (expr == null)
  45                                 throw new ArgumentNullException ();
  46
  47                         this.Expr = expr;
  48                 }
  49
  50                 public Type Type {
  51                         get { return Expr.Type; }
  52                 }
  53
  54                 public Parameter.Modifier Modifier {
  55                         get {
  56                                 switch (ArgType) {
  57                                 case AType.Out:
  58                                         return Parameter.Modifier.OUT;
  59
  60                                 case AType.Ref:
  61                                         return Parameter.Modifier.REF;
  62
  63                                 default:
  64                                         return Parameter.Modifier.NONE;
  65                                 }
  66                         }
  67                 }
  68
  69                 public virtual Expression CreateExpressionTree (ResolveContext ec)
  70                 {
  71                         if (ArgType == AType.Default)
  72                                 ec.Report.Error (854, Expr.Location, "An expression tree cannot contain an invocation which uses optional parameter");
  73
  74                         return Expr.CreateExpressionTree (ec);
  75                 }
  76
  77                 public string GetSignatureForError ()
  78                 {
  79                         if (Expr.eclass == ExprClass.MethodGroup)
  80                                 return Expr.ExprClassName;
  81
  82                         return TypeManager.CSharpName (Expr.Type);
  83                 }
  84
  85                 public bool IsByRef {
  86                         get { return ArgType == AType.Ref || ArgType == AType.Out; }
  87                 }
  88
  89                 public bool IsDefaultArgument {
  90                         get { return ArgType == AType.Default; }
  91                 }
  92
  93                 public bool ResolveMethodGroup (ResolveContext ec)
  94                 {
  95                         SimpleName sn = Expr as SimpleName;
  96                         if (sn != null)
  97                                 Expr = sn.GetMethodGroup ();
  98
  99                         // FIXME: csc doesn't report any error if you try to use `ref' or
 100                         //        `out' in a delegate creation expression.
 101                         Expr = Expr.Resolve (ec, ResolveFlags.VariableOrValue | ResolveFlags.MethodGroup);
 102                         if (Expr == null)
 103                                 return false;
 104
 105                         return true;
 106                 }
 107
 108                 public void Resolve (ResolveContext ec)
 109                 {
 110                         if (Expr == EmptyExpression.Null)
 111                                 return;
 112
 113                         using (ec.With (ResolveContext.Options.DoFlowAnalysis, true)) {
 114                                 // Verify that the argument is readable
 115                                 if (ArgType != AType.Out)
 116                                         Expr = Expr.Resolve (ec);
 117
 118                                 // Verify that the argument is writeable
 119                                 if (Expr != null && IsByRef)
 120                                         Expr = Expr.ResolveLValue (ec, EmptyExpression.OutAccess.Instance);
 121
 122                                 if (Expr == null)
 123                                         Expr = EmptyExpression.Null;
 124                         }
 125                 }
 126
 127                 public virtual void Emit (EmitContext ec)
 128                 {
 129                         if (!IsByRef) {
 130                                 Expr.Emit (ec);
 131                                 return;
 132                         }
 133
 134                         AddressOp mode = AddressOp.Store;
 135                         if (ArgType == AType.Ref)
 136                                 mode |= AddressOp.Load;
 137
 138                         IMemoryLocation ml = (IMemoryLocation) Expr;
 139                         ParameterReference pr = ml as ParameterReference;
 140
 141                         //
 142                         // ParameterReferences might already be references, so we want
 143                         // to pass just the value
 144                         //
 145                         if (pr != null && pr.IsRef)
 146                                 pr.EmitLoad (ec);
 147                         else
 148                                 ml.AddressOf (ec, mode);
 149                 }
 150
 151                 public Argument Clone (CloneContext clonectx)
 152                 {
 153                         Argument a = (Argument) MemberwiseClone ();
 154                         a.Expr = Expr.Clone (clonectx);
 155                         return a;
 156                 }
 157         }
 158
 159         public class NamedArgument : Argument
 160         {
 161                 public readonly LocatedToken Name;
 162                 LocalTemporary variable;
 163
 164                 public NamedArgument (LocatedToken name, Expression expr)
 165                         : base (expr)
 166                 {
 167                         Name = name;
 168                 }
 169
 170                 public override Expression CreateExpressionTree (ResolveContext ec)
 171                 {
 172                         ec.Report.Error (853, Name.Location, "An expression tree cannot contain named argument");
 173                         return base.CreateExpressionTree (ec);
 174                 }
 175
 176                 public override void Emit (EmitContext ec)
 177                 {
 178                         // TODO: Should guard against multiple emits
 179                         base.Emit (ec);
 180
 181                         // Release temporary variable when used
 182                         if (variable != null)
 183                                 variable.Release (ec);
 184                 }
 185
 186                 public void EmitAssign (EmitContext ec)
 187                 {
 188                         Expr.Emit (ec);
 189                         variable = new LocalTemporary (Expr.Type);
 190                         variable.Store (ec);
 191
 192                         Expr = variable;
 193                 }
 194         }
 195
 196         public class Arguments
 197         {
 198                 ArrayList args;                 // TODO: This should really be linked list
 199                 ArrayList reordered;    // TODO: LinkedList
 200                 bool has_dynamic;
 201
 202                 public Arguments (int capacity)
 203                 {
 204                         args = new ArrayList (capacity);
 205                 }
 206
 207                 public int Add (Argument arg)
 208                 {
 209                         return args.Add (arg);
 210                 }
 211
 212                 public void AddRange (Arguments args)
 213                 {
 214                         this.args.AddRange (args.args);
 215                 }
 216
 217                 public ArrayList CreateDynamicBinderArguments (ResolveContext rc)
 218                 {
 219                         ArrayList all = new ArrayList (args.Count);
 220                         Location loc = Location.Null;
 221
 222                         MemberAccess binder = DynamicExpressionStatement.GetBinderNamespace (loc);
 223
 224                         foreach (Argument a in args) {
 225                                 Arguments dargs = new Arguments (2);
 226
 227                                 // CSharpArgumentInfoFlags.None = 0
 228                                 const string info_flags_enum = "CSharpArgumentInfoFlags";
 229                                 Expression info_flags = new IntLiteral (0, loc);
 230
 231                                 var constant = a.Expr as Constant;
 232                                 if (constant != null && constant.IsLiteral) {
 233                                         info_flags = new Binary (Binary.Operator.BitwiseOr, info_flags,
 234                                                 new MemberAccess (new MemberAccess (binder, info_flags_enum, loc), "LiteralConstant", loc));
 235                                 } else if (a.ArgType == Argument.AType.Ref) {
 236                                         info_flags = new Binary (Binary.Operator.BitwiseOr, info_flags,
 237                                                 new MemberAccess (new MemberAccess (binder, info_flags_enum, loc), "IsRef", loc));
 238                                 } else if (a.ArgType == Argument.AType.Out) {
 239                                         info_flags = new Binary (Binary.Operator.BitwiseOr, info_flags,
 240                                                 new MemberAccess (new MemberAccess (binder, info_flags_enum, loc), "IsOut", loc));
 241                                 } else if (a.ArgType == Argument.AType.DynamicTypeName) {
 242                                         info_flags = new Binary (Binary.Operator.BitwiseOr, info_flags,
 243                                                 new MemberAccess (new MemberAccess (binder, info_flags_enum, loc), "IsStaticType", loc));
 244                                 }
 245
 246                                 var arg_type = a.Expr.Type;
 247
 248                                 if (!TypeManager.IsDynamicType (arg_type)) {
 249                                         MethodGroupExpr mg = a.Expr as MethodGroupExpr;
 250                                         if (mg != null) {
 251                                                 rc.Report.Error (1976, a.Expr.Location,
 252                                                         "The method group `{0}' cannot be used as an argument of dynamic operation. Consider using parentheses to invoke the method",
 253                                                         mg.Name);
 254                                         } else if (arg_type == InternalType.AnonymousMethod) {
 255                                                 rc.Report.Error (1977, a.Expr.Location,
 256                                                         "An anonymous method or lambda expression cannot be used as an argument of dynamic operation. Consider using a cast");
 257                                         } else if (arg_type == TypeManager.void_type || arg_type == InternalType.Arglist || arg_type.IsPointer) {
 258                                                 rc.Report.Error (1978, a.Expr.Location,
 259                                                         "An expression of type `{0}' cannot be used as an argument of dynamic operation",
 260                                                         TypeManager.CSharpName (arg_type));
 261                                         }
 262
 263                                         info_flags = new Binary (Binary.Operator.BitwiseOr, info_flags,
 264                                                 new MemberAccess (new MemberAccess (binder, info_flags_enum, loc), "UseCompileTimeType", loc));
 265                                 }
 266
 267                                 string named_value;
 268                                 NamedArgument na = a as NamedArgument;
 269                                 if (na != null) {
 270                                         info_flags = new Binary (Binary.Operator.BitwiseOr, info_flags,
 271                                                 new MemberAccess (new MemberAccess (binder, info_flags_enum, loc), "NamedArgument", loc));
 272
 273                                         named_value = na.Name.Value;
 274                                 } else {
 275                                         named_value = null;
 276                                 }
 277
 278                                 dargs.Add (new Argument (info_flags));
 279                                 dargs.Add (new Argument (new StringLiteral (named_value, loc)));
 280                                 all.Add (new Invocation (new MemberAccess (new MemberAccess (binder, "CSharpArgumentInfo", loc), "Create", loc), dargs));
 281                         }
 282
 283                         return all;
 284                 }
 285
 286                 public static Arguments CreateForExpressionTree (ResolveContext ec, Arguments args, params Expression[] e)
 287                 {
 288                         Arguments all = new Arguments ((args == null ? 0 : args.Count) + e.Length);
 289                         for (int i = 0; i < e.Length; ++i) {
 290                                 if (e [i] != null)
 291                                         all.Add (new Argument (e[i]));
 292                         }
 293
 294                         if (args != null) {
 295                                 foreach (Argument a in args.args) {
 296                                         Expression tree_arg = a.CreateExpressionTree (ec);
 297                                         if (tree_arg != null)
 298                                                 all.Add (new Argument (tree_arg));
 299                                 }
 300                         }
 301
 302                         return all;
 303                 }
 304
 305                 public void CheckArrayAsAttribute (CompilerContext ctx)
 306                 {
 307                         foreach (Argument arg in args) {
 308                                 // Type is undefined (was error 246)
 309                                 if (arg.Type == null)
 310                                         continue;
 311
 312                                 if (arg.Type.IsArray)
 313                                         ctx.Report.Warning (3016, 1, arg.Expr.Location, "Arrays as attribute arguments are not CLS-compliant");
 314                         }
 315                 }
 316
 317                 public Arguments Clone (CloneContext ctx)
 318                 {
 319                         Arguments cloned = new Arguments (args.Count);
 320                         foreach (Argument a in args)
 321                                 cloned.Add (a.Clone (ctx));
 322
 323                         return cloned;
 324                 }
 325
 326                 public int Count {
 327                         get { return args.Count; }
 328                 }
 329
 330                 //
 331                 // Emits a list of resolved Arguments
 332                 //
 333                 public void Emit (EmitContext ec)
 334                 {
 335                         Emit (ec, false, null);
 336                 }
 337
 338                 //
 339                 // if `dup_args' is true, a copy of the arguments will be left
 340                 // on the stack. If `dup_args' is true, you can specify `this_arg'
 341                 // which will be duplicated before any other args. Only EmitCall
 342                 // should be using this interface.
 343                 //
 344                 public void Emit (EmitContext ec, bool dup_args, LocalTemporary this_arg)
 345                 {
 346                         LocalTemporary[] temps = null;
 347
 348                         if (dup_args && Count != 0)
 349                                 temps = new LocalTemporary [Count];
 350
 351                         if (reordered != null && Count > 1) {
 352                                 foreach (NamedArgument na in reordered)
 353                                         na.EmitAssign (ec);
 354                         }
 355
 356                         int i = 0;
 357                         foreach (Argument a in args) {
 358                                 a.Emit (ec);
 359                                 if (dup_args) {
 360                                         ec.ig.Emit (OpCodes.Dup);
 361                                         (temps [i++] = new LocalTemporary (a.Type)).Store (ec);
 362                                 }
 363                         }
 364
 365                         if (dup_args) {
 366                                 if (this_arg != null)
 367                                         this_arg.Emit (ec);
 368
 369                                 for (i = 0; i < temps.Length; i++) {
 370                                         temps[i].Emit (ec);
 371                                         temps[i].Release (ec);
 372                                 }
 373                         }
 374                 }
 375
 376                 public bool GetAttributableValue (ResolveContext ec, out object[] values)
 377                 {
 378                         values = new object [args.Count];
 379                         for (int j = 0; j < values.Length; ++j) {
 380                                 Argument a = this [j];
 381                                 if (!a.Expr.GetAttributableValue (ec, a.Type, out values[j]))
 382                                         return false;
 383                         }
 384
 385                         return true;
 386                 }
 387
 388                 public IEnumerator GetEnumerator ()
 389                 {
 390                         return args.GetEnumerator ();
 391                 }
 392
 393                 //
 394                 // At least one argument is of dynamic type
 395                 //
 396                 public bool HasDynamic {
 397                         get {
 398                                 return has_dynamic;
 399                         }
 400                 }
 401
 402                 public void Insert (int index, Argument arg)
 403                 {
 404                         args.Insert (index, arg);
 405                 }
 406
 407 #if NET_4_0
 408                 public static System.Linq.Expressions.Expression[] MakeExpression (Arguments args, BuilderContext ctx)
 409                 {
 410                         if (args == null || args.Count == 0)
 411                                 return null;
 412
 413                         var exprs = new System.Linq.Expressions.Expression [args.Count];
 414                         for (int i = 0; i < exprs.Length; ++i) {
 415                                 Argument a = (Argument) args.args [i];
 416                                 exprs[i] = a.Expr.MakeExpression (ctx);
 417                         }
 418
 419                         return exprs;
 420                 }
 421 #endif
 422
 423                 public void MarkReorderedArgument (NamedArgument a)
 424                 {
 425                         //
 426                         // Constant expression can have no effect on left-to-right execution
 427                         //
 428                         if (a.Expr is Constant)
 429                                 return;
 430
 431                         if (reordered == null)
 432                                 reordered = new ArrayList ();
 433
 434                         reordered.Add (a);
 435                 }
 436
 437                 //
 438                 // Returns dynamic when at least one argument is of dynamic type
 439                 //
 440                 public void Resolve (ResolveContext ec, out bool dynamic)
 441                 {
 442                         foreach (Argument a in args) {
 443                                 a.Resolve (ec);
 444                                 this.has_dynamic |= TypeManager.IsDynamicType (a.Type);
 445                         }
 446
 447                         dynamic = has_dynamic;
 448                 }
 449
 450                 public void MutateHoistedGenericType (AnonymousMethodStorey storey)
 451                 {
 452                         foreach (Argument a in args)
 453                                 a.Expr.MutateHoistedGenericType (storey);
 454                 }
 455
 456                 public void RemoveAt (int index)
 457                 {
 458                         args.RemoveAt (index);
 459                 }
 460
 461                 public Argument this [int index] {
 462                         get { return (Argument) args [index]; }
 463                         set { args [index] = value; }
 464                 }
 465         }
 466 }