public ParameterWrapper(ActionBinder binder, Type type)
{
_type = type;
_binder = binder;
}
public ParameterWrapper(ActionBinder binder, Type type, bool prohibitNull)
{
_type = type;
_prohibitNull = prohibitNull;
_binder = binder;
}
protected override DynamicMetaObject SetBoundValue(OverloadResolverFactory resolverFactory, ActionBinder binder, Type type, DynamicMetaObject value, DynamicMetaObject instance)
{
return(SetBoundValue(resolverFactory, binder, type, value, instance, null));
}
protected OverloadResolver(ActionBinder binder) {
ContractUtils.RequiresNotNull(binder, "binder");
_binder = binder;
_maxAccessedCollapsedArg = -1;
}
public override DynamicMetaObject GetValue(OverloadResolverFactory resolverFactory, ActionBinder binder, Type type)
{
return(new DynamicMetaObject(AstUtils.Constant(GetSlot(), typeof(PythonTypeSlot)), BindingRestrictions.Empty));
}
public override DynamicMetaObject SetValue(OverloadResolverFactory resolverFactory, ActionBinder binder, Type type, DynamicMetaObject value, DynamicMetaObject errorSuggestion)
{
return(base.SetValue(resolverFactory, binder, type, value, errorSuggestion));
}
public static DynamicExpression Call(ActionBinder binder, Type result, params Expression[] arguments)
{
return(Call(OldCallAction.Make(binder, arguments.Length - 2), result, arguments));
}
public static MethodBinder MakeBinder(ActionBinder binder, string name, IList <MethodBase> mis, BinderType binderType)
{
return(new MethodBinder(binder, name, mis, binderType, SymbolId.EmptySymbols));
}
public static DynamicExpression DeleteMember(SourceSpan span, ActionBinder binder, string name, params Expression[] arguments)
{
return(DeleteMember(binder, name, arguments));
}
public static DynamicExpression Operator(ActionBinder binder, Operators op, Type resultType, params Expression[] arguments)
{
return(Expression.Dynamic(OldDoOperationAction.Make(binder, op), resultType, arguments));
}
public static DynamicExpression Operator(SourceSpan span, ActionBinder binder, Operators op, Type result, params Expression[] arguments)
{
return(Operator(binder, op, result, arguments));
}
public static DynamicExpression Create(ActionBinder binder, Type result, params Expression[] arguments)
{
return(Create(OldCreateInstanceAction.Make(binder, arguments.Length - 2), result, arguments));
}
public ByRefReturnBuilder(ActionBinder binder, IList <int> returnArgs)
: base(typeof(object))
{
_returnArgs = returnArgs;
_binder = binder;
}
public AbstractContext(ActionBinder binder)
{
_binder = binder;
}
public ParameterBinder(ActionBinder actionBinder)
{
Assert.NotNull(actionBinder);
_actionBinder = actionBinder;
}
public DelegateSignatureInfo(ActionBinder binder, Type returnType, ParameterInfo[] parameters)
{
_binder = binder;
_parameters = parameters;
_returnType = returnType;
}
protected override void DataBinding()
{
base.DataBinding();
TextBinder textBinder = base.FindTransform("PriceNum").get_gameObject().AddComponent <TextBinder>();
textBinder.BindingProxy = base.get_gameObject();
textBinder.LabelBinding.MemberName = "PriceNum";
textBinder = base.FindTransform("ExtraNum").get_gameObject().AddComponent <TextBinder>();
textBinder.BindingProxy = base.get_gameObject();
textBinder.LabelBinding.MemberName = "ExtraNum";
textBinder = base.FindTransform("ExtraEveryDay").get_gameObject().AddComponent <TextBinder>();
textBinder.BindingProxy = base.get_gameObject();
textBinder.LabelBinding.MemberName = "ExtraEveryDayNum";
textBinder = base.FindTransform("DiamondNum").get_gameObject().AddComponent <TextBinder>();
textBinder.BindingProxy = base.get_gameObject();
textBinder.LabelBinding.MemberName = "DiamondNum";
textBinder = base.FindTransform("VIPTipNum").get_gameObject().AddComponent <TextBinder>();
textBinder.BindingProxy = base.get_gameObject();
textBinder.LabelBinding.MemberName = "VIPTipNum";
textBinder = base.FindTransform("MCDayNum").get_gameObject().AddComponent <TextBinder>();
textBinder.BindingProxy = base.get_gameObject();
textBinder.LabelBinding.MemberName = "MCDayNum";
textBinder = base.FindTransform("DaysNum").get_gameObject().AddComponent <TextBinder>();
textBinder.BindingProxy = base.get_gameObject();
textBinder.LabelBinding.MemberName = "DaysNum";
textBinder = base.FindTransform("TreasureName").get_gameObject().AddComponent <TextBinder>();
textBinder.BindingProxy = base.get_gameObject();
textBinder.LabelBinding.MemberName = "TreasureName";
ImageBinder imageBinder = base.FindTransform("DiamondIcon").get_gameObject().AddComponent <ImageBinder>();
imageBinder.BindingProxy = base.get_gameObject();
imageBinder.SpriteBinding.MemberName = "BigIcon";
imageBinder.SetNativeSize = true;
imageBinder = base.FindTransform("TreasureIcon").get_gameObject().AddComponent <ImageBinder>();
imageBinder.BindingProxy = base.get_gameObject();
imageBinder.SpriteBinding.MemberName = "TreasureIcon";
imageBinder.SetNativeSize = true;
VisibilityBinder visibilityBinder = base.get_gameObject().AddComponent <VisibilityBinder>();
visibilityBinder.BindingProxy = base.get_gameObject();
visibilityBinder.Target = base.FindTransform("VIPTip").get_gameObject();
visibilityBinder.ValueBinding.MemberName = "VIPTipVisibility";
visibilityBinder = base.get_gameObject().AddComponent <VisibilityBinder>();
visibilityBinder.BindingProxy = base.get_gameObject();
visibilityBinder.Target = base.FindTransform("Extra").get_gameObject();
visibilityBinder.ValueBinding.MemberName = "VIPExtraVisibility";
visibilityBinder = base.get_gameObject().AddComponent <VisibilityBinder>();
visibilityBinder.BindingProxy = base.get_gameObject();
visibilityBinder.Target = base.FindTransform("ExtraEveryDay").get_gameObject();
visibilityBinder.ValueBinding.MemberName = "ExtraEveryDayVisibility";
visibilityBinder = base.get_gameObject().AddComponent <VisibilityBinder>();
visibilityBinder.BindingProxy = base.get_gameObject();
visibilityBinder.Target = base.FindTransform("MCDay").get_gameObject();
visibilityBinder.ValueBinding.MemberName = "MCDayVisibility";
visibilityBinder = base.get_gameObject().AddComponent <VisibilityBinder>();
visibilityBinder.BindingProxy = base.get_gameObject();
visibilityBinder.Target = base.FindTransform("Price").get_gameObject();
visibilityBinder.ValueBinding.MemberName = "PriceVisibility";
visibilityBinder = base.get_gameObject().AddComponent <VisibilityBinder>();
visibilityBinder.BindingProxy = base.get_gameObject();
visibilityBinder.Target = base.FindTransform("DailyLimitIcon").get_gameObject();
visibilityBinder.ValueBinding.MemberName = "DailyLimitIconVisibility";
visibilityBinder = base.get_gameObject().AddComponent <VisibilityBinder>();
visibilityBinder.BindingProxy = base.get_gameObject();
visibilityBinder.Target = base.FindTransform("TodayBought").get_gameObject();
visibilityBinder.ValueBinding.MemberName = "TodayBoughtVisibility";
visibilityBinder = base.get_gameObject().AddComponent <VisibilityBinder>();
visibilityBinder.BindingProxy = base.get_gameObject();
visibilityBinder.Target = base.FindTransform("Treasure").get_gameObject();
visibilityBinder.ValueBinding.MemberName = "TreasureVisibility";
visibilityBinder = base.get_gameObject().AddComponent <VisibilityBinder>();
visibilityBinder.BindingProxy = base.get_gameObject();
visibilityBinder.Target = base.FindTransform("Diamond").get_gameObject();
visibilityBinder.ValueBinding.MemberName = "DiamondVisibility";
ActionBinder actionBinder = base.get_gameObject().AddComponent <ActionBinder>();
actionBinder.BindingProxy = base.get_gameObject();
actionBinder.CallActionOfBoolBinding.MemberName = "RefreshFXOfMonthCard";
actionBinder.actoncall_bool = new Action <bool>(this.RefreshFXOfMonthCard);
}
public override DynamicMetaObject GetValue(OverloadResolverFactory factory, ActionBinder binder, Type instanceType)
{
return(GetBoundValue(factory, binder, instanceType, new DynamicMetaObject(AstUtils.Constant(null), BindingRestrictions.Empty)));
}
/// <summary>
/// ParameterInfo is not available.
/// </summary>
public ParameterWrapper(ActionBinder binder, Type type, SymbolId name, bool prohibitNull)
: this(binder, null, type, name, prohibitNull, false, false)
{
}
public override DynamicMetaObject SetValue(OverloadResolverFactory resolverFactory, ActionBinder binder, Type type, DynamicMetaObject value)
{
return(SetBoundValue(resolverFactory, binder, type, value, new DynamicMetaObject(AstUtils.Constant(null), BindingRestrictions.Empty)));
}
public MethodBinderContext(ActionBinder actionBinder)
{
_actionBinder = actionBinder;
}
protected override DynamicMetaObject GetBoundValue(OverloadResolverFactory factory, ActionBinder binder, Type instanceType, DynamicMetaObject instance)
{
return(new DynamicMetaObject(
Ast.Call(
typeof(PythonOps).GetMethod(nameof(PythonOps.SlotGetValue)),
((PythonOverloadResolverFactory)factory)._codeContext,
AstUtils.Constant(GetSlot(), typeof(PythonTypeSlot)),
AstUtils.Convert(
instance.Expression,
typeof(object)
),
AstUtils.Constant(DynamicHelpers.GetPythonTypeFromType(instanceType))
),
BindingRestrictions.Empty
));
}
public ParameterBinder(ActionBinder actionBinder) {
Assert.NotNull(actionBinder);
_actionBinder = actionBinder;
}
protected override DynamicMetaObject SetBoundValue(OverloadResolverFactory factory, ActionBinder binder, Type type, DynamicMetaObject value, DynamicMetaObject instance, DynamicMetaObject errorSuggestion)
{
return(new DynamicMetaObject(
Expression.Condition(
Ast.Call(
typeof(PythonOps).GetMethod(nameof(PythonOps.SlotTrySetValue)),
((PythonOverloadResolverFactory)factory)._codeContext,
AstUtils.Constant(GetSlot(), typeof(PythonTypeSlot)),
AstUtils.Convert(
instance.Expression,
typeof(object)
),
AstUtils.Constant(DynamicHelpers.GetPythonTypeFromType(type)),
value.Expression
),
AstUtils.Convert(value.Expression, typeof(object)),
errorSuggestion != null ?
errorSuggestion.Expression :
Expression.Throw(
Expression.Call(
typeof(PythonOps).GetMethod(nameof(PythonOps.AttributeErrorForMissingAttribute), new Type[] { typeof(object), typeof(string) }),
instance.Expression,
Expression.Constant(Name)
),
typeof(object)
)
),
BindingRestrictions.Empty
));
}
public string GetArgumentTypeName(ActionBinder binder) {
ContractUtils.RequiresNotNull(binder, "binder");
return (_arg != null) ? binder.GetObjectTypeName(_arg) : binder.GetTypeName(_argType);
}
public virtual void ReceiveInputActions(ActionBinder actions)
{
}
/// <summary>
/// Builds a new MethodCandidate which takes count arguments and the provided list of keyword arguments.
///
/// The basic idea here is to figure out which parameters map to params or a dictionary params and
/// fill in those spots w/ extra ParameterWrapper's.
/// </summary>
public MethodCandidate MakeParamsExtended(ActionBinder binder, int count, SymbolId[] names)
{
List <ParameterWrapper> newParameters = new List <ParameterWrapper>(count);
// if we don't have a param array we'll have a param dict which is type object
Type elementType = null;
int index = -1, kwIndex = -1;
// keep track of which kw args map to a real argument, and which ones
// map to the params dictionary.
List <SymbolId> unusedNames = new List <SymbolId>(names);
List <int> unusedNameIndexes = new List <int>();
for (int i = 0; i < unusedNames.Count; i++)
{
unusedNameIndexes.Add(i);
}
for (int i = 0; i < _parameters.Count; i++)
{
ParameterWrapper pw = _parameters[i];
if (_parameters[i].IsParamsArray)
{
elementType = pw.Type.GetElementType();
index = i;
}
else
{
for (int j = 0; j < unusedNames.Count; j++)
{
if (unusedNames[j] == _parameters[i].Name)
{
unusedNames.RemoveAt(j);
unusedNameIndexes.RemoveAt(j);
break;
}
}
newParameters.Add(pw);
}
}
if (index != -1)
{
while (newParameters.Count < (count - unusedNames.Count))
{
ParameterWrapper param = new ParameterWrapper(binder, elementType);
newParameters.Insert(System.Math.Min(index, newParameters.Count), param);
}
}
if (kwIndex != -1)
{
foreach (SymbolId si in unusedNames)
{
ParameterWrapper pw = new ParameterWrapper(binder, typeof(object), si);
newParameters.Add(pw);
}
}
else if (unusedNames.Count != 0)
{
// unbound kw args and no where to put them, can't call...
return(null);
}
// if we have too many or too few args we also can't call
if (count != newParameters.Count)
{
return(null);
}
return(new MethodCandidate(_target.MakeParamsExtended(count, unusedNames.ToArray(), unusedNameIndexes.ToArray()), newParameters));
}
public ParameterWrapper(ActionBinder binder, Type type, SymbolId name)
: this(binder, type)
{
_name = name;
}
public ParameterBinderWithCodeContext(ActionBinder actionBinder, Expression codeContext)
: base(actionBinder) {
Assert.NotNull(actionBinder, codeContext);
_context = codeContext;
}
public ParameterWrapper(ActionBinder binder, Type type, bool prohibitNull, SymbolId name)
: this(binder, type, prohibitNull)
{
_name = name;
}
public static MethodBinder MakeBinder(ActionBinder binder, string name, IList <MethodBase> mis, BinderType binderType, SymbolId[] keywordArgs)
{
return(new MethodBinder(binder, name, mis, binderType, keywordArgs));
}
public string GetArgumentTypeName(ActionBinder binder)
{
ContractUtils.RequiresNotNull(binder, nameof(binder));
return((_arg != null) ? binder.GetObjectTypeName(_arg) : binder.GetTypeName(ArgType));
}
public Expression MakeExpression(ActionBinder binder, StandardRule rule, Expression[] parameters)
{
MethodBinderContext context = new MethodBinderContext(binder, rule);
Expression check = Ast.True();
if (_binder.IsBinaryOperator)
{
// TODO: only if we have a narrowing level
// need to emit check to see if args are convertible...
for (int i = 0; i < _argBuilders.Count; i++)
{
Expression checkedExpr = _argBuilders[i].CheckExpression(context, parameters);
if (checkedExpr != null)
{
check = Ast.AndAlso(check, checkedExpr);
}
}
}
Expression[] args = new Expression[_argBuilders.Count];
for (int i = 0; i < _argBuilders.Count; i++)
{
args[i] = _argBuilders[i].ToExpression(context, parameters);
}
MethodInfo mi = Method as MethodInfo;
Expression ret, call;
if (!Method.IsPublic || !Method.DeclaringType.IsVisible)
{
if (mi != null)
{
mi = CompilerHelpers.GetCallableMethod(mi);
}
}
if (Method.IsPublic && Method.DeclaringType.IsVisible)
{
// public method
if (mi != null)
{
Expression instance = mi.IsStatic ? null : _instanceBuilder.ToExpression(context, parameters);
call = Ast.SimpleCallHelper(instance, mi, args);
}
else
{
call = Ast.SimpleNewHelper((ConstructorInfo)Method, args);
}
}
else
{
// Private binding, invoke via reflection
if (mi != null)
{
Expression instance = mi.IsStatic ? null : _instanceBuilder.ToExpression(context, parameters);
call = Ast.Call(
Ast.RuntimeConstant(mi),
typeof(MethodInfo).GetMethod("Invoke", new Type[] { typeof(object), typeof(object[]) }),
Ast.ConvertHelper(instance, typeof(object)),
Ast.NewArrayHelper(typeof(object[]), args)
);
}
else
{
call = Ast.Call(
Ast.RuntimeConstant((ConstructorInfo)Method),
typeof(ConstructorInfo).GetMethod("Invoke", new Type[] { typeof(object[]) }),
Ast.NewArrayHelper(typeof(object[]), args)
);
}
}
ret = _returnBuilder.ToExpression(context, _argBuilders, parameters, call);
List <Expression> updates = null;
for (int i = 0; i < _argBuilders.Count; i++)
{
Expression next = _argBuilders[i].UpdateFromReturn(context, parameters);
if (next != null)
{
if (updates == null)
{
updates = new List <Expression>();
}
updates.Add(next);
}
}
if (updates != null)
{
updates.Insert(0, ret);
ret = Ast.Comma(0, updates.ToArray());
}
if (!check.IsConstant(true))
{
ret = Ast.Condition(
check,
Ast.ConvertHelper(ret, typeof(object)),
GetNotImplemented()
);
}
return(ret);
}
