KT-11111:

- override by a final inline fun is a warning
- override by a fun with reified type parameters is an error

compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java

@@ -786,7 +786,9 @@ public interface Errors {
     DiagnosticFactory2<KtElement, KtExpression, DeclarationDescriptor> USAGE_IS_NOT_INLINABLE = DiagnosticFactory2.create(ERROR);
     DiagnosticFactory2<KtElement, KtElement, DeclarationDescriptor> NULLABLE_INLINE_PARAMETER = DiagnosticFactory2.create(ERROR);
     DiagnosticFactory2<KtElement, KtElement, DeclarationDescriptor> RECURSION_IN_INLINE = DiagnosticFactory2.create(ERROR);
-    DiagnosticFactory0<KtElement> DECLARATION_CANT_BE_INLINED = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtDeclaration> DECLARATION_CANT_BE_INLINED = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
+    DiagnosticFactory0<KtDeclaration> OVERRIDE_BY_INLINE = DiagnosticFactory0.create(WARNING, DECLARATION_SIGNATURE);
+    DiagnosticFactory0<PsiElement> REIFIED_TYPE_PARAMETER_IN_OVERRIDE = DiagnosticFactory0.create(ERROR);
     DiagnosticFactory1<PsiElement, CallableDescriptor> INLINE_CALL_CYCLE = DiagnosticFactory1.create(ERROR, DEFAULT);
     DiagnosticFactory0<PsiElement> NON_LOCAL_RETURN_IN_DISABLED_INLINE = DiagnosticFactory0.create(ERROR);
 

compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java

@@ -729,6 +729,8 @@ public class DefaultErrorMessages {
         MAP.put(PRIVATE_CLASS_MEMBER_FROM_INLINE, "Non-private inline function cannot access members of private classes: ''{0}''", SHORT_NAMES_IN_TYPES, SHORT_NAMES_IN_TYPES);
         MAP.put(NOT_YET_SUPPORTED_IN_INLINE, "''{0}'' construction is not yet supported in inline functions", ELEMENT_TEXT, SHORT_NAMES_IN_TYPES);
         MAP.put(DECLARATION_CANT_BE_INLINED, "'inline' modifier is not allowed on virtual members. Only private or final members can be inlined");
+        MAP.put(OVERRIDE_BY_INLINE, "Override by an inline function");
+        MAP.put(REIFIED_TYPE_PARAMETER_IN_OVERRIDE, "Override by a function with reified type parameter");
         MAP.put(NOTHING_TO_INLINE, "Expected performance impact of inlining ''{0}'' can be insignificant. Inlining works best for functions with lambda parameters", SHORT_NAMES_IN_TYPES);
         MAP.put(USAGE_IS_NOT_INLINABLE, "Illegal usage of inline-parameter ''{0}'' in ''{1}''. Add ''noinline'' modifier to the parameter declaration", ELEMENT_TEXT, SHORT_NAMES_IN_TYPES);
         MAP.put(NULLABLE_INLINE_PARAMETER, "Inline-parameter ''{0}'' of ''{1}'' must not be nullable. Add ''noinline'' modifier to the parameter declaration or make its type not nullable", ELEMENT_TEXT, SHORT_NAMES_IN_TYPES);

compiler/frontend/src/org/jetbrains/kotlin/resolve/inline/InlineAnalyzerExtension.kt

@@ -31,7 +31,7 @@ object InlineAnalyzerExtension : FunctionAnalyzerExtension.AnalyzerExtension {
         assert(InlineUtil.isInline(descriptor)) { "This method should be invoked on inline function: " + descriptor }
 
         checkDefaults(descriptor, function, trace)
-        checkNotVirtual(descriptor, function, trace)
+        checkModalityAndOverrides(descriptor, function, trace)
         checkHasInlinableAndNullability(descriptor, function, trace)
 
         val visitor = object : KtVisitorVoid() {
@@ -73,15 +73,35 @@ object InlineAnalyzerExtension : FunctionAnalyzerExtension.AnalyzerExtension {
         }
     }
 
-    private fun checkNotVirtual(
+    private fun checkModalityAndOverrides(
             functionDescriptor: FunctionDescriptor,
             function: KtFunction,
             trace: BindingTrace) {
-        if (Visibilities.isPrivate(functionDescriptor.visibility) || functionDescriptor.modality === Modality.FINAL) {
+        if (functionDescriptor.containingDeclaration is PackageFragmentDescriptor) {
             return
         }
 
-        if (functionDescriptor.containingDeclaration is PackageFragmentDescriptor) {
+        if (Visibilities.isPrivate(functionDescriptor.visibility)) {
+            return
+        }
+
+        val overridesAnything = functionDescriptor.overriddenDescriptors.isNotEmpty()
+
+        if (overridesAnything) {
+            val ktTypeParameters = function.typeParameters
+            for (typeParameter in functionDescriptor.typeParameters) {
+                if (typeParameter.isReified) {
+                    val ktTypeParameter = ktTypeParameters[typeParameter.index]
+                    val reportOn = ktTypeParameter.modifierList?.getModifier(KtTokens.REIFIED_KEYWORD) ?: ktTypeParameter
+                    trace.report(Errors.REIFIED_TYPE_PARAMETER_IN_OVERRIDE.on(reportOn))
+                }
+            }
+        }
+
+        if (functionDescriptor.modality == Modality.FINAL) {
+            if (overridesAnything) {
+                trace.report(Errors.OVERRIDE_BY_INLINE.on(function))
+            }
             return
         }