public static MetaObject TryBind(RubyContext /*!*/ context, GetMemberBinder /*!*/ binder, MetaObject /*!*/ target)
{
Assert.NotNull(context, target);
var metaBuilder = new MetaObjectBuilder();
var contextExpression = Ast.Constant(context);
metaBuilder.AddTargetTypeTest(target.Value, target.Expression, context, contextExpression);
RubyMemberInfo method = context.ResolveMethod(target.Value, binder.Name, true).InvalidateSitesOnOverride();
if (method != null && RubyModule.IsMethodVisible(method, false))
{
// we need to create a bound member:
metaBuilder.Result = Ast.Constant(new RubyMethod(target.Value, method, binder.Name));
}
else
{
// TODO:
// We need to throw an exception if we don't find method_missing so that our version update optimization works:
// This limits interop with other languages.
//
// class B CLR type with method 'foo'
// class C < B Ruby class
// x = C.new
//
// 1. x.GET("foo") from Ruby
// No method found or CLR method found -> fallback to Python
// Python might see its method foo or might just fallback to .NET,
// in any case it will add rule [1] with restriction on type of C w/o Ruby version check.
// 2. B.define_method("foo")
// This doesn't update C due to the optimization (there is no overridden method foo in C).
// 3. x.GET("foo") from Ruby
// This will not invoke the binder since the rule [1] is still valid.
//
object symbol = SymbolTable.StringToId(binder.Name);
RubyCallAction.BindToMethodMissing(metaBuilder, binder.Name,
new CallArguments(
new MetaObject(contextExpression, Restrictions.Empty, context),
new[] {
target,
new MetaObject(Ast.Constant(symbol), Restrictions.Empty, symbol)
},
RubyCallSignature.Simple(1)
),
method != null
);
}
// TODO: we should return null if we fail, we need to throw exception for now:
return(metaBuilder.CreateMetaObject(binder, MetaObject.EmptyMetaObjects));
}
/// <exception cref="MissingMethodException">The resolved method is Kernel#method_missing.</exception>
internal static void Bind(MetaObjectBuilder /*!*/ metaBuilder, string /*!*/ methodName, CallArguments /*!*/ args)
{
metaBuilder.AddTargetTypeTest(args);
RubyMemberInfo method = args.RubyContext.ResolveMethod(args.Target, methodName, true).InvalidateSitesOnOverride();
if (method != null && RubyModule.IsMethodVisible(method, args.Signature.HasImplicitSelf))
{
method.BuildCall(metaBuilder, args, methodName);
}
else
{
// insert the method name argument into the args
object symbol = SymbolTable.StringToId(methodName);
args.InsertSimple(0, new MetaObject(Ast.Constant(symbol), Restrictions.Empty, symbol));
BindToMethodMissing(metaBuilder, methodName, args, method != null);
}
}
internal void SetRule(MetaObjectBuilder /*!*/ metaBuilder, CallArguments /*!*/ args)
{
Assert.NotNull(metaBuilder, args);
Debug.Assert(args.SimpleArgumentCount == 0 && !args.Signature.HasBlock && !args.Signature.HasSplattedArgument && !args.Signature.HasRhsArgument);
Debug.Assert(args.Signature.HasScope);
var ec = args.RubyContext;
// implicit conversions should only depend on a static type:
if (TryImplicitConversion(metaBuilder, args))
{
if (args.Target == null)
{
metaBuilder.AddRestriction(Ast.Equal(args.TargetExpression, Ast.Constant(null, args.TargetExpression.Type)));
}
else
{
metaBuilder.AddTypeRestriction(args.Target.GetType(), args.TargetExpression);
}
return;
}
// check for type version:
metaBuilder.AddTargetTypeTest(args);
string toMethodName = ToMethodName;
Expression targetClassNameConstant = Ast.Constant(ec.GetClassOf(args.Target).Name);
// Kernel#respond_to? method is not overridden => we can optimize
RubyMemberInfo respondToMethod = ec.ResolveMethod(args.Target, Symbols.RespondTo, true).InvalidateSitesOnOverride();
if (respondToMethod == null ||
// the method is defined in library, hasn't been replaced by user defined method (TODO: maybe we should make this check better)
(respondToMethod.DeclaringModule == ec.KernelModule && respondToMethod is RubyMethodGroupInfo))
{
RubyMemberInfo conversionMethod = ec.ResolveMethod(args.Target, toMethodName, false).InvalidateSitesOnOverride();
if (conversionMethod == null)
{
// error:
SetError(metaBuilder, targetClassNameConstant, args);
return;
}
else
{
// invoke target.to_xxx() and validate it; returns an instance of TTargetType:
conversionMethod.BuildCall(metaBuilder, args, toMethodName);
if (!metaBuilder.Error && ConversionResultValidator != null)
{
metaBuilder.Result = ConversionResultValidator.OpCall(targetClassNameConstant, AstFactory.Box(metaBuilder.Result));
}
return;
}
}
else if (!RubyModule.IsMethodVisible(respondToMethod, false))
{
// respond_to? is private:
SetError(metaBuilder, targetClassNameConstant, args);
return;
}
// slow path: invoke respond_to?, to_xxx and result validation:
var conversionCallSite = Ast.Dynamic(
RubyCallAction.Make(toMethodName, RubyCallSignature.WithScope(0)),
typeof(object),
args.ScopeExpression, args.TargetExpression
);
Expression opCall;
metaBuilder.Result = Ast.Condition(
// If
// respond_to?()
Methods.IsTrue.OpCall(
Ast.Dynamic(
RubyCallAction.Make(Symbols.RespondTo, RubyCallSignature.WithScope(1)),
typeof(object),
args.ScopeExpression, args.TargetExpression, Ast.Constant(SymbolTable.StringToId(toMethodName))
)
),
// Then
// to_xxx():
opCall = (ConversionResultValidator == null) ? conversionCallSite :
ConversionResultValidator.OpCall(targetClassNameConstant, conversionCallSite),
// Else
AstUtils.Convert(
(ConversionResultValidator == null) ? args.TargetExpression :
Ast.Convert(
Ast.Throw(Methods.CreateTypeConversionError.OpCall(targetClassNameConstant, Ast.Constant(TargetTypeName))),
typeof(object)
),
opCall.Type
)
);
}
