-
- case EntryType.Field:
- if ((((FieldInfo)member_entry.Member).Attributes & (FieldAttributes.Assembly | FieldAttributes.Public)) == FieldAttributes.Assembly)
- continue;
- break;
-
- case EntryType.Method:
- if ((((MethodInfo)member_entry.Member).Attributes & (MethodAttributes.Assembly | MethodAttributes.Public)) == MethodAttributes.Assembly)
- continue;
- break;
-
- case EntryType.Property:
- PropertyInfo pi = (PropertyInfo)member_entry.Member;
- if (pi.GetSetMethod () == null && pi.GetGetMethod () == null)
- continue;
- break;
-
- case EntryType.Event:
- EventInfo ei = (EventInfo)member_entry.Member;
- MethodInfo mi = ei.GetAddMethod ();
- if ((mi.Attributes & (MethodAttributes.Assembly | MethodAttributes.Public)) == MethodAttributes.Assembly)
- continue;
- break;
- }
- string lcase = ((string)entry.Key).ToLower (System.Globalization.CultureInfo.InvariantCulture);
- locase_table [lcase] = member_entry.Member;
- break;
- }
- }
- return locase_table;
- }
-
- public IDictionary<string, List<CacheEntry>> Members {
- get {
- return member_hash;
- }
- }
-
- /// <summary>
- /// Cls compliance check whether methods or constructors parameters differing only in ref or out, or in array rank
- /// </summary>
- ///
- // TODO: refactor as method is always 'this'
- public static void VerifyClsParameterConflict (IList<CacheEntry> al, MethodCore method, MemberInfo this_builder, Report Report)
- {
- EntryType tested_type = (method is Constructor ? EntryType.Constructor : EntryType.Method) | EntryType.Public;
-
- for (int i = 0; i < al.Count; ++i) {
- var entry = al [i];
-
- // skip itself
- if (entry.Member == this_builder)
- continue;
-
- if ((entry.EntryType & tested_type) != tested_type)
- continue;
-
- MethodBase method_to_compare = (MethodBase)entry.Member;
- AttributeTester.Result result = AttributeTester.AreOverloadedMethodParamsClsCompliant (
- method.Parameters, TypeManager.GetParameterData (method_to_compare));
-
- if (result == AttributeTester.Result.Ok)
- continue;
-
- IMethodData md = TypeManager.GetMethod (method_to_compare);
-
- // TODO: now we are ignoring CLSCompliance(false) on method from other assembly which is buggy.
- // However it is exactly what csc does.
- if (md != null && !md.IsClsComplianceRequired ())
- continue;
-
- Report.SymbolRelatedToPreviousError (entry.Member);
- switch (result) {
- case AttributeTester.Result.RefOutArrayError:
- Report.Warning (3006, 1, method.Location,
- "Overloaded method `{0}' differing only in ref or out, or in array rank, is not CLS-compliant",
- method.GetSignatureForError ());
- continue;
- case AttributeTester.Result.ArrayArrayError:
- Report.Warning (3007, 1, method.Location,
- "Overloaded method `{0}' differing only by unnamed array types is not CLS-compliant",
- method.GetSignatureForError ());
- continue;
+
+ if ((name_entry.Modifiers & (Modifiers.OVERRIDE | Modifiers.COMPILER_GENERATED)) != 0)
+ continue;
+
+ if ((name_entry.Kind & MemberKind.MaskType) == 0)
+ continue;
+
+ if (name_entry.MemberDefinition.CLSAttributeValue == false)
+ continue;
+
+ IParametersMember p_a = name_entry as IParametersMember;
+ if (p_a != null && !name_entry.IsAccessor) {
+ if (!is_imported_type) {
+ var p_a_pd = p_a.Parameters;
+ for (int ii = i + 1; ii < entry.Value.Count; ++ii) {
+ var checked_entry = entry.Value[ii];
+ IParametersMember p_b = checked_entry as IParametersMember;
+ if (p_b == null)
+ continue;
+
+ if (p_a_pd.Count != p_b.Parameters.Count)
+ continue;
+
+ if (checked_entry.IsAccessor)
+ continue;
+
+ var res = ParametersCompiled.IsSameClsSignature (p_a.Parameters, p_b.Parameters);
+ if (res != 0) {
+ var last = GetLaterDefinedMember (checked_entry, name_entry);
+ if (last == checked_entry.MemberDefinition) {
+ report.SymbolRelatedToPreviousError (name_entry);
+ } else {
+ report.SymbolRelatedToPreviousError (checked_entry);
+ }
+
+ if ((res & 1) != 0) {
+ report.Warning (3006, 1, last.Location,
+ "Overloaded method `{0}' differing only in ref or out, or in array rank, is not CLS-compliant",
+ name_entry.GetSignatureForError ());
+ }
+
+ if ((res & 2) != 0) {
+ report.Warning (3007, 1, last.Location,
+ "Overloaded method `{0}' differing only by unnamed array types is not CLS-compliant",
+ name_entry.GetSignatureForError ());
+ }
+ }
+ }
+ }
+ }
+
+ if (i > 0 || name_entry.Kind == MemberKind.Constructor || name_entry.Kind == MemberKind.Indexer)
+ continue;
+
+ var name_entry_locase = name_entry.Name.ToLowerInvariant ();
+
+ MemberSpec[] found;
+ if (!locase_members.TryGetValue (name_entry_locase, out found)) {
+ found = new MemberSpec[] { name_entry };
+ locase_members.Add (name_entry_locase, found);
+ } else {
+ bool same_names_only = true;
+ foreach (var f in found) {
+ if (f.Name == name_entry.Name)
+ continue;
+
+// if (f.IsAccessor && name_entry.IsAccessor)
+// continue;
+
+ same_names_only = false;
+ if (!is_imported_type) {
+ var last = GetLaterDefinedMember (f, name_entry);
+ if (last == f.MemberDefinition) {
+ report.SymbolRelatedToPreviousError (name_entry);
+ } else {
+ report.SymbolRelatedToPreviousError (f);
+ }
+
+ report.Warning (3005, 1, last.Location,
+ "Identifier `{0}' differing only in case is not CLS-compliant", last.GetSignatureForError ());
+ }
+ }
+
+ if (!same_names_only) {
+ Array.Resize (ref found, found.Length + 1);
+ found[found.Length - 1] = name_entry;
+ locase_members[name_entry_locase] = found;
+ }
+ }