public override DynamicMetaObject FallbackGetMember(DynamicMetaObject target, DynamicMetaObject?errorSuggestion)
        {
            // First try COM binding.
            if (ComBinder.TryBindGetMember(this, target, out var result, true))
            {
                return(result);
            }

            // Defer if any object has no value so that we evaluate their Expressions and nest a
            // CallSite for the InvokeMember.
            if (!target.HasValue)
            {
                return(Defer(target));
            }

            // Find our own binding.
            var members = target.LimitType.GetMember(Name, BindingFlags.IgnoreCase | BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public);

            return(members.Length == 1
                ? new DynamicMetaObject(
                       RuntimeHelpers.EnsureObjectResult(Expression.MakeMemberAccess(
                                                             Expression.Convert(target.Expression, members[0].DeclaringType !), members[0])),
                       // Don't need restriction test for name since this rule is only used where binder
                       // is used, which is only used in sites with this binder.Name.
                       BindingRestrictions.GetTypeRestriction(target.Expression, target.LimitType))
                : errorSuggestion ?? RuntimeHelpers.CreateThrow(target, null,
                                                                BindingRestrictions.GetTypeRestriction(target.Expression, target.LimitType),
                                                                typeof(MissingMemberException), $"cannot bind member, {Name}, on object {target.Value}"));
        }
        public override DynamicMetaObject FallbackInvokeMember(DynamicMetaObject target, DynamicMetaObject[] args, DynamicMetaObject?errorSuggestion)
        {
            // First try COM binding.
            if (ComBinder.TryBindInvokeMember(this, target, args, out var result))
            {
                return(result);
            }

            // Defer if any object has no value so that we evaluate their Expressions and nest a
            // CallSite for the InvokeMember.
            if (!target.HasValue || Array.Exists(args, a => !a.HasValue))
            {
                var deferArgs = new DynamicMetaObject[args.Length + 1];
                deferArgs[0] = target;
                args.CopyTo(deferArgs.AsSpan(1));
                return(Defer(deferArgs));
            }

            // Find our own binding. Could consider allowing invoking static members from an instance.
            var members = target.LimitType.GetMember(Name, BindingFlags.IgnoreCase | BindingFlags.Instance | BindingFlags.Public);

            if (members.Length == 1 && (members[0] is PropertyInfo || members[0] is FieldInfo))
            {
                // NEED TO TEST, should check for delegate value too
                // var mem = members[0];
                throw new NotImplementedException();
                //return new DynamicMetaObject(
                //    Expression.Dynamic(
                //        new SymplInvokeBinder(new CallInfo(args.Length)),
                //        typeof(object),
                //        args.Select(a => a.Expression).AddFirst(
                //               Expression.MakeMemberAccess(this.Expression, mem)));

                // Don't test for eventinfos since we do nothing with them now.
            }
            else
            {
                // Get MethodInfos with param types that work for args. This works except for value
                // args that need to pass to reftype params. We could detect that to be smarter and
                // then explicitly StrongBox the args.
                var res = Array.FindAll(members, meth => meth is MethodInfo m && m.GetParameters().Length == args.Length && RuntimeHelpers.ParametersMatchArguments(m.GetParameters(), args));

                // False below means generate a type restriction on the MO. We are looking at the
                // members targetMO's Type.
                var restrictions = RuntimeHelpers.GetTargetArgsRestrictions(target, args, false);
                if (res.Length == 0)
                {
                    return(errorSuggestion ?? RuntimeHelpers.CreateThrow(target, args, restrictions,
                                                                         typeof(MissingMemberException), $"Can't bind member invoke -- {args}"));
                }

                // restrictions and conversion must be done consistently.
                var callArgs = RuntimeHelpers.ConvertArguments(args, ((MethodInfo)res[0]).GetParameters());
                return(new DynamicMetaObject(RuntimeHelpers.EnsureObjectResult(Expression.Call(Expression.Convert(target.Expression, target.LimitType), (MethodInfo)res[0], callArgs)), restrictions));
                // Could hve tried just letting expression.Call factory do the work, but if there is more
                // than one applicable method using just assignablefrom, expression.Call throws. It does
                // not pick a "most applicable" method or any method.
            }
        }
        public override DynamicMetaObject FallbackSetMember(DynamicMetaObject target, DynamicMetaObject value, DynamicMetaObject?errorSuggestion)
        {
            // First try COM binding.
            if (ComBinder.TryBindSetMember(this, target, value, out var result))
            {
                return(result);
            }

            // Defer if any object has no value so that we evaluate their Expressions and nest a
            // CallSite for the InvokeMember.
            if (!target.HasValue)
            {
                return(Defer(target));
            }

            // Find our own binding.
            var members = target.LimitType.GetMember(Name, BindingFlags.IgnoreCase | BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public);

            if (members.Length == 1)
            {
                var        mem = members[0];
                Expression val;
                switch (mem.MemberType)
                {
                // Should check for member domain type being Type and value being TypeModel, similar
                // to ConvertArguments, and building an expression like GetRuntimeTypeMoFromModel.
                case MemberTypes.Property:
                    val = Expression.Convert(value.Expression, ((PropertyInfo)mem).PropertyType);
                    break;

                case MemberTypes.Field:
                    val = Expression.Convert(value.Expression, ((FieldInfo)mem).FieldType);
                    break;

                default:
                    return(errorSuggestion ?? RuntimeHelpers.CreateThrow(target, null,
                                                                         BindingRestrictions.GetTypeRestriction(target.Expression, target.LimitType),
                                                                         typeof(InvalidOperationException),
                                                                         "Sympl only supports setting Properties and fields at this time."));
                }

                return(new DynamicMetaObject(
                           // Assign returns the stored value, so we're good for Sympl.
                           RuntimeHelpers.EnsureObjectResult(Expression.Assign(
                                                                 Expression.MakeMemberAccess(Expression.Convert(target.Expression, members[0].DeclaringType !),
                                                                                             members[0]), val)),
                           // Don't need restriction test for name since this rule is only used where binder
                           // is used, which is only used in sites with this binder.Name.
                           BindingRestrictions.GetTypeRestriction(target.Expression, target.LimitType)));
            }
            else
            {
                return(errorSuggestion ?? RuntimeHelpers.CreateThrow(target, null,
                                                                     BindingRestrictions.GetTypeRestriction(target.Expression, target.LimitType),
                                                                     typeof(MissingMemberException), "IDynObj member name conflict."));
            }
        }
