source: trunk/HeuristicLab.ExtLibs/HeuristicLab.NRefactory/5.5.0/NRefactory.CSharp-5.5.0/Parser/mcs/argument.cs @ 16240

//
// argument.cs: Argument expressions
//
// Author:
//   Miguel de Icaza (miguel@ximain.com)
//   Marek Safar (marek.safar@gmail.com)
//
// Dual licensed under the terms of the MIT X11 or GNU GPL
// Copyright 2003-2011 Novell, Inc.
// Copyright 2011 Xamarin Inc
//

using System;
using System.Collections.Generic;

#if STATIC
using IKVM.Reflection.Emit;
#else
using System.Reflection.Emit;
#endif

namespace Mono.CSharp
{
  //
  // Argument expression used for invocation
  //
  public class Argument
  {
    public enum AType : byte
    {
      None = 0,
      Ref = 1,      // ref modifier used
      Out = 2,      // out modifier used
      Default = 3,    // argument created from default parameter value
      DynamicTypeName = 4,  // System.Type argument for dynamic binding
      ExtensionType = 5,  // Instance expression inserted as the first argument

      // Conditional instance expression inserted as the first argument
      ExtensionTypeConditionalAccess = 5 | ConditionalAccessFlag,

      ConditionalAccessFlag = 1 << 7
    }

    public readonly AType ArgType;
    public Expression Expr;

    public Argument (Expression expr, AType type)
    {
      this.Expr = expr;
      this.ArgType = type;
    }

    public Argument (Expression expr)
    {
      this.Expr = expr;
    }

    #region Properties

    public bool IsByRef {
      get { return ArgType == AType.Ref || ArgType == AType.Out; }
    }

    public bool IsDefaultArgument {
      get { return ArgType == AType.Default; }
    }

    public bool IsExtensionType {
      get {
        return (ArgType & AType.ExtensionType) == AType.ExtensionType;
      }
    }

    public Parameter.Modifier Modifier {
      get {
        switch (ArgType) {
        case AType.Out:
          return Parameter.Modifier.OUT;

        case AType.Ref:
          return Parameter.Modifier.REF;

        default:
          return Parameter.Modifier.NONE;
        }
      }
    }

    public TypeSpec Type {
      get { return Expr.Type; }
    }

    #endregion

    public Argument Clone (Expression expr)
    {
      Argument a = (Argument) MemberwiseClone ();
      a.Expr = expr;
      return a;
    }

    public Argument Clone (CloneContext clonectx)
    {
      return Clone (Expr.Clone (clonectx));
    }

    public virtual Expression CreateExpressionTree (ResolveContext ec)
    {
      if (ArgType == AType.Default)
        ec.Report.Error (854, Expr.Location, "An expression tree cannot contain an invocation which uses optional parameter");

      return Expr.CreateExpressionTree (ec);
    }


    public virtual void Emit (EmitContext ec)
    {
      if (!IsByRef) {
        if (ArgType == AType.ExtensionTypeConditionalAccess) {
          var ie = new InstanceEmitter (Expr, false);
          ie.Emit (ec, true);
        } else {
          Expr.Emit (ec);
        }

        return;
      }

      AddressOp mode = AddressOp.Store;
      if (ArgType == AType.Ref)
        mode |= AddressOp.Load;

      IMemoryLocation ml = (IMemoryLocation) Expr;
      ml.AddressOf (ec, mode);
    }

    public Argument EmitToField (EmitContext ec, bool cloneResult)
    {
      var res = Expr.EmitToField (ec);
      if (cloneResult && res != Expr)
        return new Argument (res, ArgType);

      Expr = res;
      return this;
    }

    public void FlowAnalysis (FlowAnalysisContext fc)
    {
      if (ArgType == AType.Out) {
        var vr = Expr as VariableReference;
        if (vr != null) {
          if (vr.VariableInfo != null)
            fc.SetVariableAssigned (vr.VariableInfo);

          return;
        }

        var fe = Expr as FieldExpr;
        if (fe != null) {
          fe.SetFieldAssigned (fc);
          return;
        }

        return;
      }

      Expr.FlowAnalysis (fc);
    }

    public string GetSignatureForError ()
    {
      if (Expr.eclass == ExprClass.MethodGroup)
        return Expr.ExprClassName;

      return Expr.Type.GetSignatureForError ();
    }

