// decl.cs: Declaration base class for structs, classes, enums and interfaces.
//
// Author: Miguel de Icaza (miguel@gnu.org)
+// Marek Safar (marek.safar@seznam.cz)
//
// Licensed under the terms of the GNU GPL
//
using System;
using System.Text;
using System.Collections;
+using System.Globalization;
using System.Reflection.Emit;
using System.Reflection;
return full_name;
}
- public string GetTypeName ()
+ public string GetTypeName (bool full)
{
- string full_name;
+ string suffix = "";
+ if (full && (TypeArguments != null))
+ suffix = "!" + TypeArguments.Count;
if (Left != null)
- return Left.GetFullName () + "." + Name;
+ return Left.GetTypeName (full) + "." + Name + suffix;
else
- return Name;
+ return Name + suffix;
}
public Expression GetTypeExpression (Location loc)
if (Left != null) {
Expression lexpr = Left.GetTypeExpression (loc);
- if (TypeArguments != null)
- return new GenericMemberAccess (lexpr, Name, TypeArguments, loc);
- else
- return new MemberAccess (lexpr, Name, loc);
+ return new MemberAccess (lexpr, Name, TypeArguments, loc);
} else {
if (TypeArguments != null)
return new ConstructedType (Name, TypeArguments, loc);
this.Name = name;
}
- public MemberName (string type, MemberName name)
+ public MemberName (TypeName type, MemberName name)
{
- this.TypeName = new TypeName (type);
+ this.TypeName = type;
this.Name = name.Name;
this.TypeParameters = name.TypeParameters;
}
this.TypeParameters = type_params;
}
+ public TypeName MakeTypeName (Location loc)
+ {
+ if (TypeParameters != null) {
+ TypeArguments args = new TypeArguments (loc);
+ foreach (string param in TypeParameters)
+ args.Add (new SimpleName (param, loc));
+ return new TypeName (TypeName, Name, args);
+ }
+
+ return new TypeName (TypeName, Name, null);
+ }
+
public static readonly MemberName Null = new MemberName ("");
- public string GetMemberName ()
+ public string Basename {
+ get {
+ if (TypeParameters != null)
+ return Name + "!" + TypeParameters.Length;
+ else
+ return Name;
+ }
+ }
+
+ public string GetName (bool is_generic)
{
- string full_name;
+ string name = is_generic ? Basename : Name;
if (TypeName != null)
- return TypeName.GetFullName () + "." + Name;
+ return TypeName.GetTypeName (is_generic) + "." + name;
else
- return Name;
+ return name;
}
- public static explicit operator string (MemberName name)
- {
- if (name.TypeName != null)
- return name.TypeName + "." + name.Name;
- else
- return name.Name;
+ public int CountTypeParameters {
+ get {
+ if (TypeParameters != null)
+ return 0;
+ else
+ return TypeParameters.Length;
+ }
}
- public override string ToString ()
+ protected string PrintTypeParams ()
{
- string full_name;
if (TypeParameters != null) {
StringBuilder sb = new StringBuilder ();
- sb.Append (Name);
sb.Append ("<");
for (int i = 0; i < TypeParameters.Length; i++) {
if (i > 0)
sb.Append (TypeParameters [i]);
}
sb.Append (">");
- full_name = sb.ToString ();
- } else
- full_name = Name;
+ return sb.ToString ();
+ }
- if (TypeName != null)
- return TypeName + "." + full_name;
- else
- return full_name;
+ return "";
+ }
+
+ public string FullName {
+ get {
+ string full_name = Name + PrintTypeParams ();
+
+ if (TypeName != null)
+ return TypeName + "." + full_name;
+ else
+ return full_name;
+ }
+ }
+
+ public override string ToString ()
+ {
+ return String.Format ("MemberName [{0}:{1}:{2}]",
+ TypeName, Name, PrintTypeParams ());
}
}
/// <summary>
- /// Base representation for members. This is only used to keep track
- /// of Name, Location and Modifier flags.
+ /// Base representation for members. This is used to keep track
+ /// of Name, Location and Modifier flags, and handling Attributes.
/// </summary>
- public abstract class MemberCore {
+ public abstract class MemberCore : Attributable {
/// <summary>
/// Public name
/// </summary>
/// </summary>
public readonly Location Location;
+ [Flags]
+ public enum Flags {
+ Obsolete_Undetected = 1, // Obsolete attribute has not been detected yet
+ Obsolete = 1 << 1, // Type has obsolete attribute
+ ClsCompliance_Undetected = 1 << 2, // CLS Compliance has not been detected yet
+ ClsCompliant = 1 << 3, // Type is CLS Compliant
+ CloseTypeCreated = 1 << 4, // Tracks whether we have Closed the type
+ HasCompliantAttribute_Undetected = 1 << 5, // Presence of CLSCompliantAttribute has not been detected
+ HasClsCompliantAttribute = 1 << 6, // Type has CLSCompliantAttribute
+ ClsCompliantAttributeTrue = 1 << 7, // Type has CLSCompliant (true)
+ Excluded_Undetected = 1 << 8, // Conditional attribute has not been detected yet
+ Excluded = 1 << 9 // Method is conditional
+
+ }
+
/// <summary>
- /// Attributes for this type
- /// </summary>
- Attributes attributes;
+ /// MemberCore flags at first detected then cached
+ /// </summary>
+ protected Flags caching_flags;
public MemberCore (MemberName name, Attributes attrs, Location loc)
+ : base (attrs)
{
- Name = (string) name;
+ Name = name.GetName (!(this is GenericMethod) && !(this is Method));
MemberName = name;
Location = loc;
- attributes = attrs;
+ caching_flags = Flags.Obsolete_Undetected | Flags.ClsCompliance_Undetected | Flags.HasCompliantAttribute_Undetected | Flags.Excluded_Undetected;
+ }
+
+ /// <summary>
+ /// Tests presence of ObsoleteAttribute and report proper error
+ /// </summary>
+ protected void CheckUsageOfObsoleteAttribute (Type type)
+ {
+ if (type == null)
+ return;
+
+ ObsoleteAttribute obsolete_attr = AttributeTester.GetObsoleteAttribute (type);
+ if (obsolete_attr == null)
+ return;
+
+ AttributeTester.Report_ObsoleteMessage (obsolete_attr, type.FullName, Location);
}
public abstract bool Define (TypeContainer parent);
//
// Returns full member name for error message
//
- public virtual string GetSignatureForError () {
+ public virtual string GetSignatureForError ()
+ {
return Name;
}
- public Attributes OptAttributes
+ /// <summary>
+ /// Base Emit method. This is also entry point for CLS-Compliant verification.
+ /// </summary>
+ public virtual void Emit (TypeContainer container)
{
- get {
- return attributes;
- }
- set {
- attributes = value;
- }
+ VerifyObsoleteAttribute ();
+
+ if (!RootContext.VerifyClsCompliance)
+ return;
+
+ VerifyClsCompliance (container);
}
//
Expression.UnsafeError (Location);
return false;
}
+
+ /// <summary>
+ /// Returns instance of ObsoleteAttribute for this MemberCore
+ /// </summary>
+ public ObsoleteAttribute GetObsoleteAttribute (DeclSpace ds)
+ {
+ // ((flags & (Flags.Obsolete_Undetected | Flags.Obsolete)) == 0) is slower, but why ?
+ if ((caching_flags & Flags.Obsolete_Undetected) == 0 && (caching_flags & Flags.Obsolete) == 0) {
+ return null;
+ }
+
+ caching_flags &= ~Flags.Obsolete_Undetected;
+
+ if (OptAttributes == null)
+ return null;
+
+ // TODO: remove this allocation
+ EmitContext ec = new EmitContext (ds.Parent, ds, ds.Location,
+ null, null, ds.ModFlags, false);
+
+ Attribute obsolete_attr = OptAttributes.Search (TypeManager.obsolete_attribute_type, ec);
+ if (obsolete_attr == null)
+ return null;
+
+ ObsoleteAttribute obsolete = obsolete_attr.GetObsoleteAttribute (ds);
+ if (obsolete == null)
+ return null;
+
+ caching_flags |= Flags.Obsolete;
+ return obsolete;
+ }
+
+ /// <summary>
+ /// Analyze whether CLS-Compliant verification must be execute for this MemberCore.
+ /// </summary>
+ public override bool IsClsCompliaceRequired (DeclSpace container)
+ {
+ if ((caching_flags & Flags.ClsCompliance_Undetected) == 0)
+ return (caching_flags & Flags.ClsCompliant) != 0;
+
+ if (GetClsCompliantAttributeValue (container) && IsExposedFromAssembly (container)) {
+ caching_flags &= ~Flags.ClsCompliance_Undetected;
+ caching_flags |= Flags.ClsCompliant;
+ return true;
+ }
+
+ caching_flags &= ~Flags.ClsCompliance_Undetected;
+ return false;
+ }
+
+ /// <summary>
+ /// Returns true when MemberCore is exposed from assembly.
+ /// </summary>
+ protected bool IsExposedFromAssembly (DeclSpace ds)
+ {
+ if ((ModFlags & (Modifiers.PUBLIC | Modifiers.PROTECTED)) == 0)
+ return false;
+
+ DeclSpace parentContainer = ds;
+ while (parentContainer != null && parentContainer.ModFlags != 0) {
+ if ((parentContainer.ModFlags & (Modifiers.PUBLIC | Modifiers.PROTECTED)) == 0)
+ return false;
+ parentContainer = parentContainer.Parent;
+ }
+ return true;
+ }
+
+ /// <summary>
+ /// Resolve CLSCompliantAttribute value or gets cached value.
+ /// </summary>
+ bool GetClsCompliantAttributeValue (DeclSpace ds)
+ {
+ if (OptAttributes != null) {
+ EmitContext ec = new EmitContext (ds.Parent, ds, ds.Location,
+ null, null, ds.ModFlags, false);
+ Attribute cls_attribute = OptAttributes.GetClsCompliantAttribute (ec);
+ if (cls_attribute != null) {
+ caching_flags |= Flags.HasClsCompliantAttribute;
+ return cls_attribute.GetClsCompliantAttributeValue (ds);
+ }
+ }
+ return ds.GetClsCompliantAttributeValue ();
+ }
+
+ /// <summary>
+ /// Returns true if MemberCore is explicitly marked with CLSCompliantAttribute
+ /// </summary>
+ protected bool HasClsCompliantAttribute {
+ get {
+ return (caching_flags & Flags.HasClsCompliantAttribute) != 0;
+ }
+ }
+
+ /// <summary>
+ /// This method is used to testing error 3005 (Method or parameter name collision).
+ /// </summary>
+ protected abstract bool IsIdentifierClsCompliant (DeclSpace ds);
+
+ /// <summary>
+ /// Common helper method for identifier and parameters CLS-Compliant testing.
+ /// When return false error 3005 is reported. True means no violation.
+ /// And error 3006 tests are peformed here because of speed.
+ /// </summary>
+ protected bool IsIdentifierAndParamClsCompliant (DeclSpace ds, string name, MemberInfo methodBuilder, Type[] paramTypes)
+ {
+ MemberList ml = ds.FindMembers (MemberTypes.Event | MemberTypes.Field | MemberTypes.Method | MemberTypes.Property,
+ BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance, System.Type.FilterNameIgnoreCase, name);
+
+ if (ml.Count < 2)
+ return true;
+
+ bool error3006 = false;
+ for (int i = 0; i < ml.Count; ++i) {
+ MemberInfo mi = ml [i];
+ if (name == mi.Name) {
+ MethodBase method = mi as MethodBase;
+ if (method == null || method == methodBuilder || paramTypes == null || paramTypes.Length == 0)
+ continue;
+
+ if (AttributeTester.AreOverloadedMethodParamsClsCompliant (paramTypes, TypeManager.GetArgumentTypes (method))) {
+ error3006 = false;
+ continue;
+ }
+
+ error3006 = true;
+ }
+
+ // We need to test if member is not marked as CLSCompliant (false) and if type is not only internal
+ // because BindingFlags.Public returns internal types too
+ DeclSpace temp_ds = TypeManager.LookupDeclSpace (mi.DeclaringType);
+
+ // Type is external, we can get attribute directly
+ if (temp_ds == null) {
+ object[] cls_attribute = mi.GetCustomAttributes (TypeManager.cls_compliant_attribute_type, false);
+ if (cls_attribute.Length == 1 && (!((CLSCompliantAttribute)cls_attribute[0]).IsCompliant))
+ continue;
+ } else {
+ string tmp_name = String.Concat (temp_ds.Name, '.', mi.Name);
+
+ MemberCore mc = temp_ds.GetDefinition (tmp_name) as MemberCore;
+ if (!mc.IsClsCompliaceRequired (ds))
+ continue;
+ }
+
+ for (int ii = 0; ii < ml.Count; ++ii) {
+ mi = ml [ii];
+ if (name == mi.Name)
+ continue;
+ Report.SymbolRelatedToPreviousError (mi);
+ }
+
+ if (error3006)
+ Report.Error_T (3006, Location, GetSignatureForError ());
+
+ return error3006;
+
+ }
+ return true;
+ }
+
+ /// <summary>
+ /// The main virtual method for CLS-Compliant verifications.
+ /// The method returns true if member is CLS-Compliant and false if member is not
+ /// CLS-Compliant which means that CLS-Compliant tests are not necessary. A descendants override it
+ /// and add their extra verifications.
+ /// </summary>
+ protected virtual bool VerifyClsCompliance (DeclSpace ds)
+ {
+ if (!IsClsCompliaceRequired (ds)) {
+ if (HasClsCompliantAttribute && !IsExposedFromAssembly (ds)) {
+ Report.Warning_T (3019, Location, GetSignatureForError ());
+ }
+ return false;
+ }
+
+ if (!CodeGen.Assembly.IsClsCompliant) {
+ if (HasClsCompliantAttribute) {
+ Report.Error_T (3014, Location, GetSignatureForError ());
+ }
+ }
+
+ int index = Name.LastIndexOf ('.');
+ if (Name [index > 0 ? index + 1 : 0] == '_') {
+ Report.Error_T (3008, Location, GetSignatureForError () );
+ }
+
+ if (!IsIdentifierClsCompliant (ds)) {
+ Report.Error_T (3005, Location, GetSignatureForError ());
+ }
+
+ return true;
+ }
+
+ protected abstract void VerifyObsoleteAttribute ();
+
}
/// <summary>
/// </summary>
public TypeExpr CurrentType;
- /// <summary>
- /// This variable tracks whether we have Closed the type
- /// </summary>
- public bool Created = false;
-
//
// This is the namespace in which this typecontainer
// was declared. We use this to resolve names.
TypeContainer parent;
+ static string[] attribute_targets = new string [] { "type" };
+
public DeclSpace (NamespaceEntry ns, TypeContainer parent, MemberName name,
Attributes attrs, Location l)
: base (name, attrs, l)
public void RecordDecl ()
{
if ((NamespaceEntry != null) && (parent == RootContext.Tree.Types))
- NamespaceEntry.DefineName (Basename, this);
+ NamespaceEntry.DefineName (MemberName.Basename, this);
}
/// <summary>
public virtual void CloseType ()
{
- if (!Created){
+ if ((caching_flags & Flags.CloseTypeCreated) == 0){
try {
TypeBuilder.CreateType ();
} catch {
// Note that this still creates the type and
// it is possible to save it
}
- Created = true;
+ caching_flags |= Flags.CloseTypeCreated;
}
}
public Type ResolveType (TypeExpr d, Location loc)
{
if (!d.CheckAccessLevel (this)) {
- Report. Error (122, loc, "`" + d.Name + "' " +
- "is inaccessible because of its protection level");
+ Report.Error_T (122, loc, d.Name);
return null;
}
return null;
if (e is SimpleName){
- SimpleName s = new SimpleName (((SimpleName) e).Name, -1, loc);
+ SimpleName s = new SimpleName (((SimpleName) e).Name, loc);
d = s.ResolveAsTypeTerminal (type_resolve_ec);
if ((d == null) || (d.Type == null)) {
return true;
case TypeAttributes.NotPublic:
- //
- // This test should probably use the declaringtype.
- //
- if (check_type.Assembly == tb.Assembly){
- return true;
- }
- return false;
-
+
+ // In same cases is null.
+ if (TypeBuilder == null)
+ return true;
+
+ //
+ // This test should probably use the declaringtype.
+ //
+ return check_type.Assembly == TypeBuilder.Assembly;
+
case TypeAttributes.NestedPublic:
return true;
/// during the tree resolution process and potentially define
/// recursively the type
/// </remarks>
- public Type FindType (Location loc, string name, int num_type_args)
+ public Type FindType (Location loc, string name)
{
Type t;
bool error;
if (error)
return null;
- if ((t != null) &&
- containing_ds.CheckAccessLevel (t) &&
- TypeManager.CheckGeneric (t, num_type_args))
+ if ((t != null) && containing_ds.CheckAccessLevel (t))
return t;
current_type = current_type.BaseType;
if (error)
return null;
- if ((t != null) && TypeManager.CheckGeneric (t, num_type_args))
+ if (t != null)
return t;
}
if (error)
return null;
- if ((t != null) && TypeManager.CheckGeneric (t, num_type_args))
+ if (t != null)
return t;
//
if (error)
return null;
- if ((t != null) && TypeManager.CheckGeneric (t, num_type_args))
+ if (t != null)
return t;
+ if (name.IndexOf ('.') > 0)
+ continue;
+
+ IAlias alias_value = ns.LookupAlias (name);
+ if (alias_value != null) {
+ t = LookupInterfaceOrClass ("", alias_value.Name, out error);
+ if (error)
+ return null;
+
+ if (t != null)
+ return t;
+ }
+
//
// Now check the using clause list
//
if (error)
return null;
- if ((match != null) &&
- TypeManager.CheckGeneric (match, num_type_args)) {
+ if (match != null) {
if (t != null){
if (CheckAccessLevel (match)) {
Error_AmbiguousTypeReference (loc, name, t.FullName, match.FullName);
t = match;
}
}
- if ((t != null) && TypeManager.CheckGeneric (t, num_type_args))
+ if (t != null)
return t;
}
get;
}
+ public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb)
+ {
+ try {
+ TypeBuilder.SetCustomAttribute (cb);
+ } catch (System.ArgumentException e) {
+ Report.Warning (-21, a.Location,
+ "The CharSet named property on StructLayout\n"+
+ "\tdoes not work correctly on Microsoft.NET\n"+
+ "\tYou might want to remove the CharSet declaration\n"+
+ "\tor compile using the Mono runtime instead of the\n"+
+ "\tMicrosoft .NET runtime\n"+
+ "\tThe runtime gave the error: " + e);
+ }
+ }
+
+ /// <summary>
+ /// Goes through class hierarchy and get value of first CLSCompliantAttribute that found.
+ /// If no is attribute exists then return assembly CLSCompliantAttribute.
+ /// </summary>
+ public bool GetClsCompliantAttributeValue ()
+ {
+ if ((caching_flags & Flags.HasCompliantAttribute_Undetected) == 0)
+ return (caching_flags & Flags.ClsCompliantAttributeTrue) != 0;
+
+ caching_flags &= ~Flags.HasCompliantAttribute_Undetected;
+
+ if (OptAttributes != null) {
+ EmitContext ec = new EmitContext (parent, this, Location,
+ null, null, ModFlags, false);
+ Attribute cls_attribute = OptAttributes.GetClsCompliantAttribute (ec);
+ if (cls_attribute != null) {
+ caching_flags |= Flags.HasClsCompliantAttribute;
+ if (cls_attribute.GetClsCompliantAttributeValue (this)) {
+ caching_flags |= Flags.ClsCompliantAttributeTrue;
+ return true;
+ }
+ return false;
+ }
+ }
+
+ if (parent == null) {
+ if (CodeGen.Assembly.IsClsCompliant) {
+ caching_flags |= Flags.ClsCompliantAttributeTrue;
+ return true;
+ }
+ return false;
+ }
+
+ if (parent.GetClsCompliantAttributeValue ()) {
+ caching_flags |= Flags.ClsCompliantAttributeTrue;
+ return true;
+ }
+ return false;
+ }
+
+
+ // Tests container name for CLS-Compliant name (differing only in case)
+ // Possible optimalization: search in same namespace only
+ protected override bool IsIdentifierClsCompliant (DeclSpace ds)
+ {
+ int l = Name.Length;
+
+ if (Namespace.LookupNamespace (NamespaceEntry.FullName, false) != null) {
+ // Seek through all imported types
+ foreach (string type_name in TypeManager.all_imported_types.Keys)
+ {
+ if (l != type_name.Length)
+ continue;
+
+ if (String.Compare (Name, type_name, true, CultureInfo.InvariantCulture) == 0 &&
+ AttributeTester.IsClsCompliant (TypeManager.all_imported_types [type_name] as Type)) {
+ Report.SymbolRelatedToPreviousError ((Type)TypeManager.all_imported_types [type_name]);
+ return false;
+ }
+ }
+ }
+
+ // Seek through generated types
+ foreach (string name in RootContext.Tree.Decls.Keys) {
+ if (l != name.Length)
+ continue;
+
+ if (String.Compare (Name, name, true, CultureInfo.InvariantCulture) == 0) {
+
+ if (Name == name)
+ continue;
+
+ DeclSpace found_ds = RootContext.Tree.Decls[name] as DeclSpace;
+ if (found_ds.IsClsCompliaceRequired (found_ds.Parent)) {
+ Report.SymbolRelatedToPreviousError (found_ds.Location, found_ds.GetSignatureForError ());
+ return false;
+ }
+ }
+ }
+
+ return true;
+ }
+
//
// Extensions for generics
//
DeclSpace the_parent = parent;
if (this is GenericMethod)
- the_parent = the_parent.Parent;
+ the_parent = null;
int start = 0;
TypeParameter[] parent_params = null;
return new TypeExpression (TypeBuilder, Location);
}
}
+
+ protected override string[] ValidAttributeTargets {
+ get {
+ return attribute_targets;
+ }
+ }
}
/// <summary>
protected Hashtable member_hash;
protected Hashtable method_hash;
- Hashtable interface_hash;
-
/// <summary>
/// Create a new MemberCache for the given IMemberContainer `container'.
/// </summary>
// TypeManager.object_type), we deep-copy its MemberCache here.
if (Container.IsInterface) {
MemberCache parent;
- interface_hash = new Hashtable ();
if (Container.Parent != null)
parent = Container.Parent.MemberCache;
/// <summary>
/// Add the contents of `new_hash' to `hash'.
/// </summary>
- void AddHashtable (Hashtable hash, Hashtable new_hash)
+ void AddHashtable (Hashtable hash, MemberCache cache)
{
+ Hashtable new_hash = cache.member_hash;
IDictionaryEnumerator it = new_hash.GetEnumerator ();
while (it.MoveNext ()) {
ArrayList list = (ArrayList) hash [it.Key];
- if (list != null)
- list.AddRange ((ArrayList) it.Value);
- else
- hash [it.Key] = ((ArrayList) it.Value).Clone ();
+ if (list == null)
+ hash [it.Key] = list = new ArrayList ();
+
+ foreach (CacheEntry entry in (ArrayList) it.Value) {
+ if (entry.Container != cache.Container)
+ break;
+ list.Add (entry);
+ }
}
}
foreach (TypeExpr iface in ifaces) {
Type itype = iface.Type;
- if (interface_hash.Contains (itype))
- continue;
-
- interface_hash [itype] = null;
-
IMemberContainer iface_container =
TypeManager.LookupMemberContainer (itype);
MemberCache iface_cache = iface_container.MemberCache;
- AddHashtable (hash, iface_cache.member_hash);
-
- if (iface_cache.interface_hash == null)
- continue;
-
- foreach (Type parent_contains in iface_cache.interface_hash.Keys)
- interface_hash [parent_contains] = null;
+ AddHashtable (hash, iface_cache);
}
return hash;
ArrayList global = new ArrayList ();
bool using_global = false;
- public MemberList FindMembers (MemberTypes mt, BindingFlags bf, string name,
+ static MemberInfo [] emptyMemberInfo = new MemberInfo [0];
+
+ public MemberInfo [] FindMembers (MemberTypes mt, BindingFlags bf, string name,
MemberFilter filter, object criteria)
{
if (using_global)
applicable = (ArrayList) method_hash [name];
else
applicable = (ArrayList) member_hash [name];
-
+
if (applicable == null)
- return MemberList.Empty;
+ return emptyMemberInfo;
//
// 32 slots gives 53 rss/54 size
IMemberContainer current = Container;
+
// `applicable' is a list of all members with the given member name `name'
// in the current class and all its parent classes. The list is sorted in
// reverse order due to the way how the cache is initialy created (to speed
using_global = false;
MemberInfo [] copy = new MemberInfo [global.Count];
global.CopyTo (copy);
- return new MemberList (copy);
+ return copy;
}
//
for (int i = applicable.Count - 1; i >= 0; i--) {
CacheEntry entry = (CacheEntry) applicable [i];
- if ((entry.EntryType & (is_property ? EntryType.Property : EntryType.Method)) == 0)
+ if ((entry.EntryType & (is_property ? (EntryType.Property | EntryType.Field) : EntryType.Method)) == 0)
continue;
PropertyInfo pi = null;
MethodInfo mi = null;
- Type [] cmpAttrs;
+ FieldInfo fi = null;
+ Type [] cmpAttrs = null;
if (is_property) {
- pi = (PropertyInfo) entry.Member;
- cmpAttrs = TypeManager.GetArgumentTypes (pi);
+ if ((entry.EntryType & EntryType.Field) != 0) {
+ fi = (FieldInfo)entry.Member;
+
+ // TODO: For this case we ignore member type
+ //fb = TypeManager.GetField (fi);
+ //cmpAttrs = new Type[] { fb.MemberType };
+ } else {
+ pi = (PropertyInfo) entry.Member;
+ cmpAttrs = TypeManager.GetArgumentTypes (pi);
+ }
} else {
mi = (MethodInfo) entry.Member;
cmpAttrs = TypeManager.GetArgumentTypes (mi);
}
-
+
+ if (fi != null) {
+ // TODO: Almost duplicate !
+ // Check visibility
+ switch (fi.Attributes & FieldAttributes.FieldAccessMask) {
+ case FieldAttributes.Private:
+ //
+ // A private method is Ok if we are a nested subtype.
+ // The spec actually is not very clear about this, see bug 52458.
+ //
+ if (invocationType != entry.Container.Type &
+ TypeManager.IsNestedChildOf (invocationType, entry.Container.Type))
+ continue;
+
+ break;
+ case FieldAttributes.FamANDAssem:
+ case FieldAttributes.Assembly:
+ //
+ // Check for assembly methods
+ //
+ if (mi.DeclaringType.Assembly != CodeGen.Assembly.Builder)
+ continue;
+ break;
+ }
+ return entry.Member;
+ }
+
//
// Check the arguments
//