internal static BindingTarget /*!*/ ResolveOverload(MetaObjectBuilder /*!*/ metaBuilder, CallArguments /*!*/ args, string /*!*/ name,
IList <OverloadInfo> /*!*/ overloads, SelfCallConvention callConvention, bool implicitProtocolConversions,
out RubyOverloadResolver /*!*/ resolver)
{
resolver = new RubyOverloadResolver(metaBuilder, args, callConvention, implicitProtocolConversions);
var bindingTarget = resolver.ResolveOverload(name, overloads, NarrowingLevel.None, NarrowingLevel.All);
bool calleeHasBlockParam = bindingTarget.Success && HasBlockParameter(bindingTarget.Overload);
// At runtime the BlockParam is created with a new RFC instance that identifies the library method frame as
// a proc-converter target of a method unwinder triggered by break from a block.
if (args.Signature.HasBlock && calleeHasBlockParam)
{
metaBuilder.ControlFlowBuilder = RuleControlFlowBuilder;
}
// add restrictions used for overload resolution:
resolver.AddArgumentRestrictions(metaBuilder, bindingTarget);
return(bindingTarget);
}
internal static BindingTarget/*!*/ ResolveOverload(MetaObjectBuilder/*!*/ metaBuilder, CallArguments/*!*/ args, string/*!*/ name,
IList<OverloadInfo>/*!*/ overloads, SelfCallConvention callConvention, bool implicitProtocolConversions,
out RubyOverloadResolver/*!*/ resolver) {
resolver = new RubyOverloadResolver(metaBuilder, args, callConvention, implicitProtocolConversions);
var bindingTarget = resolver.ResolveOverload(name, overloads, NarrowingLevel.None, NarrowingLevel.All);
bool calleeHasBlockParam = bindingTarget.Success && HasBlockParameter(bindingTarget.Overload);
// At runtime the BlockParam is created with a new RFC instance that identifies the library method frame as
// a proc-converter target of a method unwinder triggered by break from a block.
if (args.Signature.HasBlock && calleeHasBlockParam) {
metaBuilder.ControlFlowBuilder = RuleControlFlowBuilder;
}
// add restrictions used for overload resolution:
resolver.AddArgumentRestrictions(metaBuilder, bindingTarget);
return bindingTarget;
}
public void OverloadResolution_Numeric1() {
var metaBuilder = new MetaObjectBuilder(null);
Context.ObjectClass.SetConstant("X", Context.GetClass(typeof(Overloads1.X)));
object c = Engine.Execute(@"class C < X; new; end");
var sym = SymbolTable.StringToId("x");
var ms = MutableString.CreateAscii("x");
var cases = new[] {
// F
new { Args = new[] { MO(1) }, Overloads = "F*", Result = "F1" },
new { Args = new[] { MO((byte)1) }, Overloads = "F*", Result = "F1" },
new { Args = new[] { MO(1L) }, Overloads = "F*", Result = "F2" },
new { Args = new[] { MO(1.2F) }, Overloads = "F*", Result = "F3" },
// G
new { Args = new[] { MO(1) }, Overloads = "G*", Result = "G1" },
new { Args = new[] { MO((byte)1) }, Overloads = "G*", Result = "G1" },
new { Args = new[] { MO(1L) }, Overloads = "G*", Result = "G2" },
new { Args = new[] { MO(1.2F) }, Overloads = "G*", Result = "G3" },
new { Args = new[] { MO(c) }, Overloads = "G*", Result = "G1" },
// I
new { Args = new[] { MO(c) }, Overloads = "I*", Result = "I3" },
// J
new { Args = new[] { MO(1) }, Overloads = "J*", Result = "J1" },
new { Args = new[] { MO((BigInteger)1000) }, Overloads = "J*", Result = "J2" },
new { Args = new[] { MO((byte)12) }, Overloads = "J*", Result = "J1" },
new { Args = new[] { MO(c) }, Overloads = "J*", Result = "J3" },
new { Args = new[] { MO(1.0) }, Overloads = "J*", Result = "J3" },
// K
new { Args = new[] { MO(1) }, Overloads = "K*", Result = "K2" },
new { Args = new[] { MO(c) }, Overloads = "K*", Result = "K1" },
new { Args = new[] { MO("x") }, Overloads = "K*", Result = "K1" },
// L
new { Args = new[] { MO(sym), MO(sym) }, Overloads = "L*", Result = "L1" },
new { Args = new[] { MO("x"), MO(sym) }, Overloads = "L*", Result = "L2" },
new { Args = new[] { MO(ms), MO(sym) }, Overloads = "L*", Result = "L3" },
new { Args = new[] { MO(null), MO(sym) }, Overloads = "L*", Result = "L3" },
new { Args = new[] { MO(c), MO(sym) }, Overloads = "L*", Result = "L3" },
};
for (int i = 0; i < cases.Length; i++) {
var args = new CallArguments(Context, MO(new Overloads1()), cases[i].Args, RubyCallSignature.Simple(cases[i].Args.Length));
var resolver = new RubyOverloadResolver(metaBuilder, args, SelfCallConvention.SelfIsInstance, false);
var overloads = GetInstanceMethods(typeof(Overloads1), cases[i].Overloads);
var result = resolver.ResolveOverload(i.ToString(), overloads, NarrowingLevel.None, NarrowingLevel.All);
Assert(result.Success && result.Method.Name == cases[i].Result);
}
}
internal static BindingTarget/*!*/ ResolveOverload(MetaObjectBuilder/*!*/ metaBuilder, CallArguments/*!*/ args, string/*!*/ name,
IList<MethodBase>/*!*/ overloads, SelfCallConvention callConvention, out RubyOverloadResolver/*!*/ resolver) {
resolver = new RubyOverloadResolver(metaBuilder, args, callConvention);
var bindingTarget = resolver.ResolveOverload(name, overloads, NarrowingLevel.None, NarrowingLevel.All);
bool calleeHasBlockParam = bindingTarget.Success && HasBlockParameter(bindingTarget.Method);
// At runtime the BlockParam is created with a new RFC instance that identifies the library method frame as
// a proc-converter target of a method unwinder triggered by break from a block.
if (args.Signature.HasBlock) {
var metaBlock = args.GetMetaBlock();
if (metaBlock.Value != null && calleeHasBlockParam) {
Debug.Assert(metaBuilder.BfcVariable != null);
metaBuilder.ControlFlowBuilder = RuleControlFlowBuilder;
}
// Overload resolution might not need to distinguish between nil and non-nil block.
// However, we still do since we construct CF only for non-nil blocks.
if (metaBlock.Value == null) {
metaBuilder.AddRestriction(Ast.Equal(metaBlock.Expression, AstUtils.Constant(null)));
} else {
// don't need to test the exact type of the Proc since the code is subclass agnostic:
metaBuilder.AddRestriction(Ast.NotEqual(metaBlock.Expression, AstUtils.Constant(null)));
}
}
// add restrictions used for overload resolution:
resolver.AddArgumentRestrictions(metaBuilder, bindingTarget);
return bindingTarget;
}