    public bool ResolveMethodGroup (ResolveContext ec)
    {
      SimpleName sn = Expr as SimpleName;
      if (sn != null)
        Expr = sn.GetMethodGroup ();

      // FIXME: csc doesn't report any error if you try to use `ref' or
      //        `out' in a delegate creation expression.
      Expr = Expr.Resolve (ec, ResolveFlags.VariableOrValue | ResolveFlags.MethodGroup);
      if (Expr == null)
        return false;

      return true;
    }

    public void Resolve (ResolveContext ec)
    {
      // Verify that the argument is readable
      if (ArgType != AType.Out)
        Expr = Expr.Resolve (ec);

      // Verify that the argument is writeable
      if (Expr != null && IsByRef)
        Expr = Expr.ResolveLValue (ec, EmptyExpression.OutAccess);

      if (Expr == null)
        Expr = ErrorExpression.Instance;
    }
  }

  public class MovableArgument : Argument
  {
    LocalTemporary variable;

    public MovableArgument (Argument arg)
      : this (arg.Expr, arg.ArgType)
    {
    }

    protected MovableArgument (Expression expr, AType modifier)
      : base (expr, modifier)
    {
    }

    public override void Emit (EmitContext ec)
    {
      // TODO: Should guard against multiple emits
      base.Emit (ec);

      // Release temporary variable when used
      if (variable != null)
        variable.Release (ec);
    }

    public void EmitToVariable (EmitContext ec)
    {
      var type = Expr.Type;
      if (IsByRef) {
        var ml = (IMemoryLocation) Expr;
        ml.AddressOf (ec, AddressOp.LoadStore);
        type = ReferenceContainer.MakeType (ec.Module, type);
      } else {
        Expr.Emit (ec);
      }

      variable = new LocalTemporary (type);
      variable.Store (ec);

      Expr = variable;
    }
  }

  public class NamedArgument : MovableArgument
  {
    public readonly string Name;
    readonly Location loc;

    public NamedArgument (string name, Location loc, Expression expr)
      : this (name, loc, expr, AType.None)
    {
    }

    public NamedArgument (string name, Location loc, Expression expr, AType modifier)
      : base (expr, modifier)
    {
      this.Name = name;
      this.loc = loc;
    }

    public override Expression CreateExpressionTree (ResolveContext ec)
    {
      ec.Report.Error (853, loc, "An expression tree cannot contain named argument");
      return base.CreateExpressionTree (ec);
    }

    public Location Location {
      get { return loc; }
    }
  }
  
  public class Arguments
  {
    sealed class ArgumentsOrdered : Arguments
    {
      readonly List<MovableArgument> ordered;

      public ArgumentsOrdered (Arguments args)
        : base (args.Count)
      {
        AddRange (args);
        ordered = new List<MovableArgument> ();
      }

      public void AddOrdered (MovableArgument arg)
      {
        ordered.Add (arg);
      }

      public override void FlowAnalysis (FlowAnalysisContext fc, List<MovableArgument> movable = null)
      {
        foreach (var arg in ordered) {
          if (arg.ArgType != Argument.AType.Out)
            arg.FlowAnalysis (fc);
        }

        base.FlowAnalysis (fc, ordered);
      }

      public override Arguments Emit (EmitContext ec, bool dup_args, bool prepareAwait)
      {
        foreach (var a in ordered) {
          if (prepareAwait)
            a.EmitToField (ec, false);
          else
            a.EmitToVariable (ec);
        }

        return base.Emit (ec, dup_args, prepareAwait);
      }
    }

    // Try not to add any more instances to this class, it's allocated a lot
    List<Argument> args;

    public Arguments (int capacity)
    {
      args = new List<Argument> (capacity);
    }

    private Arguments (List<Argument> args)
    {
      this.args = args;
    }

    public void Add (Argument arg)
    {
      args.Add (arg);
    }

    public void AddRange (Arguments args)
    {
      this.args.AddRange (args.args);
    }

    public bool ContainsEmitWithAwait ()
    {
      foreach (var arg in args) {
        if (arg.Expr.ContainsEmitWithAwait ())
          return true;
      }

      return false;
    }

