/NRefactory/ICSharpCode.NRefactory.CSharp/Parser/mcs/argument.cs
http://github.com/icsharpcode/ILSpy · C# · 674 lines · 492 code · 125 blank · 57 comment · 127 complexity · fb3b608686c43c9c2d9b35c1d0eedc7f MD5 · raw file
- //
- // 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; }
- }
- }
- }