← Back to branch summary

~halega/+junk/sharpdevelop

« back to all changes in this revision

Viewing changes to src/AddIns/BackendBindings/Python/PythonBinding/Project/Src/PythonMemberResolver.cs

  • Committer: sk
  • Date: 2011-09-10 05:17:57 UTC
  • Revision ID: halega@halega.com-20110910051757-qfouz1llya9m6boy
4.1.0.7915 Release Candidate 1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/AddIns/BackendBindings/Python/PythonBinding/Project/Src/PythonMemberResolver.cs
 
1
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
 
2
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
3
 
 
4
using System;
 
5
using System.Collections.Generic;
 
6
using ICSharpCode.SharpDevelop.Dom;
 
7
 
 
8
namespace ICSharpCode.PythonBinding
 
9
{
 
10
        /// <summary>
 
11
        /// Resolves properties, events and fields.
 
12
        /// </summary>
 
13
        public class PythonMemberResolver : IPythonResolver
 
14
        {
 
15
                PythonClassResolver classResolver;
 
16
                PythonLocalVariableResolver localVariableResolver;
 
17
                PythonResolverContext resolverContext;
 
18
                PythonSelfResolver selfResolver = new PythonSelfResolver();
 
19
                
 
20
                public PythonMemberResolver(PythonClassResolver classResolver, PythonLocalVariableResolver localVariableResolver)
 
21
                {
 
22
                        this.classResolver = classResolver;
 
23
                        this.localVariableResolver = localVariableResolver;
 
24
                }
 
25
                
 
26
                public ResolveResult Resolve(PythonResolverContext resolverContext)
 
27
                {
 
28
                        IMember member = FindMember(resolverContext);
 
29
                        return CreateResolveResult(member);
 
30
                }
 
31
                
 
32
                public IMember FindMember(PythonResolverContext resolverContext)
 
33
                {
 
34
                        this.resolverContext = resolverContext;
 
35
                        return FindMember();
 
36
                }
 
37
                
 
38
                IMember FindMember()
 
39
                {
 
40
                        return FindMember(resolverContext.Expression);
 
41
                }
 
42
                
 
43
                IMember FindMember(string expression)
 
44
                {
 
45
                        MemberName memberName = new MemberName(expression);
 
46
                        if (memberName.HasName) {
 
47
                                IClass c = FindClass(memberName.Type);
 
48
                                if (c != null) {
 
49
                                        return FindMemberInClass(c, memberName.Name);
 
50
                                } else {
 
51
                                        return FindMemberInParent(memberName);
 
52
                                }
 
53
                        }
 
54
                        return null;
 
55
                }
 
56
                
 
57
                IClass FindClass(string className)
 
58
                {
 
59
                        IClass c = FindClassFromClassResolver(className);
 
60
                        if (c != null) {
 
61
                                return c;
 
62
                        }
 
63
                        if (PythonSelfResolver.IsSelfExpression(className)) {
 
64
                                return FindClassFromSelfResolver();
 
65
                        }
 
66
                        return FindClassFromLocalVariableResolver(className);
 
67
                }
 
68
                
 
69
                IClass FindClassFromClassResolver(string className)
 
70
                {
 
71
                        return classResolver.GetClass(resolverContext, className);
 
72
                }
 
73
                
 
74
                IClass FindClassFromLocalVariableResolver(string localVariableName)
 
75
                {
 
76
                         MemberName memberName = new MemberName(localVariableName);
 
77
                         if (!memberName.HasName) {
 
78
                                string typeName = localVariableResolver.Resolve(localVariableName, resolverContext.FileContent);
 
79
                                return FindClassFromClassResolver(typeName);
 
80
                         }
 
81
                         return null;
 
82
                }
 
83
                
 
84
                IClass FindClassFromSelfResolver()
 
85
                {
 
86
                        PythonResolverContext newContext = resolverContext.Clone("self");
 
87
                        ResolveResult result = selfResolver.Resolve(newContext);
 
88
                        if (result != null) {
 
89
                                return result.ResolvedType.GetUnderlyingClass();
 
90
                        }
 
91
                        return null;
 
92
                }
 
93
                
 
94
                ResolveResult CreateResolveResult(IMember member)
 
95
                {
 
96
                        if (member != null) {
 
97
                                if (member is IMethod) {
 
98
                                        return new PythonMethodGroupResolveResult(member.DeclaringType, member.Name);
 
99
                                }
 
100
                                return new MemberResolveResult(null, null, member);
 
101
                        }
 
102
                        return null;
 
103
                }
 
104
                
 
105
                IMember FindMemberInClass(IClass matchingClass, string memberName)
 
106
                {
 
107
                        PythonClassMembers classMembers = new PythonClassMembers(matchingClass);
 
108
                        return classMembers.FindMember(memberName);
 
109
                }
 
110
                
 
111
                IMember FindMemberInParent(MemberName memberName)
 
112
                {
 
113
                        IMember parentMember = FindMember(memberName.Type);
 
114
                        if (parentMember != null) {
 
115
                                return FindMemberInParent(parentMember, memberName.Name);
 
116
                        }
 
117
                        return null;
 
118
                }
 
119
                
 
120
                IMember FindMemberInParent(IMember parentMember, string memberName)
 
121
                {
 
122
                        IReturnType returnType = parentMember.ReturnType;
 
123
                        if (returnType != null) {
 
124
                                IClass parentMemberClass = returnType.GetUnderlyingClass();
 
125
                                return FindMemberInClass(parentMemberClass, memberName);
 
126
                        }
 
127
                        return null;
 
128
                }
 
129
        }
 
130
}