    public ArrayInitializer CreateDynamicBinderArguments (ResolveContext rc)
    {
      Location loc = Location.Null;
      var all = new ArrayInitializer (args.Count, loc);

      MemberAccess binder = DynamicExpressionStatement.GetBinderNamespace (loc);

      foreach (Argument a in args) {
        Arguments dargs = new Arguments (2);

        // CSharpArgumentInfoFlags.None = 0
        const string info_flags_enum = "CSharpArgumentInfoFlags";
        Expression info_flags = new IntLiteral (rc.BuiltinTypes, 0, loc);

        if (a.Expr is Constant) {
          info_flags = new Binary (Binary.Operator.BitwiseOr, info_flags,
            new MemberAccess (new MemberAccess (binder, info_flags_enum, loc), "Constant", loc));
        } else if (a.ArgType == Argument.AType.Ref) {
          info_flags = new Binary (Binary.Operator.BitwiseOr, info_flags,
            new MemberAccess (new MemberAccess (binder, info_flags_enum, loc), "IsRef", loc));
          info_flags = new Binary (Binary.Operator.BitwiseOr, info_flags,
            new MemberAccess (new MemberAccess (binder, info_flags_enum, loc), "UseCompileTimeType", loc));
        } else if (a.ArgType == Argument.AType.Out) {
          info_flags = new Binary (Binary.Operator.BitwiseOr, info_flags,
            new MemberAccess (new MemberAccess (binder, info_flags_enum, loc), "IsOut", loc));
          info_flags = new Binary (Binary.Operator.BitwiseOr, info_flags,
            new MemberAccess (new MemberAccess (binder, info_flags_enum, loc), "UseCompileTimeType", loc));
        } else if (a.ArgType == Argument.AType.DynamicTypeName) {
          info_flags = new Binary (Binary.Operator.BitwiseOr, info_flags,
            new MemberAccess (new MemberAccess (binder, info_flags_enum, loc), "IsStaticType", loc));
        }

        var arg_type = a.Expr.Type;

        if (arg_type.BuiltinType != BuiltinTypeSpec.Type.Dynamic && arg_type != InternalType.NullLiteral) {
          MethodGroupExpr mg = a.Expr as MethodGroupExpr;
          if (mg != null) {
            rc.Report.Error (1976, a.Expr.Location,
              "The method group `{0}' cannot be used as an argument of dynamic operation. Consider using parentheses to invoke the method",
              mg.Name);
          } else if (arg_type == InternalType.AnonymousMethod) {
            rc.Report.Error (1977, a.Expr.Location,
              "An anonymous method or lambda expression cannot be used as an argument of dynamic operation. Consider using a cast");
          } else if (arg_type.Kind == MemberKind.Void || arg_type == InternalType.Arglist || arg_type.IsPointer) {
            rc.Report.Error (1978, a.Expr.Location,
              "An expression of type `{0}' cannot be used as an argument of dynamic operation",
              arg_type.GetSignatureForError ());
          }

          info_flags = new Binary (Binary.Operator.BitwiseOr, info_flags,
            new MemberAccess (new MemberAccess (binder, info_flags_enum, loc), "UseCompileTimeType", loc));
        }

        string named_value;
        NamedArgument na = a as NamedArgument;
        if (na != null) {
          info_flags = new Binary (Binary.Operator.BitwiseOr, info_flags,
            new MemberAccess (new MemberAccess (binder, info_flags_enum, loc), "NamedArgument", loc));

          named_value = na.Name;
        } else {
          named_value = null;
        }

        dargs.Add (new Argument (info_flags));
        dargs.Add (new Argument (new StringLiteral (rc.BuiltinTypes, named_value, loc)));
        all.Add (new Invocation (new MemberAccess (new MemberAccess (binder, "CSharpArgumentInfo", loc), "Create", loc), dargs));
      }

      return all;
    }

    public static Arguments CreateForExpressionTree (ResolveContext ec, Arguments args, params Expression[] e)
    {
      Arguments all = new Arguments ((args == null ? 0 : args.Count) + e.Length);
      for (int i = 0; i < e.Length; ++i) {
        if (e [i] != null)
          all.Add (new Argument (e[i]));
      }

      if (args != null) {
        foreach (Argument a in args.args) {
          Expression tree_arg = a.CreateExpressionTree (ec);
          if (tree_arg != null)
            all.Add (new Argument (tree_arg));
        }
      }

      return all;
    }

    public void CheckArrayAsAttribute (CompilerContext ctx)
    {
      foreach (Argument arg in args) {
        // Type is undefined (was error 246)
        if (arg.Type == null)
          continue;

        if (arg.Type.IsArray)
          ctx.Report.Warning (3016, 1, arg.Expr.Location, "Arrays as attribute arguments are not CLS-compliant");
      }
    }

    public Arguments Clone (CloneContext ctx)
    {
      Arguments cloned = new Arguments (args.Count);
      foreach (Argument a in args)
        cloned.Add (a.Clone (ctx));

      return cloned;
    }

    public int Count {
      get { return args.Count; }
    }

    //
    // Emits a list of resolved Arguments
    // 
    public void Emit (EmitContext ec)
    {
      Emit (ec, false, false);
    }

