From 0aeb756f98621aa9200ff0afc9f80f4497f72cec Mon Sep 17 00:00:00 2001 From: "Pavel V. Talanov" Date: Wed, 10 Oct 2012 17:42:00 +0400 Subject: [PATCH] Refactor JavaDescriptorResolver and *Resolver classes to use DI for dependency management --- .../di/InjectorForJavaDescriptorResolver.java | 74 +++++++++++++- .../di/InjectorForJavaSemanticServices.java | 74 +++++++++++++- .../di/InjectorForTopDownAnalyzerForJvm.java | 74 +++++++++++++- .../resolve/java/JavaDescriptorResolver.java | 98 ++++++------------- .../resolve/java/resolver/ClassResolver.java | 88 +++++++++++++---- .../resolver/CompileTimeConstResolver.java | 25 +++-- .../java/resolver/ConstructorResolver.java | 54 ++++++---- .../java/resolver/FunctionResolver.java | 68 +++++++++---- .../java/resolver/InnerClassResolver.java | 16 +-- .../java/resolver/JavaAnnotationResolver.java | 22 +++-- .../java/resolver/NamespaceResolver.java | 44 ++++++--- .../java/resolver/PropertiesResolver.java | 69 +++++++------ .../java/resolver/ValueParameterResolver.java | 23 +++-- 13 files changed, 527 insertions(+), 202 deletions(-) diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java index d2c3126f3f0..2477b496883 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java @@ -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(); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java index 8db0f4b9c91..2c94233860f 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java @@ -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(); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java index 3e2da840c3e..bd75dfa2c8e 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java @@ -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(); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java index d8095f8aad8..241cf2acd80 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java @@ -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 taskList - ) { - return compileTimeConstResolver.getCompileTimeConstFromExpression(annotationName, parameterName, value, taskList); - } - public static class ValueParameterDescriptors { private final JetType receiverType; private final List descriptors; @@ -204,26 +188,6 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes return functionResolver.resolveFunctionGroup(methodName, scopeData); } - public ValueParameterDescriptors resolveParameterDescriptors( - DeclarationDescriptor containingDeclaration, - List parameters, TypeVariableResolver typeVariableResolver - ) { - return valueParameterResolver.resolveParameterDescriptors(containingDeclaration, parameters, typeVariableResolver); - } - - public List resolveAnnotations(PsiModifierListOwner owner, @NotNull List tasks) { - return annotationResolver.resolveAnnotations(owner, tasks); - } - - public List resolveAnnotations(PsiModifierListOwner owner) { - return annotationResolver.resolveAnnotations(owner); - } - - @Nullable - public AnnotationDescriptor resolveAnnotation(PsiAnnotation psiAnnotation, @NotNull List taskList) { - return annotationResolver.resolveAnnotation(psiAnnotation, taskList); - } - public List resolveMethods(@NotNull ResolverScopeData scopeData) { return functionResolver.resolveMethods(scopeData); } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/ClassResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/ClassResolver.java index 9aa7049f1fa..0ed111a9355 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/ClassResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/ClassResolver.java @@ -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 classDescriptorCache = new THashMap(new TObjectHashingStrategy() { @@ -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 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 supertypes = new ArrayList(); List typeParameterDescriptorInitializations - = javaDescriptorResolver.getJavaDescriptorSignatureResolver().createUninitializedClassTypeParameters(psiClass, classData); + = signatureResolver.createUninitializedClassTypeParameters(psiClass, classData); List typeParameters = new ArrayList(); 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.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); + } } \ No newline at end of file diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/CompileTimeConstResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/CompileTimeConstResolver.java index 77ee59463dc..83e6f891b15 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/CompileTimeConstResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/CompileTimeConstResolver.java @@ -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 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> 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; } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/ConstructorResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/ConstructorResolver.java index 836eeb6dcf5..c187ff97287 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/ConstructorResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/ConstructorResolver.java @@ -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.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.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; } } \ No newline at end of file diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/FunctionResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/FunctionResolver.java index 2ea99048cd6..f526328bbe2 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/FunctionResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/FunctionResolver.java @@ -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 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); } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/InnerClassResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/InnerClassResolver.java index 4f6f9ed741d..a63bddc8662 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/InnerClassResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/InnerClassResolver.java @@ -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 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; } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaAnnotationResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaAnnotationResolver.java index 633974adc79..9775615272e 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaAnnotationResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaAnnotationResolver.java @@ -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 resolveAnnotations(PsiModifierListOwner owner, @NotNull List 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); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/NamespaceResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/NamespaceResolver.java index d8512075ab0..d6e1fc4875a 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/NamespaceResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/NamespaceResolver.java @@ -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 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); } } \ No newline at end of file diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/PropertiesResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/PropertiesResolver.java index bb7ff249165..fba3a8aeb83 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/PropertiesResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/PropertiesResolver.java @@ -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 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; diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/ValueParameterResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/ValueParameterResolver.java index 012be76b59e..1c3c0c4194c 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/ValueParameterResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/ValueParameterResolver.java @@ -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();