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); } }