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