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