diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt index d4b664ccb60..f9fee9dc803 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt @@ -62,6 +62,7 @@ private fun StorageComponentContainer.configureJavaTopDownAnalysis( useInstance(VirtualFileFinderFactory.getInstance(project).create(moduleContentScope)) useImpl() + useImpl() useImpl() useImpl() diff --git a/compiler/frontend/src/org/jetbrains/kotlin/analyzer/common/DefaultAnalyzerFacade.kt b/compiler/frontend/src/org/jetbrains/kotlin/analyzer/common/DefaultAnalyzerFacade.kt index a23a5534c98..5da707aa6d3 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/analyzer/common/DefaultAnalyzerFacade.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/analyzer/common/DefaultAnalyzerFacade.kt @@ -134,6 +134,7 @@ object DefaultAnalyzerFacade : AnalyzerFacade() { useImpl() useImpl() useInstance(languageVersionSettings) + useImpl() useImpl() useInstance(packagePartProvider) useInstance(declarationProviderFactory) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/frontend/di/injection.kt b/compiler/frontend/src/org/jetbrains/kotlin/frontend/di/injection.kt index be497c39da6..4ae7e0e70fd 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/frontend/di/injection.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/frontend/di/injection.kt @@ -88,6 +88,7 @@ fun createContainerForBodyResolve( useInstance(LookupTracker.DO_NOTHING) useInstance(BodyResolveCache.ThrowException) useInstance(languageVersionSettings) + useImpl() useImpl() } @@ -108,6 +109,7 @@ fun createContainerForLazyBodyResolve( useInstance(kotlinCodeAnalyzer.fileScopeProvider) useInstance(bodyResolveCache) useInstance(languageVersionSettings) + useImpl() useImpl() useImpl() } @@ -134,6 +136,7 @@ fun createContainerForLazyLocalClassifierAnalyzer( CompilerEnvironment.configure(this) useInstance(FileScopeProvider.ThrowException) + useImpl() useImpl() useImpl() @@ -158,6 +161,7 @@ fun createContainerForLazyResolve( useInstance(languageVersionSettings) useImpl() + useImpl() useImpl() targetEnvironment.configure(this) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolver.kt new file mode 100644 index 00000000000..43cbb3a8343 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolver.kt @@ -0,0 +1,90 @@ +/* + * Copyright 2010-2017 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.kotlin.resolve + +import org.jetbrains.kotlin.descriptors.FunctionDescriptor +import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor +import org.jetbrains.kotlin.descriptors.annotations.Annotations +import org.jetbrains.kotlin.psi.KtAnnotationEntry +import org.jetbrains.kotlin.psi.KtModifierList +import org.jetbrains.kotlin.resolve.calls.model.ResolvedValueArgument +import org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResults +import org.jetbrains.kotlin.resolve.constants.ConstantValue +import org.jetbrains.kotlin.resolve.scopes.LexicalScope +import org.jetbrains.kotlin.types.KotlinType + +abstract class AnnotationResolver { + fun resolveAnnotationsWithoutArguments( + scope: LexicalScope, + modifierList: KtModifierList?, + trace: BindingTrace + ): Annotations = resolveAnnotationsFromModifierList(scope, modifierList, trace, false) + + fun resolveAnnotationsWithArguments( + scope: LexicalScope, + modifierList: KtModifierList?, + trace: BindingTrace + ): Annotations = resolveAnnotationsFromModifierList(scope, modifierList, trace, true) + + + private fun resolveAnnotationsFromModifierList( + scope: LexicalScope, + modifierList: KtModifierList?, + trace: BindingTrace, + shouldResolveArguments: Boolean + ): Annotations { + if (modifierList == null) { + return Annotations.EMPTY + } + + return resolveAnnotationEntries(scope, modifierList.annotationEntries, trace, shouldResolveArguments) + } + + fun resolveAnnotationsWithoutArguments( + scope: LexicalScope, + annotationEntries: @JvmSuppressWildcards List, + trace: BindingTrace + ): Annotations = resolveAnnotationEntries(scope, annotationEntries, trace, false) + + fun resolveAnnotationsWithArguments( + scope: LexicalScope, + annotationEntries: @JvmSuppressWildcards List, + trace: BindingTrace + ): Annotations = resolveAnnotationEntries(scope, annotationEntries, trace, true) + + protected abstract fun resolveAnnotationEntries( + scope: LexicalScope, + annotationEntries: @JvmSuppressWildcards List, + trace: BindingTrace, + shouldResolveArguments: Boolean + ): Annotations + + + abstract fun resolveAnnotationType(scope: LexicalScope, entryElement: KtAnnotationEntry, trace: BindingTrace): KotlinType + + abstract fun resolveAnnotationCall( + annotationEntry: KtAnnotationEntry, + scope: LexicalScope, + trace: BindingTrace + ): OverloadResolutionResults + + abstract fun getAnnotationArgumentValue( + trace: BindingTrace, + valueParameter: ValueParameterDescriptor, + resolvedArgument: ResolvedValueArgument + ): ConstantValue<*>? +} diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolverImpl.java similarity index 79% rename from compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolver.java rename to compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolverImpl.java index 3c6dc4998ce..ccaa65b0bcd 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolverImpl.java @@ -44,13 +44,13 @@ import java.util.List; import static org.jetbrains.kotlin.diagnostics.Errors.NOT_AN_ANNOTATION_CLASS; import static org.jetbrains.kotlin.types.TypeUtils.NO_EXPECTED_TYPE; -public class AnnotationResolver { +public class AnnotationResolverImpl extends AnnotationResolver { @NotNull private final CallResolver callResolver; @NotNull private final StorageManager storageManager; @NotNull private TypeResolver typeResolver; @NotNull private final ConstantExpressionEvaluator constantExpressionEvaluator; - public AnnotationResolver( + public AnnotationResolverImpl( @NotNull CallResolver callResolver, @NotNull ConstantExpressionEvaluator constantExpressionEvaluator, @NotNull StorageManager storageManager @@ -67,56 +67,10 @@ public class AnnotationResolver { this.typeResolver = typeResolver; } - @NotNull - public Annotations resolveAnnotationsWithoutArguments( - @NotNull LexicalScope scope, - @Nullable KtModifierList modifierList, - @NotNull BindingTrace trace - ) { - return resolveAnnotations(scope, modifierList, trace, false); - } @NotNull - public Annotations resolveAnnotationsWithArguments( - @NotNull LexicalScope scope, - @Nullable KtModifierList modifierList, - @NotNull BindingTrace trace - ) { - return resolveAnnotations(scope, modifierList, trace, true); - } - - @NotNull - public Annotations resolveAnnotationsWithoutArguments( - @NotNull LexicalScope scope, - @NotNull List annotationEntries, - @NotNull BindingTrace trace - ) { - return resolveAnnotationEntries(scope, annotationEntries, trace, false); - } - - @NotNull - public Annotations resolveAnnotationsWithArguments( - @NotNull LexicalScope scope, - @NotNull List annotationEntries, - @NotNull BindingTrace trace - ) { - return resolveAnnotationEntries(scope, annotationEntries, trace, true); - } - - private Annotations resolveAnnotations( - @NotNull LexicalScope scope, - @Nullable KtModifierList modifierList, - @NotNull BindingTrace trace, - boolean shouldResolveArguments - ) { - if (modifierList == null) { - return Annotations.Companion.getEMPTY(); - } - - return resolveAnnotationEntries(scope, modifierList.getAnnotationEntries(), trace, shouldResolveArguments); - } - - private Annotations resolveAnnotationEntries( + @Override + public Annotations resolveAnnotationEntries( @NotNull LexicalScope scope, @NotNull List annotationEntryElements, @NotNull BindingTrace trace, @@ -145,8 +99,13 @@ public class AnnotationResolver { return AnnotationsImpl.create(result); } + @Override @NotNull - public KotlinType resolveAnnotationType(@NotNull LexicalScope scope, @NotNull KtAnnotationEntry entryElement, @NotNull BindingTrace trace) { + public KotlinType resolveAnnotationType( + @NotNull LexicalScope scope, + @NotNull KtAnnotationEntry entryElement, + @NotNull BindingTrace trace + ) { KtTypeReference typeReference = entryElement.getTypeReference(); if (typeReference == null) { return ErrorUtils.createErrorType("No type reference: " + entryElement.getText()); @@ -180,11 +139,12 @@ public class AnnotationResolver { } } + @Override @NotNull public OverloadResolutionResults resolveAnnotationCall( - KtAnnotationEntry annotationEntry, - LexicalScope scope, - BindingTrace trace + @NotNull KtAnnotationEntry annotationEntry, + @NotNull LexicalScope scope, + @NotNull BindingTrace trace ) { return callResolver.resolveFunctionCall( trace, scope, @@ -204,6 +164,7 @@ public class AnnotationResolver { } } + @Override @Nullable public ConstantValue getAnnotationArgumentValue( @NotNull BindingTrace trace, diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.kt index ca1c4d1c1f4..c242dae866f 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.kt @@ -448,7 +448,7 @@ class DeclarationsChecker( private fun checkTypeParameters(typeParameterListOwner: KtTypeParameterListOwner) { // TODO: Support annotation for type parameters for (jetTypeParameter in typeParameterListOwner.typeParameters) { - AnnotationResolver.reportUnsupportedAnnotationForTypeParameter(jetTypeParameter, trace) + AnnotationResolverImpl.reportUnsupportedAnnotationForTypeParameter(jetTypeParameter, trace) trace.get(TYPE_PARAMETER, jetTypeParameter)?.let { DescriptorResolver.checkConflictingUpperBounds(trace, it, jetTypeParameter) } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt index f37b664aa1e..316e25e0633 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt @@ -17,7 +17,10 @@ package org.jetbrains.kotlin.resolve import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.builtins.* +import org.jetbrains.kotlin.builtins.KotlinBuiltIns +import org.jetbrains.kotlin.builtins.getReceiverTypeFromFunctionType +import org.jetbrains.kotlin.builtins.getValueParameterTypesFromFunctionType +import org.jetbrains.kotlin.builtins.isBuiltinFunctionalType import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.descriptors.annotations.Annotations import org.jetbrains.kotlin.descriptors.annotations.AnnotationsImpl @@ -44,12 +47,10 @@ import org.jetbrains.kotlin.resolve.scopes.LexicalScopeKind import org.jetbrains.kotlin.resolve.scopes.LexicalWritableScope import org.jetbrains.kotlin.resolve.scopes.TraceBasedLocalRedeclarationChecker import org.jetbrains.kotlin.resolve.source.toSourceElement -import org.jetbrains.kotlin.storage.StorageManager import org.jetbrains.kotlin.types.ErrorUtils import org.jetbrains.kotlin.types.KotlinType import org.jetbrains.kotlin.types.TypeUtils import org.jetbrains.kotlin.types.checker.KotlinTypeChecker -import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils.isFunctionExpression import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils.isFunctionLiteral import org.jetbrains.kotlin.types.typeUtil.replaceAnnotations @@ -59,8 +60,6 @@ class FunctionDescriptorResolver( private val typeResolver: TypeResolver, private val descriptorResolver: DescriptorResolver, private val annotationResolver: AnnotationResolver, - private val storageManager: StorageManager, - private val expressionTypingServices: ExpressionTypingServices, private val builtIns: KotlinBuiltIns, private val modifiersChecker: ModifiersChecker, private val overloadChecker: OverloadChecker diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/LocalVariableResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/LocalVariableResolver.kt index 0e15470022d..20b22131f6f 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/LocalVariableResolver.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/LocalVariableResolver.kt @@ -30,7 +30,6 @@ import org.jetbrains.kotlin.psi.KtPsiUtil import org.jetbrains.kotlin.psi.KtVariableDeclaration import org.jetbrains.kotlin.resolve.calls.context.ContextDependency import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo -import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValue import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValueFactory import org.jetbrains.kotlin.resolve.calls.util.isSingleUnderscore import org.jetbrains.kotlin.resolve.lazy.ForceResolveUtil diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSession.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSession.java index 40e318ff3b4..5c39f370497 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSession.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSession.java @@ -71,7 +71,7 @@ public class ResolveSession implements KotlinCodeAnalyzer, LazyClassContext { private final MemoizedFunctionToNotNull danglingAnnotations; private KtImportsFactory jetImportFactory; - private AnnotationResolver annotationResolve; + private AnnotationResolver annotationResolver; private DescriptorResolver descriptorResolver; private FunctionDescriptorResolver functionDescriptorResolver; private TypeResolver typeResolver; @@ -93,8 +93,8 @@ public class ResolveSession implements KotlinCodeAnalyzer, LazyClassContext { } @Inject - public void setAnnotationResolve(AnnotationResolver annotationResolve) { - this.annotationResolve = annotationResolve; + public void setAnnotationResolve(AnnotationResolver annotationResolver) { + this.annotationResolver = annotationResolver; } @Inject @@ -216,7 +216,7 @@ public class ResolveSession implements KotlinCodeAnalyzer, LazyClassContext { private LazyAnnotations createAnnotations(KtFile file, List annotationEntries) { LexicalScope scope = fileScopeProvider.getFileResolutionScope(file); LazyAnnotationsContextImpl lazyAnnotationContext = - new LazyAnnotationsContextImpl(annotationResolve, storageManager, trace, scope); + new LazyAnnotationsContextImpl(annotationResolver, storageManager, trace, scope); return new LazyAnnotations(lazyAnnotationContext, annotationEntries); } @@ -398,7 +398,7 @@ public class ResolveSession implements KotlinCodeAnalyzer, LazyClassContext { @Override @NotNull public AnnotationResolver getAnnotationResolver() { - return annotationResolve; + return annotationResolver; } @Override diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyAnnotations.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyAnnotations.kt index fb797c6ecc4..6e855ee2bc1 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyAnnotations.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyAnnotations.kt @@ -23,10 +23,7 @@ import org.jetbrains.kotlin.descriptors.annotations.Annotations import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.psi.KtAnnotationEntry -import org.jetbrains.kotlin.resolve.AnnotationResolver -import org.jetbrains.kotlin.resolve.BindingContext -import org.jetbrains.kotlin.resolve.BindingTrace -import org.jetbrains.kotlin.resolve.DescriptorUtils +import org.jetbrains.kotlin.resolve.* import org.jetbrains.kotlin.resolve.constants.ConstantValue import org.jetbrains.kotlin.resolve.lazy.ForceResolveUtil import org.jetbrains.kotlin.resolve.lazy.LazyEntity @@ -144,7 +141,7 @@ class LazyAnnotationDescriptor( private fun computeValueArguments(): Map> { val resolutionResults = c.annotationResolver.resolveAnnotationCall(annotationEntry, scope, c.trace) - AnnotationResolver.checkAnnotationType(annotationEntry, c.trace, resolutionResults) + AnnotationResolverImpl.checkAnnotationType(annotationEntry, c.trace, resolutionResults) if (!resolutionResults.isSingleResult) return mapOf() diff --git a/compiler/tests-common/org/jetbrains/kotlin/tests/di/injection.kt b/compiler/tests-common/org/jetbrains/kotlin/tests/di/injection.kt index 554cefa4bea..6901228b3ea 100644 --- a/compiler/tests-common/org/jetbrains/kotlin/tests/di/injection.kt +++ b/compiler/tests-common/org/jetbrains/kotlin/tests/di/injection.kt @@ -27,10 +27,7 @@ import org.jetbrains.kotlin.context.ModuleContext import org.jetbrains.kotlin.descriptors.ModuleDescriptor import org.jetbrains.kotlin.frontend.di.configureModule import org.jetbrains.kotlin.incremental.components.LookupTracker -import org.jetbrains.kotlin.resolve.DescriptorResolver -import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver -import org.jetbrains.kotlin.resolve.TypeResolver -import org.jetbrains.kotlin.resolve.createContainer +import org.jetbrains.kotlin.resolve.* import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices import org.jetbrains.kotlin.types.expressions.FakeCallResolver @@ -40,6 +37,7 @@ fun createContainerForTests(project: Project, module: ModuleDescriptor): Contain configureModule(ModuleContext(module, project), JvmPlatform, JvmTarget.JVM_1_6) useInstance(LookupTracker.DO_NOTHING) useInstance(LanguageVersionSettingsImpl.DEFAULT) + useImpl() useImpl() }) } diff --git a/js/js.frontend/src/org/jetbrains/kotlin/frontend/js/di/injection.kt b/js/js.frontend/src/org/jetbrains/kotlin/frontend/js/di/injection.kt index 55c2f85e2ef..80b71b797e3 100644 --- a/js/js.frontend/src/org/jetbrains/kotlin/frontend/js/di/injection.kt +++ b/js/js.frontend/src/org/jetbrains/kotlin/frontend/js/di/injection.kt @@ -26,10 +26,7 @@ import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl import org.jetbrains.kotlin.frontend.di.configureModule import org.jetbrains.kotlin.incremental.components.LookupTracker import org.jetbrains.kotlin.js.resolve.JsPlatform -import org.jetbrains.kotlin.resolve.BindingTrace -import org.jetbrains.kotlin.resolve.CompilerEnvironment -import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzer -import org.jetbrains.kotlin.resolve.createContainer +import org.jetbrains.kotlin.resolve.* import org.jetbrains.kotlin.resolve.lazy.FileScopeProviderImpl import org.jetbrains.kotlin.resolve.lazy.KotlinCodeAnalyzer import org.jetbrains.kotlin.resolve.lazy.ResolveSession @@ -46,6 +43,7 @@ fun createTopDownAnalyzerForJs( useInstance(declarationProviderFactory) useImpl() + useImpl() CompilerEnvironment.configure(this)