001 /*
002 * Copyright 2010-2013 JetBrains s.r.o.
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 * http://www.apache.org/licenses/LICENSE-2.0
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016
017 package org.jetbrains.jet.lang.resolve.java.scope;
018
019 import org.jetbrains.annotations.NotNull;
020 import org.jetbrains.annotations.Nullable;
021 import org.jetbrains.annotations.TestOnly;
022 import org.jetbrains.jet.lang.descriptors.*;
023 import org.jetbrains.jet.lang.resolve.java.resolver.JavaMemberResolver;
024 import org.jetbrains.jet.lang.resolve.java.resolver.ProgressChecker;
025 import org.jetbrains.jet.lang.resolve.name.Name;
026 import org.jetbrains.jet.lang.resolve.scopes.JetScopeImpl;
027 import org.jetbrains.jet.utils.Printer;
028
029 import java.util.*;
030
031 public abstract class JavaBaseScope extends JetScopeImpl {
032 @NotNull
033 protected final JavaMemberResolver memberResolver;
034 @NotNull
035 protected final MembersProvider membersProvider;
036 @NotNull
037 private final Map<Name, Set<FunctionDescriptor>> functionDescriptors = new HashMap<Name, Set<FunctionDescriptor>>();
038 @NotNull
039 private final Map<Name, Set<VariableDescriptor>> propertyDescriptors = new HashMap<Name, Set<VariableDescriptor>>();
040 @Nullable
041 private Collection<DeclarationDescriptor> allDescriptors = null;
042 @NotNull
043 protected final ClassOrNamespaceDescriptor descriptor;
044
045 private Collection<ClassDescriptor> innerClasses = null;
046
047
048 protected JavaBaseScope(
049 @NotNull ClassOrNamespaceDescriptor descriptor,
050 @NotNull JavaMemberResolver memberResolver,
051 @NotNull MembersProvider membersProvider
052 ) {
053 this.memberResolver = memberResolver;
054 this.membersProvider = membersProvider;
055 this.descriptor = descriptor;
056 }
057
058 @NotNull
059 @Override
060 public DeclarationDescriptor getContainingDeclaration() {
061 return descriptor;
062 }
063
064 @NotNull
065 @Override
066 public Collection<VariableDescriptor> getProperties(@NotNull Name name) {
067 Set<VariableDescriptor> cached = propertyDescriptors.get(name);
068 if (cached != null) return cached;
069
070 if (allDescriptorsComputed()) {
071 return Collections.emptySet();
072 }
073
074 Set<VariableDescriptor> computedDescriptors = computePropertyDescriptors(name);
075 propertyDescriptors.put(name, computedDescriptors);
076 return computedDescriptors;
077 }
078
079 @NotNull
080 private Set<VariableDescriptor> computePropertyDescriptors(@NotNull Name name) {
081 NamedMembers members = membersProvider.get(name);
082 if (members == null) {
083 return Collections.emptySet();
084 }
085 return memberResolver.resolveFieldGroup(members, descriptor);
086 }
087
088 @NotNull
089 @Override
090 public Collection<FunctionDescriptor> getFunctions(@NotNull Name name) {
091 Set<FunctionDescriptor> cached = functionDescriptors.get(name);
092 if (cached != null) return cached;
093
094 if (allDescriptorsComputed()) {
095 return Collections.emptySet();
096 }
097
098 Set<FunctionDescriptor> computedDescriptors = computeFunctionDescriptor(name);
099 functionDescriptors.put(name, computedDescriptors);
100 return computedDescriptors;
101 }
102
103 @NotNull
104 protected abstract Set<FunctionDescriptor> computeFunctionDescriptor(@NotNull Name name);
105
106 @NotNull
107 @Override
108 public Collection<DeclarationDescriptor> getAllDescriptors() {
109 if (allDescriptorsComputed()) {
110 return allDescriptors;
111 }
112
113 allDescriptors = computeAllDescriptors();
114
115 return allDescriptors;
116 }
117
118 private boolean allDescriptorsComputed() {
119 return allDescriptors != null;
120 }
121
122 @NotNull
123 protected Collection<DeclarationDescriptor> computeAllDescriptors() {
124 Collection<DeclarationDescriptor> result = new HashSet<DeclarationDescriptor>();
125 result.addAll(computeFieldAndFunctionDescriptors());
126 result.addAll(getInnerClasses());
127 return result;
128 }
129
130 @NotNull
131 protected abstract Collection<ClassDescriptor> computeInnerClasses();
132
133 @NotNull
134 private Collection<DeclarationDescriptor> computeFieldAndFunctionDescriptors() {
135 Collection<DeclarationDescriptor> result = new ArrayList<DeclarationDescriptor>();
136 for (NamedMembers members : membersProvider.allMembers()) {
137 Name name = members.getName();
138 ProgressChecker.getInstance().checkCanceled();
139 result.addAll(getFunctions(name));
140 ProgressChecker.getInstance().checkCanceled();
141 result.addAll(getProperties(name));
142 }
143 return result;
144 }
145
146 @NotNull
147 protected Collection<ClassDescriptor> getInnerClasses() {
148 if (innerClasses == null) {
149 innerClasses = computeInnerClasses();
150 }
151 return innerClasses;
152 }
153
154 @TestOnly
155 @Override
156 public void printScopeStructure(@NotNull Printer p) {
157 p.println(getClass().getSimpleName(), " {");
158 p.pushIndent();
159
160 p.println("descriptor = ", descriptor);
161
162 p.popIndent();
163 p.println("}");
164 }
165 }