protected RubyAttributeAccessorInfo(RubyMemberFlags flags, RubyModule/*!*/ declaringModule, string/*!*/ variableName)
: base(flags, declaringModule)
{
Assert.NotEmpty(variableName);
Debug.Assert(variableName.StartsWith("@"));
_instanceVariableName = variableName;
}
/// <summary>
/// Creates a Ruby method implemented by a method group of CLR methods.
/// </summary>
internal RubyLibraryMethodInfo(LibraryOverload/*!*/[]/*!*/ overloads, RubyMemberFlags flags, RubyModule/*!*/ declaringModule)
: base(null, flags, declaringModule)
{
Assert.NotNullItems(overloads);
Assert.NotEmpty(overloads);
_overloads = overloads;
}
public RubyFieldInfo(FieldInfo/*!*/ fieldInfo, RubyMemberFlags flags, RubyModule/*!*/ declaringModule, bool isSetter, bool isDetached)
: base(flags, declaringModule) {
Assert.NotNull(fieldInfo, declaringModule);
_fieldInfo = fieldInfo;
_isSetter = isSetter;
_isDetached = isDetached;
}
// copy ctor
private RubyMethodGroupInfo(RubyMethodGroupInfo/*!*/ info, RubyMemberFlags flags, RubyModule/*!*/ module)
: base(info.MethodBases, flags, module) {
_isStatic = info._isStatic;
_hasVirtuals = info._hasVirtuals;
_staticDispatchMethods = info._staticDispatchMethods;
// Note: overloadOwners and maxCachedOverloadLevel are cleared whenever the group is copied.
}
internal RubyLambdaMethodInfo(Proc/*!*/ block, string/*!*/ definitionName, RubyMemberFlags flags, RubyModule/*!*/ declaringModule)
: base(flags, declaringModule) {
Assert.NotNull(block, definitionName, declaringModule);
_lambda = block.ToLambda(this);
_definitionName = definitionName;
_id = Interlocked.Increment(ref _Id);
}
protected RubyMethodGroupBase(OverloadInfo/*!*/[] methods, RubyMemberFlags flags, RubyModule/*!*/ declaringModule)
: base(flags, declaringModule)
{
if (methods != null) {
SetMethodBasesNoLock(methods);
}
}
public RubyEventInfo(EventTracker/*!*/ tracker, RubyMemberFlags flags, RubyModule/*!*/ declaringModule, bool isDetached)
: base(flags, declaringModule)
{
Assert.NotNull(tracker, declaringModule);
_tracker = tracker;
_isDetached = isDetached;
}
/// <summary>
/// Creates a Ruby method implemented by a method group of CLR methods.
/// </summary>
internal RubyLibraryMethodInfo(LibraryOverload /*!*/[] /*!*/ overloads, RubyMemberFlags flags, RubyModule /*!*/ declaringModule)
: base(null, flags, declaringModule)
{
Assert.NotNullItems(overloads);
Assert.NotEmpty(overloads);
_overloads = overloads;
}
// method:
internal RubyMethodInfo(RubyMethodBody/*!*/ body, RubyScope/*!*/ declaringScope, RubyModule/*!*/ declaringModule, RubyMemberFlags flags)
: base(flags, declaringModule) {
Assert.NotNull(body, declaringModule);
_body = body;
_declaringScope = declaringScope;
}
public RubyFieldInfo(FieldInfo /*!*/ fieldInfo, RubyMemberFlags flags, RubyModule /*!*/ declaringModule, bool isSetter)
: base(flags, declaringModule)
{
Assert.NotNull(fieldInfo, declaringModule);
_fieldInfo = fieldInfo;
_isSetter = isSetter;
}
public RubyEventInfo(EventTracker /*!*/ tracker, RubyMemberFlags flags, RubyModule /*!*/ declaringModule, bool isDetached)
: base(flags, declaringModule)
{
Assert.NotNull(tracker, declaringModule);
_tracker = tracker;
_isDetached = isDetached;
}
protected RubyAttributeAccessorInfo(RubyMemberFlags flags, RubyModule /*!*/ declaringModule, string /*!*/ variableName)
: base(flags, declaringModule)
{
Assert.NotEmpty(variableName);
Debug.Assert(variableName.StartsWith("@"));
_instanceVariableName = variableName;
}
internal RubyMemberInfo(RubyMemberFlags flags, RubyModule/*!*/ declaringModule)
{
Assert.NotNull(declaringModule);
Debug.Assert(flags != RubyMemberFlags.Invalid);
_flags = flags;
_declaringModule = declaringModule;
}
// copy ctor
private RubyMethodGroupInfo(RubyMethodGroupInfo /*!*/ info, RubyMemberFlags flags, RubyModule /*!*/ module)
: base(flags, module)
{
_methodBases = info._methodBases;
_overloads = info._overloads;
_isRubyMethod = info._isRubyMethod;
_isClrStatic = info._isClrStatic;
}
internal RubyMemberInfo(RubyMemberFlags flags, RubyModule /*!*/ declaringModule)
{
Assert.NotNull(declaringModule);
Debug.Assert(flags != RubyMemberFlags.Invalid);
_flags = flags;
_declaringModule = declaringModule;
}
internal RubyLambdaMethodInfo(Proc /*!*/ block, string /*!*/ definitionName, RubyMemberFlags flags, RubyModule /*!*/ declaringModule)
: base(flags, declaringModule)
{
Assert.NotNull(block, definitionName, declaringModule);
_lambda = block.ToLambda(this);
_definitionName = definitionName;
_id = Interlocked.Increment(ref _Id);
}
protected RubyMethodGroupBase(OverloadInfo /*!*/[] methods, RubyMemberFlags flags, RubyModule /*!*/ declaringModule)
: base(flags, declaringModule)
{
if (methods != null)
{
SetMethodBasesNoLock(methods);
}
}
// copy ctor
private RubyMethodGroupInfo(RubyMethodGroupInfo/*!*/ info, RubyMemberFlags flags, RubyModule/*!*/ module)
: base(info.MethodBases, flags, module) {
_isStatic = info._isStatic;
_hasVirtuals = info._hasVirtuals;
_staticDispatchMethods = info._staticDispatchMethods;
// Note: overloadOwners and maxCachedOverloadLevel are cleared whenever the group is copied
// The resulting group captures an immutable set of underlying CLR members.
}
/// <summary>
/// Creates a Ruby method implemented by a method group of CLR methods.
/// </summary>
internal RubyMethodGroupInfo(Delegate/*!*/[]/*!*/ overloads, RubyMemberFlags flags,
RubyModule/*!*/ declaringModule)
: base(flags, declaringModule) {
Assert.NotNullItems(overloads);
Assert.NotNull(declaringModule);
_overloads = overloads;
_isClrStatic = false;
_isRubyMethod = true;
}
/// <summary>
/// Creates a Ruby method implemented by a method group of CLR methods.
/// </summary>
internal RubyMethodGroupInfo(Delegate /*!*/[] /*!*/ overloads, RubyMemberFlags flags,
RubyModule /*!*/ declaringModule)
: base(flags, declaringModule)
{
Assert.NotNullItems(overloads);
Assert.NotNull(declaringModule);
_overloads = overloads;
_isClrStatic = false;
_isRubyMethod = true;
}
// method:
internal RubyMethodInfo(object/*!*/ ast, Delegate/*!*/ method, RubyModule/*!*/ declaringModule,
string/*!*/ definitionName, int mandatory, int optional, bool hasUnsplatParameter, RubyMemberFlags flags)
: base(flags, declaringModule) {
Assert.NotNull(ast, method, declaringModule, definitionName);
_ast = ast;
_method = method;
_mandatoryParamCount = mandatory;
_optionalParamCount = optional;
_hasUnsplatParameter = hasUnsplatParameter;
_definitionName = definitionName;
}
public RubyAttributeWriterInfo(RubyMemberFlags flags, RubyModule /*!*/ declaringModule, string /*!*/ name)
: base(flags, declaringModule, name)
{
}
protected internal override RubyMemberInfo /*!*/ Copy(RubyMemberFlags flags, RubyModule /*!*/ module)
{
return(new RubyScopeMethodMissingInfo(flags, module));
}
// method:
internal RubyMethodInfo(RubyMethodBody /*!*/ body, RubyScope /*!*/ declaringScope, RubyModule /*!*/ declaringModule, RubyMemberFlags flags)
: base(flags, declaringModule)
{
Assert.NotNull(body, declaringModule);
_body = body;
_declaringScope = declaringScope;
}
internal protected override RubyMemberInfo Copy(RubyMemberFlags flags, RubyModule /*!*/ module)
{
return(new SuperForwarderInfo(flags, module, _superName));
}
protected internal override RubyMemberInfo/*!*/ Copy(RubyMemberFlags flags, RubyModule/*!*/ module) {
return new RubyEventInfo(_tracker, flags, module, true);
}
protected internal override RubyMemberInfo/*!*/ Copy(RubyMemberFlags flags, RubyModule/*!*/ module) {
return new RubyFieldInfo(_fieldInfo, flags, module, _isSetter, true);
}
protected internal override RubyMemberInfo/*!*/ Copy(RubyMemberFlags flags, RubyModule/*!*/ module) {
return new RubyMethodGroupInfo(this, flags, module);
}
protected internal override RubyMemberInfo /*!*/ Copy(RubyMemberFlags flags, RubyModule /*!*/ module)
{
return(new RubyMethodInfo(_body, _declaringScope, module, flags));
}
protected internal override RubyMemberInfo /*!*/ Copy(RubyMemberFlags flags, RubyModule /*!*/ module)
{
return(new RubyEventInfo(_tracker, flags, module, true));
}
protected internal override RubyMemberInfo/*!*/ Copy(RubyMemberFlags flags, RubyModule/*!*/ module) {
return new RubyMethodInfo(_ast, _method, module, _definitionName, _mandatoryParamCount, _optionalParamCount,
_hasUnsplatParameter, flags
);
}
public RubyAttributeWriterInfo(RubyMemberFlags flags, RubyModule/*!*/ declaringModule, string/*!*/ name)
: base(flags, declaringModule, name) {
}
protected internal override RubyMemberInfo /*!*/ Copy(RubyMemberFlags flags, RubyModule /*!*/ module)
{
return(new RubyMethodInfo(_ast, _method, module, _definitionName, _mandatoryParamCount, _optionalParamCount,
_hasUnsplatParameter, flags
));
}
public RubyAttributeReaderInfo(RubyMemberFlags flags, RubyModule /*!*/ declaringModule, string /*!*/ variableName)
: base(flags, declaringModule, variableName)
{
}
internal RubyScopeMethodMissingInfo(RubyMemberFlags flags, RubyModule /*!*/ declaringModule)
: base(flags, declaringModule)
{
}
// undefined, hidden, interop method:
private RubyMemberInfo(RubyMemberFlags flags)
{
_flags = flags;
}
protected internal override RubyMemberInfo /*!*/ Copy(RubyMemberFlags flags, RubyModule /*!*/ module)
{
return(new RubyAttributeReaderInfo(flags, module, InstanceVariableName));
}
public RubyCustomMethodInfo(RuleGenerator/*!*/ ruleGenerator, RubyMemberFlags flags, RubyModule/*!*/ declaringModule)
: base(flags, declaringModule)
{
Assert.NotNull(ruleGenerator, declaringModule);
_ruleGenerator = ruleGenerator;
}
public RubyAttributeReaderInfo(RubyMemberFlags flags, RubyModule/*!*/ declaringModule, string/*!*/ variableName)
: base(flags, declaringModule, variableName) {
}
/*!*/
protected internal override RubyMemberInfo Copy(RubyMemberFlags flags, RubyModule/*!*/ module)
{
return new RubyCustomMethodInfo(_ruleGenerator, flags, module);
}
protected internal override RubyMemberInfo/*!*/ Copy(RubyMemberFlags flags, RubyModule/*!*/ module) {
return new RubyAttributeWriterInfo(flags, module, InstanceVariableName);
}
public RubyCustomMethodInfo(RuleGenerator /*!*/ ruleGenerator, RubyMemberFlags flags, RubyModule /*!*/ declaringModule)
: base(flags, declaringModule)
{
Assert.NotNull(ruleGenerator, declaringModule);
_ruleGenerator = ruleGenerator;
}
protected internal override RubyMemberInfo /*!*/ Copy(RubyMemberFlags flags, RubyModule /*!*/ module)
{
return(new RubyMethodGroupInfo(this, flags, module));
}
protected internal override RubyMemberInfo /*!*/ Copy(RubyMemberFlags flags, RubyModule /*!*/ module)
{
return(new RubyCustomMethodInfo(_ruleGenerator, flags, module));
}
// copy ctor
private RubyMethodGroupInfo(RubyMethodGroupInfo/*!*/ info, RubyMemberFlags flags, RubyModule/*!*/ module)
: base(flags, module) {
_methodBases = info._methodBases;
_overloads = info._overloads;
_isRubyMethod = info._isRubyMethod;
_isClrStatic = info._isClrStatic;
}
// copy ctor
private RubyMethodGroupInfo(RubyMethodGroupInfo/*!*/ info, RubyMemberFlags flags, RubyModule/*!*/ module)
: this(info, flags, module, info._methodBases) {
}
internal RubyScopeMethodMissingInfo(RubyMemberFlags flags, RubyModule/*!*/ declaringModule)
: base(flags, declaringModule) {
}
// undefined, hidden, interop method:
private RubyMemberInfo(RubyMemberFlags flags)
{
_flags = flags;
}
protected internal override RubyMemberInfo /*!*/ Copy(RubyMemberFlags flags, RubyModule /*!*/ module)
{
return(new RubyLambdaMethodInfo(_lambda, _definitionName, flags, module));
}
protected internal override RubyMemberInfo Copy(RubyMemberFlags flags, RubyModule/*!*/ module)
{
return new SuperForwarderInfo(flags, module, _superName);
}
// method:
internal RubyMethodInfo(object /*!*/ ast, Delegate /*!*/ method, RubyModule /*!*/ declaringModule,
string /*!*/ definitionName, int mandatory, int optional, bool hasUnsplatParameter, RubyMemberFlags flags)
: base(flags, declaringModule)
{
Assert.NotNull(ast, method, declaringModule, definitionName);
_ast = ast;
_method = method;
_mandatoryParamCount = mandatory;
_optionalParamCount = optional;
_hasUnsplatParameter = hasUnsplatParameter;
_definitionName = definitionName;
}
protected internal override RubyMemberInfo /*!*/ Copy(RubyMemberFlags flags, RubyModule /*!*/ module)
{
return(new RubyLibraryMethodInfo(_overloads, flags, module));
}
protected internal override RubyMemberInfo /*!*/ Copy(RubyMemberFlags flags, RubyModule /*!*/ module)
{
return(new RubyFieldInfo(_fieldInfo, flags, module, _isSetter, true));
}
// copy ctor
private RubyMethodGroupInfo(RubyMethodGroupInfo /*!*/ info, RubyMemberFlags flags, RubyModule /*!*/ module)
: base(info.MethodBases, flags, module)
{
_isStatic = info._isStatic;
}
protected internal override RubyMemberInfo/*!*/ Copy(RubyMemberFlags flags, RubyModule/*!*/ module) {
return new RubyLambdaMethodInfo(_lambda, _definitionName, flags, module);
}
public SuperForwarderInfo(RubyMemberFlags flags, RubyModule /*!*/ declaringModule, string /*!*/ superName)
: base(flags, declaringModule)
{
_superName = superName;
}
protected internal override RubyMemberInfo/*!*/ Copy(RubyMemberFlags flags, RubyModule/*!*/ module) {
return new RubyMethodInfo(_body, _declaringScope, module, flags);
}
internal protected virtual RubyMemberInfo Copy(RubyMemberFlags flags, RubyModule /*!*/ module)
{
throw Assert.Unreachable;
}
protected internal override RubyMemberInfo/*!*/ Copy(RubyMemberFlags flags, RubyModule/*!*/ module) {
return new RubyScopeMethodMissingInfo(flags, module);
}
public SuperForwarderInfo(RubyMemberFlags flags, RubyModule/*!*/ declaringModule, string/*!*/ superName)
: base(flags, declaringModule)
{
_superName = superName;
}
