remove requirements for explicit return type for public members

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

@@ -245,8 +245,6 @@ public interface Errors {
 
     // Members
 
-    DiagnosticFactory0<JetNamedDeclaration> PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
-
     DiagnosticFactory2<JetDeclaration, CallableMemberDescriptor, String> CONFLICTING_OVERLOADS =
             DiagnosticFactory2.create(ERROR, DECLARATION_SIGNATURE_OR_DEFAULT);
 

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

@@ -217,8 +217,6 @@ public class DefaultErrorMessages {
         MAP.put(FUNCTION_EXPRESSION_WITH_NAME, "Function expressions with names are deprecated");
         MAP.put(NON_FINAL_MEMBER_IN_FINAL_CLASS, "\"open\" has no effect in a final class");
 
-        MAP.put(PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE, "Public or protected member should have specified type");
-
         MAP.put(FUNCTION_EXPRESSION_PARAMETER_WITH_DEFAULT_VALUE, "A function expression is not allowed to specify default values for its parameters");
         MAP.put(USELESS_VARARG_ON_PARAMETER, "Vararg on this parameter is useless");
         MAP.put(DEPRECATED_LAMBDA_SYNTAX,

compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.java

@@ -327,22 +327,6 @@ public class DeclarationsChecker {
         }
         checkPropertyInitializer(property, propertyDescriptor);
         checkAccessors(property, propertyDescriptor);
-        checkDeclaredTypeInPublicMember(property, propertyDescriptor);
-    }
-
-    private void checkDeclaredTypeInPublicMember(JetNamedDeclaration member, CallableMemberDescriptor memberDescriptor) {
-        boolean hasDeferredType;
-        if (member instanceof JetProperty) {
-            hasDeferredType = ((JetProperty) member).getTypeReference() == null && DescriptorResolver.hasBody((JetProperty) member);
-        }
-        else {
-            assert member instanceof JetFunction;
-            JetFunction function = (JetFunction) member;
-            hasDeferredType = function.getTypeReference() == null && function.hasBody() && !function.hasBlockBody();
-        }
-        if ((memberDescriptor.getVisibility().getIsPublicAPI()) && memberDescriptor.getOverriddenDescriptors().size() == 0 && hasDeferredType) {
-            trace.report(PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE.on(member));
-        }
     }
 
     private void checkPropertyAbstractness(
@@ -449,7 +433,6 @@ public class DeclarationsChecker {
     protected void checkFunction(JetNamedFunction function, SimpleFunctionDescriptor functionDescriptor) {
         DeclarationDescriptor containingDescriptor = functionDescriptor.getContainingDeclaration();
         boolean hasAbstractModifier = function.hasModifier(JetTokens.ABSTRACT_KEYWORD);
-        checkDeclaredTypeInPublicMember(function, functionDescriptor);
         if (containingDescriptor instanceof ClassDescriptor) {
             ClassDescriptor classDescriptor = (ClassDescriptor) containingDescriptor;
             boolean inTrait = classDescriptor.getKind() == ClassKind.INTERFACE;

compiler/testData/diagnostics/tests/FunctionReturnTypes.kt

@@ -164,9 +164,9 @@ fun f(): Int {
 
 fun f1(): Int = if (1 < 2) 1 else returnNothing()
 
-<!PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE!>public fun f2()<!> = 1
+public fun f2() = 1
 class B() {
-   <!PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE!>protected fun f()<!> = "ss"
+   protected fun f() = "ss"
 }
 
 fun testFunctionLiterals() {

compiler/testData/diagnostics/tests/Properties.kt

@@ -26,5 +26,5 @@ class Test() {
     <!NO_BACKING_FIELD_CUSTOM_ACCESSORS!>$b<!> = $a
     a = <!NO_BACKING_FIELD_CUSTOM_ACCESSORS!>$b<!>
    }
-   <!PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE!>public val i<!> = 1
+   public val i = 1
 }

compiler/testData/diagnostics/tests/declarationChecks/ambiguousObjectExpressionType.kt

@@ -16,13 +16,13 @@ class Foo {
       privateProperty.f2()
     }
 
-    <!PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE!>protected val protectedProperty<!> = object : MyClass(), MyTrait {}
+    protected val protectedProperty = object : MyClass(), MyTrait {}
 
     <!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>val internalProperty<!> = object : MyClass(), MyTrait {}
 
     <!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>internal val internal2Property<!> = object : MyClass(), MyTrait {}
 
-    <!PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE!>public val publicProperty<!> = object : MyClass(), MyTrait {}
+    public val publicProperty = object : MyClass(), MyTrait {}
 
 
     private fun privateFunction() = object : MyClass(), MyTrait {}
@@ -32,13 +32,13 @@ class Foo {
       privateFunction().f2()
     }
 
-    <!PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE!>protected fun protectedFunction()<!> = object : MyClass(), MyTrait {}
+    protected fun protectedFunction() = object : MyClass(), MyTrait {}
 
     <!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>fun internalFunction()<!> = object : MyClass(), MyTrait {}
 
     <!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>internal fun internal2Function()<!> = object : MyClass(), MyTrait {}
 
-    <!PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE!>public fun publicFunction()<!> = object : MyClass(), MyTrait {}
+    public fun publicFunction() = object : MyClass(), MyTrait {}
 
 
 
@@ -50,13 +50,13 @@ class Foo {
         privatePropertyInner.f2()
     }
 
-    <!PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE!>protected val protectedProperty<!> = object : MyClass(), MyTrait {}
+    protected val protectedProperty = object : MyClass(), MyTrait {}
 
     <!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>val internalProperty<!> = object : MyClass(), MyTrait {}
 
     <!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>internal val internal2Property<!> = object : MyClass(), MyTrait {}
 
-    <!PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE!>public val publicProperty<!> = object : MyClass(), MyTrait {}
+    public val publicProperty = object : MyClass(), MyTrait {}
 
 
     private fun privateFunctionInner() = object : MyClass(), MyTrait {}
@@ -66,13 +66,13 @@ class Foo {
       privateFunctionInner().f2()
     }
 
-    <!PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE!>protected fun protectedFunction()<!> = object : MyClass(), MyTrait {}
+    protected fun protectedFunction() = object : MyClass(), MyTrait {}
 
     <!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>fun internalFunction()<!> = object : MyClass(), MyTrait {}
 
     <!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>internal fun internal2Function()<!> = object : MyClass(), MyTrait {}
 
-    <!PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE!>public fun publicFunction()<!> = object : MyClass(), MyTrait {}
+    public fun publicFunction() = object : MyClass(), MyTrait {}
 
   }
 
@@ -90,21 +90,21 @@ class Foo {
 
 <!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>private val packagePrivateProperty<!> = object : MyClass(), MyTrait {}
 
-<!PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE!><!WRONG_MODIFIER_TARGET!>protected<!> val packageProtectedProperty<!> = object : MyClass(), MyTrait {}
+<!WRONG_MODIFIER_TARGET!>protected<!> val packageProtectedProperty = object : MyClass(), MyTrait {}
 
 <!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>val packageInternalProperty<!> = object : MyClass(), MyTrait {}
 
 <!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>internal val packageInternal2Property<!> = object : MyClass(), MyTrait {}
 
-<!PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE!>public val packagePublicProperty<!> = object : MyClass(), MyTrait {}
+public val packagePublicProperty = object : MyClass(), MyTrait {}
 
-<!PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE!><!WRONG_MODIFIER_TARGET!>protected<!> fun packageProtectedFunction()<!> = object : MyClass(), MyTrait {}
+<!WRONG_MODIFIER_TARGET!>protected<!> fun packageProtectedFunction() = object : MyClass(), MyTrait {}
 
 <!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>fun packageInternalFunction()<!> = object : MyClass(), MyTrait {}
 
 <!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>internal fun packageInternal2Function()<!> = object : MyClass(), MyTrait {}
 
-<!PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE!>public fun packagePublicFunction()<!> = object : MyClass(), MyTrait {}
+public fun packagePublicFunction() = object : MyClass(), MyTrait {}
 
 fun fooPackage() {
     val packageLocalVar = object : MyClass(), MyTrait {}

compiler/testData/diagnostics/tests/declarationChecks/unambiguousObjectExpressionType.kt

@@ -5,9 +5,9 @@ open class MyClass {
 
 class Foo {
 
-    <!PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE!>protected val protectedProperty<!> = object : MyClass() {}
+    protected val protectedProperty = object : MyClass() {}
 
-    <!PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE!>public val publicProperty<!> = object : MyClass() {}
+    public val publicProperty = object : MyClass() {}
 
     protected val protected2Property : MyClass = object : MyClass() {fun invisible() {}}
 
@@ -35,9 +35,9 @@ class Foo {
     }
 
 
-    <!PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE!>protected fun protectedFunction()<!> = object : MyClass() {}
+    protected fun protectedFunction() = object : MyClass() {}
 
-    <!PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE!>public fun publicFunction()<!> = object : MyClass() {}
+    public fun publicFunction() = object : MyClass() {}
 
     protected fun protected2Function(): MyClass = object : MyClass() {fun visible() {}}
 
@@ -67,9 +67,9 @@ class Foo {
 
     class FooInner {
 
-        <!PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE!>public val publicProperty<!> = object : MyClass() {}
+        public val publicProperty = object : MyClass() {}
 
-        <!PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE!>protected val protectedProperty<!> = object : MyClass() {}
+        protected val protectedProperty = object : MyClass() {}
 
         protected val protected2Property : MyClass = object : MyClass() {fun invisible() {}}
 
@@ -97,9 +97,9 @@ class Foo {
         }
 
 
-         <!PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE!>protected fun protectedFunction()<!> = object : MyClass() {}
+         protected fun protectedFunction() = object : MyClass() {}
 
-         <!PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE!>public fun publicFunction()<!> = object : MyClass() {}
+         public fun publicFunction() = object : MyClass() {}
 
          protected fun protected2Function(): MyClass = object : MyClass() {fun visible() {}}
 
@@ -136,9 +136,9 @@ class Foo {
 
 }
 
-<!PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE!><!WRONG_MODIFIER_TARGET!>protected<!> val packageProtectedProperty<!> = object : MyClass() {}
+<!WRONG_MODIFIER_TARGET!>protected<!> val packageProtectedProperty = object : MyClass() {}
 
-<!PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE!>public val packagePublicProperty<!> = object : MyClass() {}
+public val packagePublicProperty = object : MyClass() {}
 
 public val packagePublic2Property : MyClass = object : MyClass() {fun invisible() {}}
 
@@ -164,9 +164,9 @@ fun testProperties() {
 
 private fun privateFunction() = object : MyClass() {fun invisible() {}}
 
-<!PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE!><!WRONG_MODIFIER_TARGET!>protected<!> fun protectedFunction()<!> = object : MyClass() {}
+<!WRONG_MODIFIER_TARGET!>protected<!> fun protectedFunction() = object : MyClass() {}
 
-<!PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE!>public fun publicFunction()<!> = object : MyClass() {}
+public fun publicFunction() = object : MyClass() {}
 
 public fun public2Function() : MyClass = object : MyClass() {fun invisible() {}}
 
@@ -197,4 +197,3 @@ fun fooPackage() {
     fooPackageLocal().f1()
     fooPackageLocal().visible()
 }
-

compiler/testData/diagnostics/tests/delegatedProperty/publicDelegatedProperty.kt

@@ -1,9 +0,0 @@
-// !DIAGNOSTICS: -UNUSED_PARAMETER
-
-<!PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE!>public val a<!> by Delegate()
-
-class Delegate {
-  fun get(t: Any?, p: PropertyMetadata): Int {
-    return 1
-  }
-}

compiler/testData/diagnostics/tests/delegatedProperty/publicDelegatedProperty.txt

@@ -1,11 +0,0 @@
-package
-
-public val a: kotlin.Int
-
-internal final class Delegate {
-    public constructor Delegate()
-    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-    internal final fun get(/*0*/ t: kotlin.Any?, /*1*/ p: kotlin.PropertyMetadata): kotlin.Int
-    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
-    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
-}

compiler/tests/org/jetbrains/kotlin/checkers/JetDiagnosticsTestGenerated.java

@@ -4245,12 +4245,6 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest {
                 doTest(fileName);
             }
 
-            @TestMetadata("publicDelegatedProperty.kt")
-            public void testPublicDelegatedProperty() throws Exception {
-                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/publicDelegatedProperty.kt");
-                doTest(fileName);
-            }
-
             @TestMetadata("recursiveType.kt")
             public void testRecursiveType() throws Exception {
                 String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/recursiveType.kt");

idea/src/org/jetbrains/kotlin/idea/intentions/SpecifyTypeExplicitlyIntention.kt

@@ -42,7 +42,7 @@ public class SpecifyTypeExplicitlyIntention : JetSelfTargetingIntention<JetCalla
         if (element is JetConstructor<*>) return false
         if (element.getTypeReference() != null) return false
 
-        if (getTypeForDeclaration(element).isError() || hasPublicMemberDiagnostic(element)) return false
+        if (getTypeForDeclaration(element).isError()) return false
 
         val initializer = (element as? JetWithExpressionInitializer)?.getInitializer()
         if (initializer != null && initializer.getTextRange().containsOffset(caretOffset)) return false
@@ -54,11 +54,6 @@ public class SpecifyTypeExplicitlyIntention : JetSelfTargetingIntention<JetCalla
         return true
     }
 
-    private fun hasPublicMemberDiagnostic(declaration: JetNamedDeclaration): Boolean {
-        return declaration.analyze().getDiagnostics().forElement(declaration)
-                .any { it.getFactory() == Errors.PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE }
-    }
-
     override fun applyTo(element: JetCallableDeclaration, editor: Editor) {
         val type = getTypeForDeclaration(element)
         addTypeAnnotation(editor, element, type)

idea/src/org/jetbrains/kotlin/idea/quickfix/QuickFixRegistrar.kt

@@ -172,7 +172,6 @@ public class QuickFixRegistrar : QuickFixContributor {
         UNNECESSARY_NOT_NULL_ASSERTION.registerFactory(RemoveExclExclCallFix)
         UNSAFE_INFIX_CALL.registerFactory(ReplaceInfixCallFix)
 
-        PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE.registerActions(SpecifyTypeExplicitlyFix())
         AMBIGUOUS_ANONYMOUS_TYPE_INFERRED.registerActions(SpecifyTypeExplicitlyFix())
 
         ELSE_MISPLACED_IN_WHEN.registerFactory(MoveWhenElseBranchFix.createFactory())

idea/testData/quickfix/typeAddition/noAddErrorType.kt

@@ -1,6 +1,5 @@
 // "Specify type explicitly" "false"
 // ACTION: Convert property to function
-// ERROR: Public or protected member should have specified type
 // ERROR: Unresolved reference: foo
 
 class A() {

idea/testData/quickfix/typeImports/importFromAnotherFile.after.kt

@@ -1,5 +1,4 @@
 // "Specify type explicitly" "true"
-// ERROR: Public or protected member should have specified type
 
 package a
 

idea/testData/quickfix/typeImports/importFromAnotherFile.before.Main.kt

@@ -1,5 +1,4 @@
 // "Specify type explicitly" "true"
-// ERROR: Public or protected member should have specified type
 
 package a