001 /*
002 * Copyright 2010-2014 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.lazy;
018
019 import com.google.common.collect.Lists;
020 import com.intellij.openapi.project.Project;
021 import com.intellij.psi.PsiElement;
022 import com.intellij.psi.util.PsiTreeUtil;
023 import com.intellij.util.Function;
024 import com.intellij.util.containers.ContainerUtil;
025 import kotlin.Function1;
026 import org.jetbrains.annotations.NotNull;
027 import org.jetbrains.annotations.Nullable;
028 import org.jetbrains.annotations.ReadOnly;
029 import org.jetbrains.jet.context.GlobalContext;
030 import org.jetbrains.jet.lang.descriptors.*;
031 import org.jetbrains.jet.lang.descriptors.annotations.Annotations;
032 import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
033 import org.jetbrains.jet.lang.psi.*;
034 import org.jetbrains.jet.lang.resolve.*;
035 import org.jetbrains.jet.lang.resolve.lazy.data.JetClassLikeInfo;
036 import org.jetbrains.jet.lang.resolve.lazy.data.JetScriptInfo;
037 import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFactory;
038 import org.jetbrains.jet.lang.resolve.lazy.declarations.PackageMemberDeclarationProvider;
039 import org.jetbrains.jet.lang.resolve.lazy.descriptors.*;
040 import org.jetbrains.jet.lang.resolve.name.FqName;
041 import org.jetbrains.jet.lang.resolve.name.Name;
042 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
043 import org.jetbrains.jet.renderer.DescriptorRenderer;
044 import org.jetbrains.jet.storage.*;
045
046 import javax.inject.Inject;
047 import java.util.Collection;
048 import java.util.Collections;
049 import java.util.List;
050
051 public class ResolveSession implements KotlinCodeAnalyzer {
052 private final LazyResolveStorageManager storageManager;
053 private final ExceptionTracker exceptionTracker;
054
055 private final ModuleDescriptor module;
056
057 private final BindingTrace trace;
058 private final DeclarationProviderFactory declarationProviderFactory;
059
060 private final MemoizedFunctionToNullable<FqName, LazyPackageDescriptor> packages;
061 private final PackageFragmentProvider packageFragmentProvider;
062
063 private final MemoizedFunctionToNotNull<JetScript, LazyScriptDescriptor> scriptDescriptors;
064
065 private final MemoizedFunctionToNotNull<JetFile, LazyAnnotations> annotations;
066
067 private ScopeProvider scopeProvider;
068
069 private JetImportsFactory jetImportFactory;
070 private AnnotationResolver annotationResolve;
071 private DescriptorResolver descriptorResolver;
072 private TypeResolver typeResolver;
073 private QualifiedExpressionResolver qualifiedExpressionResolver;
074 private ScriptBodyResolver scriptBodyResolver;
075
076 @Inject
077 public void setJetImportFactory(JetImportsFactory jetImportFactory) {
078 this.jetImportFactory = jetImportFactory;
079 }
080
081 @Inject
082 public void setAnnotationResolve(AnnotationResolver annotationResolve) {
083 this.annotationResolve = annotationResolve;
084 }
085
086 @Inject
087 public void setDescriptorResolver(DescriptorResolver descriptorResolver) {
088 this.descriptorResolver = descriptorResolver;
089 }
090
091 @Inject
092 public void setTypeResolver(TypeResolver typeResolver) {
093 this.typeResolver = typeResolver;
094 }
095
096 @Inject
097 public void setQualifiedExpressionResolver(QualifiedExpressionResolver qualifiedExpressionResolver) {
098 this.qualifiedExpressionResolver = qualifiedExpressionResolver;
099 }
100
101 @Inject
102 public void setScopeProvider(ScopeProvider scopeProvider) {
103 this.scopeProvider = scopeProvider;
104 }
105
106 @Inject
107 public void setScriptBodyResolver(ScriptBodyResolver scriptBodyResolver) {
108 this.scriptBodyResolver = scriptBodyResolver;
109 }
110
111 // Only calls from injectors expected
112 @Deprecated
113 public ResolveSession(
114 @NotNull Project project,
115 @NotNull GlobalContext globalContext,
116 @NotNull ModuleDescriptorImpl rootDescriptor,
117 @NotNull DeclarationProviderFactory declarationProviderFactory,
118 @NotNull BindingTrace delegationTrace
119 ) {
120 LockBasedLazyResolveStorageManager lockBasedLazyResolveStorageManager = new LockBasedLazyResolveStorageManager(
121 (LockBasedStorageManager) globalContext.getStorageManager());
122 this.storageManager = lockBasedLazyResolveStorageManager;
123 this.exceptionTracker = globalContext.getExceptionTracker();
124 this.trace = lockBasedLazyResolveStorageManager.createSafeTrace(delegationTrace);
125 this.module = rootDescriptor;
126
127 this.packages = storageManager.createMemoizedFunctionWithNullableValues(new MemoizedFunctionToNullable<FqName, LazyPackageDescriptor>() {
128 @Nullable
129 @Override
130 public LazyPackageDescriptor invoke(FqName fqName) {
131 return createPackage(fqName);
132 }
133 });
134
135 this.declarationProviderFactory = declarationProviderFactory;
136
137 this.packageFragmentProvider = new PackageFragmentProvider() {
138 @NotNull
139 @Override
140 public List<PackageFragmentDescriptor> getPackageFragments(@NotNull FqName fqName) {
141 return ContainerUtil.<PackageFragmentDescriptor>createMaybeSingletonList(getPackageFragment(fqName));
142 }
143
144 @NotNull
145 @Override
146 public Collection<FqName> getSubPackagesOf(@NotNull FqName fqName) {
147 LazyPackageDescriptor packageDescriptor = getPackageFragment(fqName);
148 if (packageDescriptor == null) {
149 return Collections.emptyList();
150 }
151 return packageDescriptor.getDeclarationProvider().getAllDeclaredSubPackages();
152 }
153 };
154
155 this.scriptDescriptors = storageManager.createMemoizedFunction(
156 new Function1<JetScript, LazyScriptDescriptor>() {
157 @Override
158 public LazyScriptDescriptor invoke(JetScript script) {
159 return new LazyScriptDescriptor(
160 ResolveSession.this,
161 scriptBodyResolver,
162 script,
163 ScriptHeaderResolver.getScriptPriority(script)
164 );
165 }
166 }
167 );
168
169 annotations = storageManager.createMemoizedFunction(new Function1<JetFile, LazyAnnotations>() {
170 @Override
171 public LazyAnnotations invoke(JetFile file) {
172 JetScope scope = getScopeProvider().getFileScope(file);
173 LazyAnnotationsContextImpl lazyAnnotationContext = new LazyAnnotationsContextImpl(annotationResolve, storageManager, trace, scope);
174 return new LazyAnnotations(lazyAnnotationContext, file.getAnnotationEntries());
175 }
176 });
177 }
178
179 @NotNull
180 public PackageFragmentProvider getPackageFragmentProvider() {
181 return packageFragmentProvider;
182 }
183
184 @Override
185 @Nullable
186 public LazyPackageDescriptor getPackageFragment(@NotNull FqName fqName) {
187 return packages.invoke(fqName);
188 }
189
190 @Nullable
191 private LazyPackageDescriptor createPackage(FqName fqName) {
192 if (!fqName.isRoot() && getPackageFragment(fqName.parent()) == null) {
193 return null;
194 }
195 PackageMemberDeclarationProvider provider = declarationProviderFactory.getPackageMemberDeclarationProvider(fqName);
196 if (provider == null) {
197 return null;
198 }
199 return new LazyPackageDescriptor(module, fqName, this, provider);
200 }
201
202 @NotNull
203 @Override
204 public ModuleDescriptor getModuleDescriptor() {
205 return module;
206 }
207
208 @NotNull
209 //@Override
210 public LazyResolveStorageManager getStorageManager() {
211 return storageManager;
212 }
213
214 @NotNull
215 //@Override
216 public ExceptionTracker getExceptionTracker() {
217 return exceptionTracker;
218 }
219
220 @Override
221 @NotNull
222 @ReadOnly
223 public Collection<ClassDescriptor> getTopLevelClassDescriptors(@NotNull FqName fqName) {
224 if (fqName.isRoot()) return Collections.emptyList();
225
226 PackageMemberDeclarationProvider provider = declarationProviderFactory.getPackageMemberDeclarationProvider(fqName.parent());
227 if (provider == null) return Collections.emptyList();
228
229 return ContainerUtil.mapNotNull(
230 provider.getClassOrObjectDeclarations(fqName.shortName()),
231 new Function<JetClassLikeInfo, ClassDescriptor>() {
232 @Override
233 public ClassDescriptor fun(JetClassLikeInfo classLikeInfo) {
234 if (classLikeInfo instanceof JetScriptInfo) {
235 return getClassDescriptorForScript(((JetScriptInfo) classLikeInfo).getScript());
236 }
237 JetClassOrObject classOrObject = classLikeInfo.getCorrespondingClassOrObject();
238 if (classOrObject == null) return null;
239 return getClassDescriptor(classOrObject);
240 }
241 }
242 );
243 }
244
245 @Override
246 @NotNull
247 public ClassDescriptor getClassDescriptor(@NotNull JetClassOrObject classOrObject) {
248 if (classOrObject instanceof JetObjectDeclaration) {
249 JetObjectDeclaration objectDeclaration = (JetObjectDeclaration) classOrObject;
250 JetClassObject classObjectElement = objectDeclaration.getClassObjectElement();
251 if (classObjectElement != null) {
252 return getClassObjectDescriptor(classObjectElement);
253 }
254 }
255 JetScope resolutionScope = getScopeProvider().getResolutionScopeForDeclaration(classOrObject);
256 Name name = classOrObject.getNameAsSafeName();
257
258 // Why not use the result here. Because it may be that there is a redeclaration:
259 // class A {} class A { fun foo(): A<completion here>}
260 // and if we find the class by name only, we may b-not get the right one.
261 // This call is only needed to make sure the classes are written to trace
262 ClassifierDescriptor scopeDescriptor = resolutionScope.getClassifier(name);
263 DeclarationDescriptor descriptor = getBindingContext().get(BindingContext.DECLARATION_TO_DESCRIPTOR, classOrObject);
264
265 if (descriptor == null) {
266 throw new IllegalArgumentException(
267 String.format("Could not find a classifier for %s.\n" +
268 "Found descriptor: %s (%s).\n",
269 JetPsiUtil.getElementTextWithContext(classOrObject),
270 scopeDescriptor != null ? DescriptorRenderer.DEBUG_TEXT.render(scopeDescriptor) : "null",
271 scopeDescriptor != null ? (scopeDescriptor.getContainingDeclaration().getClass()) : null));
272 }
273
274 return (ClassDescriptor) descriptor;
275 }
276
277 @NotNull
278 public ClassDescriptor getClassDescriptorForScript(@NotNull JetScript script) {
279 JetScope resolutionScope = getScopeProvider().getResolutionScopeForDeclaration(script);
280 FqName fqName = ScriptNameUtil.classNameForScript(script);
281 ClassifierDescriptor classifier = resolutionScope.getClassifier(fqName.shortName());
282 assert classifier != null : "No descriptor for " + fqName + " in file " + script.getContainingFile();
283 return (ClassDescriptor) classifier;
284 }
285
286 @Override
287 @NotNull
288 public ScriptDescriptor getScriptDescriptor(@NotNull JetScript script) {
289 return scriptDescriptors.invoke(script);
290 }
291
292 @NotNull
293 /*package*/ LazyClassDescriptor getClassObjectDescriptor(@NotNull JetClassObject classObject) {
294 JetClass aClass = JetStubbedPsiUtil.getContainingDeclaration(classObject, JetClass.class);
295
296 LazyClassDescriptor parentClassDescriptor;
297
298 if (aClass != null) {
299 parentClassDescriptor = (LazyClassDescriptor) getClassDescriptor(aClass);
300 }
301 else {
302 // Class object in object is an error but we want to find descriptors even for this case
303 JetObjectDeclaration objectDeclaration = PsiTreeUtil.getParentOfType(classObject, JetObjectDeclaration.class);
304 assert objectDeclaration != null : String.format("Class object %s can be in class or object in file %s", classObject, classObject.getContainingFile().getText());
305 parentClassDescriptor = (LazyClassDescriptor) getClassDescriptor(objectDeclaration);
306 }
307
308 // Activate resolution and writing to trace
309 parentClassDescriptor.getClassObjectDescriptor();
310 parentClassDescriptor.getDescriptorsForExtraClassObjects();
311 DeclarationDescriptor classObjectDescriptor = getBindingContext().get(BindingContext.DECLARATION_TO_DESCRIPTOR, classObject.getObjectDeclaration());
312 assert classObjectDescriptor != null : "No descriptor found for " + JetPsiUtil.getElementTextWithContext(classObject);
313
314 return (LazyClassDescriptor) classObjectDescriptor;
315 }
316
317 @Override
318 @NotNull
319 public BindingContext getBindingContext() {
320 return trace.getBindingContext();
321 }
322
323 @NotNull
324 public BindingTrace getTrace() {
325 return trace;
326 }
327
328 @NotNull
329 public DeclarationProviderFactory getDeclarationProviderFactory() {
330 return declarationProviderFactory;
331 }
332
333 @Override
334 @NotNull
335 public DeclarationDescriptor resolveToDescriptor(@NotNull JetDeclaration declaration) {
336 DeclarationDescriptor result = declaration.accept(new JetVisitor<DeclarationDescriptor, Void>() {
337 @Override
338 public DeclarationDescriptor visitClass(@NotNull JetClass klass, Void data) {
339 return getClassDescriptor(klass);
340 }
341
342 @Override
343 public DeclarationDescriptor visitObjectDeclaration(@NotNull JetObjectDeclaration declaration, Void data) {
344 PsiElement parent = declaration.getParent();
345 if (parent instanceof JetClassObject) {
346 JetClassObject jetClassObject = (JetClassObject) parent;
347 return resolveToDescriptor(jetClassObject);
348 }
349 return getClassDescriptor(declaration);
350 }
351
352 @Override
353 public DeclarationDescriptor visitClassObject(@NotNull JetClassObject classObject, Void data) {
354 return getClassObjectDescriptor(classObject);
355 }
356
357 @Override
358 public DeclarationDescriptor visitTypeParameter(@NotNull JetTypeParameter parameter, Void data) {
359 JetTypeParameterListOwner ownerElement = PsiTreeUtil.getParentOfType(parameter, JetTypeParameterListOwner.class);
360 DeclarationDescriptor ownerDescriptor = resolveToDescriptor(ownerElement);
361
362 List<TypeParameterDescriptor> typeParameters;
363 if (ownerDescriptor instanceof CallableDescriptor) {
364 CallableDescriptor callableDescriptor = (CallableDescriptor) ownerDescriptor;
365 typeParameters = callableDescriptor.getTypeParameters();
366 }
367 else if (ownerDescriptor instanceof ClassDescriptor) {
368 ClassDescriptor classDescriptor = (ClassDescriptor) ownerDescriptor;
369 typeParameters = classDescriptor.getTypeConstructor().getParameters();
370 }
371 else {
372 throw new IllegalStateException("Unknown owner kind for a type parameter: " + ownerDescriptor);
373 }
374
375 Name name = parameter.getNameAsSafeName();
376 for (TypeParameterDescriptor typeParameterDescriptor : typeParameters) {
377 if (typeParameterDescriptor.getName().equals(name)) {
378 return typeParameterDescriptor;
379 }
380 }
381
382 throw new IllegalStateException("Type parameter " + name + " not found for " + ownerDescriptor);
383 }
384
385 @Override
386 public DeclarationDescriptor visitNamedFunction(@NotNull JetNamedFunction function, Void data) {
387 JetScope scopeForDeclaration = getScopeProvider().getResolutionScopeForDeclaration(function);
388 scopeForDeclaration.getFunctions(function.getNameAsSafeName());
389 return getBindingContext().get(BindingContext.DECLARATION_TO_DESCRIPTOR, function);
390 }
391
392 @Override
393 public DeclarationDescriptor visitParameter(@NotNull JetParameter parameter, Void data) {
394 PsiElement grandFather = parameter.getParent().getParent();
395 if (grandFather instanceof JetClass) {
396 JetClass jetClass = (JetClass) grandFather;
397 // This is a primary constructor parameter
398 ClassDescriptor classDescriptor = getClassDescriptor(jetClass);
399 if (parameter.hasValOrVarNode()) {
400 classDescriptor.getDefaultType().getMemberScope().getProperties(parameter.getNameAsSafeName());
401 return getBindingContext().get(BindingContext.PRIMARY_CONSTRUCTOR_PARAMETER, parameter);
402 }
403 else {
404 ConstructorDescriptor constructor = classDescriptor.getUnsubstitutedPrimaryConstructor();
405 assert constructor != null: "There are constructor parameters found, so a constructor should also exist";
406 constructor.getValueParameters();
407 return getBindingContext().get(BindingContext.VALUE_PARAMETER, parameter);
408 }
409 }
410 return super.visitParameter(parameter, data);
411 }
412
413 @Override
414 public DeclarationDescriptor visitProperty(@NotNull JetProperty property, Void data) {
415 JetScope scopeForDeclaration = getScopeProvider().getResolutionScopeForDeclaration(property);
416 scopeForDeclaration.getProperties(property.getNameAsSafeName());
417 return getBindingContext().get(BindingContext.DECLARATION_TO_DESCRIPTOR, property);
418 }
419
420 @Override
421 public DeclarationDescriptor visitJetElement(@NotNull JetElement element, Void data) {
422 throw new IllegalArgumentException("Unsupported declaration type: " + element + " " +
423 JetPsiUtil.getElementTextWithContext(element));
424 }
425 }, null);
426 if (result == null) {
427 throw new IllegalStateException("No descriptor resolved for " + declaration + ":\n" +
428 JetPsiUtil.getElementTextWithContext(declaration));
429 }
430 return result;
431 }
432
433 @NotNull
434 public Annotations getFileAnnotations(@NotNull JetFile file) {
435 return annotations.invoke(file);
436 }
437
438 @NotNull
439 private List<LazyPackageDescriptor> getAllPackages() {
440 LazyPackageDescriptor rootPackage = getPackageFragment(FqName.ROOT);
441 assert rootPackage != null : "Root package must be initialized";
442
443 return collectAllPackages(Lists.<LazyPackageDescriptor>newArrayList(), rootPackage);
444 }
445
446 @NotNull
447 private List<LazyPackageDescriptor> collectAllPackages(
448 @NotNull List<LazyPackageDescriptor> result,
449 @NotNull LazyPackageDescriptor current
450 ) {
451 result.add(current);
452 for (FqName subPackage : packageFragmentProvider.getSubPackagesOf(current.getFqName())) {
453 LazyPackageDescriptor fragment = getPackageFragment(subPackage);
454 assert fragment != null : "Couldn't find fragment for " + subPackage;
455 collectAllPackages(result, fragment);
456 }
457 return result;
458 }
459
460 @Override
461 public void forceResolveAll() {
462 for (LazyPackageDescriptor lazyPackage : getAllPackages()) {
463 ForceResolveUtil.forceResolveAllContents(lazyPackage);
464 }
465 }
466
467 @Override
468 @NotNull
469 public ScopeProvider getScopeProvider() {
470 return scopeProvider;
471 }
472
473 @NotNull
474 public JetImportsFactory getJetImportsFactory() {
475 return jetImportFactory;
476 }
477
478 @NotNull
479 public AnnotationResolver getAnnotationResolver() {
480 return annotationResolve;
481 }
482
483 @NotNull
484 public DescriptorResolver getDescriptorResolver() {
485 return descriptorResolver;
486 }
487
488 @NotNull
489 public TypeResolver getTypeResolver() {
490 return typeResolver;
491 }
492
493 @NotNull
494 public QualifiedExpressionResolver getQualifiedExpressionResolver() {
495 return qualifiedExpressionResolver;
496 }
497 }