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;
018
019 import com.google.common.base.Function;
020 import com.google.common.base.Predicate;
021 import com.google.common.collect.*;
022 import com.intellij.openapi.util.Pair;
023 import com.intellij.psi.PsiElement;
024 import org.jetbrains.annotations.NotNull;
025 import org.jetbrains.annotations.Nullable;
026 import org.jetbrains.jet.lang.descriptors.*;
027 import org.jetbrains.jet.lang.descriptors.impl.MutableClassDescriptor;
028 import org.jetbrains.jet.lang.descriptors.impl.MutableClassDescriptorLite;
029 import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorImpl;
030 import org.jetbrains.jet.lang.descriptors.impl.NamespaceLikeBuilder;
031 import org.jetbrains.jet.lang.psi.*;
032 import org.jetbrains.jet.lang.resolve.name.Name;
033 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
034 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
035 import org.jetbrains.jet.lang.types.ErrorUtils;
036 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
037 import org.jetbrains.jet.renderer.DescriptorRenderer;
038
039 import javax.inject.Inject;
040 import java.util.*;
041
042 import static org.jetbrains.jet.lang.diagnostics.Errors.*;
043
044 public class DeclarationResolver {
045 @NotNull
046 private AnnotationResolver annotationResolver;
047 @NotNull
048 private TopDownAnalysisContext context;
049 @NotNull
050 private ImportsResolver importsResolver;
051 @NotNull
052 private DescriptorResolver descriptorResolver;
053 @NotNull
054 private ScriptHeaderResolver scriptHeaderResolver;
055 @NotNull
056 private BindingTrace trace;
057
058
059 @Inject
060 public void setAnnotationResolver(@NotNull AnnotationResolver annotationResolver) {
061 this.annotationResolver = annotationResolver;
062 }
063
064 @Inject
065 public void setContext(@NotNull TopDownAnalysisContext context) {
066 this.context = context;
067 }
068
069 @Inject
070 public void setImportsResolver(@NotNull ImportsResolver importsResolver) {
071 this.importsResolver = importsResolver;
072 }
073
074 @Inject
075 public void setDescriptorResolver(@NotNull DescriptorResolver descriptorResolver) {
076 this.descriptorResolver = descriptorResolver;
077 }
078
079 @Inject
080 public void setTrace(@NotNull BindingTrace trace) {
081 this.trace = trace;
082 }
083
084 @Inject
085 public void setScriptHeaderResolver(@NotNull ScriptHeaderResolver scriptHeaderResolver) {
086 this.scriptHeaderResolver = scriptHeaderResolver;
087 }
088
089
090
091 public void process(@NotNull JetScope rootScope) {
092 resolveAnnotationConstructors();
093 resolveConstructorHeaders();
094 resolveAnnotationStubsOnClassesAndConstructors();
095 resolveFunctionAndPropertyHeaders();
096 createFunctionsForDataClasses();
097 importsResolver.processMembersImports(rootScope);
098 checkRedeclarationsInNamespaces();
099 checkRedeclarationsInInnerClassNames();
100 }
101
102 private void resolveAnnotationConstructors() {
103 for (Map.Entry<JetClass, MutableClassDescriptor> entry : context.getClasses().entrySet()) {
104 MutableClassDescriptor classDescriptor = entry.getValue();
105
106 if (DescriptorUtils.isAnnotationClass(classDescriptor)) {
107 processPrimaryConstructor(classDescriptor, entry.getKey());
108 }
109 }
110 }
111
112 private void resolveConstructorHeaders() {
113 for (Map.Entry<JetClass, MutableClassDescriptor> entry : context.getClasses().entrySet()) {
114 MutableClassDescriptor classDescriptor = entry.getValue();
115
116 if (!DescriptorUtils.isAnnotationClass(classDescriptor)) {
117 processPrimaryConstructor(classDescriptor, entry.getKey());
118 }
119 }
120 }
121
122 private void resolveAnnotationStubsOnClassesAndConstructors() {
123 for (Map.Entry<JetClass, MutableClassDescriptor> entry : context.getClasses().entrySet()) {
124 JetClass jetClass = entry.getKey();
125 MutableClassDescriptor descriptor = entry.getValue();
126 resolveAnnotationsForClassOrObject(annotationResolver, jetClass, descriptor);
127 }
128 for (Map.Entry<JetObjectDeclaration, MutableClassDescriptor> entry : context.getObjects().entrySet()) {
129 JetObjectDeclaration objectDeclaration = entry.getKey();
130 MutableClassDescriptor descriptor = entry.getValue();
131 resolveAnnotationsForClassOrObject(annotationResolver, objectDeclaration, descriptor);
132 }
133 }
134
135 private void resolveAnnotationsForClassOrObject(AnnotationResolver annotationResolver, JetClassOrObject jetClass, MutableClassDescriptor descriptor) {
136 JetModifierList modifierList = jetClass.getModifierList();
137 if (modifierList != null) {
138 descriptor.getAnnotations().addAll(annotationResolver.resolveAnnotations(descriptor.getScopeForSupertypeResolution(), modifierList, trace));
139 }
140 }
141
142 private void resolveFunctionAndPropertyHeaders() {
143 for (Map.Entry<JetFile, WritableScope> entry : context.getNamespaceScopes().entrySet()) {
144 JetFile namespace = entry.getKey();
145 WritableScope namespaceScope = entry.getValue();
146 NamespaceLikeBuilder namespaceDescriptor = context.getNamespaceDescriptors().get(namespace).getBuilder();
147
148 resolveFunctionAndPropertyHeaders(namespace.getDeclarations(), namespaceScope, namespaceScope, namespaceScope, namespaceDescriptor);
149 }
150 for (Map.Entry<JetClass, MutableClassDescriptor> entry : context.getClasses().entrySet()) {
151 JetClass jetClass = entry.getKey();
152 MutableClassDescriptor classDescriptor = entry.getValue();
153
154 JetClassBody jetClassBody = jetClass.getBody();
155 if (classDescriptor.getKind() == ClassKind.ANNOTATION_CLASS && jetClassBody != null) {
156 trace.report(ANNOTATION_CLASS_WITH_BODY.on(jetClassBody));
157 }
158
159 resolveFunctionAndPropertyHeaders(
160 jetClass.getDeclarations(), classDescriptor.getScopeForMemberResolution(),
161 classDescriptor.getScopeForInitializers(), classDescriptor.getScopeForMemberResolution(),
162 classDescriptor.getBuilder());
163 // processPrimaryConstructor(classDescriptor, jetClass);
164 // for (JetSecondaryConstructor jetConstructor : jetClass.getSecondaryConstructors()) {
165 // processSecondaryConstructor(classDescriptor, jetConstructor);
166 // }
167 }
168 for (Map.Entry<JetObjectDeclaration, MutableClassDescriptor> entry : context.getObjects().entrySet()) {
169 JetObjectDeclaration object = entry.getKey();
170 MutableClassDescriptor classDescriptor = entry.getValue();
171
172 resolveFunctionAndPropertyHeaders(object.getDeclarations(), classDescriptor.getScopeForMemberResolution(),
173 classDescriptor.getScopeForInitializers(), classDescriptor.getScopeForMemberResolution(),
174 classDescriptor.getBuilder());
175 }
176
177 scriptHeaderResolver.resolveScriptDeclarations();
178
179 // TODO : Extensions
180 }
181
182 private void resolveFunctionAndPropertyHeaders(@NotNull List<JetDeclaration> declarations,
183 final @NotNull JetScope scopeForFunctions,
184 final @NotNull JetScope scopeForPropertyInitializers, final @NotNull JetScope scopeForPropertyAccessors,
185 final @NotNull NamespaceLikeBuilder namespaceLike)
186 {
187 for (JetDeclaration declaration : declarations) {
188 declaration.accept(new JetVisitorVoid() {
189 @Override
190 public void visitNamedFunction(JetNamedFunction function) {
191 SimpleFunctionDescriptor functionDescriptor = descriptorResolver.resolveFunctionDescriptor(namespaceLike.getOwnerForChildren(), scopeForFunctions, function, trace);
192 namespaceLike.addFunctionDescriptor(functionDescriptor);
193 context.getFunctions().put(function, functionDescriptor);
194 context.registerDeclaringScope(function, scopeForFunctions);
195 }
196
197 @Override
198 public void visitProperty(JetProperty property) {
199 PropertyDescriptor propertyDescriptor = descriptorResolver.resolvePropertyDescriptor(namespaceLike.getOwnerForChildren(), scopeForPropertyInitializers, property, trace);
200 namespaceLike.addPropertyDescriptor(propertyDescriptor);
201 context.getProperties().put(property, propertyDescriptor);
202 context.registerDeclaringScope(property, scopeForPropertyInitializers);
203 JetPropertyAccessor getter = property.getGetter();
204 if (getter != null) {
205 context.registerDeclaringScope(getter, scopeForPropertyAccessors);
206 }
207 JetPropertyAccessor setter = property.getSetter();
208 if (setter != null) {
209 context.registerDeclaringScope(setter, scopeForPropertyAccessors);
210 }
211 }
212
213 @Override
214 public void visitObjectDeclaration(JetObjectDeclaration declaration) {
215 PropertyDescriptor propertyDescriptor = descriptorResolver.resolveObjectDeclarationAsPropertyDescriptor(
216 namespaceLike.getOwnerForChildren(), declaration, context.getObjects().get(declaration), trace);
217
218 namespaceLike.addPropertyDescriptor(propertyDescriptor);
219 }
220
221 @Override
222 public void visitEnumEntry(JetEnumEntry enumEntry) {
223 // FIX: Bad cast
224 MutableClassDescriptorLite classObjectDescriptor =
225 ((MutableClassDescriptorLite)namespaceLike.getOwnerForChildren()).getClassObjectDescriptor();
226 assert classObjectDescriptor != null;
227 PropertyDescriptor propertyDescriptor = descriptorResolver.resolveObjectDeclarationAsPropertyDescriptor(
228 classObjectDescriptor, enumEntry, context.getClasses().get(enumEntry), trace);
229 classObjectDescriptor.getBuilder().addPropertyDescriptor(propertyDescriptor);
230 }
231 });
232 }
233 }
234
235 private void createFunctionsForDataClasses() {
236 for (Map.Entry<JetClass, MutableClassDescriptor> entry : context.getClasses().entrySet()) {
237 JetClass jetClass = entry.getKey();
238 MutableClassDescriptor classDescriptor = entry.getValue();
239
240 if (jetClass.hasPrimaryConstructor() && KotlinBuiltIns.getInstance().isData(classDescriptor)) {
241 ConstructorDescriptor constructor = DescriptorUtils.getConstructorOfDataClass(classDescriptor);
242 createComponentFunctions(classDescriptor, constructor);
243 createCopyFunction(classDescriptor, constructor);
244 }
245 }
246 }
247
248 private void createComponentFunctions(@NotNull MutableClassDescriptor classDescriptor, @NotNull ConstructorDescriptor constructorDescriptor) {
249 int parameterIndex = 0;
250 for (ValueParameterDescriptor parameter : constructorDescriptor.getValueParameters()) {
251 if (!ErrorUtils.isErrorType(parameter.getType())) {
252 PropertyDescriptor property = trace.get(BindingContext.VALUE_PARAMETER_AS_PROPERTY, parameter);
253 if (property != null) {
254 ++parameterIndex;
255
256 SimpleFunctionDescriptor functionDescriptor =
257 DescriptorResolver.createComponentFunctionDescriptor(parameterIndex, property, parameter, classDescriptor, trace);
258
259 classDescriptor.getBuilder().addFunctionDescriptor(functionDescriptor);
260 }
261 }
262 }
263 }
264
265 private void createCopyFunction(@NotNull MutableClassDescriptor classDescriptor, @NotNull ConstructorDescriptor constructorDescriptor) {
266 SimpleFunctionDescriptor functionDescriptor = DescriptorResolver.createCopyFunctionDescriptor(
267 constructorDescriptor.getValueParameters(), classDescriptor, trace);
268
269 classDescriptor.getBuilder().addFunctionDescriptor(functionDescriptor);
270 }
271
272 private void processPrimaryConstructor(MutableClassDescriptor classDescriptor, JetClass klass) {
273 if (classDescriptor.getKind() == ClassKind.TRAIT) {
274 JetParameterList primaryConstructorParameterList = klass.getPrimaryConstructorParameterList();
275 if (primaryConstructorParameterList != null) {
276 trace.report(CONSTRUCTOR_IN_TRAIT.on(primaryConstructorParameterList));
277 }
278 }
279
280 // TODO : not all the parameters are real properties
281 JetScope memberScope = classDescriptor.getScopeForSupertypeResolution();
282 ConstructorDescriptor constructorDescriptor = descriptorResolver.resolvePrimaryConstructorDescriptor(memberScope, classDescriptor, klass, trace);
283 if (constructorDescriptor != null) {
284 List<ValueParameterDescriptor> valueParameterDescriptors = constructorDescriptor.getValueParameters();
285 List<JetParameter> primaryConstructorParameters = klass.getPrimaryConstructorParameters();
286 assert valueParameterDescriptors.size() == primaryConstructorParameters.size();
287 for (ValueParameterDescriptor valueParameterDescriptor : valueParameterDescriptors) {
288 JetParameter parameter = primaryConstructorParameters.get(valueParameterDescriptor.getIndex());
289 if (parameter.getValOrVarNode() != null) {
290 PropertyDescriptor propertyDescriptor = descriptorResolver.resolvePrimaryConstructorParameterToAProperty(
291 classDescriptor,
292 valueParameterDescriptor,
293 memberScope,
294 parameter, trace
295 );
296 classDescriptor.getBuilder().addPropertyDescriptor(propertyDescriptor);
297 context.getPrimaryConstructorParameterProperties().put(parameter, propertyDescriptor);
298 }
299 }
300 if (classDescriptor.getKind() != ClassKind.TRAIT) {
301 classDescriptor.setPrimaryConstructor(constructorDescriptor, trace);
302 }
303 }
304 }
305
306 private void checkRedeclarationsInNamespaces() {
307 for (NamespaceDescriptorImpl descriptor : context.getNamespaceDescriptors().values()) {
308 Multimap<Name, DeclarationDescriptor> simpleNameDescriptors = descriptor.getMemberScope().getDeclaredDescriptorsAccessibleBySimpleName();
309 for (Name name : simpleNameDescriptors.keySet()) {
310 // Keep only properties with no receiver
311 Collection<DeclarationDescriptor> descriptors = Collections2.filter(simpleNameDescriptors.get(name), new Predicate<DeclarationDescriptor>() {
312 @Override
313 public boolean apply(@Nullable DeclarationDescriptor descriptor) {
314 if (descriptor instanceof PropertyDescriptor) {
315 PropertyDescriptor propertyDescriptor = (PropertyDescriptor)descriptor;
316 return propertyDescriptor.getReceiverParameter() == null;
317 }
318 return true;
319 }
320 });
321 if (descriptors.size() > 1) {
322 for (DeclarationDescriptor declarationDescriptor : descriptors) {
323 for (PsiElement declaration : getDeclarationsByDescriptor(declarationDescriptor)) {
324 assert declaration != null : "Null declaration for descriptor: " + declarationDescriptor + " " +
325 (declarationDescriptor != null ? DescriptorRenderer.TEXT.render(declarationDescriptor) : "");
326 trace.report(REDECLARATION.on(declaration, declarationDescriptor.getName().asString()));
327 }
328 }
329 }
330 }
331 }
332 }
333
334 private Collection<PsiElement> getDeclarationsByDescriptor(DeclarationDescriptor declarationDescriptor) {
335 Collection<PsiElement> declarations;
336 if (declarationDescriptor instanceof NamespaceDescriptor) {
337 final NamespaceDescriptor namespace = (NamespaceDescriptor)declarationDescriptor;
338 Collection<JetFile> files = trace.get(BindingContext.NAMESPACE_TO_FILES, namespace);
339
340 if (files == null) {
341 throw new IllegalStateException("declarations corresponding to " + namespace + " are not found");
342 }
343
344 declarations = Collections2.transform(files, new Function<JetFile, PsiElement>() {
345 @Override
346 public PsiElement apply(@Nullable JetFile file) {
347 assert file != null : "File is null for namespace " + namespace;
348 return file.getNamespaceHeader().getNameIdentifier();
349 }
350 });
351 }
352 else {
353 declarations = Collections.singletonList(BindingContextUtils.descriptorToDeclaration(trace.getBindingContext(), declarationDescriptor));
354 }
355 return declarations;
356 }
357
358 private void checkRedeclarationsInInnerClassNames() {
359 Iterable<MutableClassDescriptor> classesAndObjects = Iterables.concat(context.getClasses().values(), context.getObjects().values());
360 for (MutableClassDescriptor classDescriptor : classesAndObjects) {
361 if (classDescriptor.getKind() == ClassKind.CLASS_OBJECT) {
362 // Class objects should be considered during analysing redeclarations in classes
363 continue;
364 }
365
366 Collection<DeclarationDescriptor> allDescriptors = classDescriptor.getScopeForMemberLookup().getOwnDeclaredDescriptors();
367
368 MutableClassDescriptorLite classObj = classDescriptor.getClassObjectDescriptor();
369 if (classObj != null) {
370 Collection<DeclarationDescriptor> classObjDescriptors = classObj.getScopeForMemberLookup().getOwnDeclaredDescriptors();
371 if (!classObjDescriptors.isEmpty()) {
372 allDescriptors = Lists.newArrayList(allDescriptors);
373 allDescriptors.addAll(classObjDescriptors);
374 }
375 }
376
377 Multimap<Name, DeclarationDescriptor> descriptorMap = HashMultimap.create();
378 for (DeclarationDescriptor desc : allDescriptors) {
379 if (desc instanceof ClassDescriptor || desc instanceof PropertyDescriptor) {
380 descriptorMap.put(desc.getName(), desc);
381 }
382 }
383
384 reportRedeclarations(descriptorMap);
385 }
386 }
387
388 private void reportRedeclarations(@NotNull Multimap<Name, DeclarationDescriptor> descriptorMap) {
389 Set<Pair<PsiElement, Name>> redeclarations = Sets.newHashSet();
390 for (Name name : descriptorMap.keySet()) {
391 Collection<DeclarationDescriptor> descriptors = descriptorMap.get(name);
392 if (descriptors.size() > 1) {
393 // We mustn't compare PropertyDescriptor with PropertyDescriptor because we do this at OverloadResolver
394 for (DeclarationDescriptor descriptor : descriptors) {
395 if (descriptor instanceof ClassDescriptor) {
396 for (DeclarationDescriptor descriptor2 : descriptors) {
397 if (descriptor == descriptor2) {
398 continue;
399 }
400
401 redeclarations.add(Pair.create(
402 BindingContextUtils.classDescriptorToDeclaration(trace.getBindingContext(), (ClassDescriptor) descriptor),
403 descriptor.getName()));
404 if (descriptor2 instanceof PropertyDescriptor) {
405 redeclarations.add(Pair.create(
406 BindingContextUtils.descriptorToDeclaration(trace.getBindingContext(), descriptor2),
407 descriptor2.getName()));
408 }
409 }
410 }
411 }
412 }
413 }
414 for (Pair<PsiElement, Name> redeclaration : redeclarations) {
415 trace.report(REDECLARATION.on(redeclaration.getFirst(), redeclaration.getSecond().asString()));
416 }
417 }
418
419
420 }