internal SetMember(RubyContext /*!*/ context, string /*!*/ name)
{
Assert.NotNull(context, name);
_name = name;
_context = context;
_tryGetMember = RubyMetaBinderFactory.InteropTryGetMemberExact(name);
_setMember = RubyMetaBinderFactory.InteropSetMemberExact(name);
string unmanagled = RubyUtils.TryUnmangleMethodName(name);
if (unmanagled != null)
{
_setMemberUnmangled = RubyMetaBinderFactory.InteropSetMemberExact(unmanagled);
_tryGetMemberUnmangled = RubyMetaBinderFactory.InteropTryGetMemberExact(unmanagled);
}
}
internal override void BuildMethodMissingCallNoFlow(MetaObjectBuilder /*!*/ metaBuilder, CallArguments /*!*/ args, string /*!*/ name)
{
var globalScope = args.TargetClass.GlobalScope;
var context = globalScope.Context;
if (name.LastCharacter() == '=')
{
var normalizedArgs = RubyOverloadResolver.NormalizeArguments(metaBuilder, args, 1, 1);
if (!metaBuilder.Error)
{
var scopeVar = metaBuilder.GetTemporary(typeof(Scope), "#scope");
metaBuilder.AddInitialization(
Ast.Assign(scopeVar, Methods.GetGlobalScopeFromScope.OpCall(AstUtils.Convert(args.MetaScope.Expression, typeof(RubyScope))))
);
var interopSetter = context.MetaBinderFactory.InteropSetMember(name.Substring(0, name.Length - 1));
metaBuilder.SetMetaResult(
interopSetter.Bind(
new DynamicMetaObject(
scopeVar,
BindingRestrictions.Empty,
globalScope.Scope
),
new[] { normalizedArgs[0] }
),
true
);
}
}
else
{
RubyOverloadResolver.NormalizeArguments(metaBuilder, args, 0, 0);
Expression errorExpr = metaBuilder.Error ? Ast.Throw(metaBuilder.Result, typeof(object)) : null;
var scopeVar = metaBuilder.GetTemporary(typeof(Scope), "#scope");
var scopeLookupResultVar = metaBuilder.GetTemporary(typeof(object), "#result");
metaBuilder.AddInitialization(
Ast.Assign(scopeVar, Methods.GetGlobalScopeFromScope.OpCall(AstUtils.Convert(args.MetaScope.Expression, typeof(RubyScope))))
);
Expression scopeLookupResultExpr = errorExpr ?? scopeLookupResultVar;
Expression fallbackExp;
if (name == "scope")
{
fallbackExp = errorExpr ?? args.TargetExpression;
}
else
{
// super(methodName, ...args...) - ignore argument error:
args.InsertMethodName(name);
fallbackExp = AstUtils.LightDynamic(
context.MetaBinderFactory.Call(Symbols.MethodMissing,
new RubyCallSignature(
args.Signature.ArgumentCount + 1,
args.Signature.Flags | RubyCallFlags.HasImplicitSelf | RubyCallFlags.IsSuperCall
)
),
typeof(object),
args.GetCallSiteArguments(args.TargetExpression)
);
}
var scopeLookup = Ast.NotEqual(
Ast.Assign(scopeLookupResultVar, AstUtils.LightDynamic(RubyMetaBinderFactory.InteropTryGetMemberExact(name), typeof(object), scopeVar)),
Expression.Constant(OperationFailed.Value)
);
string unmanagled = RubyUtils.TryUnmangleMethodName(name);
if (unmanagled != null)
{
scopeLookup = Ast.OrElse(
scopeLookup,
Ast.NotEqual(
Ast.Assign(scopeLookupResultVar, AstUtils.LightDynamic(RubyMetaBinderFactory.InteropTryGetMemberExact(unmanagled), typeof(object), scopeVar)),
Expression.Constant(OperationFailed.Value)
)
);
}
metaBuilder.Result = Ast.Condition(
scopeLookup,
scopeLookupResultExpr,
fallbackExp
);
}
}
