public void AddEvent (Event e)
{
if (!AddMember (e))
return;
if (e is EventProperty) {
if (!AddMember (e.Add))
return;
if (!AddMember (e.Remove))
return;
}
if (events == null)
events = new MemberCoreArrayList ();
events.Add (e);
}
public void AddOperator (Operator op)
{
if (!AddMember (op))
return;
if (operators == null)
operators = new OperatorArrayList (this);
operators.Add (op);
}
public bool AddField (FieldBase field)
{
if (!AddMember (field))
return false;
if (fields == null)
fields = new MemberCoreArrayList ();
fields.Add (field);
if ((field.ModFlags & Modifiers.STATIC) != 0)
return true;
if (first_nonstatic_field == null) {
first_nonstatic_field = field;
return true;
}
if (Kind == Kind.Struct && first_nonstatic_field.Parent != field.Parent) {
Report.SymbolRelatedToPreviousError (first_nonstatic_field.Parent);
Report.Warning (282, 3, field.Location,
"struct instance field `{0}' found in different declaration from instance field `{1}'",
field.GetSignatureForError (), first_nonstatic_field.GetSignatureForError ());
}
return true;
}
public void AddProperty (Property prop)
{
if (!AddMember (prop) ||
!AddMember (prop.Get) || !AddMember (prop.Set))
return;
if (properties == null)
properties = new MemberCoreArrayList ();
if (prop.MemberName.Left != null)
AddMemberToList (prop, properties, true);
else
AddMemberToList (prop, properties, false);
}
public void AddMethod (MethodOrOperator method)
{
if (!AddToContainer (method, method.MemberName.Basename))
return;
if (methods == null)
methods = new MemberCoreArrayList ();
if (method.MemberName.Left != null)
AddMemberToList (method, methods, true);
else
AddMemberToList (method, methods, false);
}
public void AddConstructor (Constructor c)
{
bool is_static = (c.ModFlags & Modifiers.STATIC) != 0;
if (!AddToContainer (c, is_static ?
ConstructorBuilder.ConstructorName : ConstructorBuilder.TypeConstructorName))
return;
if (is_static && c.Parameters.IsEmpty){
if (default_static_constructor != null) {
Report.SymbolRelatedToPreviousError (default_static_constructor);
Report.Error (111, c.Location,
"A member `{0}' is already defined. Rename this member or use different parameter types",
c.GetSignatureForError ());
return;
}
default_static_constructor = c;
} else {
if (c.Parameters.IsEmpty)
default_constructor = c;
if (instance_constructors == null)
instance_constructors = new MemberCoreArrayList ();
instance_constructors.Add (c);
}
}
public void AddDelegate (Delegate d)
{
if (!AddMemberType (d))
return;
if (delegates == null)
delegates = new MemberCoreArrayList ();
delegates.Add (d);
}
private void AddMemberToList (MemberCore mc, ArrayList alist, bool isexplicit)
{
if (ordered_explicit_member_list == null) {
ordered_explicit_member_list = new MemberCoreArrayList ();
ordered_member_list = new MemberCoreArrayList ();
}
if (isexplicit) {
if (Kind == Kind.Interface) {
Report.Error (541, mc.Location,
"`{0}': explicit interface declaration can only be declared in a class or struct",
mc.GetSignatureForError ());
}
ordered_explicit_member_list.Add (mc);
alist.Insert (0, mc);
} else {
ordered_member_list.Add (mc);
alist.Add (mc);
}
}
public void AddConstant (Const constant)
{
if (!AddMember (constant))
return;
if (constants == null)
constants = new MemberCoreArrayList ();
constants.Add (constant);
}
protected override void DefineContainerMembers (MemberCoreArrayList list)
{
if (list == null)
return;
if (!IsStatic) {
base.DefineContainerMembers (list);
return;
}
foreach (MemberCore m in list) {
if (m is Operator) {
Report.Error (715, m.Location, "`{0}': Static classes cannot contain user-defined operators", m.GetSignatureForError ());
continue;
}
if (m is Destructor) {
Report.Error (711, m.Location, "`{0}': Static classes cannot contain destructor", GetSignatureForError ());
continue;
}
if (m is Indexer) {
Report.Error (720, m.Location, "`{0}': cannot declare indexers in a static class", m.GetSignatureForError ());
continue;
}
if ((m.ModFlags & Modifiers.STATIC) != 0 || m is Enum || m is Delegate)
continue;
if (m is Constructor) {
Report.Error (710, m.Location, "`{0}': Static classes cannot have instance constructors", GetSignatureForError ());
continue;
}
Method method = m as Method;
if (method != null && method.Parameters.HasExtensionMethodType) {
Report.Error (1105, m.Location, "`{0}': Extension methods must be declared static", m.GetSignatureForError ());
continue;
}
Report.Error (708, m.Location, "`{0}': cannot declare instance members in a static class", m.GetSignatureForError ());
}
base.DefineContainerMembers (list);
}
public override void CloseType ()
{
if ((caching_flags & Flags.CloseTypeCreated) != 0)
return;
try {
caching_flags |= Flags.CloseTypeCreated;
TypeBuilder.CreateType ();
} catch (TypeLoadException){
//
// This is fine, the code still created the type
//
// Report.Warning (-20, "Exception while creating class: " + TypeBuilder.Name);
// Console.WriteLine (e.Message);
} catch (Exception e) {
throw new InternalErrorException (this, e);
}
if (Types != null){
foreach (TypeContainer tc in Types)
if (tc.Kind == Kind.Struct)
tc.CloseType ();
foreach (TypeContainer tc in Types)
if (tc.Kind != Kind.Struct)
tc.CloseType ();
}
if (Delegates != null)
foreach (Delegate d in Delegates)
d.CloseType ();
if (compiler_generated != null)
foreach (CompilerGeneratedClass c in compiler_generated)
c.CloseType ();
PartialContainer = null;
types = null;
// properties = null;
delegates = null;
fields = null;
initialized_fields = null;
initialized_static_fields = null;
constants = null;
ordered_explicit_member_list = null;
ordered_member_list = null;
methods = null;
events = null;
indexers = null;
operators = null;
compiler_generated = null;
default_constructor = null;
default_static_constructor = null;
type_bases = null;
OptAttributes = null;
ifaces = null;
base_cache = null;
member_cache = null;
}
void CheckMemberUsage (MemberCoreArrayList al, string member_type)
{
if (al == null)
return;
foreach (MemberCore mc in al) {
if ((mc.ModFlags & Modifiers.Accessibility) != Modifiers.PRIVATE)
continue;
if (!mc.IsUsed && (mc.caching_flags & Flags.Excluded) == 0) {
Report.Warning (169, 3, mc.Location, "The private {0} `{1}' is never used", member_type, mc.GetSignatureForError ());
}
}
}
protected virtual void DefineContainerMembers (MemberCoreArrayList mcal)
{
if (mcal != null)
mcal.DefineContainerMembers ();
}