    //
    // if `dup_args' is true or any of arguments contains await.
    // A copy of all arguments will be returned to the caller
    //
    public virtual Arguments Emit (EmitContext ec, bool dup_args, bool prepareAwait)
    {
      List<Argument> dups;

      if ((dup_args && Count != 0) || prepareAwait)
        dups = new List<Argument> (Count);
      else
        dups = null;

      LocalTemporary lt;
      foreach (Argument a in args) {
        if (prepareAwait) {
          dups.Add (a.EmitToField (ec, true));
          continue;
        }
        
        a.Emit (ec);

        if (!dup_args) {
          continue;
        }

        if (a.Expr.IsSideEffectFree) {
          //
          // No need to create a temporary variable for side effect free expressions. I assume
          // all side-effect free expressions are cheap, this has to be tweaked when we become
          // more aggressive on detection
          //
          dups.Add (a);
        } else {
          ec.Emit (OpCodes.Dup);

          // TODO: Release local temporary on next Emit
          // Need to add a flag to argument to indicate this
          lt = new LocalTemporary (a.Type);
          lt.Store (ec);

          dups.Add (new Argument (lt, a.ArgType));
        }
      }

      if (dups != null)
        return new Arguments (dups);

      return null;
    }

    public virtual void FlowAnalysis (FlowAnalysisContext fc, List<MovableArgument> movable = null)
    {
      bool has_out = false;
      foreach (var arg in args) {
        if (arg.ArgType == Argument.AType.Out) {
          has_out = true;
          continue;
        }

        if (movable == null) {
          arg.FlowAnalysis (fc);
          continue;
        }

        var ma = arg as MovableArgument;
        if (ma != null && !movable.Contains (ma))
          arg.FlowAnalysis (fc);
      }

      if (!has_out)
        return;

      foreach (var arg in args) {
        if (arg.ArgType != Argument.AType.Out)
          continue;

        arg.FlowAnalysis (fc);
      }
    }

    public List<Argument>.Enumerator GetEnumerator ()
    {
      return args.GetEnumerator ();
    }

    //
    // At least one argument is of dynamic type
    //
    public bool HasDynamic {
      get {
        foreach (Argument a in args) {
          if (a.Type.BuiltinType == BuiltinTypeSpec.Type.Dynamic && !a.IsByRef)
            return true;
        }
        
        return false;
      }
    }

    //
    // At least one argument is named argument
    //
    public bool HasNamed {
      get {
        foreach (Argument a in args) {
          if (a is NamedArgument)
            return true;
        }
        
        return false;
      }
    }


    public void Insert (int index, Argument arg)
    {
      args.Insert (index, arg);
    }

    public static System.Linq.Expressions.Expression[] MakeExpression (Arguments args, BuilderContext ctx)
    {
      if (args == null || args.Count == 0)
        return null;

      var exprs = new System.Linq.Expressions.Expression [args.Count];
      for (int i = 0; i < exprs.Length; ++i) {
        Argument a = args.args [i];
        exprs[i] = a.Expr.MakeExpression (ctx);
      }

      return exprs;
    }

    //
    // For named arguments when the order of execution is different
    // to order of invocation
    //
    public Arguments MarkOrderedArgument (NamedArgument a)
    {
      //
      // An expression has no effect on left-to-right execution
      //
      if (a.Expr.IsSideEffectFree)
        return this;

      ArgumentsOrdered ra = this as ArgumentsOrdered;
      if (ra == null) {
        ra = new ArgumentsOrdered (this);

        for (int i = 0; i < args.Count; ++i) {
          var la = args [i];
          if (la == a)
            break;

          //
          // When the argument is filled later by default expression
          //
          if (la == null)
            continue;

          var ma = la as MovableArgument;
          if (ma == null) {
            ma = new MovableArgument (la);
            ra.args[i] = ma;
          }

          ra.AddOrdered (ma);
        }
      }

      ra.AddOrdered (a);
      return ra;
    }

    //
    // Returns dynamic when at least one argument is of dynamic type
    //
    public void Resolve (ResolveContext ec, out bool dynamic)
    {
      dynamic = false;
      foreach (Argument a in args) {
        a.Resolve (ec);
        if (a.Type.BuiltinType == BuiltinTypeSpec.Type.Dynamic && !a.IsByRef)
          dynamic = true;
      }
    }

    public void RemoveAt (int index)
    {
      args.RemoveAt (index);
    }

    public Argument this [int index] {
      get { return args [index]; }
      set { args [index] = value; }
    }
  }
}