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

 protected RubyAttributeAccessorInfo(RubyMemberFlags flags, RubyModule/*!*/ declaringModule, string/*!*/ variableName)
     : base(flags, declaringModule)
 {
     Assert.NotEmpty(variableName);
     Debug.Assert(variableName.StartsWith("@"));
     _instanceVariableName = variableName;
 }

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

 /// <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 RubyEventInfo(EventTracker/*!*/ tracker, RubyMemberFlags flags, RubyModule/*!*/ declaringModule, bool isDetached)
     : base(flags, declaringModule)
 {
     Assert.NotNull(tracker, declaringModule);
     _tracker = tracker;
     _isDetached = isDetached;
 }

        // method:
        internal RubyMethodInfo(RubyMethodBody/*!*/ body, RubyScope/*!*/ declaringScope, RubyModule/*!*/ declaringModule, RubyMemberFlags flags)
            : base(flags, declaringModule) {
            Assert.NotNull(body, declaringModule);

            _body = body;
            _declaringScope = declaringScope;
        }

        internal RubyMemberInfo(RubyMemberFlags flags, RubyModule/*!*/ declaringModule)
        {
            Assert.NotNull(declaringModule);
            Debug.Assert(flags != RubyMemberFlags.Invalid);

            _flags = flags;
            _declaringModule = declaringModule;
        }

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

 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 RubyMethodGroupInfo(this, 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 RubyMethodInfo(_ast, _method, module, _definitionName, _mandatoryParamCount, _optionalParamCount, 
         _hasUnsplatParameter, flags
     );
 }

 internal RubyScopeMethodMissingInfo(RubyMemberFlags flags, RubyModule/*!*/ declaringModule)
     : base(flags, declaringModule) {
 }

 protected internal override RubyMemberInfo Copy(RubyMemberFlags flags, RubyModule/*!*/ module)
 {
     return new SuperForwarderInfo(flags, module, _superName);
 }

 public SuperForwarderInfo(RubyMemberFlags flags, RubyModule/*!*/ declaringModule, string/*!*/ superName)
     : base(flags, declaringModule)
 {
     _superName = superName;
 }

 // copy ctor
 private RubyMethodGroupInfo(RubyMethodGroupInfo/*!*/ info, RubyMemberFlags flags, RubyModule/*!*/ module)
     : this(info, flags, module, info._methodBases) {
 }