private static RuleGenerator /*!*/ CreateGetter(int index)
{
return(delegate(MetaObjectBuilder /*!*/ metaBuilder, CallArguments /*!*/ args, string /*!*/ name) {
RubyOverloadResolver.NormalizeArguments(metaBuilder, args, 0, 0);
if (!metaBuilder.Error)
{
metaBuilder.Result = Methods.RubyStruct_GetValue.OpCall(
Ast.Convert(args.TargetExpression, typeof(RubyStruct)),
AstUtils.Constant(index)
);
}
});
}
private void BuildCall(MetaObjectBuilder /*!*/ metaBuilder, CallArguments /*!*/ args, string /*!*/ name)
{
var actualArgs = RubyOverloadResolver.NormalizeArguments(metaBuilder, args, 0, Int32.MaxValue);
if (metaBuilder.Error)
{
return;
}
metaBuilder.AddRestriction(
Ast.Equal(
Ast.Property(Ast.Convert(args.TargetExpression, typeof(Win32API)), VersionProperty),
Ast.Constant(_version)
)
);
if (_function == IntPtr.Zero)
{
metaBuilder.SetError(Ast.Throw(new Func <Exception>(UninitializedFunctionError).Method.OpCall(), typeof(object)));
return;
}
if (_signature.Length != actualArgs.Count)
{
metaBuilder.SetError(Ast.Throw(new Func <int, int, Exception>(InvalidParameterCountError).Method.OpCall(
Ast.Constant(_signature.Length), Ast.Constant(actualArgs.Count)), typeof(object)
));
return;
}
var calliArgs = new AstExpressions();
calliArgs.Add(Ast.Property(Ast.Convert(args.TargetExpression, typeof(Win32API)), FunctionProperty));
for (int i = 0; i < actualArgs.Count; i++)
{
calliArgs.Add(MarshalArgument(metaBuilder, actualArgs[i], _signature[i]));
}
metaBuilder.Result = Ast.Call(EmitCalliStub(), calliArgs);
// MRI returns 0 if void return type is given:
if (_returnType == ArgType.None)
{
metaBuilder.Result = Ast.Block(metaBuilder.Result, AstUtils.Constant(0));
}
}
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 = Context.CreateAsciiSymbol("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" },
// M
new { Args = new[] { MO(1) }, Overloads = "M*", Result = "M1" },
new { Args = new[] { MO(Overloads1.E.A) }, Overloads = "M*", Result = "M2" },
// N
new { Args = new[] { MO(MutableString.CreateAscii("x")) }, Overloads = "N*", Result = "N1" },
};
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.Overload.Name == cases[i].Result);
}
}
