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