← Back to branch summary

~ubuntu-branches/ubuntu/saucy/monodevelop/saucy-proposed

« back to all changes in this revision

Viewing changes to contrib/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultMemberReference.cs

  • Committer: Package Import Robot
  • Author(s): Jo Shields
  • Date: 2012-06-22 20:35:35 UTC
  • mfrom: (10.3.2)
  • Revision ID: package-import@ubuntu.com-20120622203535-zrozwvcf6kfk6l6i
Tags: 3.0.3.2+dfsg-1
* [3fd89ae] Imported Upstream version 3.0.3.2+dfsg
* [379a680] Remove old patches we haven't used for ages from git.
* [d71161d] Remove correct_paths_in_monodevelop-core-addins.pc.patch.
  Upstream claim to have fixed this by moving assembly install locations.
* [15dbfb9] Fix install location for MonoDevelop.Gettext.dll.config.
* [26eb434] Fix install location for MonoDevelop.SourceEditor2.dll.config.
* [4169974] Upstream commit 53282c9 which finally reconciles the 
  MonoDevelop.Gettext.dll install location with the 
  monodevelop-core-addins.pc location.

Show diffs side-by-side

added added

removed removed

Lines of Context:
contrib/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultMemberReference.cs
24
24
{
25
25
        /// <summary>
26
26
        /// References an entity by its type and name.
27
 
        /// This class can be used to refer to fields, events, and parameterless properties.
 
27
        /// This class can be used to refer to all members except for constructors and explicit interface implementations.
28
28
        /// </summary>
 
29
        /// <remarks>
 
30
        /// Resolving a DefaultMemberReference requires a context that provides enough information for resolving the declaring type reference
 
31
        /// and the parameter types references.
 
32
        /// </remarks>
29
33
        [Serializable]
30
34
        public sealed class DefaultMemberReference : IMemberReference, ISupportsInterning
31
35
        {
50
54
                        this.parameterTypes = parameterTypes ?? EmptyList<ITypeReference>.Instance;
51
55
                }
52
56
                
 
57
                public ITypeReference DeclaringTypeReference {
 
58
                        get { return typeReference; }
 
59
                }
 
60
                
53
61
                public IMember Resolve(ITypeResolveContext context)
54
62
                {
55
63
                        IType type = typeReference.Resolve(context);
56
64
                        IEnumerable<IMember> members;
57
65
                        if (entityType == EntityType.Method) {
58
66
                                members = type.GetMethods(
59
 
                                        m => m.Name == name && m.EntityType == EntityType.Method && m.TypeParameters.Count == typeParameterCount,
 
67
                                        m => m.Name == name && m.EntityType == EntityType.Method
 
68
                                        && m.TypeParameters.Count == typeParameterCount && !m.IsExplicitInterfaceImplementation,
60
69
                                        GetMemberOptions.IgnoreInheritedMembers);
61
70
                        } else {
62
71
                                members = type.GetMembers(
63
 
                                        m => m.Name == name && m.EntityType == entityType,
 
72
                                        m => m.Name == name && m.EntityType == entityType && !m.IsExplicitInterfaceImplementation,
64
73
                                        GetMemberOptions.IgnoreInheritedMembers);
65
74
                        }
66
75
                        var resolvedParameterTypes = parameterTypes.Resolve(context);
67
76
                        foreach (IMember member in members) {
68
77
                                IParameterizedMember parameterizedMember = member as IParameterizedMember;
69
 
                                if (parameterTypes.Count == 0) {
70
 
                                        if (parameterizedMember == null || parameterizedMember.Parameters.Count == 0)
 
78
                                if (parameterizedMember == null) {
 
79
                                        if (parameterTypes.Count == 0)
71
80
                                                return member;
72
81
                                } else if (parameterTypes.Count == parameterizedMember.Parameters.Count) {
73
82
                                        bool signatureMatches = true;
74
83
                                        for (int i = 0; i < parameterTypes.Count; i++) {
75
 
                                                IType type1 = ParameterListComparer.Instance.NormalizeMethodTypeParameters(resolvedParameterTypes[i]);
76
 
                                                IType type2 = ParameterListComparer.Instance.NormalizeMethodTypeParameters(parameterizedMember.Parameters[i].Type);
 
84
                                                IType type1 = DummyTypeParameter.NormalizeAllTypeParameters(resolvedParameterTypes[i]);
 
85
                                                IType type2 = DummyTypeParameter.NormalizeAllTypeParameters(parameterizedMember.Parameters[i].Type);
77
86
                                                if (!type1.Equals(type2)) {
78
87
                                                        signatureMatches = false;
79
88
                                                        break;