Exemple #4
0
 public override DynamicMetaObject FallbackSetMember(
     DynamicMetaObject target, DynamicMetaObject value,
     DynamicMetaObject errorSuggestion)
 {
     return(errorSuggestion ??
            RuntimeHelpers.CreateThrow(
                target, null, BindingRestrictions.Empty,
                typeof(MissingMemberException),
                "If IDynObj doesn't support setting members, " +
                "DOHelpers can't do it for the IDO."));
 }
        public override DynamicMetaObject FallbackInvoke(
            DynamicMetaObject targetMO, DynamicMetaObject[] argMOs,
            DynamicMetaObject errorSuggestion)
        {
#if !NETSTANDARD
            // First try COM binding.
            DynamicMetaObject result;

            if (ComBinder.TryBindInvoke(this, targetMO, argMOs, out result))
            {
                return(result);
            }
#endif
            // Defer if any object has no value so that we evaulate their
            // Expressions and nest a CallSite for the InvokeMember.
            if (!targetMO.HasValue || argMOs.Any((a) => !a.HasValue))
            {
                var deferArgs = new DynamicMetaObject[argMOs.Length + 1];
                for (int i = 0; i < argMOs.Length; i++)
                {
                    deferArgs[i + 1] = argMOs[i];
                }
                deferArgs[0] = targetMO;
                return(Defer(deferArgs));
            }
            // Find our own binding.
            if (targetMO.LimitType.IsSubclassOf(typeof(Delegate)))
            {
                var parms = targetMO.LimitType.GetMethod("Invoke").GetParameters();
                if (parms.Length == argMOs.Length)
                {
                    // Don't need to check if argument types match parameters.
                    // If they don't, users get an argument conversion error.
                    var callArgs   = RuntimeHelpers.ConvertArguments(argMOs, parms);
                    var expression = Expression.Invoke(
                        Expression.Convert(targetMO.Expression, targetMO.LimitType),
                        callArgs);
                    return(new DynamicMetaObject(
                               RuntimeHelpers.EnsureObjectResult(expression),
                               BindingRestrictions.GetTypeRestriction(targetMO.Expression,
                                                                      targetMO.LimitType)));
                }
            }
            return(errorSuggestion ??
                   RuntimeHelpers.CreateThrow(
                       targetMO, argMOs,
                       BindingRestrictions.GetTypeRestriction(targetMO.Expression,
                                                              targetMO.LimitType),
                       typeof(InvalidOperationException),
                       "Wrong number of arguments for function -- " +
                       targetMO.LimitType.ToString() + " got " + argMOs.ToString()));
        }
        public override DynamicMetaObject FallbackGetMember(
            DynamicMetaObject targetMO, DynamicMetaObject errorSuggestion)
        {
#if !SILVERLIGHT
            // First try COM binding.
            DynamicMetaObject result;
            if (ComBinder.TryBindGetMember(this, targetMO, out result))
            {
                return(result);
            }
#endif
            // Defer if any object has no value so that we evaulate their
            // Expressions and nest a CallSite for the InvokeMember.
            if (!targetMO.HasValue)
            {
                return(Defer(targetMO));
            }
            // Find our own binding.
            var flags = BindingFlags.IgnoreCase | BindingFlags.Static |
                        BindingFlags.Instance | BindingFlags.Public;
            var members = targetMO.LimitType.GetMember(this.Name, flags);
            if (members.Length == 1)
            {
                return(new DynamicMetaObject(
                           RuntimeHelpers.EnsureObjectResult(
                               Expression.MakeMemberAccess(
                                   Expression.Convert(targetMO.Expression,
                                                      members[0].DeclaringType),
                                   members[0])),
                           // Don't need restriction test for name since this
                           // rule is only used where binder is used, which is
                           // only used in sites with this binder.Name.
                           BindingRestrictions.GetTypeRestriction(targetMO.Expression,
                                                                  targetMO.LimitType)));
            }
            else
            {
                return(errorSuggestion ??
                       RuntimeHelpers.CreateThrow(
                           targetMO, null,
                           BindingRestrictions.GetTypeRestriction(targetMO.Expression,
                                                                  targetMO.LimitType),
                           typeof(MissingMemberException),
                           "cannot bind member, " + this.Name +
                           ", on object " + targetMO.Value.ToString()));
            }
        }
