From ad05b5a70936c8c9af06179fc535fa11f28e91cd Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Thu, 18 Sep 2014 15:19:03 +0400 Subject: [PATCH] Injector for additional body resolve with lazy analyzer Fix resolve JS modules with JVM resolver --- .../jet/di/InjectorForLazyBodyResolve.java | 255 ++++++++++++++++++ .../jet/lang/resolve/LazyTopDownAnalyzer.java | 12 +- .../jet/lang/resolve/TopDownAnalyzer.java | 3 +- .../generators/injectors/GenerateInjectors.kt | 19 +- .../caches/resolve/KotlinResolveCache.kt | 17 +- .../plugin/project/ResolveElementCache.java | 6 +- .../jet/plugin/project/TargetPlatform.java | 9 +- .../plugin/project/TargetPlatformImpl.java | 13 + 8 files changed, 316 insertions(+), 18 deletions(-) create mode 100644 compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyBodyResolve.java diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyBodyResolve.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyBodyResolve.java new file mode 100644 index 00000000000..1d14f0b30b0 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyBodyResolve.java @@ -0,0 +1,255 @@ +/* + * Copyright 2010-2014 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 com.intellij.openapi.project.Project; +import org.jetbrains.jet.context.GlobalContext; +import org.jetbrains.jet.storage.StorageManager; +import org.jetbrains.jet.lang.resolve.BindingTrace; +import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider; +import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; +import org.jetbrains.jet.lang.PlatformToKotlinClassMap; +import org.jetbrains.jet.lang.resolve.LazyTopDownAnalyzer; +import org.jetbrains.jet.lang.resolve.BodyResolver; +import org.jetbrains.jet.lang.resolve.AnnotationResolver; +import org.jetbrains.jet.lang.resolve.calls.CallResolver; +import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver; +import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; +import org.jetbrains.jet.lang.types.expressions.ExpressionTypingComponents; +import org.jetbrains.jet.lang.types.expressions.ControlStructureTypingUtils; +import org.jetbrains.jet.lang.types.expressions.ExpressionTypingUtils; +import org.jetbrains.jet.lang.types.expressions.ForLoopConventionsChecker; +import org.jetbrains.jet.lang.reflect.ReflectionTypes; +import org.jetbrains.jet.lang.resolve.calls.CallExpressionResolver; +import org.jetbrains.jet.lang.resolve.DescriptorResolver; +import org.jetbrains.jet.lang.resolve.DelegatedPropertyResolver; +import org.jetbrains.jet.lang.resolve.TypeResolver; +import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver; +import org.jetbrains.jet.lang.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider; +import org.jetbrains.jet.context.LazinessToken; +import org.jetbrains.jet.lang.resolve.calls.CallResolverExtensionProvider; +import org.jetbrains.jet.lang.resolve.calls.CallCompleter; +import org.jetbrains.jet.lang.resolve.calls.CandidateResolver; +import org.jetbrains.jet.lang.resolve.calls.tasks.TaskPrioritizer; +import org.jetbrains.jet.lang.resolve.ControlFlowAnalyzer; +import org.jetbrains.jet.lang.resolve.DeclarationsChecker; +import org.jetbrains.jet.lang.resolve.ModifiersChecker; +import org.jetbrains.jet.lang.resolve.FunctionAnalyzerExtension; +import org.jetbrains.jet.lang.resolve.ScriptBodyResolver; +import org.jetbrains.jet.lang.resolve.DeclarationResolver; +import org.jetbrains.jet.lang.resolve.ImportsResolver; +import org.jetbrains.jet.lang.psi.JetImportsFactory; +import org.jetbrains.jet.lang.resolve.OverloadResolver; +import org.jetbrains.jet.lang.resolve.OverrideResolver; +import org.jetbrains.jet.lang.resolve.lazy.KotlinCodeAnalyzer; +import org.jetbrains.annotations.NotNull; +import javax.annotation.PreDestroy; + +/* This file is generated by org.jetbrains.jet.generators.injectors.InjectorsPackage. DO NOT EDIT! */ +@SuppressWarnings("all") +public class InjectorForLazyBodyResolve { + + private final Project project; + private final GlobalContext globalContext; + private final StorageManager storageManager; + private final BindingTrace bindingTrace; + private final AdditionalCheckerProvider additionalCheckerProvider; + private final ModuleDescriptor moduleDescriptor; + private final PlatformToKotlinClassMap platformToKotlinClassMap; + private final LazyTopDownAnalyzer lazyTopDownAnalyzer; + private final BodyResolver bodyResolver; + private final AnnotationResolver annotationResolver; + private final CallResolver callResolver; + private final ArgumentTypeResolver argumentTypeResolver; + private final ExpressionTypingServices expressionTypingServices; + private final ExpressionTypingComponents expressionTypingComponents; + private final ControlStructureTypingUtils controlStructureTypingUtils; + private final ExpressionTypingUtils expressionTypingUtils; + private final ForLoopConventionsChecker forLoopConventionsChecker; + private final ReflectionTypes reflectionTypes; + private final CallExpressionResolver callExpressionResolver; + private final DescriptorResolver descriptorResolver; + private final DelegatedPropertyResolver delegatedPropertyResolver; + private final TypeResolver typeResolver; + private final QualifiedExpressionResolver qualifiedExpressionResolver; + private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider; + private final LazinessToken lazinessToken; + private final CallResolverExtensionProvider callResolverExtensionProvider; + private final CallCompleter callCompleter; + private final CandidateResolver candidateResolver; + private final TaskPrioritizer taskPrioritizer; + private final ControlFlowAnalyzer controlFlowAnalyzer; + private final DeclarationsChecker declarationsChecker; + private final ModifiersChecker modifiersChecker; + private final FunctionAnalyzerExtension functionAnalyzerExtension; + private final ScriptBodyResolver scriptBodyResolver; + private final DeclarationResolver declarationResolver; + private final ImportsResolver importsResolver; + private final JetImportsFactory jetImportsFactory; + private final OverloadResolver overloadResolver; + private final OverrideResolver overrideResolver; + + public InjectorForLazyBodyResolve( + @NotNull Project project, + @NotNull GlobalContext globalContext, + @NotNull KotlinCodeAnalyzer analyzer, + @NotNull BindingTrace bindingTrace, + @NotNull AdditionalCheckerProvider additionalCheckerProvider + ) { + this.project = project; + this.globalContext = globalContext; + this.storageManager = globalContext.getStorageManager(); + this.bindingTrace = bindingTrace; + this.additionalCheckerProvider = additionalCheckerProvider; + this.moduleDescriptor = analyzer.getModuleDescriptor(); + this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap(); + this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer(); + this.bodyResolver = new BodyResolver(); + this.annotationResolver = new AnnotationResolver(); + this.callResolver = new CallResolver(); + this.argumentTypeResolver = new ArgumentTypeResolver(); + this.expressionTypingComponents = new ExpressionTypingComponents(); + this.expressionTypingServices = new ExpressionTypingServices(expressionTypingComponents); + this.controlStructureTypingUtils = new ControlStructureTypingUtils(expressionTypingServices); + this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver); + this.forLoopConventionsChecker = new ForLoopConventionsChecker(); + this.reflectionTypes = new ReflectionTypes(moduleDescriptor); + this.callExpressionResolver = new CallExpressionResolver(); + this.descriptorResolver = new DescriptorResolver(); + this.delegatedPropertyResolver = new DelegatedPropertyResolver(); + this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); + this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider(); + this.lazinessToken = new LazinessToken(); + this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, flexibleTypeCapabilitiesProvider, storageManager, lazinessToken); + this.callResolverExtensionProvider = new CallResolverExtensionProvider(); + this.candidateResolver = new CandidateResolver(); + this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver); + this.taskPrioritizer = new TaskPrioritizer(storageManager); + this.controlFlowAnalyzer = new ControlFlowAnalyzer(); + this.declarationsChecker = new DeclarationsChecker(); + this.modifiersChecker = new ModifiersChecker(bindingTrace, additionalCheckerProvider); + this.functionAnalyzerExtension = new FunctionAnalyzerExtension(); + this.scriptBodyResolver = new ScriptBodyResolver(); + this.declarationResolver = new DeclarationResolver(); + this.importsResolver = new ImportsResolver(); + this.jetImportsFactory = new JetImportsFactory(); + this.overloadResolver = new OverloadResolver(); + this.overrideResolver = new OverrideResolver(); + + this.lazyTopDownAnalyzer.setBodyResolver(bodyResolver); + this.lazyTopDownAnalyzer.setDeclarationResolver(declarationResolver); + this.lazyTopDownAnalyzer.setModuleDescriptor(moduleDescriptor); + this.lazyTopDownAnalyzer.setOverloadResolver(overloadResolver); + this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver); + this.lazyTopDownAnalyzer.setTrace(bindingTrace); + + bodyResolver.setAnnotationResolver(annotationResolver); + bodyResolver.setCallResolver(callResolver); + bodyResolver.setControlFlowAnalyzer(controlFlowAnalyzer); + bodyResolver.setDeclarationsChecker(declarationsChecker); + bodyResolver.setDelegatedPropertyResolver(delegatedPropertyResolver); + bodyResolver.setExpressionTypingServices(expressionTypingServices); + bodyResolver.setFunctionAnalyzerExtension(functionAnalyzerExtension); + bodyResolver.setScriptBodyResolverResolver(scriptBodyResolver); + bodyResolver.setTrace(bindingTrace); + + annotationResolver.setCallResolver(callResolver); + annotationResolver.setStorageManager(storageManager); + annotationResolver.setTypeResolver(typeResolver); + + callResolver.setArgumentTypeResolver(argumentTypeResolver); + callResolver.setCallCompleter(callCompleter); + callResolver.setCandidateResolver(candidateResolver); + callResolver.setExpressionTypingServices(expressionTypingServices); + callResolver.setTaskPrioritizer(taskPrioritizer); + callResolver.setTypeResolver(typeResolver); + + argumentTypeResolver.setExpressionTypingServices(expressionTypingServices); + argumentTypeResolver.setTypeResolver(typeResolver); + + expressionTypingServices.setAnnotationResolver(annotationResolver); + expressionTypingServices.setCallExpressionResolver(callExpressionResolver); + expressionTypingServices.setCallResolver(callResolver); + expressionTypingServices.setDescriptorResolver(descriptorResolver); + expressionTypingServices.setExtensionProvider(callResolverExtensionProvider); + expressionTypingServices.setProject(project); + expressionTypingServices.setTypeResolver(typeResolver); + + expressionTypingComponents.setAdditionalCheckerProvider(additionalCheckerProvider); + expressionTypingComponents.setCallResolver(callResolver); + expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils); + expressionTypingComponents.setExpressionTypingServices(expressionTypingServices); + expressionTypingComponents.setExpressionTypingUtils(expressionTypingUtils); + expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker); + expressionTypingComponents.setGlobalContext(globalContext); + expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap); + expressionTypingComponents.setReflectionTypes(reflectionTypes); + + forLoopConventionsChecker.setExpressionTypingServices(expressionTypingServices); + forLoopConventionsChecker.setExpressionTypingUtils(expressionTypingUtils); + forLoopConventionsChecker.setProject(project); + + callExpressionResolver.setExpressionTypingServices(expressionTypingServices); + + descriptorResolver.setAnnotationResolver(annotationResolver); + descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver); + descriptorResolver.setExpressionTypingServices(expressionTypingServices); + descriptorResolver.setStorageManager(storageManager); + descriptorResolver.setTypeResolver(typeResolver); + + delegatedPropertyResolver.setCallResolver(callResolver); + delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices); + + candidateResolver.setArgumentTypeResolver(argumentTypeResolver); + + controlFlowAnalyzer.setTrace(bindingTrace); + + declarationsChecker.setDescriptorResolver(descriptorResolver); + declarationsChecker.setModifiersChecker(modifiersChecker); + declarationsChecker.setTrace(bindingTrace); + + functionAnalyzerExtension.setTrace(bindingTrace); + + scriptBodyResolver.setExpressionTypingServices(expressionTypingServices); + + declarationResolver.setAnnotationResolver(annotationResolver); + declarationResolver.setDescriptorResolver(descriptorResolver); + declarationResolver.setImportsResolver(importsResolver); + declarationResolver.setTrace(bindingTrace); + + importsResolver.setImportsFactory(jetImportsFactory); + importsResolver.setModuleDescriptor(moduleDescriptor); + importsResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver); + importsResolver.setTrace(bindingTrace); + + jetImportsFactory.setProject(project); + + overloadResolver.setTrace(bindingTrace); + + overrideResolver.setTrace(bindingTrace); + + } + + @PreDestroy + public void destroy() { + } + + public LazyTopDownAnalyzer getLazyTopDownAnalyzer() { + return this.lazyTopDownAnalyzer; + } + +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/LazyTopDownAnalyzer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/LazyTopDownAnalyzer.java index b65a1e15eaf..9615ae6fae5 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/LazyTopDownAnalyzer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/LazyTopDownAnalyzer.java @@ -59,10 +59,18 @@ public class LazyTopDownAnalyzer { @NotNull private ModuleDescriptor moduleDescriptor = null; + @SuppressWarnings("ConstantConditions") + @NotNull + private KotlinCodeAnalyzer resolveSession = null; + @SuppressWarnings("ConstantConditions") @NotNull private BodyResolver bodyResolver = null; + public void setKotlinCodeAnalyzer(@NotNull KotlinCodeAnalyzer kotlinCodeAnalyzer) { + this.resolveSession = kotlinCodeAnalyzer; + } + @Inject public void setTrace(@NotNull BindingTrace trace) { this.trace = trace; @@ -95,7 +103,6 @@ public class LazyTopDownAnalyzer { @NotNull public TopDownAnalysisContext analyzeDeclarations( - final KotlinCodeAnalyzer resolveSession, @NotNull TopDownAnalysisParameters topDownAnalysisParameters, @NotNull Collection declarations ) { @@ -111,7 +118,6 @@ public class LazyTopDownAnalyzer { for (PsiElement declaration : declarations) { declaration.accept( new JetVisitorVoid() { - private void registerDeclarations(@NotNull List declarations) { for (JetDeclaration jetDeclaration : declarations) { jetDeclaration.accept(this); @@ -270,7 +276,6 @@ public class LazyTopDownAnalyzer { bodyResolver.resolveBodies(c); - return c; } @@ -351,7 +356,6 @@ public class LazyTopDownAnalyzer { } } } - } 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 3ad88deafda..eeb94696987 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java @@ -143,8 +143,9 @@ public class TopDownAnalyzer { additionalCheckerProvider ).getResolveSession(); + lazyTopDownAnalyzer.setKotlinCodeAnalyzer(resolveSession); + lazyTopDownAnalyzer.analyzeDeclarations( - resolveSession, c.getTopDownAnalysisParameters(), declarations ); diff --git a/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt b/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt index 85cc644a586..703f9bb183a 100644 --- a/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt +++ b/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt @@ -42,6 +42,7 @@ import org.jetbrains.jet.lang.resolve.java.lazy.SingleModuleClassResolver import org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinderFactory import org.jetbrains.jet.lang.resolve.java.TopDownAnalyzerFacadeForJVM import org.jetbrains.jet.lang.resolve.kotlin.JavaDeclarationCheckerProvider +import org.jetbrains.jet.lang.resolve.lazy.KotlinCodeAnalyzer import org.jetbrains.jet.lang.resolve.java.JavaFlexibleTypeCapabilitiesProvider import org.jetbrains.jet.context.LazyResolveToken @@ -69,7 +70,8 @@ public fun createInjectorGenerators(): List = generatorForMacro(), generatorForTests(), generatorForLazyResolve(), - generatorForBodyResolve() + generatorForBodyResolve(), + generatorForLazyBodyResolve() ) private fun DependencyInjectorGenerator.commonForTopDownAnalyzer() { @@ -92,6 +94,21 @@ private fun generatorForTopDownAnalyzerBasic() = parameter(javaClass()) } +private fun generatorForLazyBodyResolve() = + generator("compiler/frontend/src", "org.jetbrains.jet.di", "InjectorForLazyBodyResolve") { + parameter(javaClass()) + parameter(javaClass(), useAsContext = true) + parameter(javaClass(), name = "analyzer") + parameter(javaClass()) + parameter(javaClass()) + + field(javaClass(), init = GivenExpression("analyzer.getModuleDescriptor()"), useAsContext = true) + + publicFields( + javaClass() + ) + } + private fun generatorForTopDownAnalyzerForJs() = generator("js/js.frontend/src", "org.jetbrains.jet.di", "InjectorForTopDownAnalyzerForJs") { commonForTopDownAnalyzer() diff --git a/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/KotlinResolveCache.kt b/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/KotlinResolveCache.kt index 74429005ba3..6f46e8fdc07 100644 --- a/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/KotlinResolveCache.kt +++ b/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/KotlinResolveCache.kt @@ -27,7 +27,6 @@ import com.intellij.util.containers.SLRUCache import com.intellij.psi.util.PsiModificationTracker import com.intellij.openapi.project.DumbService import org.jetbrains.jet.lang.resolve.DelegatingBindingTrace -import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm import org.jetbrains.jet.context.SimpleGlobalContext import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters import com.intellij.openapi.progress.ProcessCanceledException @@ -61,6 +60,8 @@ import org.jetbrains.jet.lang.resolve.BindingTraceContext import org.jetbrains.jet.lang.types.TypeUtils import org.jetbrains.jet.lang.resolve.scopes.ChainedScope import org.jetbrains.jet.lang.resolve.bindingContextUtil.getDataFlowInfo +import org.jetbrains.jet.di.InjectorForLazyBodyResolve +import org.jetbrains.jet.plugin.project.TargetPlatformDetector import org.jetbrains.jet.lang.resolve.lazy.descriptors.LazyClassDescriptor import org.jetbrains.jet.lang.resolve.calls.smartcasts.DataFlowInfo import org.jetbrains.jet.lang.resolve.scopes.JetScope @@ -237,14 +238,18 @@ private object KotlinResolveDataProvider { } val trace = DelegatingBindingTrace(resolveSession.getBindingContext(), "Trace for resolution of " + analyzableElement) - val injector = InjectorForTopDownAnalyzerForJvm( + + val lazyTopDownAnalyzer = InjectorForLazyBodyResolve( project, SimpleGlobalContext(resolveSession.getStorageManager(), resolveSession.getExceptionTracker()), - trace, - resolveSession.getModuleDescriptor() - ) - injector.getLazyTopDownAnalyzer()!!.analyzeDeclarations( resolveSession, + trace, + TargetPlatformDetector.getPlatform(analyzableElement.getContainingJetFile()).getAdditionalCheckerProvider() + ).getLazyTopDownAnalyzer()!! + + lazyTopDownAnalyzer.setKotlinCodeAnalyzer(resolveSession); + + lazyTopDownAnalyzer.analyzeDeclarations( TopDownAnalysisParameters.createForLazy( resolveSession.getStorageManager(), resolveSession.getExceptionTracker(), diff --git a/idea/idea-analysis/src/org/jetbrains/jet/plugin/project/ResolveElementCache.java b/idea/idea-analysis/src/org/jetbrains/jet/plugin/project/ResolveElementCache.java index 5e6ca9a5d9e..da204bf1ae6 100644 --- a/idea/idea-analysis/src/org/jetbrains/jet/plugin/project/ResolveElementCache.java +++ b/idea/idea-analysis/src/org/jetbrains/jet/plugin/project/ResolveElementCache.java @@ -73,10 +73,6 @@ public class ResolveElementCache extends ElementResolver { @NotNull @Override public AdditionalCheckerProvider getAdditionalCheckerProvider(@NotNull JetFile jetFile) { - TargetPlatform platform = TargetPlatformDetector.getPlatform(jetFile); - if (platform == TargetPlatform.JS) { - return AdditionalCheckerProvider.Empty.INSTANCE$; - } - return JavaDeclarationCheckerProvider.INSTANCE$; + return TargetPlatformDetector.getPlatform(jetFile).getAdditionalCheckerProvider(); } } diff --git a/idea/idea-analysis/src/org/jetbrains/jet/plugin/project/TargetPlatform.java b/idea/idea-analysis/src/org/jetbrains/jet/plugin/project/TargetPlatform.java index d5a7c361d6f..899bf4f5767 100644 --- a/idea/idea-analysis/src/org/jetbrains/jet/plugin/project/TargetPlatform.java +++ b/idea/idea-analysis/src/org/jetbrains/jet/plugin/project/TargetPlatform.java @@ -16,7 +16,14 @@ package org.jetbrains.jet.plugin.project; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider; +import org.jetbrains.jet.lang.resolve.kotlin.JavaDeclarationCheckerProvider; + public interface TargetPlatform { - TargetPlatform JVM = new TargetPlatformImpl("JVM"); + @NotNull + AdditionalCheckerProvider getAdditionalCheckerProvider(); + + TargetPlatform JVM = new TargetPlatformImpl("JVM", JavaDeclarationCheckerProvider.INSTANCE$); TargetPlatform JS = new TargetPlatformImpl("JS"); } diff --git a/idea/idea-analysis/src/org/jetbrains/jet/plugin/project/TargetPlatformImpl.java b/idea/idea-analysis/src/org/jetbrains/jet/plugin/project/TargetPlatformImpl.java index 8a7d08cb952..6dd29f4f7c0 100644 --- a/idea/idea-analysis/src/org/jetbrains/jet/plugin/project/TargetPlatformImpl.java +++ b/idea/idea-analysis/src/org/jetbrains/jet/plugin/project/TargetPlatformImpl.java @@ -17,14 +17,27 @@ package org.jetbrains.jet.plugin.project; import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider; public class TargetPlatformImpl implements TargetPlatform { @NotNull private final String platformName; + @NotNull private final AdditionalCheckerProvider additionalCheckerProvider; public TargetPlatformImpl(@NotNull String platformName) { + this(platformName, AdditionalCheckerProvider.Empty.INSTANCE$); + } + + public TargetPlatformImpl(@NotNull String platformName, @NotNull AdditionalCheckerProvider additionalCheckerProvider) { + this.additionalCheckerProvider = additionalCheckerProvider; this.platformName = platformName; } + @NotNull + @Override + public AdditionalCheckerProvider getAdditionalCheckerProvider() { + return additionalCheckerProvider; + } + @Override public String toString() { return platformName;