internal SuperCallAction(RubyContext context, RubyCallSignature signature, int lexicalScopeId)
: base(context)
{
Debug.Assert(signature.HasImplicitSelf && signature.HasScope && (signature.HasBlock || signature.ResolveOnly));
_signature = signature;
_lexicalScopeId = lexicalScopeId;
}
// Ruby binders:
internal CallArguments(RubyContext context, DynamicMetaObject/*!*/ scopeOrContextOrTargetOrArgArray, DynamicMetaObject/*!*/[]/*!*/ args, RubyCallSignature signature)
{
Assert.NotNull(scopeOrContextOrTargetOrArgArray);
Assert.NotNullItems(args);
ArgumentArray argArray = scopeOrContextOrTargetOrArgArray.Value as ArgumentArray;
if (argArray != null) {
Debug.Assert(args.Length == 0 && argArray.Count >= 1);
// build meta-objects for arguments wrapped in the array:
args = new DynamicMetaObject[argArray.Count - 1];
for (int i = 0; i < args.Length; i++) {
args[i] = argArray.GetMetaObject(scopeOrContextOrTargetOrArgArray.Expression, 1 + i);
}
scopeOrContextOrTargetOrArgArray = argArray.GetMetaObject(scopeOrContextOrTargetOrArgArray.Expression, 0);
}
Debug.Assert(signature.HasScope == scopeOrContextOrTargetOrArgArray.Value is RubyScope);
Debug.Assert((context == null && !signature.HasScope) == scopeOrContextOrTargetOrArgArray.Value is RubyContext);
if (context != null) {
// bound site:
_context = new DynamicMetaObject(AstUtils.Constant(context), BindingRestrictions.Empty, context);
if (signature.HasScope) {
_scope = scopeOrContextOrTargetOrArgArray;
_hasScopeOrContextArg = true;
} else {
_target = scopeOrContextOrTargetOrArgArray;
}
} else if (signature.HasScope) {
// unbound site with scope:
_context = new DynamicMetaObject(
Methods.GetContextFromScope.OpCall(scopeOrContextOrTargetOrArgArray.Expression), BindingRestrictions.Empty,
((RubyScope)scopeOrContextOrTargetOrArgArray.Value).RubyContext
);
_scope = scopeOrContextOrTargetOrArgArray;
_hasScopeOrContextArg = true;
_target = null;
} else {
// unbound site with context:
_context = scopeOrContextOrTargetOrArgArray;
_hasScopeOrContextArg = true;
_target = null;
}
Debug.Assert(_target != null || args.Length > 0);
_args = args;
_copyArgsOnWrite = true;
_signature = signature;
Debug.Assert(!signature.HasSplattedArgument || GetSplattedArgument() != null);
}
internal override MemberDispatcher GetDispatcher(Type/*!*/ delegateType, RubyCallSignature signature, object target, int version) {
if (!(target is IRubyObject)) {
return null;
}
if (signature.ArgumentCount != 0 || signature.HasRhsArgument || signature.HasBlock || !signature.HasScope) {
return null;
}
var dispatcher = new RubyObjectAttributeReaderDispatcherWithScope();
dispatcher.Initialize(InstanceVariableName, version);
return dispatcher;
}
internal protected RubyCallAction(RubyContext context, string/*!*/ methodName, RubyCallSignature signature)
: base(context) {
Assert.NotNull(methodName);
// a virtual call cannot be a super call nor interop call:
Debug.Assert(!signature.IsVirtualCall || !signature.IsSuperCall && !signature.IsInteropCall);
// a super call must have implicit self:
Debug.Assert(!signature.IsSuperCall || signature.HasImplicitSelf);
_methodName = methodName;
_signature = signature;
}
internal static MSA.DynamicExpression/*!*/ InvokeMethod(RubyContext/*!*/ context, string/*!*/ name, RubyCallSignature signature,
params MSA.Expression[]/*!*/ args) {
Debug.Assert(args.Length >= 2);
var scope = args[0];
var target = args[1];
switch (args.Length) {
case 2: return InvokeMethod(context, name, signature, scope, target);
case 3: return InvokeMethod(context, name, signature, scope, target, args[2]);
case 4: return InvokeMethod(context, name, signature, scope, target, args[2], args[3]);
default: return InvokeMethod(context, name, signature, scope, target, args);
}
}
private static MSA.DynamicExpression/*!*/ MakeCallAction(RubyContext/*!*/ context, string/*!*/ name, RubyCallSignature signature,
params MSA.Expression[]/*!*/ args) {
RubyCallAction call = RubyCallAction.Make(context, name, signature);
switch (args.Length) {
case 0: return Ast.Dynamic(call, typeof(object), AstFactory.EmptyExpressions);
case 1: return Ast.Dynamic(call, typeof(object), args[0]);
case 2: return Ast.Dynamic(call, typeof(object), args[0], args[1]);
case 3: return Ast.Dynamic(call, typeof(object), args[0], args[1], args[2]);
case 4: return Ast.Dynamic(call, typeof(object), args[0], args[1], args[2], args[3]);
default:
return Ast.Dynamic(
call,
typeof(object),
new ReadOnlyCollection<MSA.Expression>(args)
);
}
}
internal MSA.Expression <T> /*!*/ Transform <T>(AstGenerator /*!*/ gen)
{
Debug.Assert(gen != null);
ScopeBuilder scope = DefineLocals();
MSA.ParameterExpression[] parameters;
MSA.ParameterExpression selfVariable;
MSA.ParameterExpression runtimeScopeVariable;
MSA.ParameterExpression blockParameter;
if (gen.CompilerOptions.FactoryKind == TopScopeFactoryKind.None ||
gen.CompilerOptions.FactoryKind == TopScopeFactoryKind.ModuleEval)
{
parameters = new MSA.ParameterExpression[4];
runtimeScopeVariable = parameters[0] = Ast.Parameter(typeof(RubyScope), "#scope");
selfVariable = parameters[1] = Ast.Parameter(typeof(object), "#self");
parameters[2] = Ast.Parameter(typeof(RubyModule), "#module");
blockParameter = parameters[3] = Ast.Parameter(typeof(Proc), "#block");
}
else
{
parameters = new MSA.ParameterExpression[2];
runtimeScopeVariable = parameters[0] = Ast.Parameter(typeof(RubyScope), "#scope");
selfVariable = parameters[1] = Ast.Parameter(typeof(object), "#self");
blockParameter = null;
}
gen.EnterSourceUnit(
scope,
selfVariable,
runtimeScopeVariable,
blockParameter,
gen.CompilerOptions.TopLevelMethodName, // method name for blocks
null // parameters for super calls
);
MSA.Expression body;
if (_statements.Count > 0)
{
if (gen.PrintInteractiveResult)
{
var resultVariable = scope.DefineHiddenVariable("#result", typeof(object));
var epilogue = Methods.PrintInteractiveResult.OpCall(runtimeScopeVariable,
AstUtils.LightDynamic(ConvertToSAction.Make(gen.Context), typeof(MutableString),
CallSiteBuilder.InvokeMethod(gen.Context, "inspect", RubyCallSignature.WithScope(0),
gen.CurrentScopeVariable, resultVariable
)
)
);
body = gen.TransformStatements(null, _statements, epilogue, ResultOperation.Store(resultVariable));
}
else
{
body = gen.TransformStatements(_statements, ResultOperation.Return);
}
// TODO:
var exceptionVariable = Ast.Parameter(typeof(Exception), "#exception");
body = AstUtils.Try(
body
).Filter(exceptionVariable, Methods.TraceTopLevelCodeFrame.OpCall(runtimeScopeVariable, exceptionVariable),
Ast.Empty()
);
}
else
{
body = AstUtils.Constant(null);
}
// scope initialization:
MSA.Expression prologue;
switch (gen.CompilerOptions.FactoryKind)
{
case TopScopeFactoryKind.None:
case TopScopeFactoryKind.ModuleEval:
prologue = Methods.InitializeScopeNoLocals.OpCall(runtimeScopeVariable, EnterInterpretedFrameExpression.Instance);
break;
case TopScopeFactoryKind.Hosted:
case TopScopeFactoryKind.File:
case TopScopeFactoryKind.WrappedFile:
prologue = Methods.InitializeScope.OpCall(
runtimeScopeVariable, scope.MakeLocalsStorage(), scope.GetVariableNamesExpression(),
EnterInterpretedFrameExpression.Instance
);
break;
case TopScopeFactoryKind.Main:
prologue = Methods.InitializeScope.OpCall(
runtimeScopeVariable, scope.MakeLocalsStorage(), scope.GetVariableNamesExpression(),
EnterInterpretedFrameExpression.Instance
);
if (_dataOffset >= 0)
{
prologue = Ast.Block(
prologue,
Methods.SetDataConstant.OpCall(
runtimeScopeVariable,
gen.SourcePathConstant,
AstUtils.Constant(_dataOffset)
)
);
}
break;
default:
throw Assert.Unreachable;
}
// BEGIN blocks:
if (gen.FileInitializers != null)
{
var b = new AstBlock();
b.Add(prologue);
b.Add(gen.FileInitializers);
b.Add(body);
body = b;
}
body = gen.AddReturnTarget(scope.CreateScope(body));
gen.LeaveSourceUnit();
return(Ast.Lambda <T>(body, GetEncodedName(gen), parameters));
}
private static VisibilityContext GetVisibilityContext(RubyCallSignature callSignature, RubyScope scope) {
return callSignature.HasImplicitSelf || !callSignature.HasScope ?
new VisibilityContext(callSignature.IsInteropCall ? RubyMethodAttributes.Public : RubyMethodAttributes.VisibilityMask) :
new VisibilityContext(scope.SelfImmediateClass);
}
// interop binders: the target is a Ruby meta-object closed over the context
internal CallArguments(DynamicMetaObject/*!*/ context, DynamicMetaObject/*!*/ target, DynamicMetaObject/*!*/[]/*!*/ args, RubyCallSignature signature) {
Assert.NotNull(target, context);
Assert.NotNullItems(args);
Debug.Assert(!signature.HasScope && !signature.HasSplattedArgument);
_target = target;
_context = context;
_args = args;
_copyArgsOnWrite = true;
_signature = signature;
}
internal CallArguments(DynamicMetaObject/*!*/ context, DynamicMetaObject/*!*/[]/*!*/ args, RubyCallSignature signature) {
Assert.NotNull(context);
Assert.NotNullItems(args);
Assert.NotEmpty(args);
Debug.Assert(signature.HasScope == context.Value is RubyScope);
Debug.Assert(!signature.HasScope == context.Value is RubyContext);
_target = null;
_context = context;
_args = args;
_copyArgsOnWrite = true;
_signature = signature;
}
internal override MethodDispatcher GetDispatcher(Type/*!*/ delegateType, RubyCallSignature signature, object target, int version) {
if (HasUnsplatParameter || OptionalParamCount > 0) {
return null;
}
if (!(target is IRubyObject)) {
return null;
}
return MethodDispatcher.CreateRubyObjectDispatcher(
delegateType, GetDelegate(), MandatoryParamCount, signature.HasScope, signature.HasBlock, version
);
}
public static RubyCallAction InstanceCallAction(string/*!*/ name, RubyCallSignature callSignature) {
return RubyCallAction.Make(name, callSignature);
}
/*!*/
public static SuperCallAction Make(RubyContext/*!*/ context, RubyCallSignature signature, int lexicalScopeId)
{
ContractUtils.RequiresNotNull(context, "context");
return context.MetaBinderFactory.SuperCall(lexicalScopeId, signature);
}
// when <expr>
// generates into:
// RubyOps.IsTrue(<expr>) if the case has no value, otherise:
// RubyOps.IsTrue(Call("===", <expr>, <value>))
private static MSA.Expression /*!*/ MakeTest(AstGenerator /*!*/ gen, Expression /*!*/ expr, MSA.Expression value)
{
MSA.Expression transformedExpr = expr.TransformRead(gen);
if (expr is SplattedArgument)
{
if (value != null)
{
return(Methods.ExistsUnsplatCompare.OpCall(
Ast.Constant(CallSite <Func <CallSite, object, object, object> > .Create(
RubyCallAction.Make(gen.Context, "===", RubyCallSignature.WithImplicitSelf(2))
)),
AstUtils.LightDynamic(ExplicitTrySplatAction.Make(gen.Context), transformedExpr),
AstUtils.Box(value)
));
}
else
{
return(Methods.ExistsUnsplat.OpCall(
AstUtils.LightDynamic(ExplicitTrySplatAction.Make(gen.Context), transformedExpr)
));
}
}
else
{
if (value != null)
{
return(AstFactory.IsTrue(
CallSiteBuilder.InvokeMethod(gen.Context, "===", RubyCallSignature.WithScope(1),
gen.CurrentScopeVariable,
transformedExpr,
value
)
));
}
else
{
return(AstFactory.IsTrue(transformedExpr));
}
}
}
internal protected RubyCallAction(RubyContext context, string/*!*/ methodName, RubyCallSignature signature)
: base(context) {
Assert.NotNull(methodName);
_methodName = methodName;
_signature = signature;
}
internal static MSA.DynamicExpression/*!*/ InvokeMethod(RubyContext/*!*/ context, string/*!*/ name, RubyCallSignature signature,
MSA.Expression/*!*/ scope, MSA.Expression/*!*/ target, MSA.Expression/*!*/ arg0) {
Debug.Assert(signature.HasScope);
return Ast.Dynamic(RubyCallAction.Make(context, name, signature), typeof(object), AstUtils.Convert(scope, typeof(RubyScope)), target, arg0);
}
internal static MSA.DynamicExpression/*!*/ InvokeMethod(RubyContext/*!*/ context, string/*!*/ name, RubyCallSignature signature,
MSA.Expression/*!*/ scope, MSA.Expression/*!*/ target, MSA.Expression/*!*/[]/*!*/ args) {
Debug.Assert(signature.HasScope);
Debug.Assert(args.Length >= 2);
args[0] = Ast.Convert(args[0], typeof(RubyScope));
return Ast.Dynamic(RubyCallAction.Make(context, name, signature), typeof(object), args);
}
internal static void BuildConversion(MetaObjectBuilder /*!*/ metaBuilder, CallArguments /*!*/ args, Type /*!*/ resultType,
params ProtocolConversionAction /*!*/[] /*!*/ conversions)
{
Assert.NotNull(metaBuilder, args, conversions);
Debug.Assert(args.SimpleArgumentCount == 0 && !args.Signature.HasBlock && !args.Signature.HasSplattedArgument && !args.Signature.HasRhsArgument);
Debug.Assert(!args.Signature.HasScope);
// implicit conversions should only depend on the static type:
foreach (var conversion in conversions)
{
if (conversion.TryImplicitConversion(metaBuilder, args))
{
metaBuilder.AddObjectTypeRestriction(args.Target, args.TargetExpression);
if (!metaBuilder.Error)
{
metaBuilder.Result = ConvertResult(metaBuilder.Result, resultType);
}
return;
}
}
RubyClass targetClass = args.RubyContext.GetImmediateClassOf(args.Target);
Expression targetClassNameConstant = AstUtils.Constant(targetClass.GetNonSingletonClass().Name);
MethodResolutionResult respondToMethod, methodMissing = MethodResolutionResult.NotFound;
ProtocolConversionAction selectedConversion = null;
RubyMemberInfo conversionMethod = null;
using (targetClass.Context.ClassHierarchyLocker()) {
// check for type version:
metaBuilder.AddTargetTypeTest(args.Target, targetClass, args.TargetExpression, args.MetaContext,
ArrayUtils.Insert(Symbols.RespondTo, Symbols.MethodMissing, ArrayUtils.ConvertAll(conversions, (c) => c.ToMethodName))
);
// we can optimize if Kernel#respond_to? method is not overridden:
respondToMethod = targetClass.ResolveMethodForSiteNoLock(Symbols.RespondTo, VisibilityContext.AllVisible);
if (respondToMethod.Found && respondToMethod.Info.DeclaringModule == targetClass.Context.KernelModule && respondToMethod.Info is RubyLibraryMethodInfo) // TODO: better override detection
{
respondToMethod = MethodResolutionResult.NotFound;
// get the first applicable conversion:
foreach (var conversion in conversions)
{
selectedConversion = conversion;
conversionMethod = targetClass.ResolveMethodForSiteNoLock(conversion.ToMethodName, VisibilityContext.AllVisible).Info;
if (conversionMethod != null)
{
break;
}
else
{
// find method_missing - we need to add "to_xxx" methods to the missing methods table:
if (!methodMissing.Found)
{
methodMissing = targetClass.ResolveMethodNoLock(Symbols.MethodMissing, VisibilityContext.AllVisible);
}
methodMissing.InvalidateSitesOnMissingMethodAddition(conversion.ToMethodName, targetClass.Context);
}
}
}
}
if (!respondToMethod.Found)
{
if (conversionMethod == null)
{
// error:
selectedConversion.SetError(metaBuilder, args, targetClassNameConstant, resultType);
return;
}
else
{
// invoke target.to_xxx() and validate it; returns an instance of TTargetType:
conversionMethod.BuildCall(metaBuilder, args, selectedConversion.ToMethodName);
if (!metaBuilder.Error)
{
metaBuilder.Result = ConvertResult(
selectedConversion.MakeValidatorCall(args, targetClassNameConstant, metaBuilder.Result),
resultType
);
}
return;
}
}
// slow path: invoke respond_to?, to_xxx and result validation:
for (int i = conversions.Length - 1; i >= 0; i--)
{
string toMethodName = conversions[i].ToMethodName;
var conversionCallSite = AstUtils.LightDynamic(
RubyCallAction.Make(args.RubyContext, toMethodName, RubyCallSignature.WithImplicitSelf(0)),
args.TargetExpression
);
metaBuilder.Result = Ast.Condition(
// If
// respond_to?()
Methods.IsTrue.OpCall(
AstUtils.LightDynamic(
RubyCallAction.Make(args.RubyContext, Symbols.RespondTo, RubyCallSignature.WithImplicitSelf(1)),
args.TargetExpression,
Ast.Constant(args.RubyContext.CreateSymbol(toMethodName, RubyEncoding.Binary))
)
),
// Then
// to_xxx():
ConvertResult(
conversions[i].MakeValidatorCall(args, targetClassNameConstant, conversionCallSite),
resultType
),
// Else
(i < conversions.Length - 1) ? metaBuilder.Result :
conversions[i].MakeErrorExpression(args, targetClassNameConstant, resultType)
);
}
}
internal virtual MemberDispatcher GetDispatcher(Type/*!*/ delegateType, RubyCallSignature signature, object target, int version)
{
return null;
}
/// <summary>
/// This is called by the IronRuby runtime to set the backtrace for an exception that has being raised.
/// Note that the backtrace may be set directly by user code as well. However, that uses a different code path.
/// </summary>
private void DynamicSetBacktrace(RubyContext /*!*/ context, RubyArray backtrace)
{
if (_setBacktraceCallSite == null)
{
Interlocked.CompareExchange(ref _setBacktraceCallSite, CallSite <Func <CallSite, RubyContext, Exception, RubyArray, object> > .
Create(RubyCallAction.MakeShared("set_backtrace", RubyCallSignature.WithImplicitSelf(1))), null);
}
_setBacktraceCallSite.Target(_setBacktraceCallSite, context, _exception, backtrace);
}
internal override MSA.Expression /*!*/ TransformRead(AstGenerator /*!*/ gen)
{
Assert.NotNull(gen);
MSA.Expression transformedBlock = _block.Transform(gen);
MSA.Expression blockArgVariable = gen.CurrentScope.DefineHiddenVariable("#forloop-block", typeof(Proc));
MSA.Expression result = CallSiteBuilder.InvokeMethod(gen.Context, "each", RubyCallSignature.WithScopeAndBlock(0),
gen.CurrentScopeVariable,
_list.TransformRead(gen),
blockArgVariable
);
return(gen.DebugMark(MethodCall.MakeCallWithBlockRetryable(gen, result, blockArgVariable, transformedBlock, true),
"#RB: method call with a block ('for-loop')"));
}
public static SuperCallAction MakeShared(RubyCallSignature signature, int lexicalScopeId)
{
return RubyMetaBinderFactory.Shared.SuperCall(lexicalScopeId, signature);
}
internal static MSA.Expression /*!*/ InvokeMethod(RubyContext /*!*/ context, string /*!*/ name, RubyCallSignature signature,
MSA.Expression /*!*/ scope, MSA.Expression /*!*/ target, MSA.Expression /*!*/ arg0, MSA.Expression /*!*/ arg1)
{
Debug.Assert(signature.HasScope);
return(AstUtils.LightDynamic(RubyCallAction.Make(context, name, signature), AstUtils.Convert(scope, typeof(RubyScope)), target, arg0, arg1));
}
internal override MemberDispatcher GetDispatcher(Type/*!*/ delegateType, RubyCallSignature signature, object target, int version) {
if (Parameters.Unsplat != null || Parameters.Optional.Length > 0) {
return null;
}
if (!(target is IRubyObject)) {
return null;
}
return MethodDispatcher.CreateRubyObjectDispatcher(
delegateType, GetDelegate(), Parameters.Mandatory.Length, signature.HasScope, signature.HasBlock, version
);
}
// friend: RubyContext
internal EqualityComparer(RubyContext /*!*/ context)
: this(
CallSite <Func <CallSite, object, object> > .Create(RubyCallAction.Make(context, "hash", RubyCallSignature.WithImplicitSelf(0))),
CallSite <Func <CallSite, object, object, object> > .Create(RubyCallAction.Make(context, "eql?", RubyCallSignature.WithImplicitSelf(1)))
)
{
}
internal override MemberDispatcher GetDispatcher(Type/*!*/ delegateType, RubyCallSignature signature, object target, int version)
{
if (!(target is IRubyObject)) {
return null;
}
if (signature.ArgumentCount + (signature.HasRhsArgument ? 1 : 0) != 1 || signature.HasBlock) {
return null;
}
return AttributeDispatcher.CreateRubyObjectWriterDispatcher(delegateType, InstanceVariableName, version);
}
/// <summary>
/// Creates a runtime-bound call site binder.
/// </summary>
public static RubyCallAction/*!*/ Make(RubyContext/*!*/ context, string/*!*/ methodName, RubyCallSignature signature) {
ContractUtils.RequiresNotNull(context, "context");
ContractUtils.RequiresNotNull(methodName, "methodName");
return context.MetaBinderFactory.Call(methodName, signature);
}
// Ruby binders:
internal CallArguments(RubyContext context, DynamicMetaObject/*!*/ scopeOrContextOrTarget, DynamicMetaObject/*!*/[]/*!*/ args, RubyCallSignature signature) {
Assert.NotNull(scopeOrContextOrTarget);
Assert.NotNullItems(args);
Debug.Assert(signature.HasScope == scopeOrContextOrTarget.Value is RubyScope);
Debug.Assert((context == null && !signature.HasScope) == scopeOrContextOrTarget.Value is RubyContext);
if (context != null) {
// bound site:
_context = new DynamicMetaObject(AstUtils.Constant(context), BindingRestrictions.Empty, context);
if (signature.HasScope) {
_scope = scopeOrContextOrTarget;
_hasScopeOrContextArg = true;
} else {
_target = scopeOrContextOrTarget;
}
} else if (signature.HasScope) {
// unbound site with scope:
_context = new DynamicMetaObject(
Methods.GetContextFromScope.OpCall(scopeOrContextOrTarget.Expression), BindingRestrictions.Empty,
((RubyScope)scopeOrContextOrTarget.Value).RubyContext
);
_scope = scopeOrContextOrTarget;
_hasScopeOrContextArg = true;
_target = null;
} else {
// unbound site with context:
_context = scopeOrContextOrTarget;
_hasScopeOrContextArg = true;
_target = null;
}
Debug.Assert(_target != null || args.Length > 0);
_args = args;
_copyArgsOnWrite = true;
_signature = signature;
Debug.Assert(!signature.HasSplattedArgument || GetSplattedArgument() != null);
}
public CallSite <TCallSiteFunc> /*!*/ GetCallSite(string /*!*/ methodName, RubyCallSignature signature)
{
return(RubyUtils.GetCallSite(ref Site, Context, methodName, signature));
}
public void InsertSimple(int index, DynamicMetaObject/*!*/ arg) {
index = GetSimpleArgumentsIndex(index);
_args = ArrayUtils.InsertAt(_args, index, arg);
_signature = new RubyCallSignature(_signature.ArgumentCount + 1, _signature.Flags);
}
internal override MethodDispatcher GetDispatcher(Type/*!*/ delegateType, RubyCallSignature signature, object target, int version) {
if (!(target is IRubyObject)) {
return null;
}
int arity;
if (!IsEmpty || (arity = GetArity()) != 1) {
return null;
}
return MethodDispatcher.CreateRubyObjectDispatcher(
delegateType, new Func<object, Proc, object, object>(EmptyRubyMethodStub1), arity, signature.HasScope, signature.HasBlock, version
);
}
internal SuperCallAction(RubyContext context, RubyCallSignature signature, int lexicalScopeId)
: base(context) {
_signature = signature;
_lexicalScopeId = lexicalScopeId;
}
public void OverloadResolution_Numeric1()
{
var metaBuilder = new MetaObjectBuilder(null);
#if FEATURE_REFEMIT
Context.ObjectClass.SetConstant("X", Context.GetClass(typeof(Overloads1.X)));
object c = Engine.Execute(@"class C < X; new; end");
#else
object c = new Overloads1.X();
#endif
var sym = Context.CreateAsciiSymbol("x");
var ms = MutableString.CreateAscii("x");
var cases = new[] {
// F
new { Args = new[] { MO(1) }, OverloadPrefix = "F", Result = "F1" },
new { Args = new[] { MO((byte)1) }, OverloadPrefix = "F", Result = "F1" },
new { Args = new[] { MO(1L) }, OverloadPrefix = "F", Result = "F2" },
new { Args = new[] { MO(1.2F) }, OverloadPrefix = "F", Result = "F3" },
// G
new { Args = new[] { MO(1) }, OverloadPrefix = "G", Result = "G1" },
new { Args = new[] { MO((byte)1) }, OverloadPrefix = "G", Result = "G1" },
new { Args = new[] { MO(1L) }, OverloadPrefix = "G", Result = "G2" },
new { Args = new[] { MO(1.2F) }, OverloadPrefix = "G", Result = "G3" },
new { Args = new[] { MO(c) }, OverloadPrefix = "G", Result = "G1" },
// I
new { Args = new[] { MO(c) }, OverloadPrefix = "I", Result = "I3" },
// J
new { Args = new[] { MO(1) }, OverloadPrefix = "J", Result = "J1" },
new { Args = new[] { MO((BigInteger)1000) }, OverloadPrefix = "J", Result = "J2" },
new { Args = new[] { MO((byte)12) }, OverloadPrefix = "J", Result = "J1" },
new { Args = new[] { MO(c) }, OverloadPrefix = "J", Result = "J3" },
new { Args = new[] { MO(1.0) }, OverloadPrefix = "J", Result = "J3" },
// K
new { Args = new[] { MO(1) }, OverloadPrefix = "K", Result = "K2" },
new { Args = new[] { MO(c) }, OverloadPrefix = "K", Result = "K1" },
new { Args = new[] { MO("x") }, OverloadPrefix = "K", Result = "K1" },
// L
new { Args = new[] { MO(sym), MO(sym) }, OverloadPrefix = "L", Result = "L1" },
new { Args = new[] { MO("x"), MO(sym) }, OverloadPrefix = "L", Result = "L2" },
new { Args = new[] { MO(ms), MO(sym) }, OverloadPrefix = "L", Result = "L3" },
new { Args = new[] { MO(null), MO(sym) }, OverloadPrefix = "L", Result = "L3" },
new { Args = new[] { MO(c), MO(sym) }, OverloadPrefix = "L", Result = "L3" },
// M
new { Args = new[] { MO(1) }, OverloadPrefix = "M", Result = "M1" },
new { Args = new[] { MO(Overloads1.E.A) }, OverloadPrefix = "M", Result = "M2" },
// N
new { Args = new[] { MO(MutableString.CreateAscii("x")) }, OverloadPrefix = "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 = GetInstanceMethodsStartingWith(typeof(Overloads1), cases[i].OverloadPrefix);
var result = resolver.ResolveOverload(i.ToString(), overloads, NarrowingLevel.None, NarrowingLevel.All);
Assert(result.Success && result.Overload.Name == cases[i].Result);
}
}
public static RubyCallAction/*!*/ MakeShared(string/*!*/ methodName, RubyCallSignature signature) {
// TODO: reduce usage of these sites to minimum
return RubyMetaBinderFactory.Shared.Call(methodName, signature);
}
public static MSA.DynamicExpression /*!*/ MakeCallAction(string /*!*/ name, ActionBinder /*!*/ binder, RubyCallSignature signature,
params MSA.Expression[] /*!*/ args)
{
RubyCallAction call = RubyCallAction.Make(name, signature);
switch (args.Length)
{
case 0: return(Ast.Dynamic(call, typeof(object), AstFactory.EmptyExpressions));
case 1: return(Ast.Dynamic(call, typeof(object), args[0]));
case 2: return(Ast.Dynamic(call, typeof(object), args[0], args[1]));
case 3: return(Ast.Dynamic(call, typeof(object), args[0], args[1], args[2]));
case 4: return(Ast.Dynamic(call, typeof(object), args[0], args[1], args[2], args[3]));
default:
return(Ast.Dynamic(
call,
typeof(object),
new ReadOnlyCollection <MSA.Expression>(args)
));
}
}