Exemple #7
0
        public override DynamicMetaObject FallbackCreateInstance(DynamicMetaObject target, DynamicMetaObject[] args, DynamicMetaObject?errorSuggestion)
        {
            // Defer if any object has no value so that we evaluate their Expressions and nest a
            // CallSite for the InvokeMember.
            if (!target.HasValue || Array.Exists(args, a => !a.HasValue))
            {
                var deferArgs = new DynamicMetaObject[args.Length + 1];
                deferArgs[0] = target;
                args.CopyTo(deferArgs.AsSpan(1));

                return(Defer(deferArgs));
            }

            // Make sure target actually contains a Type.
            if (!typeof(Type).IsAssignableFrom(target.LimitType))
            {
                return(errorSuggestion ?? RuntimeHelpers.CreateThrow(target, args, BindingRestrictions.Empty,
                                                                     typeof(InvalidOperationException),
                                                                     $"Type object must be used when creating instance -- {args}"));
            }

            var type = target.Value as Type;

            Debug.Assert(type is not null);
            var constructors = type.GetConstructors();
            // Get constructors with right arg counts.

            var res = Array.FindAll(constructors, c => c.GetParameters().Length == args.Length && RuntimeHelpers.ParametersMatchArguments(c.GetParameters(), args));

            // We generate an instance restriction on the target since it is a Type and the
            // constructor is associate with the actual Type instance.
            var restrictions = RuntimeHelpers.GetTargetArgsRestrictions(target, args, true);

            if (res.Length == 0)
            {
                return(errorSuggestion ?? RuntimeHelpers.CreateThrow(target, args, restrictions,
                                                                     typeof(MissingMemberException),
                                                                     $"Can't bind create instance -- {args}"));
            }

            var ctorArgs = RuntimeHelpers.ConvertArguments(args, res[0].GetParameters());

            return(new DynamicMetaObject(
                       // Creating an object, so don't need EnsureObjectResult.
                       Expression.New(res[0], ctorArgs), restrictions));
        }
        public override DynamicMetaObject FallbackInvoke(DynamicMetaObject target, DynamicMetaObject[] args, DynamicMetaObject?errorSuggestion)
        {
            // First try COM binding.
            if (ComBinder.TryBindInvoke(this, target, args, out var result))
            {
                return(result);
            }

            // Defer if any object has no value so that we evaulate their Expressions and nest a
            // CallSite for the InvokeMember.
            if (!target.HasValue || Array.Exists(args, a => !a.HasValue))
            {
                var deferArgs = new DynamicMetaObject[args.Length + 1];
                deferArgs[0] = target;
                args.CopyTo(deferArgs.AsSpan(1));
                return(Defer(deferArgs));
            }

            // Find our own binding.
            if (!target.LimitType.IsSubclassOf(typeof(Delegate)))
            {
                return(errorSuggestion ?? RuntimeHelpers.CreateThrow(target, args,
                                                                     BindingRestrictions.GetTypeRestriction(target.Expression, target.LimitType),
                                                                     typeof(InvalidOperationException),
                                                                     $"Wrong number of arguments for function -- {target.LimitType} got {args}"));
            }

            var parameters = target.LimitType.GetMethod("Invoke") !.GetParameters();

            if (parameters.Length != args.Length)
            {
                return(errorSuggestion ?? RuntimeHelpers.CreateThrow(target, args,
                                                                     BindingRestrictions.GetTypeRestriction(target.Expression, target.LimitType),
                                                                     typeof(InvalidOperationException),
                                                                     $"Wrong number of arguments for function -- {target.LimitType} got {args}"));
            }


            // Don't need to check if argument types match parameters. If they don't, users
            // get an argument conversion error.
            var callArgs   = RuntimeHelpers.ConvertArguments(args, parameters);
            var expression = Expression.Invoke(Expression.Convert(target.Expression, target.LimitType), callArgs);

            return(new DynamicMetaObject(RuntimeHelpers.EnsureObjectResult(expression), BindingRestrictions.GetTypeRestriction(target.Expression, target.LimitType)));
        }
