private static ErrorInfo MakeIncorrectArgumentCountError(BindingTarget target) { int minArgs = Int32.MaxValue; int maxArgs = Int32.MinValue; foreach (int argCnt in target.ExpectedArgumentCount) { minArgs = System.Math.Min(minArgs, argCnt); maxArgs = System.Math.Max(maxArgs, argCnt); } return(ErrorInfo.FromException( Ast.Call( typeof(BinderOps).GetMethod("TypeErrorForIncorrectArgumentCount", new Type[] { typeof(string), typeof(int), typeof(int), typeof(int), typeof(int), typeof(bool), typeof(bool) }), Ast.Constant(target.Name, typeof(string)), // name Ast.Constant(minArgs), // min formal normal arg cnt Ast.Constant(maxArgs), // max formal normal arg cnt Ast.Constant(0), // default cnt Ast.Constant(target.ActualArgumentCount), // args provided Ast.Constant(false), // hasArgList Ast.Constant(false) // kwargs provided ) )); }
internal void AddArgumentRestrictions(MetaObjectBuilder /*!*/ metaBuilder, BindingTarget /*!*/ bindingTarget) { var args = GetActualArguments(); var restrictedArgs = bindingTarget.Success ? bindingTarget.RestrictedArguments.GetObjects() : args.Arguments; for (int i = _firstRestrictedArg; i < restrictedArgs.Count; i++) { var arg = (bindingTarget.Success ? restrictedArgs[i] : restrictedArgs[i].Restrict(restrictedArgs[i].GetLimitType())); if (i >= args.FirstSplattedArg && i <= _lastSplattedArg) { metaBuilder.AddCondition(arg.Restrictions.ToExpression()); } else { metaBuilder.AddRestriction(arg.Restrictions); } } // Adds condition for collapsed arguments - it is the same whether we succeed or not: var splatCondition = GetCollapsedArgsCondition(); if (splatCondition != null) { metaBuilder.AddCondition(splatCondition); } }
private bool TryNumericComparison(OperatorInfo info) { MethodInfo[] targets = FilterNonMethods(_types[0], Binder.GetMember(Action, _types[0], "Compare")); if (targets.Length > 0) { MethodBinder mb = MethodBinder.MakeBinder(Binder, targets[0].Name, targets); BindingTarget target = mb.MakeBindingTarget(CallTypes.None, _types); if (target.Success) { Expression call = Ast.Convert(target.MakeExpression(_rule, _rule.Parameters), typeof(int)); switch (info.Operator) { case Operators.GreaterThan: call = Ast.GreaterThan(call, Ast.Constant(0)); break; case Operators.LessThan: call = Ast.LessThan(call, Ast.Constant(0)); break; case Operators.GreaterThanOrEqual: call = Ast.GreaterThanOrEqual(call, Ast.Constant(0)); break; case Operators.LessThanOrEqual: call = Ast.LessThanOrEqual(call, Ast.Constant(0)); break; case Operators.Equals: call = Ast.Equal(call, Ast.Constant(0)); break; case Operators.NotEquals: call = Ast.NotEqual(call, Ast.Constant(0)); break; case Operators.Compare: break; } _rule.Target = _rule.MakeReturn(Binder, call); return(true); } } return(false); }
private Expression MakeAmbiguousCallError(BindingTarget target) { StringBuilder sb = new StringBuilder(string.Format("Found multiple methods for '{0}': ", target.Name)); string outerComma = ""; foreach (MethodCandidate candidate in target.AmbiguousMatches) { IList <ParameterWrapper> parameters = candidate.GetParameters(); string innerComma = ""; sb.Append(outerComma); sb.Append(target.Name); sb.Append('('); foreach (var param in parameters) { if (!param.IsHidden) { sb.Append(innerComma); sb.Append(Binder.GetTypeName(param.Type)); if (param.ProhibitNull) { sb.Append('!'); } innerComma = ", "; } } sb.Append(')'); outerComma = ", "; } return(Methods.MakeAmbiguousMatchError.OpCall(AstUtils.Constant(sb.ToString()))); }
private Expression MakeIncorrectArgumentCountError(BindingTarget target) { IList <int> available = target.ExpectedArgumentCount; int expected; if (available.Count > 0) { int minGreater = Int32.MaxValue; int maxLesser = Int32.MinValue; int max = Int32.MinValue; foreach (int arity in available) { if (arity > target.ActualArgumentCount) { minGreater = Math.Min(minGreater, arity); } else { maxLesser = Math.Max(maxLesser, arity); } max = Math.Max(max, arity); } expected = (target.ActualArgumentCount < maxLesser ? maxLesser : Math.Min(minGreater, max)); } else { // no overload is callable: expected = 0; } return(Methods.MakeWrongNumberOfArgumentsError.OpCall(AstUtils.Constant(target.ActualArgumentCount), AstUtils.Constant(expected))); }
private MetaObject MakeMethodIndexRule(string oper, MetaObject[] args) { MethodInfo[] defaults = GetMethodsFromDefaults(args[0].LimitType.GetDefaultMembers(), oper); if (defaults.Length != 0) { MethodBinder binder = MethodBinder.MakeBinder( this, oper == StandardOperators.GetItem ? "get_Item" : "set_Item", defaults); MetaObject[] selfWithArgs = args; ParameterExpression arg2 = null; if (oper == StandardOperators.SetItem) { Debug.Assert(args.Length >= 2); // need to save arg2 in a temp because it's also our result arg2 = Ast.Variable(args[2].Expression.Type, "arg2Temp"); args[2] = new MetaObject( Ast.Assign(arg2, args[2].Expression), args[2].Restrictions ); } BindingTarget target = binder.MakeBindingTarget(CallTypes.ImplicitInstance, selfWithArgs); Restrictions restrictions = Restrictions.Combine(args); if (target.Success) { if (oper == StandardOperators.GetItem) { return(new MetaObject( target.MakeExpression(), restrictions.Merge(Restrictions.Combine(target.RestrictedArguments)) )); } else { return(new MetaObject( Ast.Block( new ParameterExpression[] { arg2 }, target.MakeExpression(), arg2 ), restrictions.Merge(Restrictions.Combine(target.RestrictedArguments)) )); } } return(MakeError( MakeInvalidParametersError(target), restrictions )); } return(null); }
private ErrorInfo MakeAmbiguousCallError(BindingTarget target) { StringBuilder sb = new StringBuilder("Multiple targets could match: "); string outerComma = ""; foreach (MethodTarget mt in target.AmbiguousMatches) { Type[] types = mt.GetParameterTypes(); string innerComma = ""; sb.Append(outerComma); sb.Append(target.Name); sb.Append('('); foreach (Type t in types) { sb.Append(innerComma); sb.Append(GetTypeName(t)); innerComma = ", "; } sb.Append(')'); outerComma = ", "; } return(ErrorInfo.FromException( Ast.Call( typeof(BinderOps).GetMethod("SimpleTypeError"), Ast.Constant(sb.ToString(), typeof(string)) ) )); }
public DynamicMetaObject MakeCallExpression(OverloadResolverFactory resolverFactory, MethodInfo method, params DynamicMetaObject[] parameters) { OverloadResolver resolver; if (method.IsStatic) { resolver = resolverFactory.CreateOverloadResolver(parameters, new CallSignature(parameters.Length), CallTypes.None); } else { resolver = resolverFactory.CreateOverloadResolver(parameters, new CallSignature(parameters.Length - 1), CallTypes.ImplicitInstance); } BindingTarget target = resolver.ResolveOverload(method.Name, new MethodBase[] { method }, NarrowingLevel.None, NarrowingLevel.All); if (!target.Success) { BindingRestrictions restrictions = BindingRestrictions.Combine(parameters); foreach (DynamicMetaObject mo in parameters) { restrictions = restrictions.Merge(BindingRestrictionsHelpers.GetRuntimeTypeRestriction(mo.Expression, mo.GetLimitType())); } return(DefaultBinder.MakeError( resolver.MakeInvalidParametersError(target), restrictions, typeof(object) )); } return(new DynamicMetaObject(target.MakeExpression(), target.RestrictedArguments.GetAllRestrictions())); }
private ErrorInfo MakeInvalidSplatteeError(BindingTarget target) { return ErrorInfo.FromException( Ast.Call(typeof(BinderOps).GetMethod("InvalidSplatteeError"), AstUtils.Constant(target.Name), AstUtils.Constant(Binder.GetTypeName(_invalidSplattee.GetLimitType())) ) ); }
public override ErrorInfo MakeInvalidParametersError(BindingTarget target) { if (target.Result == BindingResult.InvalidArguments && _invalidSplattee != null) { return(MakeInvalidSplatteeError(target)); } return(base.MakeInvalidParametersError(target)); }
/// <summary> /// Select matching method from list based on args. /// </summary> /// <param name="targetType"></param> /// <param name="args"></param> /// <param name="methods"></param> /// <param name="methodName"></param> /// <param name="isStatic"></param> /// <returns></returns> private static MethodBase GetMatchingMethodAux(Type targetType, IList <HostArg> args, IList <MethodBase> methods, string methodName, bool isStatic) { int argCount = args.Count; if (methods.Count == 0) { return(null); } if (methods.Count == 1) { return(methods[0]); } IList <DynamicMetaObject> argsPlus = new List <DynamicMetaObject>(argCount + (isStatic ? 0 : 1)); if (!isStatic) { argsPlus.Add(new DynamicMetaObject(Expression.Default(targetType), BindingRestrictions.Empty)); } foreach (HostArg ha in args) { Expr e = ha.ArgExpr; Type argType = e.HasClrType ? (e.ClrType ?? typeof(object)) : typeof(Object); Type t; switch (ha.ParamType) { case HostArg.ParameterType.ByRef: t = typeof(System.Runtime.CompilerServices.StrongBox <>).MakeGenericType(argType); break; case HostArg.ParameterType.Standard: t = argType; break; default: throw Util.UnreachableCode(); } argsPlus.Add(new DynamicMetaObject(Expression.Default(t), BindingRestrictions.Empty)); } // TODO: See if we can get rid of .Default OverloadResolverFactory factory = ClojureContext.Default.SharedOverloadResolverFactory; DefaultOverloadResolver res = factory.CreateOverloadResolver(argsPlus, new CallSignature(argCount), isStatic ? CallTypes.None : CallTypes.ImplicitInstance); BindingTarget bt = res.ResolveOverload(methodName, methods, NarrowingLevel.None, NarrowingLevel.All); if (bt.Success) { return(bt.Overload.ReflectionInfo); } return(null); }
private DynamicMetaObject MakeMethodIndexRule(IndexType oper, OverloadResolverFactory resolverFactory, DynamicMetaObject[] args) { MethodInfo[] defaults = GetMethodsFromDefaults(args[0].GetLimitType().GetDefaultMembers(), oper); if (defaults.Length != 0) { DynamicMetaObject[] selfWithArgs = args; ParameterExpression arg2 = null; if (oper == IndexType.Set) { Debug.Assert(args.Length >= 2); // need to save arg2 in a temp because it's also our result arg2 = Ast.Variable(args[2].Expression.Type, "arg2Temp"); args[2] = new DynamicMetaObject( Ast.Assign(arg2, args[2].Expression), args[2].Restrictions ); } BindingRestrictions restrictions = BindingRestrictions.Combine(args); var resolver = resolverFactory.CreateOverloadResolver(selfWithArgs, new CallSignature(selfWithArgs.Length), CallTypes.ImplicitInstance); BindingTarget target = resolver.ResolveOverload(oper == IndexType.Get ? "get_Item" : "set_Item", defaults, NarrowingLevel.None, NarrowingLevel.All); if (target.Success) { if (oper == IndexType.Get) { return(new DynamicMetaObject( target.MakeExpression(), restrictions.Merge(target.RestrictedArguments.GetAllRestrictions()) )); } else { return(new DynamicMetaObject( Ast.Block( new ParameterExpression[] { arg2 }, target.MakeExpression(), arg2 ), restrictions.Merge(target.RestrictedArguments.GetAllRestrictions()) )); } } return(MakeError( resolver.MakeInvalidParametersError(target), restrictions, typeof(object) )); } return(null); }
private Expression MakeCallFailureError(BindingTarget target) { foreach (CallFailure cf in target.CallFailures) { switch (cf.Reason) { case CallFailureReason.ConversionFailure: foreach (ConversionResult cr in cf.ConversionResults) { if (cr.Failed) { if (typeof(Proc).IsAssignableFrom(cr.To)) { return(Methods.CreateArgumentsErrorForProc.OpCall(AstUtils.Constant(cr.GetArgumentTypeName(Binder)))); } Debug.Assert(typeof(BlockParam).IsSealed); if (cr.To == typeof(BlockParam)) { return(Methods.CreateArgumentsErrorForMissingBlock.OpCall()); } string toType; if (cr.To.IsGenericType && cr.To.GetGenericTypeDefinition() == typeof(Union <,>)) { var g = cr.To.GetGenericArguments(); toType = Binder.GetTypeName(g[0]) + " or " + Binder.GetTypeName(g[1]); } else { toType = Binder.GetTypeName(cr.To); } return(Methods.CreateTypeConversionError.OpCall( AstUtils.Constant(cr.GetArgumentTypeName(Binder)), AstUtils.Constant(toType) )); } } break; case CallFailureReason.TypeInference: // TODO: Display generic parameters so it's clear what we couldn't infer. return(Methods.CreateArgumentsError.OpCall( AstUtils.Constant(String.Format("generic arguments could not be infered for method '{0}'", target.Name)) )); case CallFailureReason.DuplicateKeyword: case CallFailureReason.UnassignableKeyword: default: throw new InvalidOperationException(); } } throw new InvalidOperationException(); }
private void MakeMethodBaseRule(MethodBase[] targets) { Type[] argTypes; // will not include implicit instance argument (if any) SymbolId[] argNames; // will include ArgumentKind.Dictionary keyword names GetArgumentNamesAndTypes(out argNames, out argTypes); Type[] bindingArgs = argTypes; // will include instance argument (if any) CallTypes callType = CallTypes.None; if (_instance != null) { bindingArgs = ArrayUtils.Insert(InstanceType, argTypes); callType = CallTypes.ImplicitInstance; } if (_reversedOperator && bindingArgs.Length >= 2) { // we swap the arguments before binding, and swap back before calling. ArrayUtils.SwapLastTwo(bindingArgs); if (argNames.Length >= 2) { ArrayUtils.SwapLastTwo(argNames); } } // attempt to bind to an individual method MethodBinder binder = MethodBinder.MakeBinder(Binder, GetTargetName(targets), targets, argNames, NarrowingLevel.None, _maxLevel); BindingTarget bt = binder.MakeBindingTarget(callType, bindingArgs); if (bt.Success) { // if we succeed make the target for the rule MethodBase target = bt.Method; MethodInfo targetMethod = target as MethodInfo; if (targetMethod != null) { target = CompilerHelpers.GetCallableMethod(targetMethod, Binder.PrivateBinding); } Expression[] exprargs = FinishTestForCandidate(bt.ArgumentTests, argTypes); _rule.Target = _rule.MakeReturn( Binder, bt.MakeExpression(_rule, exprargs)); } else { // make an error rule MakeInvalidParametersRule(bt); } }
public static Bindings For(Keys key, BindingTarget target = BindingTarget.Universal) { if (key == Keys.None) { return(Bindings.None); } Bindings b; return(KeyDictionaries[target].TryGetValue(key, out b) ? b : Bindings.None); }
public DataContextChangeSynchronizer(BindingSource bindingSource, BindingTarget bindingTarget, ITypeConverterProvider typeConverterProvider) { _bindingTarget = bindingTarget; Guard.ThrowIfNull(bindingTarget.Object, nameof(bindingTarget.Object)); Guard.ThrowIfNull(bindingTarget.Property, nameof(bindingTarget.Property)); Guard.ThrowIfNull(bindingSource.SourcePropertyPath, nameof(bindingSource.SourcePropertyPath)); Guard.ThrowIfNull(bindingSource.Source, nameof(bindingSource.Source)); Guard.ThrowIfNull(typeConverterProvider, nameof(typeConverterProvider)); _bindingEndpoint = new TargetBindingEndpoint(bindingTarget.Object, bindingTarget.Property); _sourceEndpoint = new ObservablePropertyBranch(bindingSource.Source, bindingSource.SourcePropertyPath); _targetPropertyTypeConverter = typeConverterProvider.GetTypeConverter(bindingTarget.Property.PropertyType); }
private bool TryMakeInvertedBindingTarget(MethodInfo[] targets) { MethodBinder mb = MethodBinder.MakeBinder(Binder, targets[0].Name, targets); BindingTarget target = mb.MakeBindingTarget(CallTypes.None, _types); if (target.Success) { Expression call = target.MakeExpression(_rule, _rule.Parameters); _rule.Target = _rule.MakeReturn(Binder, Ast.Not(call)); return(true); } return(false); }
public virtual ErrorInfo MakeInvalidParametersError(BindingTarget target) { switch (target.Result) { case BindingResult.CallFailure: return(MakeCallFailureError(target)); case BindingResult.AmbiguousMatch: return(MakeAmbiguousCallError(target)); case BindingResult.IncorrectArgumentCount: return(MakeIncorrectArgumentCountError(target)); default: throw new InvalidOperationException(); } }
private DynamicMetaObject TryMakeInvertedBindingTarget(OverloadResolverFactory resolverFactory, MethodBase[] targets, DynamicMetaObject[] args) { var resolver = resolverFactory.CreateOverloadResolver(args, new CallSignature(args.Length), CallTypes.None); BindingTarget target = resolver.ResolveOverload(targets[0].Name, targets, NarrowingLevel.None, NarrowingLevel.All); if (target.Success) { return(new DynamicMetaObject( Expression.Not(target.MakeExpression()), target.RestrictedArguments.GetAllRestrictions() )); } return(null); }
protected virtual IBindingSource GetBindingTarget([NotNull] IDataContext context, out object target, out IBindingPath targetPath) { target = context.GetData(BindingBuilderConstants.Target, true); targetPath = context.GetData(BindingBuilderConstants.TargetPath, true); IBindingSource bindingSource = new BindingTarget(BindingServiceProvider.ObserverProvider.Observe(target, targetPath, false)) { CommandParameterDelegate = context.GetData(BindingBuilderConstants.CommandParameter) }; if (_decorators.Count != 0) { return(Decorate(bindingSource, true, context)); } return(bindingSource); }
private MetaObject TryMakeBindingTarget(MethodInfo[] targets, MetaObject[] args, Expression codeContext, Restrictions restrictions) { MethodBinder mb = MethodBinder.MakeBinder(this, targets[0].Name, targets); BindingTarget target = mb.MakeBindingTarget(CallTypes.None, args); if (target.Success) { return(new MetaObject( target.MakeExpression(new ParameterBinderWithCodeContext(this, codeContext)), restrictions.Merge(Restrictions.Combine(target.RestrictedArguments)) )); } return(null); }
private MetaObject TryMakeInvertedBindingTarget(MethodBase[] targets, MetaObject[] args) { MethodBinder mb = MethodBinder.MakeBinder(this, targets[0].Name, targets); MetaObject[] selfArgs = args; BindingTarget target = mb.MakeBindingTarget(CallTypes.None, selfArgs); if (target.Success) { return(new MetaObject( Ast.Not(target.MakeExpression()), Restrictions.Combine(target.RestrictedArguments) )); } return(null); }
private ErrorInfo MakeCallFailureError(BindingTarget target) { foreach (CallFailure cf in target.CallFailures) { switch (cf.Reason) { case CallFailureReason.ConversionFailure: foreach (ConversionResult cr in cf.ConversionResults) { if (cr.Failed) { return(ErrorInfo.FromException( Ast.Call( typeof(BinderOps).GetMethod("SimpleTypeError"), Ast.Constant(String.Format("expected {0}, got {1}", GetTypeName(cr.To), GetTypeName(cr.From))) ) )); } } break; case CallFailureReason.DuplicateKeyword: return(ErrorInfo.FromException( Ast.Call( typeof(BinderOps).GetMethod("TypeErrorForDuplicateKeywordArgument"), Ast.Constant(target.Name, typeof(string)), Ast.Constant(SymbolTable.IdToString(cf.KeywordArguments[0]), typeof(string)) // TODO: Report all bad arguments? ) )); case CallFailureReason.UnassignableKeyword: return(ErrorInfo.FromException( Ast.Call( typeof(BinderOps).GetMethod("TypeErrorForExtraKeywordArgument"), Ast.Constant(target.Name, typeof(string)), Ast.Constant(SymbolTable.IdToString(cf.KeywordArguments[0]), typeof(string)) // TODO: Report all bad arguments? ) )); default: throw new InvalidOperationException(); } } throw new InvalidOperationException(); }
private MetaObject TryNumericComparison(OperatorInfo info, MetaObject[] args) { MethodInfo[] targets = FilterNonMethods( args[0].LimitType, GetMember(OldDoOperationAction.Make(this, info.Operator), args[0].LimitType, "Compare") ); if (targets.Length > 0) { MethodBinder mb = MethodBinder.MakeBinder(this, targets[0].Name, targets); BindingTarget target = mb.MakeBindingTarget(CallTypes.None, args); if (target.Success) { Expression call = AstUtils.Convert(target.MakeExpression(), typeof(int)); switch (info.Operator) { case Operators.GreaterThan: call = Ast.GreaterThan(call, Ast.Constant(0)); break; case Operators.LessThan: call = Ast.LessThan(call, Ast.Constant(0)); break; case Operators.GreaterThanOrEqual: call = Ast.GreaterThanOrEqual(call, Ast.Constant(0)); break; case Operators.LessThanOrEqual: call = Ast.LessThanOrEqual(call, Ast.Constant(0)); break; case Operators.Equals: call = Ast.Equal(call, Ast.Constant(0)); break; case Operators.NotEquals: call = Ast.NotEqual(call, Ast.Constant(0)); break; case Operators.Compare: break; } return(new MetaObject( call, Restrictions.Combine(target.RestrictedArguments) )); } } return(null); }
private DynamicMetaObject TryNumericComparison(OperatorInfo info, OverloadResolverFactory resolverFactory, DynamicMetaObject[] args) { MethodInfo[] targets = FilterNonMethods( args[0].GetLimitType(), GetMember( MemberRequestKind.Operation, args[0].GetLimitType(), "Compare" ) ); if (targets.Length > 0) { var resolver = resolverFactory.CreateOverloadResolver(args, new CallSignature(args.Length), CallTypes.None); BindingTarget target = resolver.ResolveOverload(targets[0].Name, targets, NarrowingLevel.None, NarrowingLevel.All); if (target.Success) { Expression call = AstUtils.Convert(target.MakeExpression(), typeof(int)); switch (info.Operator) { case ExpressionType.GreaterThan: call = Expression.GreaterThan(call, AstUtils.Constant(0)); break; case ExpressionType.LessThan: call = Expression.LessThan(call, AstUtils.Constant(0)); break; case ExpressionType.GreaterThanOrEqual: call = Expression.GreaterThanOrEqual(call, AstUtils.Constant(0)); break; case ExpressionType.LessThanOrEqual: call = Expression.LessThanOrEqual(call, AstUtils.Constant(0)); break; case ExpressionType.Equal: call = Expression.Equal(call, AstUtils.Constant(0)); break; case ExpressionType.NotEqual: call = Expression.NotEqual(call, AstUtils.Constant(0)); break; } return(new DynamicMetaObject( call, target.RestrictedArguments.GetAllRestrictions() )); } } return(null); }
private static void SetUnsafe(Bindings b, Keys k) { BindingTarget target = getBindingTarget(b); Dictionary <Keys, Bindings> KeyDictionary = getKeyDictionary(target); Keys kOld; if (BindingDictionary.TryGetValue(b, out kOld)) { if (k == kOld) { return; //no change } } if (BindingDictionary.TryGetValue(b, out kOld) && kOld != Keys.None) { bool foundRebind = false; foreach (var v in BindingDictionary) { if (v.Key != b && v.Value == kOld) { KeyDictionary[kOld] = v.Key; foundRebind = true; break; } } if (!foundRebind) { KeyDictionary.Remove(kOld); } } BindingDictionary[b] = k; KeyDictionary[k] = b; //Reset binding statics. ChatEngine.keySpamCheckArray = null; }
private void MakeInvalidParametersRule(BindingTarget bt) { MakeSplatTests(); if (_args.Length > 1) { // we do an exact type check on all of the arguments types for a failed call. Expression[] argExpr = MakeArgumentExpressions(); SymbolId[] names; Type[] vals; GetArgumentNamesAndTypes(out names, out vals); if (_instance != null) { // target type was added to test already argExpr = ArrayUtils.RemoveFirst(argExpr); } _test = Ast.AndAlso(_test, MakeNecessaryTests(_rule, vals, argExpr)); } _rule.Target = Binder.MakeInvalidParametersError(bt).MakeErrorForRule(_rule, Binder); }
private static MethodBase GetMatchingMethodAux(Type targetType, object[] actualArgs, IList <MethodBase> methods, string methodName, bool isStatic) { int argCount = actualArgs.Length; if (methods.Count == 0) { return(null); } if (methods.Count == 1) { return(methods[0]); } IList <DynamicMetaObject> argsPlus = new List <DynamicMetaObject>(argCount + (isStatic ? 0 : 1)); if (!isStatic) { argsPlus.Add(new DynamicMetaObject(Expression.Default(targetType), BindingRestrictions.Empty)); } foreach (object arg in actualArgs) { argsPlus.Add(new DynamicMetaObject(Expression.Default(arg.GetType()), BindingRestrictions.Empty, arg)); } OverloadResolverFactory factory = ClojureContext.Default.SharedOverloadResolverFactory; DefaultOverloadResolver res = factory.CreateOverloadResolver(argsPlus, new CallSignature(argCount), isStatic ? CallTypes.None : CallTypes.ImplicitInstance); BindingTarget bt = res.ResolveOverload(methodName, methods, NarrowingLevel.None, NarrowingLevel.All); if (bt.Success) { return(bt.Overload.ReflectionInfo); } return(null); }
// Token: 0x06002F0D RID: 12045 // RVA: 0x00131560 File Offset: 0x0012F760 public static Bindings smethod_4(Keys keys_3, BindingTarget bindingTarget_0) { if (keys_3 == null) { return Bindings.None; } Bindings result; if (!Class795.dictionary_1[bindingTarget_0].TryGetValue(keys_3, out result)) { return Bindings.None; } return result; }
public SlotOrFunction(BindingTarget /*!*/ function, DynamicMetaObject /*!*/ target) { _target = target; _function = function; }
/// <summary> /// Helper for generating the call to a builtin function. This is used for calls from built-in method /// descriptors and built-in functions w/ and w/o a bound instance. /// /// This provides all sorts of common checks on top of the call while the caller provides a delegate /// to do the actual call. The common checks include: /// check for generic-only methods /// reversed operator support /// transforming arguments so the default binder can understand them (currently user defined mapping types to PythonDictionary) /// returning NotImplemented from binary operators /// Warning when calling certain built-in functions /// /// </summary> /// <param name="call">The call binder we're doing the call for</param> /// <param name="codeContext">An expression which points to the code context</param> /// <param name="function">the meta object for the built in function</param> /// <param name="hasSelf">true if we're calling with an instance</param> /// <param name="args">The arguments being passed to the function</param> /// <param name="functionRestriction">A restriction for the built-in function, method desc, etc...</param> /// <param name="bind">A delegate to perform the actual call to the method.</param> internal DynamicMetaObject /*!*/ MakeBuiltinFunctionCall(DynamicMetaObjectBinder /*!*/ call, Expression /*!*/ codeContext, DynamicMetaObject /*!*/ function, DynamicMetaObject /*!*/[] args, bool hasSelf, BindingRestrictions /*!*/ functionRestriction, Func <DynamicMetaObject /*!*/[] /*!*/, BindingResult /*!*/> bind) { DynamicMetaObject res = null; // if we have a user defined operator for **args then transform it into a PythonDictionary DynamicMetaObject translated = TranslateArguments(call, codeContext, new DynamicMetaObject(function.Expression, functionRestriction, function.Value), args, hasSelf, Name); if (translated != null) { return(translated); } // swap the arguments if we have a reversed operator if (IsReversedOperator) { ArrayUtils.SwapLastTwo(args); } // do the appropriate calling logic BindingResult result = bind(args); // validate the result BindingTarget target = result.Target; res = result.MetaObject; if (target.Overload != null && target.Overload.IsProtected) { // report an error when calling a protected member res = new DynamicMetaObject( BindingHelpers.TypeErrorForProtectedMember( target.Overload.DeclaringType, target.Overload.Name ), res.Restrictions ); } else if (IsBinaryOperator && args.Length == 2 && IsThrowException(res.Expression)) { // Binary Operators return NotImplemented on failure. res = new DynamicMetaObject( Ast.Property(null, typeof(PythonOps), "NotImplemented"), res.Restrictions ); } else if (target.Overload != null) { // Add profiling information for this builtin function, if applicable IPythonSite pythonSite = (call as IPythonSite); if (pythonSite != null) { var pc = pythonSite.Context; var po = pc.Options as PythonOptions; if (po != null && po.EnableProfiler) { Profiler profiler = Profiler.GetProfiler(pc); res = new DynamicMetaObject( profiler.AddProfiling(res.Expression, target.Overload.ReflectionInfo), res.Restrictions ); } } } // add any warnings that are applicable for calling this function WarningInfo info; if (target.Overload != null && BindingWarnings.ShouldWarn(PythonContext.GetPythonContext(call), target.Overload, out info)) { res = info.AddWarning(codeContext, res); } // finally add the restrictions for the built-in function and return the result. res = new DynamicMetaObject( res.Expression, functionRestriction.Merge(res.Restrictions) ); // The function can return something typed to boolean or int. // If that happens, we need to apply Python's boxing rules. if (res.Expression.Type.IsValueType()) { res = BindingHelpers.AddPythonBoxing(res); } else if (res.Expression.Type == typeof(void)) { res = new DynamicMetaObject( Expression.Block( res.Expression, Expression.Constant(null) ), res.Restrictions ); } return(res); }
// Token: 0x06002F0A RID: 12042 // RVA: 0x000233B1 File Offset: 0x000215B1 private static Dictionary<Keys, Bindings> smethod_1(BindingTarget bindingTarget_0) { return Class795.dictionary_1[bindingTarget_0]; }
public void SetBindingType(BindingTarget target) { this.BindingTarget = target; }