used as a fencepost to test against the anonymous-methodness of an
expression.
-2004-10-24 Marek Safar <marek.safar@seznam.cz>
-
- Fixed bugs #63705, #67130
- * decl.cs (MemberCache.MemberCache): Add parameter to distinguish
- imported and defined interfaces.
- (CacheEntry, EntryType): Changed to protected internal.
-
- * class.cs (TypeContainer.DoDefineMembers): Setup cache for
- interfaces too.
-
- * typemanager.cs (LookupInterfaceContainer): New method.
- Fills member container from base interfaces.
-
2004-10-20 Marek Safar <marek.safar@seznam.cz>
* class.cs (MethodCore.CheckBase): Add errors 505, 533, 544,
if (TypeBuilder.BaseType != null)
parent_container = TypeManager.LookupMemberContainer (TypeBuilder.BaseType);
- if (TypeBuilder.IsInterface)
- parent_container = TypeManager.LookupInterfaceContainer (ifaces);
+ // TODO:
+ //if (TypeBuilder.IsInterface) {
+ // parent_container = TypeManager.LookupInterfaceContainer (base_inteface_types);
+ //}
if (IsTopLevel) {
if ((ModFlags & Modifiers.NEW) != 0)
#if CACHE
if (!(this is ClassPart))
- member_cache = new MemberCache (this, false);
+ member_cache = new MemberCache (this);
#endif
if (parts != null) {
return false;
}
} else {
- if (parent_method.IsAbstract && !IsInterface) {
+ if (parent_method.IsAbstract) {
Report.SymbolRelatedToPreviousError (parent_method);
Report.Error (533, Location, "'{0}' hides inherited abstract member", GetSignatureForError (Parent));
return false;
/// </summary>
protected bool AddToContainer (MemberCore symbol, bool is_method, string fullname, string basename)
{
- if (basename == Basename && !(this is Interface)) {
+ if (basename == Basename) {
Report.SymbolRelatedToPreviousError (this);
Report.Error (542, "'{0}': member names cannot be the same as their enclosing type", symbol.Location, symbol.GetSignatureForError ());
return false;
/// <summary>
/// Create a new MemberCache for the given IMemberContainer `container'.
/// </summary>
- public MemberCache (IMemberContainer container, bool setup_inherited_interfaces)
+ public MemberCache (IMemberContainer container)
{
this.Container = container;
if (Container.ParentContainer != null)
parent = Container.ParentContainer.MemberCache;
else
- parent = null;
- member_hash = SetupCacheForInterface (parent, setup_inherited_interfaces);
+ parent = TypeHandle.ObjectType.MemberCache;
+ member_hash = SetupCacheForInterface (parent);
} else if (Container.ParentContainer != null)
member_hash = SetupCache (Container.ParentContainer.MemberCache);
else
Hashtable SetupCache (MemberCache parent)
{
Hashtable hash = new Hashtable ();
- if (parent == null)
- return hash;
IDictionaryEnumerator it = parent.member_hash.GetEnumerator ();
while (it.MoveNext ()) {
/// Type.GetMembers() won't return any inherited members for interface types,
/// so we need to do this manually. Interfaces also inherit from System.Object.
/// </summary>
- Hashtable SetupCacheForInterface (MemberCache parent, bool deep_setup)
+ Hashtable SetupCacheForInterface (MemberCache parent)
{
Hashtable hash = SetupCache (parent);
-
- if (!deep_setup)
- return hash;
-
Type [] ifaces = TypeManager.GetInterfaces (Container.Type);
foreach (Type itype in ifaces) {
{
// We need to call AddMembers() with a single member type at a time
// to get the member type part of CacheEntry.EntryType right.
- if (!container.IsInterface) {
AddMembers (MemberTypes.Constructor, container);
AddMembers (MemberTypes.Field, container);
- }
AddMembers (MemberTypes.Method, container);
AddMembers (MemberTypes.Property, container);
AddMembers (MemberTypes.Event, container);
/// number to speed up the searching process.
/// </summary>
[Flags]
- protected internal enum EntryType {
+ protected enum EntryType {
None = 0x000,
Instance = 0x001,
MaskType = Constructor|Event|Field|Method|Property|NestedType
}
- protected internal struct CacheEntry {
+ protected struct CacheEntry {
public readonly IMemberContainer Container;
public readonly EntryType EntryType;
public readonly MemberInfo Member;
return LookupTypeContainer (t);
}
- /// <summary>
- /// Fills member container from base interfaces
- /// </summary>
- public static IMemberContainer LookupInterfaceContainer (Type[] types)
- {
- if (types == null)
- return null;
-
- IMemberContainer complete = null;
- foreach (Type t in types) {
- IMemberContainer one_type_cont = null;
- if (t is TypeBuilder) {
- one_type_cont = builder_to_declspace [t] as IMemberContainer;
- } else
- one_type_cont = TypeHandle.GetTypeHandle (t);
-
- if (complete == null) {
- complete = one_type_cont;
- continue;
- }
-
- // We need to avoid including same member more than once
- foreach (DictionaryEntry de in one_type_cont.MemberCache.Members) {
- object o = complete.MemberCache.Members [de.Key];
- if (o == null) {
- complete.MemberCache.Members.Add (de.Key, de.Value);
- continue;
- }
-
- ArrayList al_old = (ArrayList)o;
- ArrayList al_new = (ArrayList)de.Value;
-
- foreach (MemberCache.CacheEntry ce in al_new) {
- bool exist = false;
- foreach (MemberCache.CacheEntry ce_old in al_old) {
- if (ce.Member == ce_old.Member) {
- exist = true;
- break;
- }
- }
- if (!exist)
- al_old.Add (ce);
- }
- }
- }
- return complete;
- }
-
public static IMemberContainer LookupMemberContainer (Type t)
{
if (t is TypeBuilder) {
// This happens with interfaces, they have a null
// basetype. Look members up in the Object class.
//
- if (current_type == null) {
+ if (current_type == null)
current_type = TypeManager.object_type;
- searching = true;
- }
}
if (list.Length == 0)
if (type.BaseType != null)
BaseType = GetTypeHandle (type.BaseType);
this.is_interface = type.IsInterface || type.IsGenericParameter;
- this.member_cache = new MemberCache (this, true);
+ this.member_cache = new MemberCache (this);
}
// IMemberContainer methods
projects / mono.git / commitdiff