Exemple #9
0
        public override DynamicMetaObject FallbackGetIndex(
            DynamicMetaObject target, DynamicMetaObject[] indexes,
            DynamicMetaObject errorSuggestion)
        {
#if !SILVERLIGHT
            // First try COM binding.
            DynamicMetaObject result;
            if (ComBinder.TryBindGetIndex(this, target, indexes, out result))
            {
                return(result);
            }
#endif
            // Defer if any object has no value so that we evaulate their
            // Expressions and nest a CallSite for the InvokeMember.
            if (!target.HasValue || indexes.Any((a) => !a.HasValue))
            {
                var deferArgs = new DynamicMetaObject[indexes.Length + 1];
                for (int i = 0; i < indexes.Length; i++)
                {
                    deferArgs[i + 1] = indexes[i];
                }
                deferArgs[0] = target;
                return(Defer(deferArgs));
            }

            var restrictions = RuntimeHelpers.GetTargetArgsRestrictions(
                target, indexes, false);

            if (target.HasValue && target.Value == null)
            {
                return(errorSuggestion ?? RuntimeHelpers.CreateThrow(target,
                                                                     indexes,
                                                                     restrictions,
                                                                     typeof(NullReferenceException),
                                                                     "Object reference not set to an instance of an object."));
            }
            var indexingExpr = RuntimeHelpers.EnsureObjectResult(
                RuntimeHelpers.GetIndexingExpression(target,
                                                     indexes));
            return(new DynamicMetaObject(indexingExpr, restrictions));
        }
        public override DynamicMetaObject FallbackGetIndex(DynamicMetaObject target, DynamicMetaObject[] args, DynamicMetaObject?errorSuggestion)
        {
            // First try COM binding.
            if (ComBinder.TryBindGetIndex(this, target, args, out var result))
            {
                return(result);
            }

            // Defer if any object has no value so that we evaulate their Expressions and nest a
            // CallSite for the InvokeMember.
            if (!target.HasValue || Array.Exists(args, a => !a.HasValue))
            {
                var deferArgs = new DynamicMetaObject[args.Length + 1];
                deferArgs[0] = target;
                args.CopyTo(deferArgs.AsSpan(1));

                return(Defer(deferArgs));
            }

            // Give good error for Cons.
            if (target.LimitType == typeof(Cons))
            {
                if (args.Length != 1)
                {
                    return(errorSuggestion ?? RuntimeHelpers.CreateThrow(target, args, BindingRestrictions.Empty,
                                                                         typeof(InvalidOperationException),
                                                                         $"Indexing list takes single index. Got {args.Length}"));
                }
            }

            // Find our own binding.
            // Conversions created in GetIndexExpression must be consistent with restrictions made in GetTargetArgsRestrictions.
            var indexingExpr = RuntimeHelpers.EnsureObjectResult(RuntimeHelpers.GetIndexingExpression(target, args));
            var restrictions = RuntimeHelpers.GetTargetArgsRestrictions(target, args, false);

            return(new DynamicMetaObject(indexingExpr, restrictions));
        }
 public override DynamicMetaObject FallbackInvoke(
     DynamicMetaObject target, DynamicMetaObject[] args,
     DynamicMetaObject errorSuggestion)
 {
     // Defer if any object has no value so that we evaulate their
     // Expressions and nest a CallSite for the InvokeMember.
     if (!target.HasValue || args.Any(a => !a.HasValue))
     {
         return(Defer(target, args));
     }
     // Find our own binding.
     if (target.LimitType.IsSubclassOf(typeof(Delegate)))
     {
         var parms = target.LimitType.GetMethod("Invoke").GetParameters();
         if (parms.Length == args.Length)
         {
             // Don't need to check if argument types match parameters.
             // If they don't, users get an argument conversion error.
             var callArgs   = RuntimeHelpers.ConvertArguments(args, parms);
             var expression = Expression.Invoke(
                 Expression.Convert(target.Expression, target.LimitType),
                 callArgs);
             return(new DynamicMetaObject(
                        RuntimeHelpers.EnsureObjectResult(expression),
                        BindingRestrictions.GetTypeRestriction(target.Expression,
                                                               target.LimitType)));
         }
     }
     return(errorSuggestion ??
            RuntimeHelpers.CreateThrow(
                target, args,
                BindingRestrictions.GetTypeRestriction(target.Expression,
                                                       target.LimitType),
                typeof(InvalidOperationException),
                "Wrong number of arguments for function -- " +
                target.LimitType.ToString() + " got " + args.ToString()));
 }
        public override DynamicMetaObject FallbackCreateInstance(
            DynamicMetaObject target,
            DynamicMetaObject[] args,
            DynamicMetaObject errorSuggestion)
        {
            // Defer if any object has no value so that we evaulate their
            // Expressions and nest a CallSite for the InvokeMember.
            if (!target.HasValue || args.Any((a) => !a.HasValue))
            {
                var deferArgs = new DynamicMetaObject[args.Length + 1];
                for (int i = 0; i < args.Length; i++)
                {
                    deferArgs[i + 1] = args[i];
                }
                deferArgs[0] = target;
                return(Defer(deferArgs));
            }
            // Make sure target actually contains a Type.
            if (!typeof(Type).IsAssignableFrom(target.LimitType))
            {
                return(errorSuggestion ??
                       RuntimeHelpers.CreateThrow(
                           target, args, BindingRestrictions.Empty,
                           typeof(InvalidOperationException),
                           "Type object must be used when creating instance -- " +
                           args.ToString()));
            }
            var type = target.Value as Type;

            Debug.Assert(type != null);
            var constructors = type.GetConstructors();
            // Get constructors with right arg counts.
            var ctors = constructors.
                        Where(c => c.GetParameters().Length == args.Length);
            List <ConstructorInfo> res = new List <ConstructorInfo>();

            foreach (var c in ctors)
            {
                if (RuntimeHelpers.ParametersMatchArguments(c.GetParameters(),
                                                            args))
                {
                    res.Add(c);
                }
            }
            // We generate an instance restriction on the target since it is a
            // Type and the constructor is associate with the actual Type instance.
            var restrictions =
                RuntimeHelpers.GetTargetArgsRestrictions(
                    target, args, true);

            if (res.Count == 0)
            {
                return(errorSuggestion ??
                       RuntimeHelpers.CreateThrow(
                           target, args, restrictions,
                           typeof(MissingMemberException),
                           "Can't bind create instance -- " + args.ToString()));
            }
            var ctorArgs =
                RuntimeHelpers.ConvertArguments(
                    args, res[0].GetParameters());

            return(new DynamicMetaObject(
                       // Creating an object, so don't need EnsureObjectResult.
                       Expression.New(res[0], ctorArgs),
                       restrictions));
        }
