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