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

Refactor JavaDescriptorResolver and *Resolver classes to use DI for dependency management

Browse Source
This commit is contained in:
Pavel V. Talanov
2012-10-10 17:42:00 +04:00
parent 0f3c2f9fca
commit 0aeb756f98
13 changed files with 527 additions and 202 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java
+72 -2
View File
@@ -26,7 +26,16 @@ import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
import org.jetbrains.jet.lang.resolve.java.PsiClassFinderImpl;
import org.jetbrains.jet.lang.resolve.java.JavaTypeTransformer;
import org.jetbrains.jet.lang.resolve.java.resolver.ClassResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.CompileTimeConstResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.NamespaceResolver;
import org.jetbrains.jet.lang.resolve.java.JavaDescriptorSignatureResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.ConstructorResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.ValueParameterResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.FunctionResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.InnerClassResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.PropertiesResolver;
import org.jetbrains.annotations.NotNull;
import javax.annotation.PreDestroy;
@@ -42,7 +51,16 @@ public class InjectorForJavaDescriptorResolver {
private JavaDescriptorResolver javaDescriptorResolver;
private PsiClassFinderImpl psiClassFinder;
private JavaTypeTransformer javaTypeTransformer;
private ClassResolver classResolver;
private JavaAnnotationResolver javaAnnotationResolver;
private CompileTimeConstResolver compileTimeConstResolver;
private NamespaceResolver namespaceResolver;
private JavaDescriptorSignatureResolver javaDescriptorSignatureResolver;
private ConstructorResolver constructorResolver;
private ValueParameterResolver valueParameterResolver;
private FunctionResolver functionResolver;
private InnerClassResolver innerClassResolver;
private PropertiesResolver propertiesResolver;
public InjectorForJavaDescriptorResolver(
@NotNull Project project,
@@ -59,7 +77,16 @@ public class InjectorForJavaDescriptorResolver {
this.javaDescriptorResolver = new JavaDescriptorResolver();
this.psiClassFinder = new PsiClassFinderImpl();
this.javaTypeTransformer = new JavaTypeTransformer();
this.classResolver = new ClassResolver();
this.javaAnnotationResolver = new JavaAnnotationResolver();
this.compileTimeConstResolver = new CompileTimeConstResolver();
this.namespaceResolver = new NamespaceResolver();
this.javaDescriptorSignatureResolver = new JavaDescriptorSignatureResolver();
this.constructorResolver = new ConstructorResolver();
this.valueParameterResolver = new ValueParameterResolver();
this.functionResolver = new FunctionResolver();
this.innerClassResolver = new InnerClassResolver();
this.propertiesResolver = new PropertiesResolver();
javaBridgeConfiguration.setBuiltinsScopeExtensionMode(builtinsScopeExtensionMode);
javaBridgeConfiguration.setJavaSemanticServices(javaSemanticServices);
@@ -70,9 +97,13 @@ public class InjectorForJavaDescriptorResolver {
this.javaSemanticServices.setTrace(bindingTrace);
this.javaSemanticServices.setTypeTransformer(javaTypeTransformer);
this.javaDescriptorResolver.setJavaDescriptorSignatureResolver(javaDescriptorSignatureResolver);
this.javaDescriptorResolver.setClassResolver(classResolver);
this.javaDescriptorResolver.setConstructorResolver(constructorResolver);
this.javaDescriptorResolver.setFunctionResolver(functionResolver);
this.javaDescriptorResolver.setInnerClassResolver(innerClassResolver);
this.javaDescriptorResolver.setNamespaceResolver(namespaceResolver);
this.javaDescriptorResolver.setProject(project);
this.javaDescriptorResolver.setPsiClassFinder(psiClassFinder);
this.javaDescriptorResolver.setPropertiesResolver(propertiesResolver);
this.javaDescriptorResolver.setSemanticServices(javaSemanticServices);
this.javaDescriptorResolver.setTrace(bindingTrace);
@@ -81,8 +112,47 @@ public class InjectorForJavaDescriptorResolver {
javaTypeTransformer.setJavaSemanticServices(javaSemanticServices);
javaTypeTransformer.setResolver(javaDescriptorResolver);
classResolver.setAnnotationResolver(javaAnnotationResolver);
classResolver.setJavaDescriptorResolver(javaDescriptorResolver);
classResolver.setNamespaceResolver(namespaceResolver);
classResolver.setPsiClassFinder(psiClassFinder);
classResolver.setSemanticServices(javaSemanticServices);
classResolver.setSignatureResolver(javaDescriptorSignatureResolver);
classResolver.setTrace(bindingTrace);
classResolver.setTypeTransformer(javaTypeTransformer);
javaAnnotationResolver.setClassResolver(classResolver);
javaAnnotationResolver.setCompileTimeConstResolver(compileTimeConstResolver);
compileTimeConstResolver.setAnnotationResolver(javaAnnotationResolver);
compileTimeConstResolver.setClassResolver(classResolver);
namespaceResolver.setJavaSemanticServices(javaSemanticServices);
namespaceResolver.setPsiClassFinder(psiClassFinder);
namespaceResolver.setTrace(bindingTrace);
javaDescriptorSignatureResolver.setJavaSemanticServices(javaSemanticServices);
constructorResolver.setTrace(bindingTrace);
constructorResolver.setTypeTransformer(javaTypeTransformer);
constructorResolver.setValueParameterResolver(valueParameterResolver);
valueParameterResolver.setTypeTransformer(javaTypeTransformer);
functionResolver.setAnnotationResolver(javaAnnotationResolver);
functionResolver.setParameterResolver(valueParameterResolver);
functionResolver.setSignatureResolver(javaDescriptorSignatureResolver);
functionResolver.setTrace(bindingTrace);
functionResolver.setTypeTransformer(javaTypeTransformer);
innerClassResolver.setClassResolver(classResolver);
propertiesResolver.setAnnotationResolver(javaAnnotationResolver);
propertiesResolver.setClassResolver(classResolver);
propertiesResolver.setJavaDescriptorSignatureResolver(javaDescriptorSignatureResolver);
propertiesResolver.setSemanticServices(javaSemanticServices);
propertiesResolver.setTrace(bindingTrace);
javaBridgeConfiguration.init();
psiClassFinder.initialize();
compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java
+72 -2
View File
@@ -26,7 +26,16 @@ import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
import org.jetbrains.jet.lang.BuiltinsScopeExtensionMode;
import com.intellij.openapi.project.Project;
import org.jetbrains.jet.lang.resolve.java.JavaTypeTransformer;
import org.jetbrains.jet.lang.resolve.java.resolver.ClassResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.CompileTimeConstResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.NamespaceResolver;
import org.jetbrains.jet.lang.resolve.java.JavaDescriptorSignatureResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.ConstructorResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.ValueParameterResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.FunctionResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.InnerClassResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.PropertiesResolver;
import org.jetbrains.annotations.NotNull;
import javax.annotation.PreDestroy;
@@ -42,7 +51,16 @@ public class InjectorForJavaSemanticServices {
private final BuiltinsScopeExtensionMode builtinsScopeExtensionMode;
private final Project project;
private JavaTypeTransformer javaTypeTransformer;
private ClassResolver classResolver;
private JavaAnnotationResolver javaAnnotationResolver;
private CompileTimeConstResolver compileTimeConstResolver;
private NamespaceResolver namespaceResolver;
private JavaDescriptorSignatureResolver javaDescriptorSignatureResolver;
private ConstructorResolver constructorResolver;
private ValueParameterResolver valueParameterResolver;
private FunctionResolver functionResolver;
private InnerClassResolver innerClassResolver;
private PropertiesResolver propertiesResolver;
public InjectorForJavaSemanticServices(
@NotNull BuiltinsScopeExtensionMode builtinsScopeExtensionMode,
@@ -57,16 +75,29 @@ public class InjectorForJavaSemanticServices {
this.builtinsScopeExtensionMode = builtinsScopeExtensionMode;
this.project = project;
this.javaTypeTransformer = new JavaTypeTransformer();
this.classResolver = new ClassResolver();
this.javaAnnotationResolver = new JavaAnnotationResolver();
this.compileTimeConstResolver = new CompileTimeConstResolver();
this.namespaceResolver = new NamespaceResolver();
this.javaDescriptorSignatureResolver = new JavaDescriptorSignatureResolver();
this.constructorResolver = new ConstructorResolver();
this.valueParameterResolver = new ValueParameterResolver();
this.functionResolver = new FunctionResolver();
this.innerClassResolver = new InnerClassResolver();
this.propertiesResolver = new PropertiesResolver();
this.javaSemanticServices.setDescriptorResolver(javaDescriptorResolver);
this.javaSemanticServices.setPsiClassFinder(psiClassFinder);
this.javaSemanticServices.setTrace(bindingTrace);
this.javaSemanticServices.setTypeTransformer(javaTypeTransformer);
this.javaDescriptorResolver.setJavaDescriptorSignatureResolver(javaDescriptorSignatureResolver);
this.javaDescriptorResolver.setClassResolver(classResolver);
this.javaDescriptorResolver.setConstructorResolver(constructorResolver);
this.javaDescriptorResolver.setFunctionResolver(functionResolver);
this.javaDescriptorResolver.setInnerClassResolver(innerClassResolver);
this.javaDescriptorResolver.setNamespaceResolver(namespaceResolver);
this.javaDescriptorResolver.setProject(project);
this.javaDescriptorResolver.setPsiClassFinder(psiClassFinder);
this.javaDescriptorResolver.setPropertiesResolver(propertiesResolver);
this.javaDescriptorResolver.setSemanticServices(javaSemanticServices);
this.javaDescriptorResolver.setTrace(bindingTrace);
@@ -79,8 +110,47 @@ public class InjectorForJavaSemanticServices {
javaTypeTransformer.setJavaSemanticServices(javaSemanticServices);
javaTypeTransformer.setResolver(javaDescriptorResolver);
classResolver.setAnnotationResolver(javaAnnotationResolver);
classResolver.setJavaDescriptorResolver(javaDescriptorResolver);
classResolver.setNamespaceResolver(namespaceResolver);
classResolver.setPsiClassFinder(psiClassFinder);
classResolver.setSemanticServices(javaSemanticServices);
classResolver.setSignatureResolver(javaDescriptorSignatureResolver);
classResolver.setTrace(bindingTrace);
classResolver.setTypeTransformer(javaTypeTransformer);
javaAnnotationResolver.setClassResolver(classResolver);
javaAnnotationResolver.setCompileTimeConstResolver(compileTimeConstResolver);
compileTimeConstResolver.setAnnotationResolver(javaAnnotationResolver);
compileTimeConstResolver.setClassResolver(classResolver);
namespaceResolver.setJavaSemanticServices(javaSemanticServices);
namespaceResolver.setPsiClassFinder(psiClassFinder);
namespaceResolver.setTrace(bindingTrace);
javaDescriptorSignatureResolver.setJavaSemanticServices(javaSemanticServices);
constructorResolver.setTrace(bindingTrace);
constructorResolver.setTypeTransformer(javaTypeTransformer);
constructorResolver.setValueParameterResolver(valueParameterResolver);
valueParameterResolver.setTypeTransformer(javaTypeTransformer);
functionResolver.setAnnotationResolver(javaAnnotationResolver);
functionResolver.setParameterResolver(valueParameterResolver);
functionResolver.setSignatureResolver(javaDescriptorSignatureResolver);
functionResolver.setTrace(bindingTrace);
functionResolver.setTypeTransformer(javaTypeTransformer);
innerClassResolver.setClassResolver(classResolver);
propertiesResolver.setAnnotationResolver(javaAnnotationResolver);
propertiesResolver.setClassResolver(classResolver);
propertiesResolver.setJavaDescriptorSignatureResolver(javaDescriptorSignatureResolver);
propertiesResolver.setSemanticServices(javaSemanticServices);
propertiesResolver.setTrace(bindingTrace);
javaBridgeConfiguration.init();
psiClassFinder.initialize();
compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java
+72 -2
View File
@@ -48,7 +48,16 @@ import org.jetbrains.jet.lang.resolve.TypeHierarchyResolver;
import org.jetbrains.jet.lang.resolve.ScriptBodyResolver;
import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
import org.jetbrains.jet.lang.resolve.java.JavaTypeTransformer;
import org.jetbrains.jet.lang.resolve.java.resolver.ClassResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.CompileTimeConstResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.NamespaceResolver;
import org.jetbrains.jet.lang.resolve.java.JavaDescriptorSignatureResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.ConstructorResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.ValueParameterResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.FunctionResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.InnerClassResolver;
import org.jetbrains.jet.lang.resolve.java.resolver.PropertiesResolver;
import org.jetbrains.annotations.NotNull;
import javax.annotation.PreDestroy;
@@ -85,7 +94,16 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
private ScriptBodyResolver scriptBodyResolver;
private JavaSemanticServices javaSemanticServices;
private JavaTypeTransformer javaTypeTransformer;
private ClassResolver classResolver;
private JavaAnnotationResolver javaAnnotationResolver;
private CompileTimeConstResolver compileTimeConstResolver;
private NamespaceResolver namespaceResolver;
private JavaDescriptorSignatureResolver javaDescriptorSignatureResolver;
private ConstructorResolver constructorResolver;
private ValueParameterResolver valueParameterResolver;
private FunctionResolver functionResolver;
private InnerClassResolver innerClassResolver;
private PropertiesResolver propertiesResolver;
public InjectorForTopDownAnalyzerForJvm(
@NotNull Project project,
@@ -124,7 +142,16 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
this.scriptBodyResolver = new ScriptBodyResolver();
this.javaSemanticServices = new JavaSemanticServices();
this.javaTypeTransformer = new JavaTypeTransformer();
this.classResolver = new ClassResolver();
this.javaAnnotationResolver = new JavaAnnotationResolver();
this.compileTimeConstResolver = new CompileTimeConstResolver();
this.namespaceResolver = new NamespaceResolver();
this.javaDescriptorSignatureResolver = new JavaDescriptorSignatureResolver();
this.constructorResolver = new ConstructorResolver();
this.valueParameterResolver = new ValueParameterResolver();
this.functionResolver = new FunctionResolver();
this.innerClassResolver = new InnerClassResolver();
this.propertiesResolver = new PropertiesResolver();
this.topDownAnalyzer.setBodyResolver(bodyResolver);
this.topDownAnalyzer.setContext(topDownAnalysisContext);
@@ -162,9 +189,13 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
this.moduleConfiguration.setJavaSemanticServices(javaSemanticServices);
this.moduleConfiguration.setProject(project);
javaDescriptorResolver.setJavaDescriptorSignatureResolver(javaDescriptorSignatureResolver);
javaDescriptorResolver.setClassResolver(classResolver);
javaDescriptorResolver.setConstructorResolver(constructorResolver);
javaDescriptorResolver.setFunctionResolver(functionResolver);
javaDescriptorResolver.setInnerClassResolver(innerClassResolver);
javaDescriptorResolver.setNamespaceResolver(namespaceResolver);
javaDescriptorResolver.setProject(project);
javaDescriptorResolver.setPsiClassFinder(psiClassFinder);
javaDescriptorResolver.setPropertiesResolver(propertiesResolver);
javaDescriptorResolver.setSemanticServices(javaSemanticServices);
javaDescriptorResolver.setTrace(bindingTrace);
@@ -236,8 +267,47 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
javaTypeTransformer.setJavaSemanticServices(javaSemanticServices);
javaTypeTransformer.setResolver(javaDescriptorResolver);
classResolver.setAnnotationResolver(javaAnnotationResolver);
classResolver.setJavaDescriptorResolver(javaDescriptorResolver);
classResolver.setNamespaceResolver(namespaceResolver);
classResolver.setPsiClassFinder(psiClassFinder);
classResolver.setSemanticServices(javaSemanticServices);
classResolver.setSignatureResolver(javaDescriptorSignatureResolver);
classResolver.setTrace(bindingTrace);
classResolver.setTypeTransformer(javaTypeTransformer);
javaAnnotationResolver.setClassResolver(classResolver);
javaAnnotationResolver.setCompileTimeConstResolver(compileTimeConstResolver);
compileTimeConstResolver.setAnnotationResolver(javaAnnotationResolver);
compileTimeConstResolver.setClassResolver(classResolver);
namespaceResolver.setJavaSemanticServices(javaSemanticServices);
namespaceResolver.setPsiClassFinder(psiClassFinder);
namespaceResolver.setTrace(bindingTrace);
javaDescriptorSignatureResolver.setJavaSemanticServices(javaSemanticServices);
constructorResolver.setTrace(bindingTrace);
constructorResolver.setTypeTransformer(javaTypeTransformer);
constructorResolver.setValueParameterResolver(valueParameterResolver);
valueParameterResolver.setTypeTransformer(javaTypeTransformer);
functionResolver.setAnnotationResolver(javaAnnotationResolver);
functionResolver.setParameterResolver(valueParameterResolver);
functionResolver.setSignatureResolver(javaDescriptorSignatureResolver);
functionResolver.setTrace(bindingTrace);
functionResolver.setTypeTransformer(javaTypeTransformer);
innerClassResolver.setClassResolver(classResolver);
propertiesResolver.setAnnotationResolver(javaAnnotationResolver);
propertiesResolver.setClassResolver(classResolver);
propertiesResolver.setJavaDescriptorSignatureResolver(javaDescriptorSignatureResolver);
propertiesResolver.setSemanticServices(javaSemanticServices);
propertiesResolver.setTrace(bindingTrace);
moduleConfiguration.init();
psiClassFinder.initialize();
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java
+31 -67
View File
@@ -17,22 +17,16 @@
package org.jetbrains.jet.lang.resolve.java;
import com.intellij.openapi.project.Project;
import com.intellij.psi.PsiAnnotation;
import com.intellij.psi.PsiAnnotationMemberValue;
import com.intellij.psi.PsiClass;
import com.intellij.psi.PsiModifierListOwner;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
import org.jetbrains.jet.lang.resolve.BindingTrace;
import org.jetbrains.jet.lang.resolve.DescriptorUtils;
import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
import org.jetbrains.jet.lang.resolve.java.data.ResolverClassData;
import org.jetbrains.jet.lang.resolve.java.data.ResolverScopeData;
import org.jetbrains.jet.lang.resolve.java.resolver.*;
import org.jetbrains.jet.lang.resolve.java.scope.JavaPackageScope;
import org.jetbrains.jet.lang.resolve.java.wrapper.PsiParameterWrapper;
import org.jetbrains.jet.lang.resolve.name.FqName;
import org.jetbrains.jet.lang.resolve.name.Name;
import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolver;
@@ -70,17 +64,12 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
protected Project project;
protected JavaSemanticServices semanticServices;
private BindingTrace trace;
private PsiClassFinder psiClassFinder;
private JavaDescriptorSignatureResolver javaDescriptorSignatureResolver;
private final PropertiesResolver propertiesResolver = new PropertiesResolver(this);
private final ClassResolver classResolver = new ClassResolver(this);
private final ConstructorResolver constructorResolver = new ConstructorResolver(this);
private final CompileTimeConstResolver compileTimeConstResolver = new CompileTimeConstResolver(this);
private final JavaAnnotationResolver annotationResolver = new JavaAnnotationResolver(this);
private final FunctionResolver functionResolver = new FunctionResolver(this);
private final NamespaceResolver namespaceResolver = new NamespaceResolver(this);
private final InnerClassResolver innerClassResolver = new InnerClassResolver(this);
private final ValueParameterResolver valueParameterResolver = new ValueParameterResolver(this);
private PropertiesResolver propertiesResolver;
private ClassResolver classResolver;
private ConstructorResolver constructorResolver;
private FunctionResolver functionResolver;
private NamespaceResolver namespaceResolver;
private InnerClassResolver innerClassResolver;
@Inject
public void setProject(Project project) {
@@ -90,24 +79,41 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
@Inject
public void setSemanticServices(JavaSemanticServices semanticServices) {
this.semanticServices = semanticServices;
this.propertiesResolver.setSemanticServices(semanticServices);
}
@Inject
public void setTrace(BindingTrace trace) {
this.trace = trace;
this.propertiesResolver.setTrace(trace);
}
@Inject
public void setPsiClassFinder(PsiClassFinder psiClassFinder) {
this.psiClassFinder = psiClassFinder;
public void setFunctionResolver(FunctionResolver functionResolver) {
this.functionResolver = functionResolver;
}
@Inject
public void setJavaDescriptorSignatureResolver(JavaDescriptorSignatureResolver javaDescriptorSignatureResolver) {
this.javaDescriptorSignatureResolver = javaDescriptorSignatureResolver;
this.propertiesResolver.setJavaDescriptorSignatureResolver(javaDescriptorSignatureResolver);
public void setClassResolver(ClassResolver classResolver) {
this.classResolver = classResolver;
}
@Inject
public void setNamespaceResolver(NamespaceResolver namespaceResolver) {
this.namespaceResolver = namespaceResolver;
}
@Inject
public void setPropertiesResolver(PropertiesResolver propertiesResolver) {
this.propertiesResolver = propertiesResolver;
}
@Inject
public void setConstructorResolver(ConstructorResolver constructorResolver) {
this.constructorResolver = constructorResolver;
}
@Inject
public void setInnerClassResolver(InnerClassResolver innerClassResolver) {
this.innerClassResolver = innerClassResolver;
}
@Nullable
@@ -117,19 +123,7 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
@Override
public ClassDescriptor resolveClass(@NotNull FqName qualifiedName) {
return classResolver.resolveClass(qualifiedName, DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN);
}
public PsiClassFinder getPsiClassFinder() {
return psiClassFinder;
}
public JavaDescriptorSignatureResolver getJavaDescriptorSignatureResolver() {
return javaDescriptorSignatureResolver;
}
public JavaSemanticServices getSemanticServices() {
return semanticServices;
return classResolver.resolveClass(qualifiedName);
}
public BindingTrace getTrace() {
@@ -169,16 +163,6 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
return classResolver.resolveClass(name, searchRule, list);
}
@Nullable
public CompileTimeConstant getCompileTimeConstFromExpression(
FqName annotationName,
Name parameterName,
PsiAnnotationMemberValue value,
List<Runnable> taskList
) {
return compileTimeConstResolver.getCompileTimeConstFromExpression(annotationName, parameterName, value, taskList);
}
public static class ValueParameterDescriptors {
private final JetType receiverType;
private final List<ValueParameterDescriptor> descriptors;
@@ -204,26 +188,6 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
return functionResolver.resolveFunctionGroup(methodName, scopeData);
}
public ValueParameterDescriptors resolveParameterDescriptors(
DeclarationDescriptor containingDeclaration,
List<PsiParameterWrapper> parameters, TypeVariableResolver typeVariableResolver
) {
return valueParameterResolver.resolveParameterDescriptors(containingDeclaration, parameters, typeVariableResolver);
}
public List<AnnotationDescriptor> resolveAnnotations(PsiModifierListOwner owner, @NotNull List<Runnable> tasks) {
return annotationResolver.resolveAnnotations(owner, tasks);
}
public List<AnnotationDescriptor> resolveAnnotations(PsiModifierListOwner owner) {
return annotationResolver.resolveAnnotations(owner);
}
@Nullable
public AnnotationDescriptor resolveAnnotation(PsiAnnotation psiAnnotation, @NotNull List<Runnable> taskList) {
return annotationResolver.resolveAnnotation(psiAnnotation, taskList);
}
public List<FunctionDescriptor> resolveMethods(@NotNull ResolverScopeData scopeData) {
return functionResolver.resolveMethods(scopeData);
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/ClassResolver.java
+71 -17
View File
@@ -27,6 +27,7 @@ import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.resolve.BindingContext;
import org.jetbrains.jet.lang.resolve.BindingTrace;
import org.jetbrains.jet.lang.resolve.java.*;
import org.jetbrains.jet.lang.resolve.java.data.ResolverBinaryClassData;
import org.jetbrains.jet.lang.resolve.java.data.ResolverClassData;
@@ -52,6 +53,7 @@ import org.jetbrains.jet.rt.signature.JetSignatureExceptionsAdapter;
import org.jetbrains.jet.rt.signature.JetSignatureReader;
import org.jetbrains.jet.rt.signature.JetSignatureVisitor;
import javax.inject.Inject;
import java.util.*;
import static org.jetbrains.jet.lang.resolve.DescriptorResolver.createEnumClassObjectValueOfMethod;
@@ -60,8 +62,6 @@ import static org.jetbrains.jet.lang.resolve.DescriptorUtils.getClassObjectName;
public final class ClassResolver {
private final JavaDescriptorResolver javaDescriptorResolver;
// NOTE: this complexity is introduced because class descriptors do not always have valid fqnames (class objects)
private final Map<FqNameBase, ResolverClassData> classDescriptorCache =
new THashMap<FqNameBase, ResolverClassData>(new TObjectHashingStrategy<FqNameBase>() {
@@ -80,10 +80,58 @@ public final class ClassResolver {
}
});
public ClassResolver(JavaDescriptorResolver javaDescriptorResolver) {
private BindingTrace trace;
private JavaDescriptorResolver javaDescriptorResolver;
private JavaDescriptorSignatureResolver signatureResolver;
private JavaSemanticServices semanticServices;
private JavaAnnotationResolver annotationResolver;
private PsiClassFinder psiClassFinder;
private NamespaceResolver namespaceResolver;
private JavaTypeTransformer typeTransformer;
public ClassResolver() {
}
@Inject
public void setTrace(BindingTrace trace) {
this.trace = trace;
}
@Inject
public void setJavaDescriptorResolver(JavaDescriptorResolver javaDescriptorResolver) {
this.javaDescriptorResolver = javaDescriptorResolver;
}
@Inject
public void setSignatureResolver(JavaDescriptorSignatureResolver signatureResolver) {
this.signatureResolver = signatureResolver;
}
@Inject
public void setSemanticServices(JavaSemanticServices semanticServices) {
this.semanticServices = semanticServices;
}
@Inject
public void setAnnotationResolver(JavaAnnotationResolver annotationResolver) {
this.annotationResolver = annotationResolver;
}
@Inject
public void setPsiClassFinder(PsiClassFinder psiClassFinder) {
this.psiClassFinder = psiClassFinder;
}
@Inject
public void setNamespaceResolver(NamespaceResolver namespaceResolver) {
this.namespaceResolver = namespaceResolver;
}
@Inject
public void setTypeTransformer(JavaTypeTransformer typeTransformer) {
this.typeTransformer = typeTransformer;
}
@Nullable
public ClassDescriptor resolveClass(@NotNull FqName qualifiedName, @NotNull DescriptorSearchRule searchRule) {
List<Runnable> tasks = Lists.newArrayList();
@@ -106,13 +154,13 @@ public final class ClassResolver {
}
ClassDescriptor builtinClassDescriptor =
javaDescriptorResolver.getSemanticServices().getKotlinBuiltinClassDescriptor(qualifiedName);
semanticServices.getKotlinBuiltinClassDescriptor(qualifiedName);
if (builtinClassDescriptor != null) {
return builtinClassDescriptor;
}
// First, let's check that this is a real Java class, not a Java's view on a Kotlin class:
ClassDescriptor kotlinClassDescriptor = javaDescriptorResolver.getSemanticServices().getKotlinClassDescriptor(qualifiedName);
ClassDescriptor kotlinClassDescriptor = semanticServices.getKotlinClassDescriptor(qualifiedName);
if (kotlinClassDescriptor != null) {
return searchRule.processFoundInKotlin(kotlinClassDescriptor);
}
@@ -121,7 +169,7 @@ public final class ClassResolver {
ResolverClassData classData = classDescriptorCache.get(qualifiedName);
if (classData == null) {
PsiClass psiClass =
javaDescriptorResolver.getPsiClassFinder().findPsiClass(qualifiedName, PsiClassFinder.RuntimeClassesHandleMode.THROW);
psiClassFinder.findPsiClass(qualifiedName, PsiClassFinder.RuntimeClassesHandleMode.THROW);
if (psiClass == null) {
ResolverClassData oldValue =
classDescriptorCache
@@ -171,7 +219,7 @@ public final class ClassResolver {
List<JetType> supertypes = new ArrayList<JetType>();
List<JavaDescriptorSignatureResolver.TypeParameterDescriptorInitialization> typeParameterDescriptorInitializations
= javaDescriptorResolver.getJavaDescriptorSignatureResolver().createUninitializedClassTypeParameters(psiClass, classData);
= signatureResolver.createUninitializedClassTypeParameters(psiClass, classData);
List<TypeParameterDescriptor> typeParameters = new ArrayList<TypeParameterDescriptor>();
for (JavaDescriptorSignatureResolver.TypeParameterDescriptorInitialization typeParameter : typeParameterDescriptorInitializations) {
@@ -193,9 +241,9 @@ public final class ClassResolver {
classData.getClassDescriptor().setModality(modality);
classData.getClassDescriptor().createTypeConstructor();
classData.getClassDescriptor()
.setScopeForMemberLookup(new JavaClassMembersScope(javaDescriptorResolver.getSemanticServices(), classData));
.setScopeForMemberLookup(new JavaClassMembersScope(semanticServices, classData));
javaDescriptorResolver.getJavaDescriptorSignatureResolver()
signatureResolver
.initializeTypeParameters(typeParameterDescriptorInitializations, classData.getClassDescriptor(), "class " + qualifiedName);
// TODO: ugly hack: tests crash if initializeTypeParameters called with class containing proper supertypes
@@ -207,7 +255,7 @@ public final class ClassResolver {
classData.getClassDescriptor().getBuilder().setClassObjectDescriptor(classObject);
}
classData.getClassDescriptor().setAnnotations(javaDescriptorResolver.resolveAnnotations(psiClass, taskList));
classData.getClassDescriptor().setAnnotations(annotationResolver.resolveAnnotations(psiClass, taskList));
javaDescriptorResolver.getTrace().record(BindingContext.CLASS, psiClass, classData.getClassDescriptor());
@@ -268,7 +316,7 @@ public final class ClassResolver {
classDescriptor.setVisibility(containing.getVisibility());
classDescriptor.setTypeParameterDescriptors(Collections.<TypeParameterDescriptor>emptyList());
classDescriptor.createTypeConstructor();
JavaClassMembersScope classMembersScope = new JavaClassMembersScope(javaDescriptorResolver.getSemanticServices(), data);
JavaClassMembersScope classMembersScope = new JavaClassMembersScope(semanticServices, data);
WritableScopeImpl writableScope =
new WritableScopeImpl(classMembersScope, classDescriptor, RedeclarationHandler.THROW_EXCEPTION, fqName.toString());
writableScope.changeLockLevel(WritableScope.LockLevel.BOTH);
@@ -283,9 +331,9 @@ public final class ClassResolver {
MutableClassDescriptorLite classObjectDescriptor = createSyntheticClassObject(containing, psiClass);
classObjectDescriptor.getBuilder()
.addFunctionDescriptor(createEnumClassObjectValuesMethod(classObjectDescriptor, javaDescriptorResolver.getTrace()));
.addFunctionDescriptor(createEnumClassObjectValuesMethod(classObjectDescriptor, trace));
classObjectDescriptor.getBuilder()
.addFunctionDescriptor(createEnumClassObjectValueOfMethod(classObjectDescriptor, javaDescriptorResolver.getTrace()));
.addFunctionDescriptor(createEnumClassObjectValueOfMethod(classObjectDescriptor, trace));
return classObjectDescriptor;
}
@@ -332,7 +380,7 @@ public final class ClassResolver {
@Override
public JetSignatureVisitor visitSuperclass() {
return new JetTypeJetSignatureReader(javaDescriptorResolver.getSemanticServices(), JetStandardLibrary.getInstance(),
return new JetTypeJetSignatureReader(semanticServices, JetStandardLibrary.getInstance(),
typeVariableResolver) {
@Override
protected void done(@NotNull JetType jetType) {
@@ -358,7 +406,7 @@ public final class ClassResolver {
for (JetType supertype : result) {
if (ErrorUtils.isErrorType(supertype)) {
javaDescriptorResolver.getTrace().record(BindingContext.INCOMPLETE_HIERARCHY, classDescriptor);
trace.record(BindingContext.INCOMPLETE_HIERARCHY, classDescriptor);
}
}
@@ -397,7 +445,7 @@ public final class ClassResolver {
}
}
JetType transform = javaDescriptorResolver.getSemanticServices().getTypeTransformer()
JetType transform = typeTransformer
.transformToType(type, JavaTypeTransformer.TypeUsage.SUPERTYPE, typeVariableResolver);
if (ErrorUtils.isErrorType(transform)) {
continue;
@@ -433,7 +481,7 @@ public final class ClassResolver {
return clazz;
}
NamespaceDescriptor ns = javaDescriptorResolver.resolveNamespace(fqName.parent(), DescriptorSearchRule.INCLUDE_KOTLIN);
NamespaceDescriptor ns = namespaceResolver.resolveNamespace(fqName.parent(), DescriptorSearchRule.INCLUDE_KOTLIN);
if (ns == null) {
throw new IllegalStateException("cannot resolve namespace " + fqName.parent() + ", required to be container for " + fqName);
}
@@ -472,4 +520,10 @@ public final class ClassResolver {
}
return null;
}
@Nullable
public ClassDescriptor resolveClass(FqName name) {
return resolveClass(name, DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN);
}
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/CompileTimeConstResolver.java
+17 -8
View File
@@ -28,22 +28,32 @@ import org.jetbrains.jet.lang.resolve.constants.*;
import org.jetbrains.jet.lang.resolve.constants.StringValue;
import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils;
import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule;
import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
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 org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.lang.types.TypeProjection;
import javax.inject.Inject;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
public final class CompileTimeConstResolver {
private final JavaDescriptorResolver javaDescriptorResolver;
private JavaAnnotationResolver annotationResolver;
private ClassResolver classResolver;
public CompileTimeConstResolver(JavaDescriptorResolver javaDescriptorResolver) {
this.javaDescriptorResolver = javaDescriptorResolver;
public CompileTimeConstResolver() {
}
@Inject
public void setAnnotationResolver(JavaAnnotationResolver annotationResolver) {
this.annotationResolver = annotationResolver;
}
@Inject
public void setClassResolver(ClassResolver classResolver) {
this.classResolver = classResolver;
}
@Nullable
@@ -72,7 +82,7 @@ public final class CompileTimeConstResolver {
@Nullable
private CompileTimeConstant<?> getCompileTimeConstFromAnnotation(PsiAnnotation value, List<Runnable> taskList) {
AnnotationDescriptor annotationDescriptor = javaDescriptorResolver.resolveAnnotation(value, taskList);
AnnotationDescriptor annotationDescriptor = annotationResolver.resolveAnnotation(value, taskList);
if (annotationDescriptor != null) {
return new AnnotationValue(annotationDescriptor);
}
@@ -89,7 +99,7 @@ public final class CompileTimeConstResolver {
List<CompileTimeConstant<?>> values = getCompileTimeConstantForArrayValues(annotationFqName, valueName, taskList, initializers);
ClassDescriptor classDescriptor =
javaDescriptorResolver.resolveClass(annotationFqName, DescriptorSearchRule.INCLUDE_KOTLIN, taskList);
classResolver.resolveClass(annotationFqName, DescriptorSearchRule.INCLUDE_KOTLIN, taskList);
ValueParameterDescriptor valueParameterDescriptor =
DescriptorResolverUtils.getValueParameterDescriptorForAnnotationParameter(valueName, classDescriptor);
@@ -131,8 +141,7 @@ public final class CompileTimeConstResolver {
}
JetScope scope;
ClassDescriptor classDescriptor =
javaDescriptorResolver.resolveClass(new FqName(fqName), DescriptorSearchRule.INCLUDE_KOTLIN, taskList);
ClassDescriptor classDescriptor = classResolver.resolveClass(new FqName(fqName), DescriptorSearchRule.INCLUDE_KOTLIN, taskList);
if (classDescriptor == null) {
return null;
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/ConstructorResolver.java
+34 -20
View File
@@ -23,11 +23,9 @@ import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
import org.jetbrains.jet.lang.resolve.BindingContext;
import org.jetbrains.jet.lang.resolve.BindingTrace;
import org.jetbrains.jet.lang.resolve.DescriptorResolver;
import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils;
import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
import org.jetbrains.jet.lang.resolve.java.TypeVariableResolver;
import org.jetbrains.jet.lang.resolve.java.TypeVariableResolvers;
import org.jetbrains.jet.lang.resolve.java.*;
import org.jetbrains.jet.lang.resolve.java.data.ResolverClassData;
import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode;
import org.jetbrains.jet.lang.resolve.java.kotlinSignature.AlternativeMethodSignatureData;
@@ -35,15 +33,32 @@ import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMethodWrapper;
import org.jetbrains.jet.lang.resolve.name.Name;
import org.jetbrains.jet.lang.types.JetType;
import javax.inject.Inject;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
public final class ConstructorResolver {
private final JavaDescriptorResolver javaDescriptorResolver;
private BindingTrace trace;
private JavaTypeTransformer typeTransformer;
private ValueParameterResolver valueParameterResolver;
public ConstructorResolver(JavaDescriptorResolver javaDescriptorResolver) {
this.javaDescriptorResolver = javaDescriptorResolver;
public ConstructorResolver() {
}
@Inject
public void setTrace(BindingTrace trace) {
this.trace = trace;
}
@Inject
public void setTypeTransformer(JavaTypeTransformer typeTransformer) {
this.typeTransformer = typeTransformer;
}
@Inject
public void setValueParameterResolver(ValueParameterResolver valueParameterResolver) {
this.valueParameterResolver = valueParameterResolver;
}
@NotNull
@@ -66,8 +81,8 @@ public final class ConstructorResolver {
constructors.add(DescriptorResolver.createPrimaryConstructorForObject(containingClass));
}
else if (psiConstructors.length == 0) {
if (javaDescriptorResolver.getTrace().get(BindingContext.CONSTRUCTOR, psiClass) != null) {
constructors.add(javaDescriptorResolver.getTrace().get(BindingContext.CONSTRUCTOR, psiClass));
if (trace.get(BindingContext.CONSTRUCTOR, psiClass) != null) {
constructors.add(trace.get(BindingContext.CONSTRUCTOR, psiClass));
}
else {
// We need to create default constructors for classes and abstract classes.
@@ -82,7 +97,7 @@ public final class ConstructorResolver {
constructorDescriptor.initialize(typeParameters, Collections.<ValueParameterDescriptor>emptyList(), containingClass
.getVisibility(), isStatic);
constructors.add(constructorDescriptor);
javaDescriptorResolver.getTrace().record(BindingContext.CONSTRUCTOR, psiClass, constructorDescriptor);
trace.record(BindingContext.CONSTRUCTOR, psiClass, constructorDescriptor);
}
if (psiClass.isAnnotationType()) {
// A constructor for an annotation type takes all the "methods" in the @interface as parameters
@@ -105,7 +120,7 @@ public final class ConstructorResolver {
// if the last method of the @interface is an array, we convert it into a vararg
JetType varargElementType = null;
if (i == methods.length - 1 && (returnType instanceof PsiArrayType)) {
varargElementType = javaDescriptorResolver.getSemanticServices().getTypeTransformer()
varargElementType = typeTransformer
.transformToType(((PsiArrayType) returnType).getComponentType(), resolverForTypeParameters);
}
@@ -116,8 +131,7 @@ public final class ConstructorResolver {
Collections.<AnnotationDescriptor>emptyList(),
Name.identifier(method.getName()),
false,
javaDescriptorResolver.getSemanticServices().getTypeTransformer()
.transformToType(returnType, resolverForTypeParameters),
typeTransformer.transformToType(returnType, resolverForTypeParameters),
annotationMethod.getDefaultValue() != null,
varargElementType));
}
@@ -125,7 +139,7 @@ public final class ConstructorResolver {
constructorDescriptor.initialize(typeParameters, valueParameters, containingClass.getVisibility(), isStatic);
constructors.add(constructorDescriptor);
javaDescriptorResolver.getTrace().record(BindingContext.CONSTRUCTOR, psiClass, constructorDescriptor);
trace.record(BindingContext.CONSTRUCTOR, psiClass, constructorDescriptor);
}
}
}
@@ -159,8 +173,8 @@ public final class ConstructorResolver {
return null;
}
if (javaDescriptorResolver.getTrace().get(BindingContext.CONSTRUCTOR, psiConstructor) != null) {
return javaDescriptorResolver.getTrace().get(BindingContext.CONSTRUCTOR, psiConstructor);
if (trace.get(BindingContext.CONSTRUCTOR, psiConstructor) != null) {
return trace.get(BindingContext.CONSTRUCTOR, psiConstructor);
}
ConstructorDescriptorImpl constructorDescriptor = new ConstructorDescriptorImpl(
@@ -169,7 +183,7 @@ public final class ConstructorResolver {
false);
String context = "constructor of class " + psiClass.getQualifiedName();
JavaDescriptorResolver.ValueParameterDescriptors valueParameterDescriptors = javaDescriptorResolver.resolveParameterDescriptors(
JavaDescriptorResolver.ValueParameterDescriptors valueParameterDescriptors = valueParameterResolver.resolveParameterDescriptors(
constructorDescriptor, constructor.getParameters(),
TypeVariableResolvers.classTypeVariableResolver(classData.getClassDescriptor(), context));
@@ -184,15 +198,15 @@ public final class ConstructorResolver {
valueParameterDescriptors = alternativeMethodSignatureData.getValueParameters();
}
else if (alternativeMethodSignatureData.hasErrors()) {
javaDescriptorResolver.getTrace().record(BindingContext.ALTERNATIVE_SIGNATURE_DATA_ERROR, constructorDescriptor,
alternativeMethodSignatureData.getError());
trace.record(BindingContext.ALTERNATIVE_SIGNATURE_DATA_ERROR, constructorDescriptor,
alternativeMethodSignatureData.getError());
}
constructorDescriptor.initialize(classData.getClassDescriptor().getTypeConstructor().getParameters(),
valueParameterDescriptors.getDescriptors(),
DescriptorResolverUtils.resolveVisibility(psiConstructor, constructor.getJetConstructor()),
aStatic);
javaDescriptorResolver.getTrace().record(BindingContext.CONSTRUCTOR, psiConstructor, constructorDescriptor);
trace.record(BindingContext.CONSTRUCTOR, psiConstructor, constructorDescriptor);
return constructorDescriptor;
}
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/FunctionResolver.java
+47 -21
View File
@@ -24,10 +24,7 @@ import com.intellij.psi.PsiType;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.resolve.BindingContext;
import org.jetbrains.jet.lang.resolve.BindingContextUtils;
import org.jetbrains.jet.lang.resolve.DescriptorUtils;
import org.jetbrains.jet.lang.resolve.OverrideResolver;
import org.jetbrains.jet.lang.resolve.*;
import org.jetbrains.jet.lang.resolve.java.*;
import org.jetbrains.jet.lang.resolve.java.data.ResolverScopeData;
import org.jetbrains.jet.lang.resolve.java.kotlinSignature.AlternativeMethodSignatureData;
@@ -39,13 +36,43 @@ import org.jetbrains.jet.lang.types.TypeUtils;
import org.jetbrains.jet.lang.types.checker.JetTypeChecker;
import org.jetbrains.jet.lang.types.lang.JetStandardLibrary;
import javax.inject.Inject;
import java.util.*;
public final class FunctionResolver {
private final JavaDescriptorResolver javaDescriptorResolver;
public FunctionResolver(JavaDescriptorResolver javaDescriptorResolver) {
this.javaDescriptorResolver = javaDescriptorResolver;
private JavaTypeTransformer typeTransformer;
private BindingTrace trace;
private JavaDescriptorSignatureResolver signatureResolver;
private ValueParameterResolver parameterResolver;
private JavaAnnotationResolver annotationResolver;
public FunctionResolver() {
}
@Inject
public void setTypeTransformer(JavaTypeTransformer typeTransformer) {
this.typeTransformer = typeTransformer;
}
@Inject
public void setTrace(BindingTrace trace) {
this.trace = trace;
}
@Inject
public void setSignatureResolver(JavaDescriptorSignatureResolver signatureResolver) {
this.signatureResolver = signatureResolver;
}
@Inject
public void setParameterResolver(ValueParameterResolver parameterResolver) {
this.parameterResolver = parameterResolver;
}
@Inject
public void setAnnotationResolver(JavaAnnotationResolver annotationResolver) {
this.annotationResolver = annotationResolver;
}
@Nullable
@@ -77,13 +104,13 @@ public final class FunctionResolver {
}
}
if (javaDescriptorResolver.getTrace().get(BindingContext.FUNCTION, psiMethod) != null) {
return javaDescriptorResolver.getTrace().get(BindingContext.FUNCTION, psiMethod);
if (trace.get(BindingContext.FUNCTION, psiMethod) != null) {
return trace.get(BindingContext.FUNCTION, psiMethod);
}
SimpleFunctionDescriptorImpl functionDescriptorImpl = new SimpleFunctionDescriptorImpl(
scopeData.getClassOrNamespaceDescriptor(),
javaDescriptorResolver.resolveAnnotations(psiMethod),
annotationResolver.resolveAnnotations(psiMethod),
Name.identifier(method.getName()),
DescriptorKindUtils.flagsToKind(method.getJetMethod().kind())
);
@@ -91,15 +118,15 @@ public final class FunctionResolver {
String context = "method " + method.getName() + " in class " + psiClass.getQualifiedName();
List<TypeParameterDescriptor> methodTypeParameters =
javaDescriptorResolver.getJavaDescriptorSignatureResolver().resolveMethodTypeParameters(method,
functionDescriptorImpl);
signatureResolver.resolveMethodTypeParameters(method,
functionDescriptorImpl);
TypeVariableResolver methodTypeVariableResolver = TypeVariableResolvers.typeVariableResolverFromTypeParameters(methodTypeParameters,
functionDescriptorImpl,
context);
JavaDescriptorResolver.ValueParameterDescriptors valueParameterDescriptors = javaDescriptorResolver
JavaDescriptorResolver.ValueParameterDescriptors valueParameterDescriptors = parameterResolver
.resolveParameterDescriptors(functionDescriptorImpl, method.getParameters(), methodTypeVariableResolver);
JetType returnType = makeReturnType(returnPsiType, method, methodTypeVariableResolver);
@@ -112,8 +139,8 @@ public final class FunctionResolver {
methodTypeParameters = alternativeMethodSignatureData.getTypeParameters();
}
else if (alternativeMethodSignatureData.hasErrors()) {
javaDescriptorResolver.getTrace().record(BindingContext.ALTERNATIVE_SIGNATURE_DATA_ERROR, functionDescriptorImpl,
alternativeMethodSignatureData.getError());
trace.record(BindingContext.ALTERNATIVE_SIGNATURE_DATA_ERROR, functionDescriptorImpl,
alternativeMethodSignatureData.getError());
}
functionDescriptorImpl.initialize(
@@ -128,11 +155,11 @@ public final class FunctionResolver {
);
if (functionDescriptorImpl.getKind() == CallableMemberDescriptor.Kind.DECLARATION) {
BindingContextUtils.recordFunctionDeclarationToDescriptor(javaDescriptorResolver.getTrace(), psiMethod, functionDescriptorImpl);
BindingContextUtils.recordFunctionDeclarationToDescriptor(trace, psiMethod, functionDescriptorImpl);
}
if (!scopeData.isKotlin()) {
javaDescriptorResolver.getTrace().record(BindingContext.IS_DECLARED_IN_JAVA, functionDescriptorImpl);
trace.record(BindingContext.IS_DECLARED_IN_JAVA, functionDescriptorImpl);
}
if (containingClass != psiClass && !method.isStatic()) {
@@ -181,7 +208,7 @@ public final class FunctionResolver {
});
}
OverrideResolver.resolveUnknownVisibilities(functions, javaDescriptorResolver.getTrace());
OverrideResolver.resolveUnknownVisibilities(functions, trace);
functions.addAll(functionsFromCurrent);
if (DescriptorUtils.isEnumClassObject(owner)) {
@@ -227,11 +254,10 @@ public final class FunctionResolver {
JetType transformedType;
if (returnTypeFromAnnotation.length() > 0) {
transformedType = javaDescriptorResolver.getSemanticServices()
.getTypeTransformer().transformToType(returnTypeFromAnnotation, typeVariableResolver);
transformedType = typeTransformer.transformToType(returnTypeFromAnnotation, typeVariableResolver);
}
else {
transformedType = javaDescriptorResolver.getSemanticServices().getTypeTransformer().transformToType(
transformedType = typeTransformer.transformToType(
returnType, JavaTypeTransformer.TypeUsage.MEMBER_SIGNATURE_COVARIANT, typeVariableResolver);
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/InnerClassResolver.java
+10 -6
View File
@@ -24,18 +24,23 @@ import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
import org.jetbrains.jet.lang.resolve.DescriptorUtils;
import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils;
import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule;
import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
import org.jetbrains.jet.lang.resolve.java.JvmAbi;
import org.jetbrains.jet.lang.resolve.name.FqName;
import javax.inject.Inject;
import java.util.ArrayList;
import java.util.List;
public final class InnerClassResolver {
private final JavaDescriptorResolver javaDescriptorResolver;
public InnerClassResolver(JavaDescriptorResolver javaDescriptorResolver) {
this.javaDescriptorResolver = javaDescriptorResolver;
private ClassResolver classResolver;
public InnerClassResolver() {
}
@Inject
public void setClassResolver(ClassResolver classResolver) {
this.classResolver = classResolver;
}
public List<ClassDescriptor> resolveInnerClasses(DeclarationDescriptor owner, PsiClass psiClass, boolean staticMembers) {
@@ -83,8 +88,7 @@ public final class InnerClassResolver {
private ClassDescriptor resolveInnerClass(@NotNull PsiClass innerPsiClass) {
String name = innerPsiClass.getQualifiedName();
assert name != null : "Inner class has no qualified name";
ClassDescriptor classDescriptor =
javaDescriptorResolver.resolveClass(new FqName(name), DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
ClassDescriptor classDescriptor = classResolver.resolveClass(new FqName(name), DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
assert classDescriptor != null : "Couldn't resolve class " + name;
return classDescriptor;
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaAnnotationResolver.java
+16 -6
View File
@@ -27,20 +27,30 @@ import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils;
import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule;
import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
import org.jetbrains.jet.lang.resolve.java.JvmAbi;
import org.jetbrains.jet.lang.resolve.name.FqName;
import org.jetbrains.jet.lang.resolve.name.Name;
import javax.inject.Inject;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public final class JavaAnnotationResolver {
private final JavaDescriptorResolver javaDescriptorResolver;
private ClassResolver classResolver;
private CompileTimeConstResolver compileTimeConstResolver;
public JavaAnnotationResolver(JavaDescriptorResolver javaDescriptorResolver) {
this.javaDescriptorResolver = javaDescriptorResolver;
public JavaAnnotationResolver() {
}
@Inject
public void setClassResolver(ClassResolver classResolver) {
this.classResolver = classResolver;
}
@Inject
public void setCompileTimeConstResolver(CompileTimeConstResolver compileTimeConstResolver) {
this.compileTimeConstResolver = compileTimeConstResolver;
}
public List<AnnotationDescriptor> resolveAnnotations(PsiModifierListOwner owner, @NotNull List<Runnable> tasks) {
@@ -79,7 +89,7 @@ public final class JavaAnnotationResolver {
FqName annotationFqName = new FqName(qname);
final ClassDescriptor clazz =
javaDescriptorResolver.resolveClass(annotationFqName, DescriptorSearchRule.INCLUDE_KOTLIN, taskList);
classResolver.resolveClass(annotationFqName, DescriptorSearchRule.INCLUDE_KOTLIN, taskList);
if (clazz == null) {
return null;
}
@@ -101,7 +111,7 @@ public final class JavaAnnotationResolver {
assert value != null;
CompileTimeConstant compileTimeConst =
javaDescriptorResolver.getCompileTimeConstFromExpression(annotationFqName, identifier, value, taskList);
compileTimeConstResolver.getCompileTimeConstFromExpression(annotationFqName, identifier, value, taskList);
if (compileTimeConst != null) {
ValueParameterDescriptor valueParameterDescriptor =
DescriptorResolverUtils.getValueParameterDescriptorForAnnotationParameter(identifier, clazz);
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/NamespaceResolver.java
+30 -14
View File
@@ -26,6 +26,7 @@ import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
import org.jetbrains.jet.lang.descriptors.NamespaceDescriptorParent;
import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
import org.jetbrains.jet.lang.resolve.BindingContext;
import org.jetbrains.jet.lang.resolve.BindingTrace;
import org.jetbrains.jet.lang.resolve.java.*;
import org.jetbrains.jet.lang.resolve.java.data.ResolverNamespaceData;
import org.jetbrains.jet.lang.resolve.java.descriptor.JavaNamespaceDescriptor;
@@ -33,6 +34,7 @@ import org.jetbrains.jet.lang.resolve.java.scope.JavaPackageScope;
import org.jetbrains.jet.lang.resolve.name.FqName;
import org.jetbrains.jet.lang.resolve.name.Name;
import javax.inject.Inject;
import java.util.Collections;
import java.util.Map;
@@ -41,19 +43,33 @@ public final class NamespaceResolver {
@NotNull
public static final ModuleDescriptor FAKE_ROOT_MODULE = new ModuleDescriptor(JavaDescriptorResolver.JAVA_ROOT);
@NotNull
private final JavaDescriptorResolver javaDescriptorResolver;
@NotNull
private final Map<FqName, ResolverNamespaceData> namespaceDescriptorCacheByFqn = Maps.newHashMap();
private PsiClassFinder psiClassFinder;
private BindingTrace trace;
private JavaSemanticServices javaSemanticServices;
public NamespaceResolver(@NotNull JavaDescriptorResolver javaDescriptorResolver) {
this.javaDescriptorResolver = javaDescriptorResolver;
public NamespaceResolver() {
}
@Inject
public void setPsiClassFinder(PsiClassFinder psiClassFinder) {
this.psiClassFinder = psiClassFinder;
}
@Inject
public void setTrace(BindingTrace trace) {
this.trace = trace;
}
@Inject
public void setJavaSemanticServices(JavaSemanticServices javaSemanticServices) {
this.javaSemanticServices = javaSemanticServices;
}
@Nullable
public NamespaceDescriptor resolveNamespace(@NotNull FqName qualifiedName, @NotNull DescriptorSearchRule searchRule) {
// First, let's check that there is no Kotlin package:
NamespaceDescriptor kotlinNamespaceDescriptor =
javaDescriptorResolver.getSemanticServices().getKotlinNamespaceDescriptor(qualifiedName);
NamespaceDescriptor kotlinNamespaceDescriptor = javaSemanticServices.getKotlinNamespaceDescriptor(qualifiedName);
if (kotlinNamespaceDescriptor != null) {
return searchRule.processFoundInKotlin(kotlinNamespaceDescriptor);
}
@@ -79,7 +95,7 @@ public final class NamespaceResolver {
return null;
}
javaDescriptorResolver.getTrace().record(BindingContext.NAMESPACE, scopeData.getPsiPackageOrPsiClass(), ns);
trace.record(BindingContext.NAMESPACE, scopeData.getPsiPackageOrPsiClass(), ns);
ns.setMemberScope(scopeData.getMemberScope());
@@ -112,15 +128,15 @@ public final class NamespaceResolver {
lookingForPsi:
{
psiClass = getPsiClassForJavaPackageScope(fqName);
psiPackage = javaDescriptorResolver.getSemanticServices().getPsiClassFinder().findPsiPackage(fqName);
psiPackage = psiClassFinder.findPsiPackage(fqName);
if (psiClass != null || psiPackage != null) {
javaDescriptorResolver.getTrace().record(JavaBindingContext.JAVA_NAMESPACE_KIND, ns, JavaNamespaceKind.PROPER);
trace.record(JavaBindingContext.JAVA_NAMESPACE_KIND, ns, JavaNamespaceKind.PROPER);
break lookingForPsi;
}
psiClass = javaDescriptorResolver.getPsiClassFinder().findPsiClass(fqName, PsiClassFinder.RuntimeClassesHandleMode.IGNORE);
psiClass = psiClassFinder.findPsiClass(fqName, PsiClassFinder.RuntimeClassesHandleMode.IGNORE);
if (psiClass != null && !psiClass.isEnum()) {
javaDescriptorResolver.getTrace().record(JavaBindingContext.JAVA_NAMESPACE_KIND, ns, JavaNamespaceKind.CLASS_STATICS);
trace.record(JavaBindingContext.JAVA_NAMESPACE_KIND, ns, JavaNamespaceKind.CLASS_STATICS);
break lookingForPsi;
}
@@ -135,7 +151,7 @@ public final class NamespaceResolver {
ResolverNamespaceData namespaceData =
new ResolverNamespaceData(psiClass, psiPackage, fqName, ns);
namespaceData.setMemberScope(new JavaPackageScope(fqName, javaDescriptorResolver.getSemanticServices(), namespaceData));
namespaceData.setMemberScope(new JavaPackageScope(fqName, javaSemanticServices, namespaceData));
ResolverNamespaceData oldValue =
namespaceDescriptorCacheByFqn.put(fqName, namespaceData);
@@ -169,7 +185,7 @@ public final class NamespaceResolver {
@Nullable
private PsiClass getPsiClassForJavaPackageScope(@NotNull FqName packageFQN) {
return javaDescriptorResolver.getPsiClassFinder()
.findPsiClass(packageFQN.child(Name.identifier(JvmAbi.PACKAGE_CLASS)), PsiClassFinder.RuntimeClassesHandleMode.IGNORE);
return psiClassFinder.findPsiClass(packageFQN.child(Name.identifier(JvmAbi.PACKAGE_CLASS)),
PsiClassFinder.RuntimeClassesHandleMode.IGNORE);
}
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/PropertiesResolver.java
+39 -30
View File
@@ -40,10 +40,45 @@ import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.lang.types.TypeUtils;
import javax.inject.Inject;
import java.util.*;
public final class PropertiesResolver {
private JavaSemanticServices semanticServices;
private JavaDescriptorSignatureResolver javaDescriptorSignatureResolver;
private BindingTrace trace;
private JavaAnnotationResolver annotationResolver;
private ClassResolver classResolver;
public PropertiesResolver() {
}
@Inject
public void setSemanticServices(JavaSemanticServices semanticServices) {
this.semanticServices = semanticServices;
}
@Inject
public void setTrace(BindingTrace trace) {
this.trace = trace;
}
@Inject
public void setJavaDescriptorSignatureResolver(JavaDescriptorSignatureResolver javaDescriptorSignatureResolver) {
this.javaDescriptorSignatureResolver = javaDescriptorSignatureResolver;
}
@Inject
public void setAnnotationResolver(JavaAnnotationResolver annotationResolver) {
this.annotationResolver = annotationResolver;
}
@Inject
public void setClassResolver(ClassResolver classResolver) {
this.classResolver = classResolver;
}
public Set<VariableDescriptor> resolveFieldGroupByName(
@NotNull Name fieldName,
@NotNull ResolverScopeData scopeData
@@ -87,7 +122,6 @@ public final class PropertiesResolver {
return descriptors;
}
private static class GroupingValue {
PropertyAccessorData getter;
PropertyAccessorData setter;
@@ -95,31 +129,6 @@ public final class PropertiesResolver {
boolean ext;
}
private final JavaDescriptorResolver javaDescriptorResolver;
private JavaSemanticServices semanticServices;
private JavaDescriptorSignatureResolver javaDescriptorSignatureResolver;
private BindingTrace trace;
/* internal */
public PropertiesResolver(JavaDescriptorResolver resolver) {
this.javaDescriptorResolver = resolver;
}
/* internal */
public void setSemanticServices(JavaSemanticServices semanticServices) {
this.semanticServices = semanticServices;
}
/* internal */
public void setTrace(BindingTrace trace) {
this.trace = trace;
}
/* internal */
public void setJavaDescriptorSignatureResolver(JavaDescriptorSignatureResolver javaDescriptorSignatureResolver) {
this.javaDescriptorSignatureResolver = javaDescriptorSignatureResolver;
}
private void resolveNamedGroupProperties(
@NotNull ClassOrNamespaceDescriptor owner,
@NotNull ResolverScopeData scopeData,
@@ -166,7 +175,7 @@ public final class PropertiesResolver {
boolean isPropertyForNamedObject = members.field != null && JvmAbi.INSTANCE_FIELD.equals(members.field.getMember().getName());
PropertyDescriptor propertyDescriptor = new PropertyDescriptor(
realOwner,
javaDescriptorResolver.resolveAnnotations(characteristicMember.getMember().getPsiMember()),
annotationResolver.resolveAnnotations(characteristicMember.getMember().getPsiMember()),
DescriptorResolverUtils
.resolveModality(characteristicMember.getMember(), isFinal || isEnumEntry || isPropertyForNamedObject),
visibility,
@@ -194,7 +203,7 @@ public final class PropertiesResolver {
if (members.getter != null) {
getterDescriptor = new PropertyGetterDescriptor(
propertyDescriptor,
javaDescriptorResolver.resolveAnnotations(members.getter.getMember().getPsiMember()),
annotationResolver.resolveAnnotations(members.getter.getMember().getPsiMember()),
Modality.OPEN,
visibility,
true,
@@ -212,7 +221,7 @@ public final class PropertiesResolver {
}
setterDescriptor = new PropertySetterDescriptor(
propertyDescriptor,
javaDescriptorResolver.resolveAnnotations(members.setter.getMember().getPsiMember()),
annotationResolver.resolveAnnotations(members.setter.getMember().getPsiMember()),
Modality.OPEN,
setterVisibility,
true,
@@ -458,7 +467,7 @@ public final class PropertiesResolver {
if (psiClass != null && psiClass.isEnum() && isStatic) {
final String qualifiedName = psiClass.getQualifiedName();
assert qualifiedName != null;
final ClassDescriptor classDescriptor = javaDescriptorResolver.resolveClass(new FqName(qualifiedName));
final ClassDescriptor classDescriptor = classResolver.resolveClass(new FqName(qualifiedName));
assert classDescriptor != null;
final ClassDescriptor classObjectDescriptor = classDescriptor.getClassObjectDescriptor();
assert classObjectDescriptor != null;
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/ValueParameterResolver.java
+16 -7
View File
@@ -34,16 +34,16 @@ import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.lang.types.TypeUtils;
import org.jetbrains.jet.lang.types.lang.JetStandardLibrary;
import javax.inject.Inject;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public final class ValueParameterResolver {
private final JavaDescriptorResolver javaDescriptorResolver;
private JavaTypeTransformer typeTransformer;
public ValueParameterResolver(JavaDescriptorResolver javaDescriptorResolver) {
this.javaDescriptorResolver = javaDescriptorResolver;
public ValueParameterResolver() {
}
@NotNull
@@ -71,12 +71,11 @@ public final class ValueParameterResolver {
JetType outType;
if (typeFromAnnotation.length() > 0) {
outType = javaDescriptorResolver.getSemanticServices().getTypeTransformer()
.transformToType(typeFromAnnotation, typeVariableResolver);
outType = getTypeTransformer().transformToType(typeFromAnnotation, typeVariableResolver);
}
else {
outType = javaDescriptorResolver.getSemanticServices().getTypeTransformer()
.transformToType(psiType, JavaTypeTransformer.TypeUsage.MEMBER_SIGNATURE_CONTRAVARIANT, typeVariableResolver);
outType = getTypeTransformer().transformToType(psiType, JavaTypeTransformer.TypeUsage.MEMBER_SIGNATURE_CONTRAVARIANT,
typeVariableResolver);
}
JetType varargElementType;
@@ -115,6 +114,16 @@ public final class ValueParameterResolver {
}
}
@NotNull
private JavaTypeTransformer getTypeTransformer() {
return typeTransformer;
}
@Inject
public void setTypeTransformer(JavaTypeTransformer typeTransformer) {
this.typeTransformer = typeTransformer;
}
@NotNull
private static String getParameterName(int number, @NotNull PsiParameterWrapper parameter) {
String psiParameterName = parameter.getPsiParameter().getName();