Exemple #13
0
        public override DynamicMetaObject FallbackInvokeMember(
            DynamicMetaObject targetMO, DynamicMetaObject[] args,
            DynamicMetaObject errorSuggestion)
        {
#if !NETSTANDARD
            // First try COM binding.
            DynamicMetaObject result;
            if (ComBinder.TryBindInvokeMember(this, targetMO, args, out result))
            {
                return(result);
            }
#endif
            // Defer if any object has no value so that we evaulate their
            // Expressions and nest a CallSite for the InvokeMember.
            if (!targetMO.HasValue || args.Any((a) => !a.HasValue))
            {
                var deferArgs = new DynamicMetaObject[args.Length + 1];
                for (int i = 0; i < args.Length; i++)
                {
                    deferArgs[i + 1] = args[i];
                }
                deferArgs[0] = targetMO;
                return(Defer(deferArgs));
            }
            // Find our own binding.
            // Could consider allowing invoking static members from an instance.
            var flags = BindingFlags.IgnoreCase | BindingFlags.Instance |
                        BindingFlags.Public;
            var members = targetMO.LimitType.GetMember(this.Name, flags);

            var restrictions = RuntimeHelpers.GetTargetArgsRestrictions(
                targetMO, args, false);

            // Assigned a Null
            if (targetMO.HasValue && targetMO.Value == null)
            {
                return(RuntimeHelpers.CreateThrow(targetMO,
                                                  args,
                                                  restrictions,
                                                  typeof(NullReferenceException),
                                                  "Object reference not set to an instance of an object."));
            }

            if ((members.Length == 1) && (members[0] is PropertyInfo ||
                                          members[0] is FieldInfo))
            {
                // NEED TO TEST, should check for delegate value too
                var mem    = members[0];
                var target = new DynamicMetaObject(
                    RuntimeHelpers.EnsureObjectResult(
                        Expression.MakeMemberAccess(
                            Expression.Convert(targetMO.Expression,
                                               members[0].DeclaringType),
                            members[0])),
                    // Don't need restriction test for name since this
                    // rule is only used where binder is used, which is
                    // only used in sites with this binder.Name.
                    BindingRestrictions.GetTypeRestriction(targetMO.Expression,
                                                           targetMO.LimitType));

                //If no arguments, to allow scenario like Request.QueryString()
                if (args == null || args.Length == 0)
                {
                    return(target);
                }

                return(new DynamicMetaObject(
                           RuntimeHelpers.GetIndexingExpression(target, args),
                           restrictions
                           ));
                // Don't test for eventinfos since we do nothing with them now.
            }
            else
            {
                bool isExtension = false;

                // Get MethodInfos with right arg counts.
                var mi_mems = members.
                              Select(m => m as MethodInfo).
                              Where(m => m is MethodInfo &&
                                    ((MethodInfo)m).GetParameters().Length ==
                                    args.Length);
                // Get MethodInfos with param types that work for args.  This works
                // except for value args that need to pass to reftype params.
                // We could detect that to be smarter and then explicitly StrongBox
                // the args.
                List <MethodInfo> res = new List <MethodInfo>();
                foreach (var mem in mi_mems)
                {
                    if (RuntimeHelpers.ParametersMatchArguments(
                            mem.GetParameters(), args))
                    {
                        res.Add(mem);
                    }
                }

                List <DynamicMetaObject> argList = new List <DynamicMetaObject>(args);

                //Try extension methods if no methods found
                if (res.Count == 0)
                {
                    isExtension = true;
                    argList.Insert(0, targetMO);

                    res = RuntimeHelpers.GetExtensionMethods(this.Name, targetMO, argList.ToArray());
                }

                // False below means generate a type restriction on the MO.
                // We are looking at the members targetMO's Type.
                if (res.Count == 0)
                {
                    return(errorSuggestion ??
                           RuntimeHelpers.CreateThrow(
                               targetMO, args, restrictions,
                               typeof(MissingMemberException),
                               string.Format("Can't bind member invoke {0}.{1}({2})", targetMO.RuntimeType.Name, this.Name, args.ToString())));
                }

                //If more than one results found, attempt overload resolution
                MethodInfo mi = null;
                if (res.Count > 1)
                {
                    mi = RuntimeHelpers.ResolveOverload(res, argList.ToArray());
                }
                else
                {
                    mi = res[0];
                }

                // restrictions and conversion must be done consistently.
                var callArgs = RuntimeHelpers.ConvertArguments(
                    argList.ToArray(), mi.GetParameters());

                if (isExtension)
                {
                    return(new DynamicMetaObject(
                               RuntimeHelpers.EnsureObjectResult(
                                   Expression.Call(
                                       null,
                                       mi, callArgs)),
                               restrictions));
                }
                else
                {
                    return(new DynamicMetaObject(
                               RuntimeHelpers.EnsureObjectResult(
                                   Expression.Call(
                                       Expression.Convert(targetMO.Expression,
                                                          targetMO.LimitType),
                                       mi, callArgs)),
                               restrictions));
                }
                // Could hve tried just letting Expr.Call factory do the work,
                // but if there is more than one applicable method using just
                // assignablefrom, Expr.Call throws.  It does not pick a "most
                // applicable" method or any method.
            }
        }
        public override DynamicMetaObject FallbackInvokeMember(DynamicMetaObject targetMO, DynamicMetaObject[] args, DynamicMetaObject errorSuggestion)
        {
            // Defer if any object has no value so that we evaulate their
            // Expressions and nest a CallSite for the InvokeMember.
            if (!targetMO.HasValue || args.Any(a => !a.HasValue))
            {
                var deferArgs = new DynamicMetaObject[args.Length + 1];
                for (int i = 0; i < args.Length; i++)
                {
                    deferArgs[i + 1] = args[i];
                }
                deferArgs[0] = targetMO;
                return(Defer(deferArgs));
            }
            // Find our own binding.
            // Could consider allowing invoking static members from an instance.
            const BindingFlags flags = BindingFlags.IgnoreCase | BindingFlags.Instance |
                                       BindingFlags.Public;
            var members = targetMO.LimitType.GetMember(Name, flags);

            if ((members.Length == 1) && (members[0] is PropertyInfo ||
                                          members[0] is FieldInfo))
            {
                // NEED TO TEST, should check for delegate value too
                throw new NotImplementedException();
            }
            // Get MethodInfos with right arg counts.
            var miMems = members.
                         Select(m => m as MethodInfo).
                         Where(m => m.GetParameters().Length == args.Length);
            // Get MethodInfos with param types that work for args.  This works
            // except for value args that need to pass to reftype params.
            // We could detect that to be smarter and then explicitly StrongBox
            // the args.
            var res = new List <MethodInfo>();

            foreach (var mem in miMems)
            {
                if (RuntimeHelpers.ParametersMatchArguments(
                        mem.GetParameters(), args))
                {
                    res.Add(mem);
                }
            }
            // False below means generate a type restriction on the MO.
            // We are looking at the members targetMO's Type.
            var restrictions = RuntimeHelpers.GetTargetArgsRestrictions(
                targetMO, args, false);

            if (res.Count == 0)
            {
                return(errorSuggestion ??
                       RuntimeHelpers.CreateThrow(
                           targetMO, args, restrictions,
                           typeof(MissingMemberException),
                           "Can't bind member invoke -- " + args.ToString()));
            }
            // restrictions and conversion must be done consistently.
            var callArgs = RuntimeHelpers.ConvertArguments(
                args, res[0].GetParameters());

            return(new DynamicMetaObject(
                       RuntimeHelpers.EnsureObjectResult(
                           Expression.Call(
                               Expression.Convert(targetMO.Expression,
                                                  targetMO.LimitType),
                               res[0], callArgs)),
                       restrictions));
            // Could hve tried just letting Expr.Call factory do the work,
            // but if there is more than one applicable method using just
            // assignablefrom, Expr.Call throws.  It does not pick a "most
            // applicable" method or any method.
        }
        public override DynamicMetaObject FallbackSetMember(
            DynamicMetaObject targetMO, DynamicMetaObject value,
            DynamicMetaObject errorSuggestion)
        {
            // Defer if any object has no value so that we evaulate their
            // Expressions and nest a CallSite for the InvokeMember.
            if (!targetMO.HasValue)
            {
                return(Defer(targetMO));
            }
            // Find our own binding.
            const BindingFlags flags = BindingFlags.IgnoreCase | BindingFlags.Static |
                                       BindingFlags.Instance | BindingFlags.Public;
            var members = targetMO.LimitType.GetMember(Name, flags);

            if (members.Length == 1)
            {
                MemberInfo mem = members[0];
                Expression val;
                // Should check for member domain type being Type and value being
                // TypeModel, similar to ConvertArguments, and building an
                // expression like GetRuntimeTypeMoFromModel.
                if (mem.MemberType == MemberTypes.Property)
                {
                    val = Expression.Convert(value.Expression,
                                             ((PropertyInfo)mem).PropertyType);
                }
                else if (mem.MemberType == MemberTypes.Field)
                {
                    val = Expression.Convert(value.Expression,
                                             ((FieldInfo)mem).FieldType);
                }
                else
                {
                    return(errorSuggestion ??
                           RuntimeHelpers.CreateThrow(
                               targetMO, null,
                               BindingRestrictions.GetTypeRestriction(
                                   targetMO.Expression,
                                   targetMO.LimitType),
                               typeof(InvalidOperationException),
                               "Crispy only supports setting Properties and " +
                               "fields at this time."));
                }
                return(new DynamicMetaObject(
                           // Assign returns the stored value, so we're good for Crispy.
                           RuntimeHelpers.EnsureObjectResult(
                               Expression.Assign(
                                   Expression.MakeMemberAccess(
                                       Expression.Convert(targetMO.Expression,
                                                          members[0].DeclaringType),
                                       members[0]),
                                   val)),
                           // Don't need restriction test for name since this
                           // rule is only used where binder is used, which is
                           // only used in sites with this binder.Name.
                           BindingRestrictions.GetTypeRestriction(targetMO.Expression,
                                                                  targetMO.LimitType)));
            }
            return(errorSuggestion ??
                   RuntimeHelpers.CreateThrow(
                       targetMO, null,
                       BindingRestrictions.GetTypeRestriction(targetMO.Expression,
                                                              targetMO.LimitType),
                       typeof(MissingMemberException),
                       "IDynObj member name conflict."));
        }