azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Lazy resolve: Generate fake overrides for functions

Browse Source
This commit is contained in:
Andrey Breslav
2012-05-31 14:29:09 +04:00
parent 5471738dfa
commit 7d550980c6
9 changed files with 107 additions and 48 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java
+18 -1
View File
@@ -18,14 +18,19 @@
package org.jetbrains.jet.di;
import com.intellij.openapi.project.Project;
import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
import org.jetbrains.jet.lang.resolve.BindingTrace;
import org.jetbrains.jet.lang.resolve.DescriptorResolver;
import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
import org.jetbrains.jet.lang.resolve.TypeResolver;
import org.jetbrains.jet.lang.resolve.lazy.ScopeProvider;
import org.jetbrains.jet.lang.resolve.AnnotationResolver;
import org.jetbrains.jet.lang.resolve.calls.CallResolver;
import org.jetbrains.jet.lang.resolve.calls.OverloadingConflictResolver;
import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver;
import com.intellij.openapi.project.Project;
import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
import org.jetbrains.jet.lang.resolve.BindingTrace;
import org.jetbrains.annotations.NotNull;
import javax.annotation.PreDestroy;
@@ -33,21 +38,29 @@ import javax.annotation.PreDestroy;
public class InjectorForLazyResolve {
private final Project project;
private final ResolveSession resolveSession;
private final BindingTrace bindingTrace;
private DescriptorResolver descriptorResolver;
private ExpressionTypingServices expressionTypingServices;
private TypeResolver typeResolver;
private ScopeProvider scopeProvider;
private AnnotationResolver annotationResolver;
private CallResolver callResolver;
private OverloadingConflictResolver overloadingConflictResolver;
private QualifiedExpressionResolver qualifiedExpressionResolver;
public InjectorForLazyResolve(
@NotNull Project project
@NotNull Project project,
@NotNull ResolveSession resolveSession,
@NotNull BindingTrace bindingTrace
) {
this.project = project;
this.resolveSession = resolveSession;
this.bindingTrace = bindingTrace;
this.descriptorResolver = new DescriptorResolver();
this.expressionTypingServices = new ExpressionTypingServices();
this.typeResolver = new TypeResolver();
this.scopeProvider = new ScopeProvider(resolveSession);
this.annotationResolver = new AnnotationResolver();
this.callResolver = new CallResolver();
this.overloadingConflictResolver = new OverloadingConflictResolver();
@@ -92,4 +105,8 @@ public class InjectorForLazyResolve {
return this.typeResolver;
}
public ScopeProvider getScopeProvider() {
return this.scopeProvider;
}
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyMemberScope.java
+6 -4
View File
@@ -99,8 +99,9 @@ public abstract class AbstractLazyMemberScope<D extends DeclarationDescriptor, D
List<JetNamedFunction> declarations = declarationProvider.getFunctionDeclarations(name);
for (JetNamedFunction functionDeclaration : declarations) {
JetScope resolutionScope = getScopeForMemberDeclarationResolution(functionDeclaration);
result.add(resolveSession.getDescriptorResolver().resolveFunctionDescriptor(thisDescriptor, resolutionScope,
functionDeclaration, resolveSession.getTrace()));
result.add(resolveSession.getInjector().getDescriptorResolver().resolveFunctionDescriptor(thisDescriptor, resolutionScope,
functionDeclaration,
resolveSession.getTrace()));
}
getNonDeclaredFunctions(name, result);
@@ -130,8 +131,9 @@ public abstract class AbstractLazyMemberScope<D extends DeclarationDescriptor, D
List<JetProperty> declarations = declarationProvider.getPropertyDeclarations(name);
for (JetProperty propertyDeclaration : declarations) {
JetScope resolutionScope = getScopeForMemberDeclarationResolution(propertyDeclaration);
result.add(resolveSession.getDescriptorResolver().resolvePropertyDescriptor(thisDescriptor, resolutionScope,
propertyDeclaration, resolveSession.getTrace()));
result.add(resolveSession.getInjector().getDescriptorResolver().resolvePropertyDescriptor(thisDescriptor, resolutionScope,
propertyDeclaration,
resolveSession.getTrace()));
}
getNonDeclaredProperties(name, result);
compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyClassDescriptor.java
+3 -3
View File
@@ -247,10 +247,10 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
public Collection<? extends JetType> getSupertypes() {
if (supertypes == null) {
JetClassOrObject declaration = declarationProvider.getOwnerClassOrObject();
this.supertypes = resolveSession.getDescriptorResolver()
this.supertypes = resolveSession.getInjector().getDescriptorResolver()
.resolveSupertypes(getScopeForClassHeaderResolution(),
declaration,
resolveSession.getTrace());
declaration,
resolveSession.getTrace());
}
return supertypes;
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyClassMemberScope.java
+34 -5
View File
@@ -16,15 +16,21 @@
package org.jetbrains.jet.lang.resolve.lazy;
import com.google.common.collect.Lists;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.psi.JetClassOrObject;
import org.jetbrains.jet.lang.diagnostics.Errors;
import org.jetbrains.jet.lang.psi.JetDeclaration;
import org.jetbrains.jet.lang.resolve.BindingContextUtils;
import org.jetbrains.jet.lang.resolve.BindingTrace;
import org.jetbrains.jet.lang.resolve.OverrideResolver;
import org.jetbrains.jet.lang.resolve.name.Name;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
import org.jetbrains.jet.lang.types.JetType;
import java.util.Collection;
import java.util.Set;
/**
@@ -47,10 +53,33 @@ public class LazyClassMemberScope extends AbstractLazyMemberScope<LazyClassDescr
}
@Override
protected void getNonDeclaredFunctions(@NotNull Name name, @NotNull Set<FunctionDescriptor> result) {
JetClassOrObject owner = declarationProvider.getOwnerClassOrObject();
//throw new UnsupportedOperationException(); // TODO
System.err.println("getNonDeclaredFunctions() should generate fake overrides for a class");
protected void getNonDeclaredFunctions(@NotNull Name name, @NotNull final Set<FunctionDescriptor> result) {
Collection<FunctionDescriptor> fromSupertypes = Lists.newArrayList();
for (JetType supertype : thisDescriptor.getTypeConstructor().getSupertypes()) {
fromSupertypes.addAll(supertype.getMemberScope().getFunctions(name));
}
OverrideResolver.generateOverridesInFunctionGroup(
name,
fromSupertypes,
Lists.newArrayList(result),
thisDescriptor,
new OverrideResolver.DescriptorSink() {
@Override
public void addToScope(@NotNull CallableMemberDescriptor fakeOverride) {
assert fakeOverride instanceof FunctionDescriptor : "A non-function overrides a function";
result.add((FunctionDescriptor) fakeOverride);
}
@Override
public void conflict(@NotNull CallableMemberDescriptor fromSuper, @NotNull CallableMemberDescriptor fromCurrent) {
BindingTrace trace = resolveSession.getTrace();
JetDeclaration declaration = (JetDeclaration) BindingContextUtils.descriptorToDeclaration(trace.getBindingContext(),
fromCurrent);
assert declaration != null : "fromCurrent can not be a fake override";
trace.report(Errors.CONFLICTING_OVERLOADS.on(declaration, fromCurrent, fromCurrent.getContainingDeclaration().getName().getName()));
}
}
);
}
@Override
compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyPackageMemberScope.java
+2 -1
View File
@@ -65,7 +65,8 @@ public class LazyPackageMemberScope extends AbstractLazyMemberScope<NamespaceDes
@NotNull
@Override
protected JetScope getScopeForMemberDeclarationResolution(JetDeclaration declaration) {
return resolveSession.getScopeProvider().getFileScopeForDeclarationResolution((JetFile) declaration.getContainingFile());
return resolveSession.getInjector().getScopeProvider()
.getFileScopeForDeclarationResolution((JetFile) declaration.getContainingFile());
}
@NotNull
compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyTypeParameterDescriptor.java
+1 -1
View File
@@ -139,7 +139,7 @@ public class LazyTypeParameterDescriptor implements TypeParameterDescriptor {
}
private JetType resolveBoundType(@NotNull JetTypeReference boundTypeReference) {
return resolveSession.getTypeResolver()
return resolveSession.getInjector().getTypeResolver()
.resolveType(containingDeclaration.getScopeForClassHeaderResolution(), boundTypeReference,
resolveSession.getTrace(), false);
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSession.java
+15 -20
View File
@@ -16,10 +16,12 @@
package org.jetbrains.jet.lang.resolve.lazy;
import com.google.common.base.Predicate;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.intellij.openapi.project.Project;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiFile;
import com.intellij.psi.util.PsiTreeUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
@@ -31,10 +33,7 @@ import org.jetbrains.jet.lang.resolve.name.FqName;
import org.jetbrains.jet.lang.resolve.name.Name;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.*;
/**
* @author abreslav
@@ -42,7 +41,6 @@ import java.util.Set;
public class ResolveSession {
private final ModuleDescriptor module;
private final LazyPackageDescriptor rootPackage;
private final ScopeProvider scopeProvider;
private final BindingTrace trace = new BindingTraceContext();
private final DeclarationProviderFactory declarationProviderFactory;
@@ -55,24 +53,26 @@ public class ResolveSession {
@NotNull ModuleDescriptor rootDescriptor,
@NotNull DeclarationProviderFactory declarationProviderFactory
) {
this.injector = new InjectorForLazyResolve(project);
TopDownAnalysisParameters mockParameters = new TopDownAnalysisParameters(new Predicate<PsiFile>() {
@Override
public boolean apply(@Nullable PsiFile file) {
throw new UnsupportedOperationException("This shouldn't be called from within lazy resolve");
}
}, false, false, Collections.<AnalyzerScriptParameter>emptyList());
this.injector = new InjectorForLazyResolve(project, this, mockParameters, trace);
this.module = rootDescriptor;
DeclarationProvider provider = declarationProviderFactory.getPackageMemberDeclarationProvider(FqName.ROOT);
assert provider != null : "No declaration provider for root package in " + rootDescriptor;
this.rootPackage = new LazyPackageDescriptor(rootDescriptor, JetPsiUtil.ROOT_NAMESPACE_NAME, this, provider);
rootDescriptor.setRootNs(rootPackage);
this.scopeProvider = new ScopeProvider(this);
this.declarationProviderFactory = declarationProviderFactory;
}
@NotNull
public DescriptorResolver getDescriptorResolver() {
return injector.getDescriptorResolver();
}
public TypeResolver getTypeResolver() {
return injector.getTypeResolver();
public InjectorForLazyResolve getInjector() {
return injector;
}
@Nullable
@@ -108,11 +108,6 @@ public class ResolveSession {
throw new UnsupportedOperationException(); // TODO
}
@NotNull
public ScopeProvider getScopeProvider() {
return scopeProvider;
}
public Collection<DeclarationDescriptor> getDescriptorsForDeclarations(Collection<PsiElement> declarationsOrFiles) {
final List<DeclarationDescriptor> descriptors = Lists.newArrayList();
for (PsiElement declarationOrFile : declarationsOrFiles) {
@@ -135,7 +130,7 @@ public class ResolveSession {
@Override
public void visitDeclaration(JetDeclaration dcl) {
JetScope scope = scopeProvider.getResolutionScopeForDeclaration(dcl);
JetScope scope = injector.getScopeProvider().getResolutionScopeForDeclaration(dcl);
collectDescriptors(scope, dcl);
}
@@ -185,7 +180,7 @@ public class ResolveSession {
PsiElement parent = element.getParent();
if (parent instanceof JetFile) {
JetFile file = (JetFile) parent;
return getScopeProvider().getFileScopeForDeclarationResolution(file);
return getInjector().getScopeProvider().getFileScopeForDeclarationResolution(file);
}
if (parent instanceof JetClassBody) {