Merge pull request #487 from mayerwin/patch-1

[mono.git] / mcs / mcs / membercache.cs

diff --git a/mcs/mcs/membercache.cs b/mcs/mcs/membercache.cs
index 2b4bbf7e7b3bd74890a6ff3e7ff116031a3286aa..c2d9a630a3aa1324bb790cd19fe42e7ebef21d60 100644 (file)
--- a/mcs/mcs/membercache.cs
+++ b/mcs/mcs/membercache.cs
@@ -73,15 +73,6 @@ namespace Mono.CSharp {
                public readonly TypeSpec MemberType;
                public readonly int Arity; // -1 to ignore the check
 
-               private MemberFilter (string name, MemberKind kind)
-               {
-                       Name = name;
-                       Kind = kind;
-                       Parameters = null;
-                       MemberType = null;
-                       Arity = -1;
-               }
-
                public MemberFilter (MethodSpec m)
                {
                        Name = m.Name;
@@ -311,7 +302,7 @@ namespace Mono.CSharp {
                                // rules (e.g. binary operators) by not setting the flag we hide them for
                                // user conversions
                                //
-                               if (!BuiltinTypeSpec.IsPrimitiveType (dt)) {
+                               if (!BuiltinTypeSpec.IsPrimitiveType (dt) || dt.BuiltinType == BuiltinTypeSpec.Type.Char) {
                                        switch (dt.BuiltinType) {
                                        case BuiltinTypeSpec.Type.String:
                                        case BuiltinTypeSpec.Type.Delegate:
@@ -444,12 +435,15 @@ namespace Mono.CSharp {
                // A special method to work with member lookup only. It returns a list of all members named @name
                // starting from @container. It's very performance sensitive
                //
-               public static IList<MemberSpec> FindMembers (TypeSpec container, string name, bool declaredOnly)
+               // declaredOnlyClass cannot be used interfaces. Manual filtering is required because names are
+               // compacted
+               //
+               public static IList<MemberSpec> FindMembers (TypeSpec container, string name, bool declaredOnlyClass)
                {
                        IList<MemberSpec> applicable;
 
                        do {
-                               if (container.MemberCache.member_hash.TryGetValue (name, out applicable) || declaredOnly)
+                               if (container.MemberCache.member_hash.TryGetValue (name, out applicable) || declaredOnlyClass)
                                        return applicable;
 
                                container = container.BaseType;
@@ -797,7 +791,7 @@ namespace Mono.CSharp {
                        while (true) {
                                foreach (var entry in abstract_type.MemberCache.member_hash) {
                                        foreach (var name_entry in entry.Value) {
-                                               if ((name_entry.Modifiers & Modifiers.ABSTRACT) == 0)
+                                               if ((name_entry.Modifiers & (Modifiers.ABSTRACT | Modifiers.OVERRIDE)) != Modifiers.ABSTRACT)
                                                        continue;
 
                                                if (name_entry.Kind != MemberKind.Method)
@@ -846,6 +840,12 @@ namespace Mono.CSharp {
                                                if ((item.Modifiers & (Modifiers.OVERRIDE | Modifiers.VIRTUAL)) == 0)
                                                        continue;
 
+                                               //
+                                               // Abstract override does not override anything
+                                               //
+                                               if ((item.Modifiers & Modifiers.ABSTRACT) != 0)
+                                                       continue;
+
                                                if (filter.Equals (item)) {
                                                        --not_implemented_count;
                                                        abstract_methods [i] = null;
@@ -1163,8 +1163,9 @@ namespace Mono.CSharp {
                        if (container.BaseType == null) {
                                locase_members = new Dictionary<string, MemberSpec[]> (member_hash.Count); // StringComparer.OrdinalIgnoreCase);
                        } else {
-                               container.BaseType.MemberCache.VerifyClsCompliance (container.BaseType, report);
-                               locase_members = new Dictionary<string, MemberSpec[]> (container.BaseType.MemberCache.locase_members); //, StringComparer.OrdinalIgnoreCase);
+                               var btype = container.BaseType.GetDefinition ();
+                               btype.MemberCache.VerifyClsCompliance (btype, report);
+                               locase_members = new Dictionary<string, MemberSpec[]> (btype.MemberCache.locase_members); //, StringComparer.OrdinalIgnoreCase);
                        }
 
                        var is_imported_type = container.MemberDefinition.IsImported;
@@ -1354,8 +1355,10 @@ namespace Mono.CSharp {
                                                type_a = parameters.Types [ii];
                                                type_b = p_types [ii];
 
-                                               if ((pd.FixedParameters [ii].ModFlags & Parameter.Modifier.ISBYREF) !=
-                                                       (parameters.FixedParameters [ii].ModFlags & Parameter.Modifier.ISBYREF))
+                                               var a_byref = (pd.FixedParameters[ii].ModFlags & Parameter.Modifier.RefOutMask) != 0;
+                                               var b_byref = (parameters.FixedParameters[ii].ModFlags & Parameter.Modifier.RefOutMask) != 0;
+
+                                               if (a_byref != b_byref)
                                                        break;
 
                                        } while (TypeSpecComparer.Override.IsEqual (type_a, type_b) && ii-- != 0);
@@ -1374,7 +1377,9 @@ namespace Mono.CSharp {
                                        //
                                        if (pd != null && member is MethodCore) {
                                                ii = method_param_count;
-                                               while (ii-- != 0 && parameters.FixedParameters[ii].ModFlags == pd.FixedParameters[ii].ModFlags &&
+                                               while (ii-- != 0 &&
+                                                       (parameters.FixedParameters[ii].ModFlags & Parameter.Modifier.ModifierMask) ==
+                                                       (pd.FixedParameters[ii].ModFlags & Parameter.Modifier.ModifierMask) &&
                                                        parameters.ExtensionMethodType == pd.ExtensionMethodType) ;
 
                                                if (ii >= 0) {