From b763aa9995336a9d33ea9fe1e7882153cdf84f1c Mon Sep 17 00:00:00 2001 From: Michael Bogdanov Date: Mon, 15 Sep 2014 14:38:29 +0400 Subject: [PATCH] Added platform static checker with provider implementation --- .../org/jetbrains/jet/codegen/AsmUtil.java | 3 +- .../jet/codegen/ExpressionCodegen.java | 3 +- .../jet/codegen/FunctionCodegen.java | 4 +- .../jetbrains/jet/codegen/JvmCodegenUtil.java | 21 ------ .../org/jetbrains/jet/codegen/StackValue.java | 3 +- .../jet/codegen/state/JetTypeMapper.java | 8 +-- .../di/InjectorForLazyResolveWithJava.java | 4 ++ .../di/InjectorForTopDownAnalyzerForJvm.java | 6 ++ .../diagnostics/DefaultErrorMessagesJvm.java | 5 ++ .../resolve/java/diagnostics/ErrorsJvm.java | 9 +++ .../kotlin/JavaDeclarationCheckerProvider.kt | 71 +++++++++++++++++++ .../jet/di/InjectorForBodyResolve.java | 8 ++- .../jet/di/InjectorForLazyResolve.java | 7 +- .../jetbrains/jet/di/InjectorForMacros.java | 4 ++ .../di/InjectorForTopDownAnalyzerBasic.java | 9 ++- .../lang/resolve/AdditionalCheckerProvider.kt | 31 ++++++++ .../jet/lang/resolve/AnnotationChecker.kt | 29 ++++++++ .../jet/lang/resolve/AnnotationUtil.kt | 33 +++++++++ .../jet/lang/resolve/DeclarationsChecker.java | 17 +++++ .../jet/lang/resolve/TopDownAnalyzer.java | 19 ++++- .../ClosureExpressionsTypingVisitor.java | 2 +- .../ExpressionTypingComponents.java | 7 ++ .../ExpressionTypingVisitorForStatements.java | 6 +- .../annotations/platformStatic/functions.kt | 54 ++++++++++++++ .../annotations/platformStatic/property.kt | 29 ++++++++ ...JetDiagnosticsTestWithStdLibGenerated.java | 24 ++++++- .../jetbrains/jet/di/InjectorForTests.java | 4 ++ ...ractLazyResolveDescriptorRendererTest.java | 4 +- .../jet/lang/resolve/DescriptorUtils.java | 5 ++ .../generators/injectors/GenerateInjectors.kt | 18 +++++ .../lang/resolve/lazy/ElementResolver.java | 20 +++--- .../plugin/caches/resolve/JsAnalyzerFacade.kt | 3 +- .../libraries/JetSourceNavigationHelper.java | 4 +- .../plugin/project/ResolveElementCache.java | 13 ++++ .../references/BuiltInsReferenceResolver.java | 2 +- .../di/InjectorForTopDownAnalyzerForJs.java | 6 ++ 36 files changed, 443 insertions(+), 52 deletions(-) create mode 100644 compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/kotlin/JavaDeclarationCheckerProvider.kt create mode 100644 compiler/frontend/src/org/jetbrains/jet/lang/resolve/AdditionalCheckerProvider.kt create mode 100644 compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationChecker.kt create mode 100644 compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationUtil.kt create mode 100644 compiler/testData/diagnostics/testsWithStdLib/annotations/platformStatic/functions.kt create mode 100644 compiler/testData/diagnostics/testsWithStdLib/annotations/platformStatic/property.kt diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/AsmUtil.java b/compiler/backend/src/org/jetbrains/jet/codegen/AsmUtil.java index 164bafacc1b..c3baae257ab 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/AsmUtil.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/AsmUtil.java @@ -31,6 +31,7 @@ import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.DescriptorToSourceUtils; import org.jetbrains.jet.lang.resolve.DescriptorUtils; +import org.jetbrains.jet.lang.resolve.annotations.AnnotationsPackage; import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall; import org.jetbrains.jet.lang.resolve.java.*; import org.jetbrains.jet.lang.resolve.java.descriptor.JavaCallableMemberDescriptor; @@ -169,7 +170,7 @@ public class AsmUtil { public static boolean isStaticMethod(OwnerKind kind, CallableMemberDescriptor functionDescriptor) { return isStaticKind(kind) || JetTypeMapper.isAccessor(functionDescriptor) || - JvmCodegenUtil.isPlatformStaticInObject(functionDescriptor); + AnnotationsPackage.isPlatformStaticInObject(functionDescriptor); } public static boolean isStaticKind(OwnerKind kind) { diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java index c5b3eeac059..87cf304dee9 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java @@ -47,6 +47,7 @@ import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingContextUtils; import org.jetbrains.jet.lang.resolve.DescriptorToSourceUtils; import org.jetbrains.jet.lang.resolve.DescriptorUtils; +import org.jetbrains.jet.lang.resolve.annotations.AnnotationsPackage; import org.jetbrains.jet.lang.resolve.calls.model.*; import org.jetbrains.jet.lang.resolve.calls.util.CallMaker; import org.jetbrains.jet.lang.resolve.calls.util.FakeCallableDescriptorForObject; @@ -2308,7 +2309,7 @@ public class ExpressionCodegen extends JetVisitor implem if (isSingleton) { if (context.hasThisDescriptor() && context.getThisDescriptor().equals(calleeContainingClass) && - !isPlatformStaticInObject(context.getContextDescriptor())) { + !AnnotationsPackage.isPlatformStaticInObject(context.getContextDescriptor())) { return StackValue.local(0, typeMapper.mapType(calleeContainingClass)); } else { diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java index d3025864fc2..b56e38ced0e 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java @@ -39,6 +39,8 @@ import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.psi.JetNamedFunction; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.DescriptorUtils; +import org.jetbrains.jet.lang.resolve.ResolvePackage; +import org.jetbrains.jet.lang.resolve.annotations.AnnotationsPackage; import org.jetbrains.jet.lang.resolve.calls.CallResolverUtil; import org.jetbrains.jet.lang.resolve.constants.ArrayValue; import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant; @@ -151,7 +153,7 @@ public class FunctionCodegen extends ParentCodegenAware { generateBridges(functionDescriptor); - if (JvmCodegenUtil.isPlatformStaticInClassObject(functionDescriptor)) { + if (AnnotationsPackage.isPlatformStaticInClassObject(functionDescriptor)) { MemberCodegen codegen = getParentCodegen().getParentCodegen(); ((ImplementationBodyCodegen) codegen).addAdditionalTask(new PlatformStaticGenerator(functionDescriptor, origin, state)); } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/JvmCodegenUtil.java b/compiler/backend/src/org/jetbrains/jet/codegen/JvmCodegenUtil.java index b74fd6393ab..551e4a47340 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/JvmCodegenUtil.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/JvmCodegenUtil.java @@ -31,7 +31,6 @@ import org.jetbrains.jet.codegen.context.PackageContext; import org.jetbrains.jet.codegen.state.JetTypeMapper; import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedCallableMemberDescriptor; import org.jetbrains.jet.lang.descriptors.*; -import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.psi.codeFragmentUtil.CodeFragmentUtilPackage; import org.jetbrains.jet.lang.resolve.DescriptorToSourceUtils; @@ -40,7 +39,6 @@ import org.jetbrains.jet.lang.resolve.java.lazy.descriptors.LazyJavaPackageFragm import org.jetbrains.jet.lang.resolve.kotlin.KotlinJvmBinaryClass; import org.jetbrains.jet.lang.resolve.kotlin.VirtualFileKotlinClass; import org.jetbrains.jet.lang.resolve.kotlin.incremental.IncrementalPackageFragmentProvider; -import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.types.JetType; import java.io.File; @@ -239,23 +237,4 @@ public class JvmCodegenUtil { ? ((PropertyAccessorDescriptor) descriptor).getCorrespondingProperty() : descriptor; } - - public static boolean isPlatformStaticInObject(CallableDescriptor descriptor) { - if (DescriptorUtils.isObject(descriptor.getContainingDeclaration())) { - return hasPlatformStaticAnnotation(descriptor); - } - return false; - } - - public static boolean isPlatformStaticInClassObject(CallableDescriptor descriptor) { - if (DescriptorUtils.isClassObject(descriptor.getContainingDeclaration())) { - return hasPlatformStaticAnnotation(descriptor); - } - return false; - } - - public static boolean hasPlatformStaticAnnotation(@NotNull CallableDescriptor descriptor) { - AnnotationDescriptor platformStaticAnnotation = descriptor.getAnnotations().findAnnotation(new FqName("kotlin.platform.platformStatic")); - return platformStaticAnnotation != null; - } } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/StackValue.java b/compiler/backend/src/org/jetbrains/jet/codegen/StackValue.java index b63d15135f8..c450df0ba6b 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/StackValue.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/StackValue.java @@ -25,6 +25,7 @@ import org.jetbrains.jet.codegen.state.GenerationState; import org.jetbrains.jet.codegen.state.JetTypeMapper; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.JetExpression; +import org.jetbrains.jet.lang.resolve.annotations.AnnotationsPackage; import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall; import org.jetbrains.jet.lang.resolve.java.JvmAbi; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue; @@ -1129,7 +1130,7 @@ public abstract class StackValue { ReceiverValue receiverArgument = resolvedCall.getReceiverArgument(); int depth = 0; if (thisObject.exists()) { - if (!JvmCodegenUtil.isPlatformStaticInObject(descriptor)) { + if (!AnnotationsPackage.isPlatformStaticInObject(descriptor)) { if (receiverArgument.exists()) { //noinspection ConstantConditions Type resultType = diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/state/JetTypeMapper.java b/compiler/backend/src/org/jetbrains/jet/codegen/state/JetTypeMapper.java index 7457c01b17c..82ac23a88ce 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/state/JetTypeMapper.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/state/JetTypeMapper.java @@ -31,10 +31,8 @@ import org.jetbrains.jet.lang.descriptors.annotations.Annotated; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.descriptors.impl.AnonymousFunctionDescriptor; import org.jetbrains.jet.lang.psi.JetFile; -import org.jetbrains.jet.lang.resolve.BindingContext; -import org.jetbrains.jet.lang.resolve.DescriptorToSourceUtils; -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.annotations.AnnotationsPackage; import org.jetbrains.jet.lang.resolve.calls.model.DefaultValueArgument; import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall; import org.jetbrains.jet.lang.resolve.calls.model.ResolvedValueArgument; @@ -445,7 +443,7 @@ public class JetTypeMapper { else { if (isStaticDeclaration(functionDescriptor) || isAccessor(functionDescriptor) || - isPlatformStaticInObject(functionDescriptor)) { + AnnotationsPackage.isPlatformStaticInObject(functionDescriptor)) { invokeOpcode = INVOKESTATIC; } else if (isInterface) { diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java index 082b784bc1f..edfd9d49345 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java @@ -36,6 +36,7 @@ import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedMethodSignatureCheck import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedExternalAnnotationResolver; import org.jetbrains.jet.lang.resolve.java.structure.impl.JavaPropertyInitializerEvaluatorImpl; import org.jetbrains.jet.lang.resolve.java.resolver.JavaSourceElementFactoryImpl; +import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider; import org.jetbrains.jet.lang.resolve.AnnotationResolver; import org.jetbrains.jet.lang.resolve.calls.CallResolver; import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver; @@ -91,6 +92,7 @@ public class InjectorForLazyResolveWithJava { private final PsiBasedExternalAnnotationResolver psiBasedExternalAnnotationResolver; private final JavaPropertyInitializerEvaluatorImpl javaPropertyInitializerEvaluator; private final JavaSourceElementFactoryImpl javaSourceElementFactory; + private final AdditionalCheckerProvider additionalCheckerProvider; private final AnnotationResolver annotationResolver; private final CallResolver callResolver; private final ArgumentTypeResolver argumentTypeResolver; @@ -152,6 +154,7 @@ public class InjectorForLazyResolveWithJava { this.globalJavaResolverContext = new GlobalJavaResolverContext(storageManager, javaClassFinder, virtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, lazyResolveBasedCache, javaPropertyInitializerEvaluator, javaSourceElementFactory, moduleClassResolver); this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, module); this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, module); + this.additionalCheckerProvider = org.jetbrains.jet.lang.resolve.kotlin.JavaDeclarationCheckerProvider.INSTANCE$; this.annotationResolver = new AnnotationResolver(); this.callResolver = new CallResolver(); this.argumentTypeResolver = new ArgumentTypeResolver(); @@ -221,6 +224,7 @@ public class InjectorForLazyResolveWithJava { expressionTypingServices.setProject(project); expressionTypingServices.setTypeResolver(typeResolver); + expressionTypingComponents.setAdditionalCheckerProvider(additionalCheckerProvider); expressionTypingComponents.setCallResolver(callResolver); expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils); expressionTypingComponents.setExpressionTypingServices(expressionTypingServices); 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 ac82017307e..c11ec3ed185 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java @@ -27,6 +27,7 @@ import org.jetbrains.jet.lang.resolve.LazyTopDownAnalyzer; import org.jetbrains.jet.lang.resolve.MutablePackageFragmentProvider; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.kotlin.DeserializationGlobalContextForJava; +import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider; import com.intellij.psi.search.GlobalSearchScope; import org.jetbrains.jet.lang.resolve.java.JavaClassFinderImpl; import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedExternalSignatureResolver; @@ -92,6 +93,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly private final MutablePackageFragmentProvider mutablePackageFragmentProvider; private final JavaDescriptorResolver javaDescriptorResolver; private final DeserializationGlobalContextForJava deserializationGlobalContextForJava; + private final AdditionalCheckerProvider additionalCheckerProvider; private final GlobalSearchScope globalSearchScope; private final JavaClassFinderImpl javaClassFinder; private final TraceBasedExternalSignatureResolver traceBasedExternalSignatureResolver; @@ -173,6 +175,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly this.annotationDescriptorLoader = new AnnotationDescriptorLoader(); this.constantDescriptorLoader = new ConstantDescriptorLoader(); this.deserializationGlobalContextForJava = new DeserializationGlobalContextForJava(storageManager, getModuleDescriptor(), javaClassDataFinder, annotationDescriptorLoader, constantDescriptorLoader, lazyJavaPackageFragmentProvider); + this.additionalCheckerProvider = org.jetbrains.jet.lang.resolve.kotlin.JavaDeclarationCheckerProvider.INSTANCE$; this.globalSearchScope = com.intellij.psi.search.GlobalSearchScope.allScope(project); this.bodyResolver = new BodyResolver(); this.annotationResolver = new AnnotationResolver(); @@ -205,6 +208,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly this.scriptHeaderResolver = new ScriptHeaderResolver(); this.descriptorLoadersStorage = new DescriptorLoadersStorage(storageManager); + this.topDownAnalyzer.setAdditionalCheckerProvider(additionalCheckerProvider); this.topDownAnalyzer.setBodyResolver(bodyResolver); this.topDownAnalyzer.setDeclarationResolver(declarationResolver); this.topDownAnalyzer.setLazyTopDownAnalyzer(lazyTopDownAnalyzer); @@ -270,6 +274,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly expressionTypingServices.setProject(project); expressionTypingServices.setTypeResolver(typeResolver); + expressionTypingComponents.setAdditionalCheckerProvider(additionalCheckerProvider); expressionTypingComponents.setCallResolver(callResolver); expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils); expressionTypingComponents.setExpressionTypingServices(expressionTypingServices); @@ -302,6 +307,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly controlFlowAnalyzer.setTrace(bindingTrace); + declarationsChecker.setAdditionalCheckerProvider(additionalCheckerProvider); declarationsChecker.setDescriptorResolver(descriptorResolver); declarationsChecker.setTrace(bindingTrace); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/diagnostics/DefaultErrorMessagesJvm.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/diagnostics/DefaultErrorMessagesJvm.java index 875b13803cf..846081862a7 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/diagnostics/DefaultErrorMessagesJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/diagnostics/DefaultErrorMessagesJvm.java @@ -23,6 +23,8 @@ import org.jetbrains.jet.lang.diagnostics.rendering.DiagnosticFactoryToRendererM import org.jetbrains.jet.renderer.DescriptorRenderer; import org.jetbrains.jet.renderer.Renderer; +import static org.jetbrains.jet.lang.diagnostics.PositioningStrategies.DECLARATION_SIGNATURE; + public class DefaultErrorMessagesJvm implements DefaultErrorMessages.Extension { private static final Renderer CONFLICTING_JVM_DECLARATIONS_DATA = new Renderer() { @@ -44,6 +46,9 @@ public class DefaultErrorMessagesJvm implements DefaultErrorMessages.Extension { static { MAP.put(ErrorsJvm.CONFLICTING_JVM_DECLARATIONS, "Platform declaration clash: {0}", CONFLICTING_JVM_DECLARATIONS_DATA); MAP.put(ErrorsJvm.ACCIDENTAL_OVERRIDE, "Accidental override: {0}", CONFLICTING_JVM_DECLARATIONS_DATA); + MAP.put(ErrorsJvm.PLATFORM_STATIC_NOT_IN_OBJECT, "Only functions in named objects and class objects of classes can be annotated with ''platformStatic''", DescriptorRenderer.SHORT_NAMES_IN_TYPES); + MAP.put(ErrorsJvm.OVERRIDE_CANNOT_BE_STATIC, "Override cannot be ''platformStatic'' in object", DescriptorRenderer.SHORT_NAMES_IN_TYPES); + MAP.put(ErrorsJvm.PLATFORM_STATIC_ILLEGAL_USAGE, "This declaration does not support ''platformStatic''", DescriptorRenderer.SHORT_NAMES_IN_TYPES); } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/diagnostics/ErrorsJvm.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/diagnostics/ErrorsJvm.java index b86a4045f21..2cb1e8afb68 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/diagnostics/ErrorsJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/diagnostics/ErrorsJvm.java @@ -17,9 +17,14 @@ package org.jetbrains.jet.lang.resolve.java.diagnostics; import com.intellij.psi.PsiElement; +import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; +import org.jetbrains.jet.lang.diagnostics.DiagnosticFactory0; import org.jetbrains.jet.lang.diagnostics.DiagnosticFactory1; import org.jetbrains.jet.lang.diagnostics.Errors; +import org.jetbrains.jet.lang.psi.JetDeclaration; +import org.jetbrains.jet.lang.psi.JetElement; +import static org.jetbrains.jet.lang.diagnostics.PositioningStrategies.DECLARATION_SIGNATURE; import static org.jetbrains.jet.lang.diagnostics.PositioningStrategies.DECLARATION_SIGNATURE_OR_DEFAULT; import static org.jetbrains.jet.lang.diagnostics.Severity.ERROR; @@ -30,6 +35,10 @@ public interface ErrorsJvm { DiagnosticFactory1 ACCIDENTAL_OVERRIDE = DiagnosticFactory1.create(ERROR, DECLARATION_SIGNATURE_OR_DEFAULT); + DiagnosticFactory1 OVERRIDE_CANNOT_BE_STATIC = DiagnosticFactory1.create(ERROR, DECLARATION_SIGNATURE); + DiagnosticFactory1 PLATFORM_STATIC_NOT_IN_OBJECT = DiagnosticFactory1.create(ERROR, DECLARATION_SIGNATURE); + DiagnosticFactory1 PLATFORM_STATIC_ILLEGAL_USAGE = DiagnosticFactory1.create(ERROR, DECLARATION_SIGNATURE); + @SuppressWarnings("UnusedDeclaration") Object _initializer = new Object() { { diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/kotlin/JavaDeclarationCheckerProvider.kt b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/kotlin/JavaDeclarationCheckerProvider.kt new file mode 100644 index 00000000000..e7bd4bb46da --- /dev/null +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/kotlin/JavaDeclarationCheckerProvider.kt @@ -0,0 +1,71 @@ +/* + * 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.lang.resolve.kotlin + +import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider +import com.google.common.collect.Lists +import org.jetbrains.jet.lang.resolve.AnnotationChecker +import org.jetbrains.jet.lang.psi.JetDeclaration +import org.jetbrains.jet.lang.descriptors.MemberDescriptor +import org.jetbrains.jet.lang.diagnostics.DiagnosticHolder +import org.jetbrains.jet.lang.resolve.annotations.hasPlatformStaticAnnotation +import org.jetbrains.jet.lang.psi.JetNamedFunction +import org.jetbrains.jet.lang.resolve.DescriptorUtils +import org.jetbrains.jet.lang.descriptors.ClassKind +import org.jetbrains.jet.lang.resolve.java.diagnostics.ErrorsJvm +import org.jetbrains.jet.lexer.JetTokens +import org.jetbrains.jet.lang.psi.JetProperty +import org.jetbrains.jet.lang.descriptors.PropertyDescriptor + +public object JavaDeclarationCheckerProvider : AdditionalCheckerProvider { + + override val annotationCheckers: List = listOf(PlatformStaticAnnotationChecker()) +} + +public class PlatformStaticAnnotationChecker : AnnotationChecker { + + override fun check(declaration: JetDeclaration, descriptor: MemberDescriptor, diagnosticHolder: DiagnosticHolder) { + if (descriptor.hasPlatformStaticAnnotation()) { + if (declaration is JetNamedFunction) { + val insideObject = DescriptorUtils.containerKindIs(descriptor, ClassKind.OBJECT) + val insideClassObject = DescriptorUtils.containerKindIs(descriptor, ClassKind.CLASS_OBJECT) + + if (!insideObject && !(insideClassObject && DescriptorUtils.containerKindIs(descriptor.getContainingDeclaration(), ClassKind.CLASS))) { + diagnosticHolder.report(ErrorsJvm.PLATFORM_STATIC_NOT_IN_OBJECT.on(declaration, descriptor)); + } + + if (insideObject && declaration.hasModifier(JetTokens.OVERRIDE_KEYWORD)) { + diagnosticHolder.report(ErrorsJvm.OVERRIDE_CANNOT_BE_STATIC.on(declaration, descriptor)); + } + } else { + //TODO: there should be general mechanism + diagnosticHolder.report(ErrorsJvm.PLATFORM_STATIC_ILLEGAL_USAGE.on(declaration, descriptor)); + } + } + + if (declaration is JetProperty) { + val getter = declaration.getGetter() + if (getter != null) { + check(getter, (descriptor as PropertyDescriptor).getGetter()!!, diagnosticHolder) + } + val setter = declaration.getSetter() + if (setter != null) { + check(setter, (descriptor as PropertyDescriptor).getSetter()!!, diagnosticHolder) + } + } + } +} \ No newline at end of file diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java index e8fe434058e..0e90a7b88fc 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java @@ -22,6 +22,7 @@ import org.jetbrains.jet.storage.StorageManager; import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.PlatformToKotlinClassMap; +import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider; import org.jetbrains.jet.lang.resolve.BodyResolver; import org.jetbrains.jet.lang.resolve.AnnotationResolver; import org.jetbrains.jet.lang.resolve.calls.CallResolver; @@ -57,6 +58,7 @@ public class InjectorForBodyResolve { private final BindingTrace bindingTrace; private final ModuleDescriptor moduleDescriptor; private final PlatformToKotlinClassMap platformToKotlinClassMap; + private final AdditionalCheckerProvider additionalCheckerProvider; private final BodyResolver bodyResolver; private final AnnotationResolver annotationResolver; private final CallResolver callResolver; @@ -84,7 +86,8 @@ public class InjectorForBodyResolve { @NotNull Project project, @NotNull GlobalContext globalContext, @NotNull BindingTrace bindingTrace, - @NotNull ModuleDescriptor moduleDescriptor + @NotNull ModuleDescriptor moduleDescriptor, + @NotNull AdditionalCheckerProvider additionalCheckerProvider ) { this.project = project; this.globalContext = globalContext; @@ -92,6 +95,7 @@ public class InjectorForBodyResolve { this.bindingTrace = bindingTrace; this.moduleDescriptor = moduleDescriptor; this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap(); + this.additionalCheckerProvider = additionalCheckerProvider; this.bodyResolver = new BodyResolver(); this.annotationResolver = new AnnotationResolver(); this.callResolver = new CallResolver(); @@ -146,6 +150,7 @@ public class InjectorForBodyResolve { expressionTypingServices.setProject(project); expressionTypingServices.setTypeResolver(typeResolver); + expressionTypingComponents.setAdditionalCheckerProvider(additionalCheckerProvider); expressionTypingComponents.setCallResolver(callResolver); expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils); expressionTypingComponents.setExpressionTypingServices(expressionTypingServices); @@ -178,6 +183,7 @@ public class InjectorForBodyResolve { controlFlowAnalyzer.setTrace(bindingTrace); + declarationsChecker.setAdditionalCheckerProvider(additionalCheckerProvider); declarationsChecker.setDescriptorResolver(descriptorResolver); declarationsChecker.setTrace(bindingTrace); diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java index 1b6150e373f..9424c33bc38 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java @@ -23,6 +23,7 @@ import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl; import org.jetbrains.jet.lang.PlatformToKotlinClassMap; import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFactory; import org.jetbrains.jet.lang.resolve.BindingTrace; +import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider; import org.jetbrains.jet.lang.resolve.lazy.ResolveSession; import org.jetbrains.jet.lang.resolve.AnnotationResolver; import org.jetbrains.jet.lang.resolve.calls.CallResolver; @@ -58,6 +59,7 @@ public class InjectorForLazyResolve { private final PlatformToKotlinClassMap platformToKotlinClassMap; private final DeclarationProviderFactory declarationProviderFactory; private final BindingTrace bindingTrace; + private final AdditionalCheckerProvider additionalCheckerProvider; private final ResolveSession resolveSession; private final AnnotationResolver annotationResolver; private final CallResolver callResolver; @@ -85,7 +87,8 @@ public class InjectorForLazyResolve { @NotNull GlobalContext globalContext, @NotNull ModuleDescriptorImpl moduleDescriptor, @NotNull DeclarationProviderFactory declarationProviderFactory, - @NotNull BindingTrace bindingTrace + @NotNull BindingTrace bindingTrace, + @NotNull AdditionalCheckerProvider additionalCheckerProvider ) { this.project = project; this.globalContext = globalContext; @@ -94,6 +97,7 @@ public class InjectorForLazyResolve { this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap(); this.declarationProviderFactory = declarationProviderFactory; this.bindingTrace = bindingTrace; + this.additionalCheckerProvider = additionalCheckerProvider; this.resolveSession = new ResolveSession(project, globalContext, moduleDescriptor, declarationProviderFactory, bindingTrace); this.annotationResolver = new AnnotationResolver(); this.callResolver = new CallResolver(); @@ -145,6 +149,7 @@ public class InjectorForLazyResolve { expressionTypingServices.setProject(project); expressionTypingServices.setTypeResolver(typeResolver); + expressionTypingComponents.setAdditionalCheckerProvider(additionalCheckerProvider); expressionTypingComponents.setCallResolver(callResolver); expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils); expressionTypingComponents.setExpressionTypingServices(expressionTypingServices); diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForMacros.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForMacros.java index 644dfd6e9c3..1d17be12363 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForMacros.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForMacros.java @@ -24,6 +24,7 @@ import org.jetbrains.jet.lang.types.expressions.ExpressionTypingComponents; import org.jetbrains.jet.lang.resolve.calls.CallResolver; import org.jetbrains.jet.context.GlobalContext; import org.jetbrains.jet.storage.StorageManager; +import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider; import org.jetbrains.jet.lang.resolve.AnnotationResolver; import org.jetbrains.jet.lang.resolve.TypeResolver; import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver; @@ -53,6 +54,7 @@ public class InjectorForMacros { private final CallResolver callResolver; private final GlobalContext globalContext; private final StorageManager storageManager; + private final AdditionalCheckerProvider additionalCheckerProvider; private final AnnotationResolver annotationResolver; private final TypeResolver typeResolver; private final QualifiedExpressionResolver qualifiedExpressionResolver; @@ -80,6 +82,7 @@ public class InjectorForMacros { this.callResolver = new CallResolver(); this.globalContext = org.jetbrains.jet.context.ContextPackage.GlobalContext(); this.storageManager = globalContext.getStorageManager(); + this.additionalCheckerProvider = org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider.Empty.INSTANCE$; this.annotationResolver = new AnnotationResolver(); this.typeResolver = new TypeResolver(); this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); @@ -103,6 +106,7 @@ public class InjectorForMacros { this.expressionTypingServices.setProject(project); this.expressionTypingServices.setTypeResolver(typeResolver); + this.expressionTypingComponents.setAdditionalCheckerProvider(additionalCheckerProvider); this.expressionTypingComponents.setCallResolver(callResolver); this.expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils); this.expressionTypingComponents.setExpressionTypingServices(expressionTypingServices); diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java index 023cfb1d74d..e9cc0c9ae52 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java @@ -25,6 +25,7 @@ import org.jetbrains.jet.lang.PlatformToKotlinClassMap; import org.jetbrains.jet.lang.resolve.TopDownAnalyzer; import org.jetbrains.jet.lang.resolve.LazyTopDownAnalyzer; import org.jetbrains.jet.lang.resolve.MutablePackageFragmentProvider; +import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider; import org.jetbrains.jet.lang.resolve.BodyResolver; import org.jetbrains.jet.lang.resolve.AnnotationResolver; import org.jetbrains.jet.lang.resolve.calls.CallResolver; @@ -70,6 +71,7 @@ public class InjectorForTopDownAnalyzerBasic { private final TopDownAnalyzer topDownAnalyzer; private final LazyTopDownAnalyzer lazyTopDownAnalyzer; private final MutablePackageFragmentProvider mutablePackageFragmentProvider; + private final AdditionalCheckerProvider additionalCheckerProvider; private final BodyResolver bodyResolver; private final AnnotationResolver annotationResolver; private final CallResolver callResolver; @@ -104,7 +106,8 @@ public class InjectorForTopDownAnalyzerBasic { @NotNull Project project, @NotNull GlobalContext globalContext, @NotNull BindingTrace bindingTrace, - @NotNull ModuleDescriptor moduleDescriptor + @NotNull ModuleDescriptor moduleDescriptor, + @NotNull AdditionalCheckerProvider additionalCheckerProvider ) { this.project = project; this.globalContext = globalContext; @@ -115,6 +118,7 @@ public class InjectorForTopDownAnalyzerBasic { this.topDownAnalyzer = new TopDownAnalyzer(); this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer(); this.mutablePackageFragmentProvider = new MutablePackageFragmentProvider(getModuleDescriptor()); + this.additionalCheckerProvider = additionalCheckerProvider; this.bodyResolver = new BodyResolver(); this.annotationResolver = new AnnotationResolver(); this.callResolver = new CallResolver(); @@ -145,6 +149,7 @@ public class InjectorForTopDownAnalyzerBasic { this.typeHierarchyResolver = new TypeHierarchyResolver(); this.scriptHeaderResolver = new ScriptHeaderResolver(); + this.topDownAnalyzer.setAdditionalCheckerProvider(additionalCheckerProvider); this.topDownAnalyzer.setBodyResolver(bodyResolver); this.topDownAnalyzer.setDeclarationResolver(declarationResolver); this.topDownAnalyzer.setLazyTopDownAnalyzer(lazyTopDownAnalyzer); @@ -194,6 +199,7 @@ public class InjectorForTopDownAnalyzerBasic { expressionTypingServices.setProject(project); expressionTypingServices.setTypeResolver(typeResolver); + expressionTypingComponents.setAdditionalCheckerProvider(additionalCheckerProvider); expressionTypingComponents.setCallResolver(callResolver); expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils); expressionTypingComponents.setExpressionTypingServices(expressionTypingServices); @@ -226,6 +232,7 @@ public class InjectorForTopDownAnalyzerBasic { controlFlowAnalyzer.setTrace(bindingTrace); + declarationsChecker.setAdditionalCheckerProvider(additionalCheckerProvider); declarationsChecker.setDescriptorResolver(descriptorResolver); declarationsChecker.setTrace(bindingTrace); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AdditionalCheckerProvider.kt b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AdditionalCheckerProvider.kt new file mode 100644 index 00000000000..179fc752c00 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AdditionalCheckerProvider.kt @@ -0,0 +1,31 @@ +/* + * 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.lang.resolve + +import org.jetbrains.annotations.ReadOnly + +import java.util.Collections + +public trait AdditionalCheckerProvider { + + public val annotationCheckers: List + + public object Empty : AdditionalCheckerProvider { + + override val annotationCheckers: List = listOf() + } +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationChecker.kt b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationChecker.kt new file mode 100644 index 00000000000..b1aa120bf0a --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationChecker.kt @@ -0,0 +1,29 @@ +/* + * 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.lang.resolve + +import org.jetbrains.jet.lang.psi.JetDeclaration +import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor +import org.jetbrains.jet.lang.descriptors.MemberDescriptor +import org.jetbrains.jet.lang.psi.JetDeclarationModifierList +import org.jetbrains.jet.lang.diagnostics.DiagnosticHolder + +public trait AnnotationChecker { + + public fun check(declaration: JetDeclaration, descriptor: MemberDescriptor, diagnosticHolder: DiagnosticHolder); + +} \ No newline at end of file diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationUtil.kt b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationUtil.kt new file mode 100644 index 00000000000..fccdbe883d4 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationUtil.kt @@ -0,0 +1,33 @@ +/* + * 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.lang.resolve.annotations + +import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor +import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor +import org.jetbrains.jet.lang.resolve.name.FqName +import org.jetbrains.jet.lang.descriptors.CallableDescriptor +import org.jetbrains.jet.lang.resolve.DescriptorUtils + +public fun DeclarationDescriptor.hasPlatformStaticAnnotation(): Boolean { + return getAnnotations().findAnnotation(FqName("kotlin.platform.platformStatic")) != null +} + +public fun CallableDescriptor.isPlatformStaticInObject(): Boolean = + DescriptorUtils.isObject(getContainingDeclaration()) && hasPlatformStaticAnnotation() + +public fun CallableDescriptor.isPlatformStaticInClassObject(): Boolean = + DescriptorUtils.isClassObject(getContainingDeclaration()) && hasPlatformStaticAnnotation() \ No newline at end of file diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationsChecker.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationsChecker.java index f5b987a4e79..425353e0d72 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationsChecker.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationsChecker.java @@ -44,6 +44,9 @@ public class DeclarationsChecker { @NotNull private DescriptorResolver descriptorResolver; + @NotNull + private AdditionalCheckerProvider additionalCheckerProvider; + @Inject public void setTrace(@NotNull BindingTrace trace) { this.trace = trace; @@ -55,6 +58,11 @@ public class DeclarationsChecker { this.descriptorResolver = descriptorResolver; } + @Inject + public void setAdditionalCheckerProvider(@NotNull AdditionalCheckerProvider additionalCheckerProvider) { + this.additionalCheckerProvider = additionalCheckerProvider; + } + public void process(@NotNull BodiesResolveContext bodiesResolveContext) { for (JetFile file : bodiesResolveContext.getFiles()) { checkModifiersAndAnnotationsInPackageDirective(file); @@ -80,6 +88,7 @@ public class DeclarationsChecker { } modifiersChecker.checkModifiersForDeclaration(classOrObject, classDescriptor); + runAnnotationCheckers(classOrObject, classDescriptor); } Map functions = bodiesResolveContext.getFunctions(); @@ -90,6 +99,7 @@ public class DeclarationsChecker { if (!bodiesResolveContext.completeAnalysisNeeded(function)) continue; checkFunction(function, functionDescriptor); modifiersChecker.checkModifiersForDeclaration(function, functionDescriptor); + runAnnotationCheckers(function, functionDescriptor); } Map properties = bodiesResolveContext.getProperties(); @@ -100,6 +110,7 @@ public class DeclarationsChecker { if (!bodiesResolveContext.completeAnalysisNeeded(property)) continue; checkProperty(property, propertyDescriptor); modifiersChecker.checkModifiersForDeclaration(property, propertyDescriptor); + runAnnotationCheckers(property, propertyDescriptor); } } @@ -559,4 +570,10 @@ public class DeclarationsChecker { } } } + + private void runAnnotationCheckers(@NotNull JetDeclaration declaration, @NotNull MemberDescriptor descriptor) { + for (AnnotationChecker checker : additionalCheckerProvider.getAnnotationCheckers()) { + checker.check(declaration, descriptor, trace); + } + } } 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 a157c2527b2..a25122bf1e9 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java @@ -62,6 +62,8 @@ public class TopDownAnalyzer { @NotNull private BodyResolver bodyResolver; @NotNull + private AdditionalCheckerProvider additionalCheckerProvider; + @NotNull private Project project; @NotNull @@ -117,6 +119,11 @@ public class TopDownAnalyzer { this.lazyTopDownAnalyzer = lazyTopDownAnalyzer; } + @Inject + public void setAdditionalCheckerProvider(@NotNull AdditionalCheckerProvider additionalCheckerProvider) { + this.additionalCheckerProvider = additionalCheckerProvider; + } + public void doProcess( @NotNull TopDownAnalysisContext c, @NotNull JetScope outerScope, @@ -132,7 +139,8 @@ public class TopDownAnalyzer { new GlobalContextImpl((LockBasedStorageManager) c.getStorageManager(), c.getExceptionTracker()), // TODO (ModuleDescriptorImpl) moduleDescriptor, // TODO new FileBasedDeclarationProviderFactory(c.getStorageManager(), getFiles(declarations)), - trace + trace, + additionalCheckerProvider ).getResolveSession(); lazyTopDownAnalyzer.analyzeDeclarations( @@ -193,7 +201,8 @@ public class TopDownAnalyzer { @Nullable final WritableScope scope, @NotNull ExpressionTypingContext context, @NotNull final DeclarationDescriptor containingDeclaration, - @NotNull JetClassOrObject object + @NotNull JetClassOrObject object, + @NotNull AdditionalCheckerProvider additionalCheckerProvider ) { TopDownAnalysisParameters topDownAnalysisParameters = TopDownAnalysisParameters.createForLocalDeclarations( @@ -203,7 +212,11 @@ public class TopDownAnalyzer { ); InjectorForTopDownAnalyzerBasic injector = new InjectorForTopDownAnalyzerBasic( - object.getProject(), topDownAnalysisParameters, context.trace, DescriptorUtils.getContainingModule(containingDeclaration) + object.getProject(), + topDownAnalysisParameters, + context.trace, + DescriptorUtils.getContainingModule(containingDeclaration), + additionalCheckerProvider ); TopDownAnalysisContext c = new TopDownAnalysisContext(topDownAnalysisParameters); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java index 0b644fba0a6..7b66ff094d8 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java @@ -89,7 +89,7 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor { null, // don't need to add classifier of object literal to any scope context.replaceBindingTrace(traceAdapter).replaceContextDependency(INDEPENDENT), context.scope.getContainingDeclaration(), - expression.getObjectDeclaration()); + expression.getObjectDeclaration(), components.additionalCheckerProvider); DelegatingBindingTrace cloneDelta = new DelegatingBindingTrace( new BindingTraceContext().getBindingContext(), "cached delta trace for object literal expression resolve", expression); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingComponents.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingComponents.java index 747e2bca89c..b051fb0df46 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingComponents.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingComponents.java @@ -20,6 +20,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.context.GlobalContext; import org.jetbrains.jet.lang.PlatformToKotlinClassMap; import org.jetbrains.jet.lang.reflect.ReflectionTypes; +import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider; import org.jetbrains.jet.lang.resolve.calls.CallResolver; import javax.inject.Inject; @@ -33,6 +34,7 @@ public class ExpressionTypingComponents { /*package*/ ControlStructureTypingUtils controlStructureTypingUtils; /*package*/ ForLoopConventionsChecker forLoopConventionsChecker; /*package*/ ReflectionTypes reflectionTypes; + /*package*/ AdditionalCheckerProvider additionalCheckerProvider; @Inject public void setGlobalContext(@NotNull GlobalContext globalContext) { @@ -74,6 +76,11 @@ public class ExpressionTypingComponents { this.reflectionTypes = reflectionTypes; } + @Inject + public void setAdditionalCheckerProvider(AdditionalCheckerProvider additionalCheckerProvider) { + this.additionalCheckerProvider = additionalCheckerProvider; + } + @NotNull public ForLoopConventionsChecker getForLoopConventionsChecker() { return forLoopConventionsChecker; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorForStatements.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorForStatements.java index 8bbf7aed6ab..4fd2b18910d 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorForStatements.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorForStatements.java @@ -89,7 +89,8 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito public JetTypeInfo visitObjectDeclaration(@NotNull JetObjectDeclaration declaration, ExpressionTypingContext context) { TopDownAnalyzer.processClassOrObject( components.globalContext, - scope, context.replaceScope(scope).replaceContextDependency(INDEPENDENT), scope.getContainingDeclaration(), declaration); + scope, context.replaceScope(scope).replaceContextDependency(INDEPENDENT), scope.getContainingDeclaration(), declaration, + components.additionalCheckerProvider); return DataFlowUtils.checkStatementType(declaration, context, context.dataFlowInfo); } @@ -185,7 +186,8 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito public JetTypeInfo visitClass(@NotNull JetClass klass, ExpressionTypingContext context) { TopDownAnalyzer.processClassOrObject( components.globalContext, - scope, context.replaceScope(scope).replaceContextDependency(INDEPENDENT), scope.getContainingDeclaration(), klass); + scope, context.replaceScope(scope).replaceContextDependency(INDEPENDENT), scope.getContainingDeclaration(), klass, + components.additionalCheckerProvider); return DataFlowUtils.checkStatementType(klass, context, context.dataFlowInfo); } diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/platformStatic/functions.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/platformStatic/functions.kt new file mode 100644 index 00000000000..c569ddb3ac1 --- /dev/null +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/platformStatic/functions.kt @@ -0,0 +1,54 @@ +// !DIAGNOSTICS: -UNUSED_VARIABLE +import kotlin.platform.platformStatic + +class A { + class object { + platformStatic fun a1() { + + } + } + + object A { + platformStatic fun a2() { + + } + } + + fun test() { + val s = object { + platformStatic fun a3() { + + } + } + } + + platformStatic fun a4() { + + } +} + +trait B { + class object { + platformStatic fun a1() { + + } + } + + object A { + platformStatic fun a2() { + + } + } + + fun test() { + val s = object { + platformStatic fun a3() { + + } + } + } + + platformStatic fun a4() { + + } +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/platformStatic/property.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/platformStatic/property.kt new file mode 100644 index 00000000000..e005c30f4b3 --- /dev/null +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/platformStatic/property.kt @@ -0,0 +1,29 @@ +// !DIAGNOSTICS: -UNUSED_VARIABLE +import kotlin.platform.platformStatic + +class A { + class object { + var p1:Int = 1 + [platformStatic] set(p: Int) { + p1 = 1 + } + + [platformStatic] val z = 1; + } + + object A { + var p:Int = 1 + [platformStatic] set(p1: Int) { + p = 1 + } + + [platformStatic] val z = 1; + } + + var p:Int = 1 + [platformStatic] set(p1: Int) { + p = 1 + } + + [platformStatic] val z = 1; +} \ No newline at end of file diff --git a/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestWithStdLibGenerated.java b/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestWithStdLibGenerated.java index 9720932c8b9..44c8cc46456 100644 --- a/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestWithStdLibGenerated.java +++ b/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestWithStdLibGenerated.java @@ -41,7 +41,7 @@ public class JetDiagnosticsTestWithStdLibGenerated extends AbstractJetDiagnostic @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations") @TestDataPath("$PROJECT_ROOT") - @InnerTestClasses({Annotations.AnnotationApplicability.class, Annotations.AnnotationParameterMustBeConstant.class}) + @InnerTestClasses({Annotations.AnnotationApplicability.class, Annotations.AnnotationParameterMustBeConstant.class, Annotations.PlatformStatic.class}) @RunWith(org.jetbrains.jet.JUnit3RunnerWithInners.class) public static class Annotations extends AbstractJetDiagnosticsTestWithStdLib { public void testAllFilesPresentInAnnotations() throws Exception { @@ -110,6 +110,28 @@ public class JetDiagnosticsTestWithStdLibGenerated extends AbstractJetDiagnostic } + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/platformStatic") + @TestDataPath("$PROJECT_ROOT") + @RunWith(org.jetbrains.jet.JUnit3RunnerWithInners.class) + public static class PlatformStatic extends AbstractJetDiagnosticsTestWithStdLib { + public void testAllFilesPresentInPlatformStatic() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/platformStatic"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("functions.kt") + public void testFunctions() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/platformStatic/functions.kt"); + doTest(fileName); + } + + @TestMetadata("property.kt") + public void testProperty() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/platformStatic/property.kt"); + doTest(fileName); + } + + } + } @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/callableReference") diff --git a/compiler/tests/org/jetbrains/jet/di/InjectorForTests.java b/compiler/tests/org/jetbrains/jet/di/InjectorForTests.java index 5ba0e110090..5c0e85128c8 100644 --- a/compiler/tests/org/jetbrains/jet/di/InjectorForTests.java +++ b/compiler/tests/org/jetbrains/jet/di/InjectorForTests.java @@ -25,6 +25,7 @@ import org.jetbrains.jet.lang.types.expressions.ExpressionTypingUtils; import org.jetbrains.jet.lang.resolve.TypeResolver; import org.jetbrains.jet.context.GlobalContext; import org.jetbrains.jet.storage.StorageManager; +import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider; import org.jetbrains.jet.lang.resolve.AnnotationResolver; import org.jetbrains.jet.lang.resolve.calls.CallResolver; import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver; @@ -54,6 +55,7 @@ public class InjectorForTests { private final TypeResolver typeResolver; private final GlobalContext globalContext; private final StorageManager storageManager; + private final AdditionalCheckerProvider additionalCheckerProvider; private final AnnotationResolver annotationResolver; private final CallResolver callResolver; private final ArgumentTypeResolver argumentTypeResolver; @@ -83,6 +85,7 @@ public class InjectorForTests { this.typeResolver = new TypeResolver(); this.globalContext = org.jetbrains.jet.context.ContextPackage.GlobalContext(); this.storageManager = globalContext.getStorageManager(); + this.additionalCheckerProvider = org.jetbrains.jet.lang.resolve.kotlin.JavaDeclarationCheckerProvider.INSTANCE$; this.annotationResolver = new AnnotationResolver(); this.argumentTypeResolver = new ArgumentTypeResolver(); this.candidateResolver = new CandidateResolver(); @@ -131,6 +134,7 @@ public class InjectorForTests { delegatedPropertyResolver.setCallResolver(callResolver); delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices); + expressionTypingComponents.setAdditionalCheckerProvider(additionalCheckerProvider); expressionTypingComponents.setCallResolver(callResolver); expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils); expressionTypingComponents.setExpressionTypingServices(expressionTypingServices); diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java index 470a26873e1..941f0964605 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java @@ -33,6 +33,7 @@ import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingTraceContext; import org.jetbrains.jet.lang.resolve.java.TopDownAnalyzerFacadeForJVM; +import org.jetbrains.jet.lang.resolve.kotlin.JavaDeclarationCheckerProvider; import org.jetbrains.jet.lang.resolve.lazy.declarations.FileBasedDeclarationProviderFactory; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; @@ -70,7 +71,8 @@ public abstract class AbstractLazyResolveDescriptorRendererTest extends KotlinTe final ResolveSession resolveSession = new InjectorForLazyResolve( getProject(), globalContext, lazyModule, new FileBasedDeclarationProviderFactory(globalContext.getStorageManager(), files), - new BindingTraceContext()).getResolveSession(); + new BindingTraceContext(), + JavaDeclarationCheckerProvider.INSTANCE$).getResolveSession(); lazyModule.initialize(resolveSession.getPackageFragmentProvider()); final List descriptors = new ArrayList(); diff --git a/core/descriptors/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java b/core/descriptors/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java index 2751d001338..d9eb99fe583 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java @@ -267,6 +267,11 @@ public class DescriptorUtils { return isKindOf(descriptor, ClassKind.CLASS); } + public static boolean containerKindIs(@NotNull DeclarationDescriptor descriptor, @NotNull ClassKind kind) { + DeclarationDescriptor parentDeclaration = descriptor.getContainingDeclaration(); + return parentDeclaration != null && isKindOf(parentDeclaration, kind); + } + public static boolean isKindOf(@Nullable DeclarationDescriptor descriptor, @NotNull ClassKind classKind) { return descriptor instanceof ClassDescriptor && ((ClassDescriptor) descriptor).getKind() == classKind; } diff --git a/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt b/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt index 5ceb63114c0..f7537eb2489 100644 --- a/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt +++ b/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt @@ -40,6 +40,7 @@ import org.jetbrains.jet.lang.resolve.kotlin.DeserializationGlobalContextForJava 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 // NOTE: After making changes, you need to re-generate the injectors. // To do that, you can run main in this file. @@ -85,11 +86,15 @@ private fun DependencyInjectorGenerator.commonForTopDownAnalyzer() { private fun generatorForTopDownAnalyzerBasic() = generator("compiler/frontend/src", "org.jetbrains.jet.di", "InjectorForTopDownAnalyzerBasic") { commonForTopDownAnalyzer() + parameter(javaClass()) } private fun generatorForTopDownAnalyzerForJs() = generator("js/js.frontend/src", "org.jetbrains.jet.di", "InjectorForTopDownAnalyzerForJs") { commonForTopDownAnalyzer() + + field(javaClass(), + init = GivenExpression(javaClass().getCanonicalName() + ".INSTANCE$")) } private fun generatorForTopDownAnalyzerForJvm() = @@ -100,6 +105,9 @@ private fun generatorForTopDownAnalyzerForJvm() = publicField(javaClass()) publicField(javaClass()) + field(javaClass(), + init = GivenExpression(javaClass().getName() + ".INSTANCE$")) + field(javaClass (), init = GivenExpression(javaClass().getName() + ".allScope(project)")) fields( @@ -179,6 +187,8 @@ private fun generatorForLazyResolveWithJava() = javaClass(), javaClass() ) + field(javaClass(), + init = GivenExpression(javaClass().getName() + ".INSTANCE$")) } private fun generatorForMacro() = @@ -192,6 +202,9 @@ private fun generatorForMacro() = field(javaClass(), useAsContext = true, init = GivenExpression("org.jetbrains.jet.context.ContextPackage.GlobalContext()")) + + field(javaClass(), + init = GivenExpression(javaClass().getCanonicalName() + ".INSTANCE$")) } private fun generatorForTests() = @@ -208,6 +221,9 @@ private fun generatorForTests() = field(javaClass(), init = GivenExpression("org.jetbrains.jet.context.ContextPackage.GlobalContext()"), useAsContext = true) + + field(javaClass(), + init = GivenExpression(javaClass().getName() + ".INSTANCE$")) } private fun generatorForBodyResolve() = @@ -216,6 +232,7 @@ private fun generatorForBodyResolve() = parameter(javaClass(), useAsContext = true) parameter(javaClass()) parameter(javaClass(), useAsContext = true) + parameter(javaClass()) publicField(javaClass()) } @@ -227,6 +244,7 @@ private fun generatorForLazyResolve() = parameter(javaClass(), useAsContext = true) parameter(javaClass()) parameter(javaClass()) + parameter(javaClass()) publicField(javaClass()) } diff --git a/idea/ide-lazy-resolve/src/org/jetbrains/jet/lang/resolve/lazy/ElementResolver.java b/idea/ide-lazy-resolve/src/org/jetbrains/jet/lang/resolve/lazy/ElementResolver.java index 784b23cc1d7..2fba5d11289 100644 --- a/idea/ide-lazy-resolve/src/org/jetbrains/jet/lang/resolve/lazy/ElementResolver.java +++ b/idea/ide-lazy-resolve/src/org/jetbrains/jet/lang/resolve/lazy/ElementResolver.java @@ -49,7 +49,7 @@ import java.util.Map; import static org.jetbrains.jet.lang.resolve.bindingContextUtil.BindingContextUtilPackage.getDataFlowInfo; -public class ElementResolver { +public abstract class ElementResolver { protected final ResolveSession resolveSession; @@ -260,7 +260,7 @@ public class ElementResolver { parameterDescriptor.forceResolveAllContents(); } - private static void delegationSpecifierAdditionalResolve( + private void delegationSpecifierAdditionalResolve( ResolveSession resolveSession, JetDelegationSpecifierList specifier, BindingTrace trace, JetFile file) { @@ -277,7 +277,7 @@ public class ElementResolver { descriptor.getScopeForMemberDeclarationResolution()); } - private static void propertyAdditionalResolve(final ResolveSession resolveSession, final JetProperty jetProperty, BindingTrace trace, JetFile file) { + private void propertyAdditionalResolve(final ResolveSession resolveSession, final JetProperty jetProperty, BindingTrace trace, JetFile file) { JetScope propertyResolutionScope = resolveSession.getScopeProvider().getResolutionScopeForDeclaration(jetProperty); BodyResolveContextForLazy bodyResolveContext = new BodyResolveContextForLazy( @@ -310,7 +310,7 @@ public class ElementResolver { } } - private static void functionAdditionalResolve( + private void functionAdditionalResolve( ResolveSession resolveSession, JetNamedFunction namedFunction, BindingTrace trace, @@ -323,7 +323,7 @@ public class ElementResolver { bodyResolver.resolveFunctionBody(createEmptyContext(resolveSession), trace, namedFunction, functionDescriptor, scope); } - private static void constructorAdditionalResolve( + private void constructorAdditionalResolve( ResolveSession resolveSession, JetClass klass, BindingTrace trace, @@ -340,7 +340,7 @@ public class ElementResolver { constructorDescriptor, scope); } - private static boolean initializerAdditionalResolve( + private boolean initializerAdditionalResolve( ResolveSession resolveSession, JetClassInitializer classInitializer, BindingTrace trace, @@ -355,12 +355,13 @@ public class ElementResolver { return true; } - private static BodyResolver createBodyResolver(ResolveSession resolveSession, BindingTrace trace, JetFile file) { + private BodyResolver createBodyResolver(ResolveSession resolveSession, BindingTrace trace, JetFile file) { InjectorForBodyResolve bodyResolve = new InjectorForBodyResolve( file.getProject(), createParameters(resolveSession), trace, - resolveSession.getModuleDescriptor() + resolveSession.getModuleDescriptor(), + getAdditionalCheckerProvider(file) ); return bodyResolve.getBodyResolver(); } @@ -458,6 +459,9 @@ public class ElementResolver { return null; } + @NotNull + protected abstract AdditionalCheckerProvider getAdditionalCheckerProvider(@NotNull JetFile jetFile); + private static class BodyResolveContextForLazy implements BodiesResolveContext { private final Function declaringScopes; diff --git a/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/JsAnalyzerFacade.kt b/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/JsAnalyzerFacade.kt index f774e27fe87..3cd5b838782 100644 --- a/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/JsAnalyzerFacade.kt +++ b/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/JsAnalyzerFacade.kt @@ -33,6 +33,7 @@ import org.jetbrains.jet.di.InjectorForLazyResolve import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl import org.jetbrains.jet.analyzer.ModuleInfo import org.jetbrains.jet.analyzer.ModuleContent +import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider public class JsResolverForModule( override val lazyResolveSession: ResolveSession @@ -54,7 +55,7 @@ public object JsAnalyzerFacade : AnalyzerFacade