diff --git a/compiler/frontend.java/frontend.java.iml b/compiler/frontend.java/frontend.java.iml index bae73d6605a..689b119f411 100644 --- a/compiler/frontend.java/frontend.java.iml +++ b/compiler/frontend.java/frontend.java.iml @@ -11,6 +11,7 @@ + diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java new file mode 100644 index 00000000000..b806ac4440d --- /dev/null +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java @@ -0,0 +1,73 @@ +/* + * Copyright 2010-2012 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +package org.jetbrains.jet.di; + +import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices; +import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; +import org.jetbrains.jet.lang.resolve.BindingTrace; +import com.intellij.openapi.project.Project; +import org.jetbrains.jet.lang.resolve.java.JavaTypeTransformer; +import com.intellij.openapi.project.Project; +import org.jetbrains.annotations.NotNull; + +/* This file is generated by org.jetbrains.jet.di.AllInjectorsGenerator. DO NOT EDIT! */ +public class InjectorForJavaSemanticServices { + + private JavaSemanticServices javaSemanticServices; + private JavaDescriptorResolver javaDescriptorResolver; + private BindingTrace bindingTrace; + private final Project project; + + public InjectorForJavaSemanticServices( + @NotNull Project project + ) { + this.javaSemanticServices = new JavaSemanticServices(); + this.javaDescriptorResolver = new JavaDescriptorResolver(); + this.bindingTrace = new org.jetbrains.jet.lang.resolve.BindingTraceContext(); + this.project = project; + JavaTypeTransformer javaTypeTransformer = new JavaTypeTransformer(); + + this.javaSemanticServices.setDescriptorResolver(javaDescriptorResolver); + this.javaSemanticServices.setTrace(bindingTrace); + this.javaSemanticServices.setTypeTransformer(javaTypeTransformer); + + this.javaDescriptorResolver.setProject(project); + this.javaDescriptorResolver.setSemanticServices(javaSemanticServices); + + javaTypeTransformer.setJavaSemanticServices(javaSemanticServices); + javaTypeTransformer.setResolver(javaDescriptorResolver); + + } + + public JavaSemanticServices getJavaSemanticServices() { + return this.javaSemanticServices; + } + + public JavaDescriptorResolver getJavaDescriptorResolver() { + return this.javaDescriptorResolver; + } + + public BindingTrace getBindingTrace() { + return this.bindingTrace; + } + + public Project getProject() { + return this.project; + } + +} diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java new file mode 100644 index 00000000000..44d0506476d --- /dev/null +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java @@ -0,0 +1,228 @@ +/* + * Copyright 2010-2012 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +package org.jetbrains.jet.di; + +import org.jetbrains.jet.lang.resolve.TopDownAnalyzer; +import org.jetbrains.jet.lang.resolve.TopDownAnalysisContext; +import org.jetbrains.jet.lang.resolve.BodyResolver; +import org.jetbrains.jet.lang.resolve.ControlFlowAnalyzer; +import org.jetbrains.jet.lang.resolve.DeclarationsChecker; +import org.jetbrains.jet.lang.resolve.DescriptorResolver; +import com.intellij.openapi.project.Project; +import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters; +import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; +import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory; +import org.jetbrains.jet.lang.resolve.java.JavaBridgeConfiguration; +import org.jetbrains.jet.lang.resolve.BindingTrace; +import org.jetbrains.jet.lang.resolve.DeclarationResolver; +import org.jetbrains.jet.lang.resolve.AnnotationResolver; +import org.jetbrains.jet.lang.resolve.calls.CallResolver; +import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; +import org.jetbrains.jet.lang.resolve.TypeResolver; +import org.jetbrains.jet.lang.resolve.calls.OverloadingConflictResolver; +import org.jetbrains.jet.lang.resolve.ImportsResolver; +import org.jetbrains.jet.lang.resolve.DelegationResolver; +import org.jetbrains.jet.lang.resolve.NamespaceFactoryImpl; +import org.jetbrains.jet.lang.resolve.OverloadResolver; +import org.jetbrains.jet.lang.resolve.OverrideResolver; +import org.jetbrains.jet.lang.resolve.TypeHierarchyResolver; +import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices; +import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; +import org.jetbrains.jet.lang.resolve.java.JavaTypeTransformer; +import com.intellij.openapi.project.Project; +import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters; +import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; +import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory; +import org.jetbrains.jet.lang.resolve.BindingTrace; +import org.jetbrains.annotations.NotNull; + +/* This file is generated by org.jetbrains.jet.di.AllInjectorsGenerator. DO NOT EDIT! */ +public class InjectorForTopDownAnalyzerForJvm { + + private TopDownAnalyzer topDownAnalyzer; + private TopDownAnalysisContext topDownAnalysisContext; + private BodyResolver bodyResolver; + private ControlFlowAnalyzer controlFlowAnalyzer; + private DeclarationsChecker declarationsChecker; + private DescriptorResolver descriptorResolver; + private final Project project; + private final TopDownAnalysisParameters topDownAnalysisParameters; + private JavaBridgeConfiguration javaBridgeConfiguration; + private final BindingTrace bindingTrace; + + public InjectorForTopDownAnalyzerForJvm( + @NotNull Project project, + @NotNull TopDownAnalysisParameters topDownAnalysisParameters, + @NotNull ModuleDescriptor moduleDescriptor, + JetControlFlowDataTraceFactory jetControlFlowDataTraceFactory, + @NotNull BindingTrace bindingTrace + ) { + this.topDownAnalyzer = new TopDownAnalyzer(); + this.topDownAnalysisContext = new TopDownAnalysisContext(); + this.bodyResolver = new BodyResolver(); + this.controlFlowAnalyzer = new ControlFlowAnalyzer(); + this.declarationsChecker = new DeclarationsChecker(); + this.descriptorResolver = new DescriptorResolver(); + this.project = project; + this.topDownAnalysisParameters = topDownAnalysisParameters; + this.javaBridgeConfiguration = new JavaBridgeConfiguration(); + this.bindingTrace = bindingTrace; + DeclarationResolver declarationResolver = new DeclarationResolver(); + AnnotationResolver annotationResolver = new AnnotationResolver(); + CallResolver callResolver = new CallResolver(); + ExpressionTypingServices expressionTypingServices = new ExpressionTypingServices(); + TypeResolver typeResolver = new TypeResolver(); + OverloadingConflictResolver overloadingConflictResolver = new OverloadingConflictResolver(); + ImportsResolver importsResolver = new ImportsResolver(); + DelegationResolver delegationResolver = new DelegationResolver(); + NamespaceFactoryImpl namespaceFactoryImpl = new NamespaceFactoryImpl(); + OverloadResolver overloadResolver = new OverloadResolver(); + OverrideResolver overrideResolver = new OverrideResolver(); + TypeHierarchyResolver typeHierarchyResolver = new TypeHierarchyResolver(); + JavaSemanticServices javaSemanticServices = new JavaSemanticServices(); + JavaDescriptorResolver javaDescriptorResolver = new JavaDescriptorResolver(); + JavaTypeTransformer javaTypeTransformer = new JavaTypeTransformer(); + + this.topDownAnalyzer.setBodyResolver(bodyResolver); + this.topDownAnalyzer.setConfiguration(javaBridgeConfiguration); + this.topDownAnalyzer.setContext(topDownAnalysisContext); + this.topDownAnalyzer.setControlFlowAnalyzer(controlFlowAnalyzer); + this.topDownAnalyzer.setDeclarationResolver(declarationResolver); + this.topDownAnalyzer.setDeclarationsChecker(declarationsChecker); + this.topDownAnalyzer.setDelegationResolver(delegationResolver); + this.topDownAnalyzer.setModuleDescriptor(moduleDescriptor); + this.topDownAnalyzer.setNamespaceFactory(namespaceFactoryImpl); + this.topDownAnalyzer.setOverloadResolver(overloadResolver); + this.topDownAnalyzer.setOverrideResolver(overrideResolver); + this.topDownAnalyzer.setTopDownAnalysisParameters(topDownAnalysisParameters); + this.topDownAnalyzer.setTypeHierarchyResolver(typeHierarchyResolver); + + this.topDownAnalysisContext.setTopDownAnalysisParameters(topDownAnalysisParameters); + + this.bodyResolver.setCallResolver(callResolver); + this.bodyResolver.setContext(topDownAnalysisContext); + this.bodyResolver.setDescriptorResolver(descriptorResolver); + this.bodyResolver.setExpressionTypingServices(expressionTypingServices); + this.bodyResolver.setTopDownAnalysisParameters(topDownAnalysisParameters); + + this.controlFlowAnalyzer.setContext(topDownAnalysisContext); + this.controlFlowAnalyzer.setFlowDataTraceFactory(jetControlFlowDataTraceFactory); + this.controlFlowAnalyzer.setTopDownAnalysisParameters(topDownAnalysisParameters); + + this.declarationsChecker.setContext(topDownAnalysisContext); + + this.descriptorResolver.setAnnotationResolver(annotationResolver); + this.descriptorResolver.setExpressionTypingServices(expressionTypingServices); + this.descriptorResolver.setTypeResolver(typeResolver); + + this.javaBridgeConfiguration.setJavaSemanticServices(javaSemanticServices); + this.javaBridgeConfiguration.setProject(project); + + declarationResolver.setAnnotationResolver(annotationResolver); + declarationResolver.setContext(topDownAnalysisContext); + declarationResolver.setDescriptorResolver(descriptorResolver); + declarationResolver.setImportsResolver(importsResolver); + + annotationResolver.setCallResolver(callResolver); + annotationResolver.setExpressionTypingServices(expressionTypingServices); + + callResolver.setDescriptorResolver(descriptorResolver); + callResolver.setExpressionTypingServices(expressionTypingServices); + callResolver.setOverloadingConflictResolver(overloadingConflictResolver); + callResolver.setTypeResolver(typeResolver); + + expressionTypingServices.setCallResolver(callResolver); + expressionTypingServices.setDescriptorResolver(descriptorResolver); + expressionTypingServices.setProject(project); + expressionTypingServices.setTypeResolver(typeResolver); + + typeResolver.setAnnotationResolver(annotationResolver); + typeResolver.setDescriptorResolver(descriptorResolver); + + importsResolver.setConfiguration(javaBridgeConfiguration); + importsResolver.setContext(topDownAnalysisContext); + + delegationResolver.setContext(topDownAnalysisContext); + + namespaceFactoryImpl.setConfiguration(javaBridgeConfiguration); + namespaceFactoryImpl.setContext(topDownAnalysisContext); + namespaceFactoryImpl.setModuleDescriptor(moduleDescriptor); + + overloadResolver.setContext(topDownAnalysisContext); + + overrideResolver.setContext(topDownAnalysisContext); + overrideResolver.setTopDownAnalysisParameters(topDownAnalysisParameters); + + typeHierarchyResolver.setContext(topDownAnalysisContext); + typeHierarchyResolver.setDescriptorResolver(descriptorResolver); + typeHierarchyResolver.setImportsResolver(importsResolver); + typeHierarchyResolver.setNamespaceFactory(namespaceFactoryImpl); + + javaSemanticServices.setDescriptorResolver(javaDescriptorResolver); + javaSemanticServices.setTrace(bindingTrace); + javaSemanticServices.setTypeTransformer(javaTypeTransformer); + + javaDescriptorResolver.setProject(project); + javaDescriptorResolver.setSemanticServices(javaSemanticServices); + + javaTypeTransformer.setJavaSemanticServices(javaSemanticServices); + javaTypeTransformer.setResolver(javaDescriptorResolver); + + } + + public TopDownAnalyzer getTopDownAnalyzer() { + return this.topDownAnalyzer; + } + + public TopDownAnalysisContext getTopDownAnalysisContext() { + return this.topDownAnalysisContext; + } + + public BodyResolver getBodyResolver() { + return this.bodyResolver; + } + + public ControlFlowAnalyzer getControlFlowAnalyzer() { + return this.controlFlowAnalyzer; + } + + public DeclarationsChecker getDeclarationsChecker() { + return this.declarationsChecker; + } + + public DescriptorResolver getDescriptorResolver() { + return this.descriptorResolver; + } + + public Project getProject() { + return this.project; + } + + public TopDownAnalysisParameters getTopDownAnalysisParameters() { + return this.topDownAnalysisParameters; + } + + public JavaBridgeConfiguration getJavaBridgeConfiguration() { + return this.javaBridgeConfiguration; + } + + public BindingTrace getBindingTrace() { + return this.bindingTrace; + } + +} diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java index b749b40d63d..5939de7a797 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java @@ -29,14 +29,15 @@ import com.intellij.psi.util.CachedValuesManager; import com.intellij.psi.util.PsiModificationTracker; import com.intellij.util.Function; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.DefaultModuleConfiguration; +import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm; import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory; +import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils; import org.jetbrains.jet.lang.diagnostics.Errors; import org.jetbrains.jet.lang.psi.JetFile; -import org.jetbrains.jet.lang.resolve.AnalyzingUtils; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingTraceContext; +import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters; import java.util.Collection; import java.util.Collections; @@ -145,14 +146,18 @@ public class AnalyzerFacadeForJVM { public static BindingContext analyzeFilesWithJavaIntegration(Project project, Collection files, Predicate filesToAnalyzeCompletely, JetControlFlowDataTraceFactory flowDataTraceFactory) { BindingTraceContext bindingTraceContext = new BindingTraceContext(); - AnalyzingUtils.analyzeFilesWithGivenTrace( - project, - JavaBridgeConfiguration.createJavaBridgeConfiguration(project, bindingTraceContext, DefaultModuleConfiguration.createStandardConfiguration(project)), - files, - filesToAnalyzeCompletely, - flowDataTraceFactory, - bindingTraceContext - ); + + final ModuleDescriptor owner = new ModuleDescriptor(""); + + TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters( + filesToAnalyzeCompletely, false, false, bindingTraceContext); + + + InjectorForTopDownAnalyzerForJvm injector = new InjectorForTopDownAnalyzerForJvm( + project, topDownAnalysisParameters, owner, flowDataTraceFactory, bindingTraceContext); + + + injector.getTopDownAnalyzer().doAnalyzeFilesWithGivenTrance2(files); return bindingTraceContext.getBindingContext(); } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaBridgeConfiguration.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaBridgeConfiguration.java index 889e261c93f..68a3566205e 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaBridgeConfiguration.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaBridgeConfiguration.java @@ -18,6 +18,7 @@ package org.jetbrains.jet.lang.resolve.java; import com.intellij.openapi.project.Project; import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.DefaultModuleConfiguration; import org.jetbrains.jet.lang.ModuleConfiguration; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; @@ -29,6 +30,7 @@ import org.jetbrains.jet.lang.resolve.FqName; import org.jetbrains.jet.lang.resolve.ImportPath; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; +import javax.inject.Inject; import java.util.Collection; import java.util.Collections; @@ -39,20 +41,27 @@ public class JavaBridgeConfiguration implements ModuleConfiguration { public static final ImportPath[] DEFAULT_JAVA_IMPORTS = new ImportPath[] { new ImportPath("java.lang.*") }; - public static ModuleConfiguration createJavaBridgeConfiguration(@NotNull Project project, @NotNull BindingTrace trace, ModuleConfiguration delegateConfiguration) { - return new JavaBridgeConfiguration(project, trace, delegateConfiguration); - } - private final Project project; - private final JavaSemanticServices javaSemanticServices; - private final ModuleConfiguration delegateConfiguration; + @NotNull + private Project project; + @NotNull + private JavaSemanticServices javaSemanticServices; + @NotNull + private ModuleConfiguration delegateConfiguration; - private JavaBridgeConfiguration(Project project, BindingTrace trace, ModuleConfiguration delegateConfiguration) { + @Inject + public void setProject(@NotNull Project project) { this.project = project; - this.javaSemanticServices = new JavaSemanticServices(project, trace); - this.delegateConfiguration = delegateConfiguration; + this.delegateConfiguration = DefaultModuleConfiguration.createStandardConfiguration(project); } + @Inject + public void setJavaSemanticServices(@NotNull JavaSemanticServices javaSemanticServices) { + this.javaSemanticServices = javaSemanticServices; + } + + + @Override public void addDefaultImports(@NotNull WritableScope rootScope, @NotNull Collection directives) { for (ImportPath importPath : DEFAULT_JAVA_IMPORTS) { 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 42a6f07e3aa..48f02974962 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 @@ -48,6 +48,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.*; /** @@ -193,23 +194,32 @@ public class JavaDescriptorResolver { protected final Map namespaceDescriptorCacheByFqn = Maps.newHashMap(); protected final Map namespaceDescriptorCache = Maps.newHashMap(); - protected final JavaPsiFacade javaFacade; - protected final GlobalSearchScope javaSearchScope; - protected final JavaSemanticServices semanticServices; - private final AltClassFinder altClassFinder; + protected JavaPsiFacade javaFacade; + protected Project project; + protected GlobalSearchScope javaSearchScope ; + protected JavaSemanticServices semanticServices; + private AltClassFinder altClassFinder; - public JavaDescriptorResolver(Project project, JavaSemanticServices semanticServices) { - this.javaFacade = JavaPsiFacade.getInstance(project); + @Inject + public void setProject(Project project) { + this.project = project; + this.altClassFinder = new AltClassFinder(project); this.javaSearchScope = new DelegatingGlobalSearchScope(GlobalSearchScope.allScope(project)) { @Override public boolean contains(VirtualFile file) { return myBaseScope.contains(file) && file.getFileType() != JetFileType.INSTANCE; } }; - this.semanticServices = semanticServices; - altClassFinder = new AltClassFinder(project); + this.javaFacade = JavaPsiFacade.getInstance(project); } - + + @Inject + public void setSemanticServices(JavaSemanticServices semanticServices) { + this.semanticServices = semanticServices; + } + + + @Nullable ResolverClassData resolveClassData(@NotNull PsiClass psiClass, @NotNull DescriptorSearchRule searchRule) { FqName qualifiedName = new FqName(psiClass.getQualifiedName()); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaSemanticServices.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaSemanticServices.java index c05652899b2..ec9058cb4bf 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaSemanticServices.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaSemanticServices.java @@ -26,20 +26,37 @@ import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.FqName; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; +import javax.inject.Inject; + /** * @author abreslav */ public class JavaSemanticServices { - private final JavaTypeTransformer typeTransformer; - private final JavaDescriptorResolver descriptorResolver; - private final BindingTrace trace; + @NotNull + private JavaTypeTransformer typeTransformer; + @NotNull + private JavaDescriptorResolver descriptorResolver; + @NotNull + private BindingTrace trace; - public JavaSemanticServices(Project project, BindingTrace trace) { - this.trace = trace; - this.descriptorResolver = new JavaDescriptorResolver(project, this); - this.typeTransformer = new JavaTypeTransformer(this, JetStandardLibrary.getInstance(), descriptorResolver); + + @Inject + public void setTypeTransformer(@NotNull JavaTypeTransformer typeTransformer) { + this.typeTransformer = typeTransformer; } + @Inject + public void setDescriptorResolver(@NotNull JavaDescriptorResolver descriptorResolver) { + this.descriptorResolver = descriptorResolver; + } + + @Inject + public void setTrace(@NotNull BindingTrace trace) { + this.trace = trace; + } + + + @NotNull public JavaTypeTransformer getTypeTransformer() { return typeTransformer; diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaTypeTransformer.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaTypeTransformer.java index fac8d4e0868..4ae8fbafcca 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaTypeTransformer.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaTypeTransformer.java @@ -28,6 +28,7 @@ import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; import org.jetbrains.jet.lang.types.lang.PrimitiveType; import org.jetbrains.jet.rt.signature.JetSignatureReader; +import javax.inject.Inject; import java.util.Collections; import java.util.HashMap; import java.util.List; @@ -38,18 +39,26 @@ import java.util.Map; */ public class JavaTypeTransformer { - private final JavaSemanticServices javaSemanticServices; - private final JavaDescriptorResolver resolver; - private final JetStandardLibrary standardLibrary; + private JavaSemanticServices javaSemanticServices; + private JavaDescriptorResolver resolver; + + @Inject + public void setJavaSemanticServices(JavaSemanticServices javaSemanticServices) { + this.javaSemanticServices = javaSemanticServices; + } + + @Inject + public void setResolver(JavaDescriptorResolver resolver) { + this.resolver = resolver; + } + + + private Map primitiveTypesMap; private Map classTypesMap; private Map classDescriptorMap; - public JavaTypeTransformer(JavaSemanticServices javaSemanticServices, JetStandardLibrary standardLibrary, JavaDescriptorResolver resolver) { - this.javaSemanticServices = javaSemanticServices; - this.resolver = resolver; - this.standardLibrary = standardLibrary; - } + @NotNull public TypeProjection transformToTypeProjection(@NotNull final PsiType javaType, @@ -85,7 +94,7 @@ public class JavaTypeTransformer { @NotNull public JetType transformToType(@NotNull String kotlinSignature, TypeVariableResolver typeVariableResolver) { final JetType[] r = new JetType[1]; - JetTypeJetSignatureReader reader = new JetTypeJetSignatureReader(javaSemanticServices, standardLibrary, typeVariableResolver) { + JetTypeJetSignatureReader reader = new JetTypeJetSignatureReader(javaSemanticServices, JetStandardLibrary.getInstance(), typeVariableResolver) { @Override protected void done(@NotNull JetType jetType) { r[0] = jetType; @@ -173,7 +182,7 @@ public class JavaTypeTransformer { } JetType type = transformToType(componentType, typeVariableResolver); - return TypeUtils.makeNullable(standardLibrary.getArrayType(type)); + return TypeUtils.makeNullable(JetStandardLibrary.getInstance().getArrayType(type)); } @Override @@ -188,9 +197,9 @@ public class JavaTypeTransformer { primitiveTypesMap = new HashMap(); for (JvmPrimitiveType jvmPrimitiveType : JvmPrimitiveType.values()) { PrimitiveType primitiveType = jvmPrimitiveType.getPrimitiveType(); - primitiveTypesMap.put(jvmPrimitiveType.getName(), standardLibrary.getPrimitiveJetType(primitiveType)); - primitiveTypesMap.put("[" + jvmPrimitiveType.getName(), standardLibrary.getPrimitiveArrayJetType(primitiveType)); - primitiveTypesMap.put(jvmPrimitiveType.getWrapper().getFqName(), standardLibrary.getNullablePrimitiveJetType(primitiveType)); + primitiveTypesMap.put(jvmPrimitiveType.getName(), JetStandardLibrary.getInstance().getPrimitiveJetType(primitiveType)); + primitiveTypesMap.put("[" + jvmPrimitiveType.getName(), JetStandardLibrary.getInstance().getPrimitiveArrayJetType(primitiveType)); + primitiveTypesMap.put(jvmPrimitiveType.getWrapper().getFqName(), JetStandardLibrary.getInstance().getNullablePrimitiveJetType(primitiveType)); } primitiveTypesMap.put("void", JetStandardClasses.getUnitType()); } @@ -202,12 +211,12 @@ public class JavaTypeTransformer { classTypesMap = new HashMap(); for (JvmPrimitiveType jvmPrimitiveType : JvmPrimitiveType.values()) { PrimitiveType primitiveType = jvmPrimitiveType.getPrimitiveType(); - classTypesMap.put(jvmPrimitiveType.getWrapper().getFqName(), standardLibrary.getNullablePrimitiveJetType(primitiveType)); + classTypesMap.put(jvmPrimitiveType.getWrapper().getFqName(), JetStandardLibrary.getInstance().getNullablePrimitiveJetType(primitiveType)); } classTypesMap.put("java.lang.Object", JetStandardClasses.getNullableAnyType()); - classTypesMap.put("java.lang.String", standardLibrary.getNullableStringType()); - classTypesMap.put("java.lang.CharSequence", standardLibrary.getNullableCharSequenceType()); - classTypesMap.put("java.lang.Throwable", standardLibrary.getNullableThrowableType()); + classTypesMap.put("java.lang.String", JetStandardLibrary.getInstance().getNullableStringType()); + classTypesMap.put("java.lang.CharSequence", JetStandardLibrary.getInstance().getNullableCharSequenceType()); + classTypesMap.put("java.lang.Throwable", JetStandardLibrary.getInstance().getNullableThrowableType()); } return classTypesMap; } @@ -217,11 +226,11 @@ public class JavaTypeTransformer { classDescriptorMap = new HashMap(); for (JvmPrimitiveType jvmPrimitiveType : JvmPrimitiveType.values()) { PrimitiveType primitiveType = jvmPrimitiveType.getPrimitiveType(); - classDescriptorMap.put(jvmPrimitiveType.getWrapper().getFqName(), standardLibrary.getPrimitiveClassDescriptor(primitiveType)); + classDescriptorMap.put(jvmPrimitiveType.getWrapper().getFqName(), JetStandardLibrary.getInstance().getPrimitiveClassDescriptor(primitiveType)); } - classDescriptorMap.put("java.lang.String", standardLibrary.getString()); - classDescriptorMap.put("java.lang.CharSequence", standardLibrary.getCharSequence()); - classDescriptorMap.put("java.lang.Throwable", standardLibrary.getThrowable()); + classDescriptorMap.put("java.lang.String", JetStandardLibrary.getInstance().getString()); + classDescriptorMap.put("java.lang.CharSequence", JetStandardLibrary.getInstance().getCharSequence()); + classDescriptorMap.put("java.lang.Throwable", JetStandardLibrary.getInstance().getThrowable()); } return classDescriptorMap; } diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzer.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java similarity index 98% rename from compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzer.java rename to compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java index 6589a530abc..e43fa83ea94 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzer.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java @@ -25,9 +25,9 @@ import org.jetbrains.jet.lang.resolve.DeclarationsChecker; import org.jetbrains.jet.lang.resolve.DescriptorResolver; import com.intellij.openapi.project.Project; import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters; -import org.jetbrains.jet.lang.ModuleConfiguration; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory; +import org.jetbrains.jet.lang.ModuleConfiguration; import org.jetbrains.jet.lang.resolve.DeclarationResolver; import org.jetbrains.jet.lang.resolve.AnnotationResolver; import org.jetbrains.jet.lang.resolve.calls.CallResolver; @@ -42,13 +42,13 @@ import org.jetbrains.jet.lang.resolve.OverrideResolver; import org.jetbrains.jet.lang.resolve.TypeHierarchyResolver; import com.intellij.openapi.project.Project; import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters; -import org.jetbrains.jet.lang.ModuleConfiguration; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory; +import org.jetbrains.jet.lang.ModuleConfiguration; import org.jetbrains.annotations.NotNull; /* This file is generated by org.jetbrains.jet.di.AllInjectorsGenerator. DO NOT EDIT! */ -public class InjectorForTopDownAnalyzer { +public class InjectorForTopDownAnalyzerBasic { private TopDownAnalyzer topDownAnalyzer; private TopDownAnalysisContext topDownAnalysisContext; @@ -59,12 +59,12 @@ public class InjectorForTopDownAnalyzer { private final Project project; private final TopDownAnalysisParameters topDownAnalysisParameters; - public InjectorForTopDownAnalyzer( + public InjectorForTopDownAnalyzerBasic( @NotNull Project project, @NotNull TopDownAnalysisParameters topDownAnalysisParameters, - @NotNull ModuleConfiguration moduleConfiguration, @NotNull ModuleDescriptor moduleDescriptor, - JetControlFlowDataTraceFactory jetControlFlowDataTraceFactory + JetControlFlowDataTraceFactory jetControlFlowDataTraceFactory, + @NotNull ModuleConfiguration moduleConfiguration ) { this.topDownAnalyzer = new TopDownAnalyzer(); this.topDownAnalysisContext = new TopDownAnalysisContext(); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java index 1f9e86986b5..7940da746da 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java @@ -16,17 +16,11 @@ package org.jetbrains.jet.lang.resolve; -import com.google.common.base.Predicate; import com.google.common.collect.Maps; import com.google.common.collect.Sets; -import com.intellij.openapi.project.Project; import com.intellij.psi.PsiElement; import com.intellij.psi.PsiFile; import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.di.InjectorForTopDownAnalyzer; -import org.jetbrains.jet.lang.ModuleConfiguration; -import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.scopes.JetScope; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java index 9da43018ebb..37af495eb5f 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java @@ -18,12 +18,11 @@ package org.jetbrains.jet.lang.resolve; import com.google.common.base.Predicate; import com.google.common.base.Predicates; -import com.google.common.collect.Lists; import com.intellij.openapi.project.Project; import com.intellij.psi.PsiElement; import com.intellij.psi.PsiFile; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.di.InjectorForTopDownAnalyzer; +import org.jetbrains.jet.di.InjectorForTopDownAnalyzerBasic; import org.jetbrains.jet.lang.ModuleConfiguration; import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory; import org.jetbrains.jet.lang.descriptors.*; @@ -31,11 +30,9 @@ import org.jetbrains.jet.lang.psi.JetDeclaration; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.psi.JetObjectDeclaration; import org.jetbrains.jet.lang.resolve.scopes.JetScope; -import org.jetbrains.jet.lang.resolve.scopes.JetScopeAdapter; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl; import org.jetbrains.jet.lang.types.lang.JetStandardClasses; -import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; import javax.inject.Inject; import java.util.ArrayList; @@ -155,7 +152,7 @@ public class TopDownAnalyzer { TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters(analyzeCompletely, false, declaredLocally, trace); - InjectorForTopDownAnalyzer injector = new InjectorForTopDownAnalyzer(project, topDownAnalysisParameters, configuration, moduleDescriptor, flowDataTraceFactory); + InjectorForTopDownAnalyzerBasic injector = new InjectorForTopDownAnalyzerBasic(project, topDownAnalysisParameters, moduleDescriptor, flowDataTraceFactory, configuration); injector.getTopDownAnalyzer().doProcess(outerScope, owner, declarations); @@ -208,9 +205,9 @@ public class TopDownAnalyzer { @NotNull List files) { TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters(Predicates.alwaysFalse(), true, false, trace); - InjectorForTopDownAnalyzer injector = new InjectorForTopDownAnalyzer( - project, topDownAnalysisParameters, ModuleConfiguration.EMPTY, - JetStandardClasses.FAKE_STANDARD_CLASSES_MODULE, null); + InjectorForTopDownAnalyzerBasic injector = new InjectorForTopDownAnalyzerBasic( + project, topDownAnalysisParameters, + JetStandardClasses.FAKE_STANDARD_CLASSES_MODULE, null, ModuleConfiguration.EMPTY); injector.getTopDownAnalyzer().doProcessStandardLibraryNamespace(outerScope, standardLibraryNamespace, files); } @@ -279,14 +276,14 @@ public class TopDownAnalyzer { TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters( filesToAnalyzeCompletely, false, false, bindingTraceContext); - InjectorForTopDownAnalyzer injector = new InjectorForTopDownAnalyzer( - project, topDownAnalysisParameters, configuration, owner, flowDataTraceFactory); + InjectorForTopDownAnalyzerBasic injector = new InjectorForTopDownAnalyzerBasic( + project, topDownAnalysisParameters, owner, flowDataTraceFactory, configuration); injector.getTopDownAnalyzer().doAnalyzeFilesWithGivenTrance2(files); } - private void doAnalyzeFilesWithGivenTrance2(Collection files) { + public void doAnalyzeFilesWithGivenTrance2(Collection files) { final WritableScope scope = new WritableScopeImpl( JetScope.EMPTY, moduleDescriptor, new TraceBasedRedeclarationHandler(topDownAnalysisParameters.getTrace())).setDebugName("Root scope in analyzeNamespace"); diff --git a/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestForever.java b/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestForever.java new file mode 100644 index 00000000000..e92f74159b9 --- /dev/null +++ b/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestForever.java @@ -0,0 +1,69 @@ +/* + * Copyright 2010-2012 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.checkers; + +import junit.textui.ResultPrinter; +import junit.textui.TestRunner; + +import java.io.ByteArrayOutputStream; +import java.io.PrintStream; + +/** + * @author Stepan Koltsov + */ +public class JetDiagnosticsTestForever { + public static void main(String[] args) { + TestRunner.run(JetDiagnosticsTest.suite()); + TestRunner.run(JetDiagnosticsTest.suite()); + + int limit = args.length > 0 ? Integer.parseInt(args[0]) : Integer.MAX_VALUE; + + long total = 0; + long min = Long.MAX_VALUE; + long[] last100 = new long[100]; + long[] last10 = new long[10]; + for (int i = -100; i < limit; ++i) { + TestRunner runner = new TestRunner(); + runner.setPrinter(new ResultPrinter(new PrintStream(new ByteArrayOutputStream()))); + long start = System.nanoTime(); + runner.doRun(JetDiagnosticsTest.suite()); + long d = System.nanoTime() - start; + last100[(i + 100) % 100] = d; + last10[(i + 100) % 10] = d; + long dMs = d / 1000 / 1000; + if (i >= 1) { + total += d; + min = Math.min(min, d); + long avg = total / i / 1000 / 1000; + long avg10 = avg(last10) / 1000 / 1000; + long avg100 = avg(last100) / 1000 / 1000; + long minMs = min / 1000 / 1000; + System.out.println(dMs + "ms; avg=" + avg + "ms; avg10=" + avg10 + "ms; avg100=" + avg100 + "ms; min=" + minMs + "ms; iteration=" + i); + } else { + System.out.println(dMs + "ms; iteration=" + i); + } + } + } + + private static long avg(long[] array) { + long sum = 0; + for (long l : array) { + sum += l; + } + return sum / array.length; + } +} diff --git a/compiler/tests/org/jetbrains/jet/compiler/ReadJavaBinaryClassTest.java b/compiler/tests/org/jetbrains/jet/compiler/ReadJavaBinaryClassTest.java index 02c9ea23c2e..082c9c96c34 100644 --- a/compiler/tests/org/jetbrains/jet/compiler/ReadJavaBinaryClassTest.java +++ b/compiler/tests/org/jetbrains/jet/compiler/ReadJavaBinaryClassTest.java @@ -25,6 +25,7 @@ import junit.framework.Test; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.JetTestCaseBuilder; import org.jetbrains.jet.JetTestUtils; +import org.jetbrains.jet.di.InjectorForJavaSemanticServices; import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; import org.jetbrains.jet.lang.psi.JetFile; @@ -113,9 +114,7 @@ public class ReadJavaBinaryClassTest extends TestCaseWithTmpdir { jetCoreEnvironment.addToClasspath(tmpdir); jetCoreEnvironment.addToClasspath(new File("out/production/runtime")); - JavaSemanticServices semanticServices = new JavaSemanticServices(jetCoreEnvironment.getProject(), new BindingTraceContext()); - - JavaDescriptorResolver javaDescriptorResolver = semanticServices.getDescriptorResolver(); + JavaDescriptorResolver javaDescriptorResolver = new InjectorForJavaSemanticServices(jetCoreEnvironment.getProject()).getJavaDescriptorResolver(); return javaDescriptorResolver.resolveNamespace(FqName.topLevel("test"), DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN); } diff --git a/compiler/tests/org/jetbrains/jet/compiler/ReadKotlinBinaryClassTest.java b/compiler/tests/org/jetbrains/jet/compiler/ReadKotlinBinaryClassTest.java index d0af3c24d4e..693ffe82b87 100644 --- a/compiler/tests/org/jetbrains/jet/compiler/ReadKotlinBinaryClassTest.java +++ b/compiler/tests/org/jetbrains/jet/compiler/ReadKotlinBinaryClassTest.java @@ -29,15 +29,14 @@ import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.codegen.ClassBuilderFactories; import org.jetbrains.jet.codegen.ClassFileFactory; import org.jetbrains.jet.codegen.GenerationState; +import org.jetbrains.jet.di.InjectorForJavaSemanticServices; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.AnalyzingUtils; import org.jetbrains.jet.lang.resolve.BindingContext; -import org.jetbrains.jet.lang.resolve.BindingTraceContext; import org.jetbrains.jet.lang.resolve.FqName; import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; -import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices; import org.jetbrains.jet.plugin.JetLanguage; import org.junit.Assert; @@ -91,9 +90,7 @@ public class ReadKotlinBinaryClassTest extends TestCaseWithTmpdir { jetCoreEnvironment.addToClasspath(tmpdir); jetCoreEnvironment.addToClasspath(new File("out/production/runtime")); - JavaSemanticServices semanticServices = new JavaSemanticServices(jetCoreEnvironment.getProject(), new BindingTraceContext()); - - JavaDescriptorResolver javaDescriptorResolver = semanticServices.getDescriptorResolver(); + JavaDescriptorResolver javaDescriptorResolver = new InjectorForJavaSemanticServices(jetCoreEnvironment.getProject()).getJavaDescriptorResolver(); NamespaceDescriptor namespaceFromClass = javaDescriptorResolver.resolveNamespace(FqName.topLevel("test"), DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN); NamespaceComparator.compareNamespaces(namespaceFromSource, namespaceFromClass, false, txtFile); diff --git a/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java b/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java index 92a38d5bafb..a68fb05871a 100644 --- a/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java +++ b/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java @@ -25,18 +25,18 @@ import com.intellij.psi.PsiMethod; import junit.framework.Test; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.JetTestCaseBuilder; +import org.jetbrains.jet.di.InjectorForJavaSemanticServices; import org.jetbrains.jet.di.InjectorForTests; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; import org.jetbrains.jet.lang.psi.JetFile; -import org.jetbrains.jet.lang.resolve.BindingTraceContext; import org.jetbrains.jet.lang.resolve.FqName; import org.jetbrains.jet.lang.resolve.calls.CallResolver; import org.jetbrains.jet.lang.resolve.calls.OverloadResolutionResults; import org.jetbrains.jet.lang.resolve.calls.ResolvedCall; -import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices; +import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.TypeProjection; @@ -123,8 +123,8 @@ public class JetResolveTest extends ExtensibleResolveTestCase { @NotNull private PsiClass findClass(String qualifiedName) { Project project = getProject(); - JavaSemanticServices javaSemanticServices = new JavaSemanticServices(project, new BindingTraceContext()); - return javaSemanticServices.getDescriptorResolver().findClass(new FqName(qualifiedName)); + JavaDescriptorResolver javaDescriptorResolver = new InjectorForJavaSemanticServices(project).getJavaDescriptorResolver(); + return javaDescriptorResolver.findClass(new FqName(qualifiedName)); } @NotNull diff --git a/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java b/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java index 322b0bcc8f5..0c4a6874137 100644 --- a/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java +++ b/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java @@ -23,6 +23,7 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.JetLiteFixture; import org.jetbrains.jet.JetTestCaseBuilder; import org.jetbrains.jet.JetTestUtils; +import org.jetbrains.jet.di.InjectorForJavaSemanticServices; import org.jetbrains.jet.di.InjectorForTests; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; @@ -584,9 +585,11 @@ public class JetTypeCheckerTest extends JetLiteFixture { private WritableScopeImpl addImports(JetScope scope) { WritableScopeImpl writableScope = new WritableScopeImpl(scope, scope.getContainingDeclaration(), RedeclarationHandler.DO_NOTHING); writableScope.importScope(library.getLibraryScope()); - JavaSemanticServices javaSemanticServices = new JavaSemanticServices(getProject(), JetTestUtils.DUMMY_TRACE); - writableScope.importScope(javaSemanticServices.getDescriptorResolver().resolveNamespace(FqName.ROOT, DescriptorSearchRule.INCLUDE_KOTLIN).getMemberScope()); - writableScope.importScope(javaSemanticServices.getDescriptorResolver().resolveNamespace(new FqName("java.lang"), DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN).getMemberScope()); + JavaDescriptorResolver javaDescriptorResolver = new InjectorForJavaSemanticServices(getProject()).getJavaDescriptorResolver(); + writableScope.importScope(javaDescriptorResolver.resolveNamespace(FqName.ROOT, + DescriptorSearchRule.INCLUDE_KOTLIN).getMemberScope()); + writableScope.importScope(javaDescriptorResolver.resolveNamespace(new FqName("java.lang"), + DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN).getMemberScope()); writableScope.changeLockLevel(WritableScope.LockLevel.BOTH); return writableScope; } diff --git a/idea/src/org/jetbrains/jet/plugin/libraries/DecompiledDataFactory.java b/idea/src/org/jetbrains/jet/plugin/libraries/DecompiledDataFactory.java index 385e252eb94..8589dada756 100644 --- a/idea/src/org/jetbrains/jet/plugin/libraries/DecompiledDataFactory.java +++ b/idea/src/org/jetbrains/jet/plugin/libraries/DecompiledDataFactory.java @@ -26,11 +26,11 @@ import com.intellij.psi.util.PsiTreeUtil; import jet.runtime.typeinfo.JetClass; import jet.runtime.typeinfo.JetMethod; import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.di.InjectorForJavaSemanticServices; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.JetDeclaration; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.BindingContext; -import org.jetbrains.jet.lang.resolve.BindingTraceContext; import org.jetbrains.jet.lang.resolve.FqName; import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; @@ -60,9 +60,9 @@ class DecompiledDataFactory { private DecompiledDataFactory(ClsFileImpl clsFile) { myClsFile = clsFile; Project project = myClsFile.getProject(); - JavaSemanticServices jss = new JavaSemanticServices(project, new BindingTraceContext()); - myBindingContext = jss.getTrace().getBindingContext(); - myJavaDescriptorResolver = jss.getDescriptorResolver(); + InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices(project); + myBindingContext = injector.getBindingTrace().getBindingContext(); + myJavaDescriptorResolver = injector.getJavaDescriptorResolver(); } @NotNull diff --git a/injector-generator/src/org/jetbrains/jet/di/AllInjectorsGenerator.java b/injector-generator/src/org/jetbrains/jet/di/AllInjectorsGenerator.java index 02f5966e5a2..7a46ebaef10 100644 --- a/injector-generator/src/org/jetbrains/jet/di/AllInjectorsGenerator.java +++ b/injector-generator/src/org/jetbrains/jet/di/AllInjectorsGenerator.java @@ -22,6 +22,9 @@ import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.resolve.*; import org.jetbrains.jet.lang.resolve.calls.CallResolver; +import org.jetbrains.jet.lang.resolve.java.JavaBridgeConfiguration; +import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; +import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices; import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; @@ -35,14 +38,29 @@ import java.io.IOException; public class AllInjectorsGenerator { public static void main(String[] args) throws IOException { - generateProductionInjector(); + generateInjectorForTopDownAnalyzerBasic(); + generateInjectorForTopDownAnalyzerForJvm(); generateMacroInjector(); generateTestInjector(); + generateInjectorForJavaSemanticServices(); } - private static void generateProductionInjector() throws IOException { + private static void generateInjectorForTopDownAnalyzerBasic() throws IOException { DependencyInjectorGenerator generator = new DependencyInjectorGenerator(false); + generateInjectorForTopDownAnalyzerCommon(generator); + generator.addParameter(ModuleConfiguration.class); + generator.generate("compiler/frontend/src", "org.jetbrains.jet.di", "InjectorForTopDownAnalyzerBasic"); + } + private static void generateInjectorForTopDownAnalyzerForJvm() throws IOException { + DependencyInjectorGenerator generator = new DependencyInjectorGenerator(false); + generateInjectorForTopDownAnalyzerCommon(generator); + generator.addPublicField(JavaBridgeConfiguration.class); + generator.addPublicParameter(BindingTrace.class); + generator.generate("compiler/frontend.java/src", "org.jetbrains.jet.di", "InjectorForTopDownAnalyzerForJvm"); + } + + private static void generateInjectorForTopDownAnalyzerCommon(DependencyInjectorGenerator generator) { // Fields generator.addPublicField(TopDownAnalyzer.class); generator.addPublicField(TopDownAnalysisContext.class); @@ -54,11 +72,8 @@ public class AllInjectorsGenerator { // Parameters generator.addPublicParameter(Project.class); generator.addPublicParameter(TopDownAnalysisParameters.class); - generator.addParameter(ModuleConfiguration.class); generator.addParameter(ModuleDescriptor.class); generator.addParameter(JetControlFlowDataTraceFactory.class, false); - - generator.generate("compiler/frontend/src", "org.jetbrains.jet.di", "InjectorForTopDownAnalyzer"); } private static void generateMacroInjector() throws IOException { @@ -88,5 +103,19 @@ public class AllInjectorsGenerator { generator.generate("compiler/tests", "org.jetbrains.jet.di", "InjectorForTests"); } + + private static void generateInjectorForJavaSemanticServices() throws IOException { + DependencyInjectorGenerator generator = new DependencyInjectorGenerator(false); + + // Fields + generator.addPublicField(JavaSemanticServices.class); + generator.addPublicField(JavaDescriptorResolver.class); + generator.addField(true, BindingTrace.class, null, new GivenExpression("new org.jetbrains.jet.lang.resolve.BindingTraceContext()")); + + // Parameters + generator.addPublicParameter(Project.class); + + generator.generate("compiler/frontend.java/src", "org.jetbrains.jet.di", "InjectorForJavaSemanticServices"); + } } diff --git a/injector-generator/src/org/jetbrains/jet/di/DependencyInjectorGenerator.java b/injector-generator/src/org/jetbrains/jet/di/DependencyInjectorGenerator.java index b6579d5604f..d64b190379d 100644 --- a/injector-generator/src/org/jetbrains/jet/di/DependencyInjectorGenerator.java +++ b/injector-generator/src/org/jetbrains/jet/di/DependencyInjectorGenerator.java @@ -329,7 +329,13 @@ public class DependencyInjectorGenerator { } private Field findDependencyOfType(Class parameterType, String errorMessage, Field neededFor) { - Collection fields = typeToField.get(parameterType); + List fields = Lists.newArrayList(); + for (Map.Entry, Field> entry : typeToField.entries()) { + if (parameterType.isAssignableFrom(entry.getKey())) { + fields.add(entry.getValue()); + } + } + Field dependency; if (fields.isEmpty()) { dependency = addField(parameterType);