diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java
index 422b1ca2188..9bd87fffe39 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java
@@ -395,6 +395,9 @@ public interface Errors {
 
     DiagnosticFactory0<JetParameter> USELESS_VARARG_ON_PARAMETER = DiagnosticFactory0.create(WARNING);
 
+    DiagnosticFactory1<JetFunction, ClassDescriptor> FUNCTION_RETURN_TYPE_DEPENDS_ON_LOCAL_CLASS = DiagnosticFactory1.create(ERROR, DECLARATION_RETURN_TYPE);
+    DiagnosticFactory1<JetProperty, ClassDescriptor> PROPERTY_TYPE_DEPENDS_ON_LOCAL_CLASS = DiagnosticFactory1.create(ERROR, DECLARATION_RETURN_TYPE);
+
     // Named parameters
 
     DiagnosticFactory0<JetParameter> DEFAULT_VALUE_NOT_ALLOWED_IN_OVERRIDE = DiagnosticFactory0.create(ERROR, PARAMETER_DEFAULT_VALUE);
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java
index 19bd60dc3ff..700be23ac76 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java
@@ -268,6 +268,8 @@ public class DefaultErrorMessages {
         MAP.put(UNUSED_CHANGED_VALUE, "The value changed at ''{0}'' is never used", ELEMENT_TEXT);
         MAP.put(UNUSED_EXPRESSION, "The expression is unused");
         MAP.put(UNUSED_FUNCTION_LITERAL, "The function literal is unused. If you mean block, you can use 'run { ... }'");
+        MAP.put(FUNCTION_RETURN_TYPE_DEPENDS_ON_LOCAL_CLASS, "Function return type depends on local class or object {0}", NAME);
+        MAP.put(PROPERTY_TYPE_DEPENDS_ON_LOCAL_CLASS, "Property type depends on local class or object {0}", NAME);
 
         MAP.put(VAL_REASSIGNMENT, "Val cannot be reassigned", NAME);
         MAP.put(SETTER_PROJECTED_OUT, "Setter for ''{0}'' is removed by type projection", NAME);
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.java
index 92f6e698ccd..3d4c6f46496 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.java
@@ -24,6 +24,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.descriptors.*;
+import org.jetbrains.kotlin.diagnostics.DiagnosticFactory1;
 import org.jetbrains.kotlin.diagnostics.DiagnosticFactory0;
 import org.jetbrains.kotlin.diagnostics.Errors;
 import org.jetbrains.kotlin.lexer.JetModifierKeywordToken;
@@ -653,6 +654,58 @@ public class DeclarationsChecker {
         }
     }
 
+    private void checkLocalTypesInFunctionReturnType(@NotNull JetFunction function, @NotNull FunctionDescriptor functionDescriptor) {
+        if (functionDescriptor instanceof ConstructorDescriptor) return;
+        if (!isExposedAsPublicAPI(functionDescriptor)) return;
+        JetType returnType = functionDescriptor.getReturnType();
+        if (returnType == null) return;
+        checkLocalTypesExposedInType(function, functionDescriptor, returnType,
+                                     FUNCTION_RETURN_TYPE_DEPENDS_ON_LOCAL_CLASS,
+                                     new HashSet<JetType>());
+    }
+
+    private void checkLocalTypesInPropertyType(@NotNull JetProperty property, @NotNull PropertyDescriptor propertyDescriptor) {
+        if (!isExposedAsPublicAPI(propertyDescriptor)) return;
+        JetType propertyType = propertyDescriptor.getType();
+        checkLocalTypesExposedInType(property, propertyDescriptor, propertyType,
+                                     PROPERTY_TYPE_DEPENDS_ON_LOCAL_CLASS,
+                                     new HashSet<JetType>());
+    }
+
+    private static boolean isExposedAsPublicAPI(@NotNull DeclarationDescriptor descriptor) {
+        for (DeclarationDescriptor finger = descriptor; finger != null; finger = finger.getContainingDeclaration()) {
+            if (finger instanceof DeclarationDescriptorWithVisibility) {
+                Visibility visibility = ((DeclarationDescriptorWithVisibility) finger).getVisibility();
+                if (Visibilities.isPrivate(visibility) || visibility == Visibilities.LOCAL) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+    private <D extends JetDeclaration> void checkLocalTypesExposedInType(
+            @NotNull D reportOnDeclaration,
+            @NotNull DeclarationDescriptor parentDeclarationDescriptor,
+            @NotNull JetType type,
+            @NotNull DiagnosticFactory1<D, ClassDescriptor> diagnostic,
+            @NotNull Set<JetType> visitedTypes
+    ) {
+        visitedTypes.add(type);
+        ClassDescriptor classDescriptor = TypeUtils.getClassDescriptor(type);
+        if (classDescriptor != null) {
+            if (DescriptorUtils.isLocal(classDescriptor) && DescriptorUtils.isAncestor(parentDeclarationDescriptor, classDescriptor, true)) {
+                trace.report(diagnostic.on(reportOnDeclaration, classDescriptor));
+            }
+        }
+        for (TypeProjection projection : type.getArguments()) {
+            JetType projectedType = projection.getType();
+            if (!visitedTypes.contains(projectedType)) {
+                checkLocalTypesExposedInType(reportOnDeclaration, parentDeclarationDescriptor, projectedType, diagnostic, visitedTypes);
+            }
+        }
+    }
+
     private void checkPropertyExposedType(@NotNull JetProperty property, @NotNull PropertyDescriptor propertyDescriptor) {
         EffectiveVisibility propertyVisibility = EffectiveVisibility.Companion.forMember(propertyDescriptor);
         EffectiveVisibility typeVisibility = EffectiveVisibility.Companion.forType(propertyDescriptor.getType());
@@ -660,6 +713,7 @@ public class DeclarationsChecker {
             trace.report(EXPOSED_PROPERTY_TYPE.on(property, propertyVisibility, typeVisibility));
         }
         checkMemberReceiverExposedType(property.getReceiverTypeReference(), propertyDescriptor);
+        checkLocalTypesInPropertyType(property, propertyDescriptor);
     }
 
     protected void checkFunction(JetNamedFunction function, SimpleFunctionDescriptor functionDescriptor) {
@@ -729,6 +783,7 @@ public class DeclarationsChecker {
             i++;
         }
         checkMemberReceiverExposedType(function.getReceiverTypeReference(), functionDescriptor);
+        checkLocalTypesInFunctionReturnType(function, functionDescriptor);
     }
 
     private void checkAccessors(@NotNull JetProperty property, @NotNull PropertyDescriptor propertyDescriptor) {
diff --git a/compiler/testData/codegen/box/objects/objectLiteralInClosure.kt b/compiler/testData/codegen/box/objects/objectLiteralInClosure.kt
index 34ea54ddebf..49e19260616 100644
--- a/compiler/testData/codegen/box/objects/objectLiteralInClosure.kt
+++ b/compiler/testData/codegen/box/objects/objectLiteralInClosure.kt
@@ -1,6 +1,6 @@
 package p
 
-class C(val y: Int) {
+private class C(val y: Int) {
     val initChild = { ->
         object {
             override fun toString(): String {
diff --git a/compiler/testData/codegen/boxWithStdlib/regressions/kt3850.kt b/compiler/testData/codegen/boxWithStdlib/regressions/kt3850.kt
index ca5e250355d..03acfce7df7 100644
--- a/compiler/testData/codegen/boxWithStdlib/regressions/kt3850.kt
+++ b/compiler/testData/codegen/boxWithStdlib/regressions/kt3850.kt
@@ -1,6 +1,7 @@
-class One {
+private class One {
     val a1 = arrayOf(
             object { val fy = "text"}
-    )}
+    )
+}
 
 fun box() = if (One().a1[0].fy == "text") "OK" else "fail"
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/declarationChecks/ambiguousObjectExpressionType.kt b/compiler/testData/diagnostics/tests/declarationChecks/ambiguousObjectExpressionType.kt
index aad1486a8e7..e12826cbafe 100644
--- a/compiler/testData/diagnostics/tests/declarationChecks/ambiguousObjectExpressionType.kt
+++ b/compiler/testData/diagnostics/tests/declarationChecks/ambiguousObjectExpressionType.kt
@@ -16,13 +16,13 @@ class Foo {
       privateProperty.f2()
     }
 
-    <!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>protected val protectedProperty<!> = object : MyClass(), MyTrait {}
+    <!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>protected val <!PROPERTY_TYPE_DEPENDS_ON_LOCAL_CLASS!>protectedProperty<!><!> = object : MyClass(), MyTrait {}
 
-    <!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>val internalProperty<!> = object : MyClass(), MyTrait {}
+    <!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>val <!PROPERTY_TYPE_DEPENDS_ON_LOCAL_CLASS!>internalProperty<!><!> = object : MyClass(), MyTrait {}
 
-    <!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>internal val internal2Property<!> = object : MyClass(), MyTrait {}
+    <!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>internal val <!PROPERTY_TYPE_DEPENDS_ON_LOCAL_CLASS!>internal2Property<!><!> = object : MyClass(), MyTrait {}
 
-    <!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>public val publicProperty<!> = object : MyClass(), MyTrait {}
+    <!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>public val <!PROPERTY_TYPE_DEPENDS_ON_LOCAL_CLASS!>publicProperty<!><!> = object : MyClass(), MyTrait {}
 
 
     private fun privateFunction() = object : MyClass(), MyTrait {}
@@ -32,13 +32,13 @@ class Foo {
       privateFunction().f2()
     }
 
-    <!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>protected fun protectedFunction()<!> = object : MyClass(), MyTrait {}
+    <!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>protected fun <!FUNCTION_RETURN_TYPE_DEPENDS_ON_LOCAL_CLASS!>protectedFunction<!>()<!> = object : MyClass(), MyTrait {}
 
-    <!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>fun internalFunction()<!> = object : MyClass(), MyTrait {}
+    <!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>fun <!FUNCTION_RETURN_TYPE_DEPENDS_ON_LOCAL_CLASS!>internalFunction<!>()<!> = object : MyClass(), MyTrait {}
 
-    <!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>internal fun internal2Function()<!> = object : MyClass(), MyTrait {}
+    <!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>internal fun <!FUNCTION_RETURN_TYPE_DEPENDS_ON_LOCAL_CLASS!>internal2Function<!>()<!> = object : MyClass(), MyTrait {}
 
-    <!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>public fun publicFunction()<!> = object : MyClass(), MyTrait {}
+    <!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>public fun <!FUNCTION_RETURN_TYPE_DEPENDS_ON_LOCAL_CLASS!>publicFunction<!>()<!> = object : MyClass(), MyTrait {}
 
 
 
@@ -50,13 +50,13 @@ class Foo {
         privatePropertyInner.f2()
     }
 
-    <!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>protected val protectedProperty<!> = object : MyClass(), MyTrait {}
+    <!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>protected val <!PROPERTY_TYPE_DEPENDS_ON_LOCAL_CLASS!>protectedProperty<!><!> = object : MyClass(), MyTrait {}
 
-    <!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>val internalProperty<!> = object : MyClass(), MyTrait {}
+    <!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>val <!PROPERTY_TYPE_DEPENDS_ON_LOCAL_CLASS!>internalProperty<!><!> = object : MyClass(), MyTrait {}
 
-    <!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>internal val internal2Property<!> = object : MyClass(), MyTrait {}
+    <!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>internal val <!PROPERTY_TYPE_DEPENDS_ON_LOCAL_CLASS!>internal2Property<!><!> = object : MyClass(), MyTrait {}
 
-    <!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>public val publicProperty<!> = object : MyClass(), MyTrait {}
+    <!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>public val <!PROPERTY_TYPE_DEPENDS_ON_LOCAL_CLASS!>publicProperty<!><!> = object : MyClass(), MyTrait {}
 
 
     private fun privateFunctionInner() = object : MyClass(), MyTrait {}
@@ -66,13 +66,13 @@ class Foo {
       privateFunctionInner().f2()
     }
 
-    <!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>protected fun protectedFunction()<!> = object : MyClass(), MyTrait {}
+    <!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>protected fun <!FUNCTION_RETURN_TYPE_DEPENDS_ON_LOCAL_CLASS!>protectedFunction<!>()<!> = object : MyClass(), MyTrait {}
 
-    <!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>fun internalFunction()<!> = object : MyClass(), MyTrait {}
+    <!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>fun <!FUNCTION_RETURN_TYPE_DEPENDS_ON_LOCAL_CLASS!>internalFunction<!>()<!> = object : MyClass(), MyTrait {}
 
-    <!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>internal fun internal2Function()<!> = object : MyClass(), MyTrait {}
+    <!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>internal fun <!FUNCTION_RETURN_TYPE_DEPENDS_ON_LOCAL_CLASS!>internal2Function<!>()<!> = object : MyClass(), MyTrait {}
 
-    <!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>public fun publicFunction()<!> = object : MyClass(), MyTrait {}
+    <!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>public fun <!FUNCTION_RETURN_TYPE_DEPENDS_ON_LOCAL_CLASS!>publicFunction<!>()<!> = object : MyClass(), MyTrait {}
 
   }
 
@@ -90,21 +90,21 @@ class Foo {
 
 <!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>private val packagePrivateProperty<!> = object : MyClass(), MyTrait {}
 
-<!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!><!WRONG_MODIFIER_TARGET!>protected<!> val packageProtectedProperty<!> = object : MyClass(), MyTrait {}
+<!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!><!WRONG_MODIFIER_TARGET!>protected<!> val <!PROPERTY_TYPE_DEPENDS_ON_LOCAL_CLASS!>packageProtectedProperty<!><!> = object : MyClass(), MyTrait {}
 
-<!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>val packageInternalProperty<!> = object : MyClass(), MyTrait {}
+<!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>val <!PROPERTY_TYPE_DEPENDS_ON_LOCAL_CLASS!>packageInternalProperty<!><!> = object : MyClass(), MyTrait {}
 
-<!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>internal val packageInternal2Property<!> = object : MyClass(), MyTrait {}
+<!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>internal val <!PROPERTY_TYPE_DEPENDS_ON_LOCAL_CLASS!>packageInternal2Property<!><!> = object : MyClass(), MyTrait {}
 
-<!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>public val packagePublicProperty<!> = object : MyClass(), MyTrait {}
+<!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>public val <!PROPERTY_TYPE_DEPENDS_ON_LOCAL_CLASS!>packagePublicProperty<!><!> = object : MyClass(), MyTrait {}
 
-<!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!><!WRONG_MODIFIER_TARGET!>protected<!> fun packageProtectedFunction()<!> = object : MyClass(), MyTrait {}
+<!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!><!WRONG_MODIFIER_TARGET!>protected<!> fun <!FUNCTION_RETURN_TYPE_DEPENDS_ON_LOCAL_CLASS!>packageProtectedFunction<!>()<!> = object : MyClass(), MyTrait {}
 
-<!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>fun packageInternalFunction()<!> = object : MyClass(), MyTrait {}
+<!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>fun <!FUNCTION_RETURN_TYPE_DEPENDS_ON_LOCAL_CLASS!>packageInternalFunction<!>()<!> = object : MyClass(), MyTrait {}
 
-<!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>internal fun packageInternal2Function()<!> = object : MyClass(), MyTrait {}
+<!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>internal fun <!FUNCTION_RETURN_TYPE_DEPENDS_ON_LOCAL_CLASS!>packageInternal2Function<!>()<!> = object : MyClass(), MyTrait {}
 
-<!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>public fun packagePublicFunction()<!> = object : MyClass(), MyTrait {}
+<!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>public fun <!FUNCTION_RETURN_TYPE_DEPENDS_ON_LOCAL_CLASS!>packagePublicFunction<!>()<!> = object : MyClass(), MyTrait {}
 
 fun fooPackage() {
     val packageLocalVar = object : MyClass(), MyTrait {}
diff --git a/compiler/testData/diagnostics/tests/exposed/local.kt b/compiler/testData/diagnostics/tests/exposed/local.kt
index 27a29159e09..bd067eda702 100644
--- a/compiler/testData/diagnostics/tests/exposed/local.kt
+++ b/compiler/testData/diagnostics/tests/exposed/local.kt
@@ -2,21 +2,21 @@ fun <T> run(f: () -> T): T {
     return f()
 }
 
-// valid, A here is effectively Any
-fun foo() = run {
+// invalid, depends on local class
+fun <!FUNCTION_RETURN_TYPE_DEPENDS_ON_LOCAL_CLASS!>foo<!>() = run {
     class A
     A()
 }
 
-// valid, B here is also effectively Any
-fun gav() = {
+// invalid, depends on local class
+fun <!FUNCTION_RETURN_TYPE_DEPENDS_ON_LOCAL_CLASS!>gav<!>() = {
     class B
     B()
 }
 
 abstract class My
 
-// valid, object literal here is also effectively Any
+// valid, object literal here is effectively My
 fun bar() = run {
     object: My() {}
-}
+}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/exposed/localInFunReturnType.kt b/compiler/testData/diagnostics/tests/exposed/localInFunReturnType.kt
new file mode 100644
index 00000000000..8729e367f53
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/exposed/localInFunReturnType.kt
@@ -0,0 +1,64 @@
+fun <T> run(f: () -> T): T {
+    return f()
+}
+
+class My<T>(val value: T)
+
+open class Base
+
+fun <!FUNCTION_RETURN_TYPE_DEPENDS_ON_LOCAL_CLASS!>invalid1<!>() = run {
+    class Local
+    My(Local())
+}
+
+fun <!FUNCTION_RETURN_TYPE_DEPENDS_ON_LOCAL_CLASS!>invalid2<!>() = My(object {})
+
+fun <!FUNCTION_RETURN_TYPE_DEPENDS_ON_LOCAL_CLASS!>invalid3<!>() = My(object : Base() {})
+
+fun <!FUNCTION_RETURN_TYPE_DEPENDS_ON_LOCAL_CLASS!>invalid4<!>() = run {
+    class Local
+    My(My(Local()))
+}
+
+fun <!FUNCTION_RETURN_TYPE_DEPENDS_ON_LOCAL_CLASS!>invalid5<!>() = run {
+    fun invalid5a() = run {
+        class Local
+        Local()
+    }
+    My(invalid5a())
+}
+
+// Valid: effectively Any
+fun valid1() = object {}
+
+// Valid: effectively Base
+fun valid2() = object : Base() {}
+
+// Valid: explicit type argument
+fun valid3() = My<Base>(object : Base() {})
+
+// Valid: explicit type specified
+fun valid4() : My<Base> = My(object : Base() {})
+
+// Valid: local class denotable in local scope
+fun valid5() = run {
+    class Local
+    fun valid5a() = My(Local())
+    My<Any>(valid5a())
+}
+
+// Valid: local class denotable in local scope
+fun valid6() = run {
+    class Local
+    fun valid6a() = run {
+        fun valid6b() = My(Local())
+        valid6b()
+    }
+    My<Any>(valid6a())
+}
+
+// Valid: effectively My<Any>
+fun valid7() = run {
+    class Local
+    My<My<*>>(My(Local()))
+}
diff --git a/compiler/testData/diagnostics/tests/exposed/localInFunReturnType.txt b/compiler/testData/diagnostics/tests/exposed/localInFunReturnType.txt
new file mode 100644
index 00000000000..c59df0b8916
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/exposed/localInFunReturnType.txt
@@ -0,0 +1,30 @@
+package
+
+public fun invalid1(): My<invalid1.<anonymous>.Local>
+public fun invalid2(): My<invalid2.<no name provided>>
+public fun invalid3(): My<invalid3.<no name provided>>
+public fun invalid4(): My<My<invalid4.<anonymous>.Local>>
+public fun invalid5(): My<invalid5.<anonymous>.invalid5a.<anonymous>.Local>
+public fun </*0*/ T> run(/*0*/ f: () -> T): T
+public fun valid1(): kotlin.Any
+public fun valid2(): Base
+public fun valid3(): My<Base>
+public fun valid4(): My<Base>
+public fun valid5(): My<kotlin.Any>
+public fun valid6(): My<kotlin.Any>
+public fun valid7(): My<My<*>>
+
+public open class Base {
+    public constructor Base()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class My</*0*/ T> {
+    public constructor My</*0*/ T>(/*0*/ value: T)
+    public final val value: T
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/exposed/localInMemberType.kt b/compiler/testData/diagnostics/tests/exposed/localInMemberType.kt
new file mode 100644
index 00000000000..2d81a039dd1
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/exposed/localInMemberType.kt
@@ -0,0 +1,24 @@
+fun <T> run(f: () -> T): T = f()
+
+
+class Something {
+    public val publicVal1 = object { override fun toString() = "!" }
+    protected val protectedVal1 = object { override fun toString() = "!" }
+    internal val internalVal1 = object { override fun toString() = "!" }
+    private val privateVal1 = object { override fun toString() = "!" }
+
+    public val <!PROPERTY_TYPE_DEPENDS_ON_LOCAL_CLASS!>publicVal2<!> = run { class A; A() }
+    protected val <!PROPERTY_TYPE_DEPENDS_ON_LOCAL_CLASS!>protectedVal2<!> = run { class A; A() }
+    internal val <!PROPERTY_TYPE_DEPENDS_ON_LOCAL_CLASS!>internalVal2<!> = run { class A; A() }
+    private val privateVal2 = run { class A; A() }
+
+    public fun publicFun1() = object { override fun toString() = "!" }
+    protected fun protectedFun1() = object { override fun toString() = "!" }
+    internal fun internalFun1() = object { override fun toString() = "!" }
+    private fun privateFun1() = object { override fun toString() = "!" }
+
+    public fun <!FUNCTION_RETURN_TYPE_DEPENDS_ON_LOCAL_CLASS!>publicFun2<!>() = run { class A; A() }
+    protected fun <!FUNCTION_RETURN_TYPE_DEPENDS_ON_LOCAL_CLASS!>protectedFun2<!>() = run { class A; A() }
+    internal fun <!FUNCTION_RETURN_TYPE_DEPENDS_ON_LOCAL_CLASS!>internalFun2<!>() = run { class A; A() }
+    private fun privateFun2() = run { class A; A() }
+}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/exposed/localInMemberType.txt b/compiler/testData/diagnostics/tests/exposed/localInMemberType.txt
new file mode 100644
index 00000000000..44735439fc8
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/exposed/localInMemberType.txt
@@ -0,0 +1,26 @@
+package
+
+public fun </*0*/ T> run(/*0*/ f: () -> T): T
+
+public final class Something {
+    public constructor Something()
+    internal final val internalVal1: kotlin.Any
+    internal final val internalVal2: Something.internalVal2.<anonymous>.A
+    private final val privateVal1: Something.privateVal1.<no name provided>
+    private final val privateVal2: Something.privateVal2.<anonymous>.A
+    protected final val protectedVal1: kotlin.Any
+    protected final val protectedVal2: Something.protectedVal2.<anonymous>.A
+    public final val publicVal1: kotlin.Any
+    public final val publicVal2: Something.publicVal2.<anonymous>.A
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    internal final fun internalFun1(): kotlin.Any
+    internal final fun internalFun2(): Something.internalFun2.<anonymous>.A
+    private final fun privateFun1(): Something.privateFun1.<no name provided>
+    private final fun privateFun2(): Something.privateFun2.<anonymous>.A
+    protected final fun protectedFun1(): kotlin.Any
+    protected final fun protectedFun2(): Something.protectedFun2.<anonymous>.A
+    public final fun publicFun1(): kotlin.Any
+    public final fun publicFun2(): Something.publicFun2.<anonymous>.A
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/exposed/localInPropertyType.kt b/compiler/testData/diagnostics/tests/exposed/localInPropertyType.kt
new file mode 100644
index 00000000000..695fc8830b4
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/exposed/localInPropertyType.kt
@@ -0,0 +1,64 @@
+fun <T> run(f: () -> T): T {
+    return f()
+}
+
+class My<T>(val value: T)
+
+open class Base
+
+val <!PROPERTY_TYPE_DEPENDS_ON_LOCAL_CLASS!>invalid1<!> = run {
+    class Local
+    My(Local())
+}
+
+val <!PROPERTY_TYPE_DEPENDS_ON_LOCAL_CLASS!>invalid2<!> = My(object {})
+
+val <!PROPERTY_TYPE_DEPENDS_ON_LOCAL_CLASS!>invalid3<!> = My(object : Base() {})
+
+val <!PROPERTY_TYPE_DEPENDS_ON_LOCAL_CLASS!>invalid4<!> = run {
+    class Local
+    My(My(Local()))
+}
+
+val <!PROPERTY_TYPE_DEPENDS_ON_LOCAL_CLASS!>invalid5<!> = run {
+    fun invalid5a() = run {
+        class Local
+        Local()
+    }
+    My(invalid5a())
+}
+
+// Valid: effectively Any
+val valid1 = object {}
+
+// Valid: effectively Base
+val valid2 = object : Base() {}
+
+// Valid: explicit type argument
+val valid3 = My<Base>(object : Base() {})
+
+// Valid: explicit type specified
+val valid4 : My<Base> = My(object : Base() {})
+
+// Valid: local class denotable in local scope
+val valid5 = run {
+    class Local
+    fun valid5a() = My(Local())
+    My<Any>(valid5a())
+}
+
+// Valid: local class denotable in local scope
+val valid6 = run {
+    class Local
+    fun valid6a() = run {
+        fun valid6b() = My(Local())
+        valid6b()
+    }
+    My<Any>(valid6a())
+}
+
+// Valid: effectively My<Any>
+val valid7 = run {
+    class Local
+    My<My<*>>(My(Local()))
+}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/exposed/localInPropertyType.txt b/compiler/testData/diagnostics/tests/exposed/localInPropertyType.txt
new file mode 100644
index 00000000000..698ff01d067
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/exposed/localInPropertyType.txt
@@ -0,0 +1,30 @@
+package
+
+public val invalid1: My<invalid1.<anonymous>.Local>
+public val invalid2: My<invalid2.<no name provided>>
+public val invalid3: My<invalid3.<no name provided>>
+public val invalid4: My<My<invalid4.<anonymous>.Local>>
+public val invalid5: My<invalid5.<anonymous>.invalid5a.<anonymous>.Local>
+public val valid1: kotlin.Any
+public val valid2: Base
+public val valid3: My<Base>
+public val valid4: My<Base>
+public val valid5: My<kotlin.Any>
+public val valid6: My<kotlin.Any>
+public val valid7: My<My<*>>
+public fun </*0*/ T> run(/*0*/ f: () -> T): T
+
+public open class Base {
+    public constructor Base()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class My</*0*/ T> {
+    public constructor My</*0*/ T>(/*0*/ value: T)
+    public final val value: T
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
diff --git a/compiler/testData/diagnostics/tests/subtyping/localClasses.kt b/compiler/testData/diagnostics/tests/subtyping/localClasses.kt
index 4683bd66ceb..ef6b12f4c61 100644
--- a/compiler/testData/diagnostics/tests/subtyping/localClasses.kt
+++ b/compiler/testData/diagnostics/tests/subtyping/localClasses.kt
@@ -6,12 +6,12 @@ fun <T> run(f: () -> T): T {
     return f()
 }
 
-fun foo(a: Int) = run {
+private fun foo(a: Int) = run {
     class A
     A()
 }
 
-fun foo() = run {
+private fun foo() = run {
     class A
     A()
 }
diff --git a/compiler/testData/diagnostics/tests/subtyping/localClasses.txt b/compiler/testData/diagnostics/tests/subtyping/localClasses.txt
index 28ac40e5c3d..6dfc3b90898 100644
--- a/compiler/testData/diagnostics/tests/subtyping/localClasses.txt
+++ b/compiler/testData/diagnostics/tests/subtyping/localClasses.txt
@@ -1,8 +1,8 @@
 package
 
 package p {
-    public fun foo(): p.foo.<anonymous>.A
-    public fun foo(/*0*/ a: kotlin.Int): p.foo.<anonymous>.A
+    private fun foo(): p.foo.<anonymous>.A
+    private fun foo(/*0*/ a: kotlin.Int): p.foo.<anonymous>.A
     public fun </*0*/ T> run(/*0*/ f: () -> T): T
     public fun test(): kotlin.Unit
 }
diff --git a/compiler/testData/diagnostics/tests/subtyping/nestedIntoLocalClasses.kt b/compiler/testData/diagnostics/tests/subtyping/nestedIntoLocalClasses.kt
index 4154728c38f..7de8004b5c6 100644
--- a/compiler/testData/diagnostics/tests/subtyping/nestedIntoLocalClasses.kt
+++ b/compiler/testData/diagnostics/tests/subtyping/nestedIntoLocalClasses.kt
@@ -6,14 +6,14 @@ fun <T> run(f: () -> T): T {
     return f()
 }
 
-fun foo(a: Int) = run {
+private fun foo(a: Int) = run {
     object {
         inner class A
         fun foo() = A()
     }.foo()
 }
 
-fun foo() = run {
+private fun foo() = run {
     object {
         inner class A
         fun foo() = A()
diff --git a/compiler/testData/diagnostics/tests/subtyping/nestedIntoLocalClasses.txt b/compiler/testData/diagnostics/tests/subtyping/nestedIntoLocalClasses.txt
index 8bc514a0054..9f888781e53 100644
--- a/compiler/testData/diagnostics/tests/subtyping/nestedIntoLocalClasses.txt
+++ b/compiler/testData/diagnostics/tests/subtyping/nestedIntoLocalClasses.txt
@@ -1,8 +1,8 @@
 package
 
 package p {
-    public fun foo(): p.foo.<anonymous>.<no name provided>.A
-    public fun foo(/*0*/ a: kotlin.Int): p.foo.<anonymous>.<no name provided>.A
+    private fun foo(): p.foo.<anonymous>.<no name provided>.A
+    private fun foo(/*0*/ a: kotlin.Int): p.foo.<anonymous>.<no name provided>.A
     public fun </*0*/ T> run(/*0*/ f: () -> T): T
     public fun test(): kotlin.Unit
 }
diff --git a/compiler/testData/diagnostics/tests/subtyping/nestedLocalClasses.kt b/compiler/testData/diagnostics/tests/subtyping/nestedLocalClasses.kt
index 35c5df482d8..7a66372714a 100644
--- a/compiler/testData/diagnostics/tests/subtyping/nestedLocalClasses.kt
+++ b/compiler/testData/diagnostics/tests/subtyping/nestedLocalClasses.kt
@@ -6,14 +6,14 @@ fun <T> run(f: () -> T): T {
     return f()
 }
 
-fun foo(a: Int) = run {
+private fun foo(a: Int) = run {
     class A {
         inner class B
     }
     A().B()
 }
 
-fun foo() = run {
+private fun foo() = run {
     class A {
         inner class B
     }
diff --git a/compiler/testData/diagnostics/tests/subtyping/nestedLocalClasses.txt b/compiler/testData/diagnostics/tests/subtyping/nestedLocalClasses.txt
index 5b21759c37a..f0475258b96 100644
--- a/compiler/testData/diagnostics/tests/subtyping/nestedLocalClasses.txt
+++ b/compiler/testData/diagnostics/tests/subtyping/nestedLocalClasses.txt
@@ -1,8 +1,8 @@
 package
 
 package p {
-    public fun foo(): p.foo.<anonymous>.A.B
-    public fun foo(/*0*/ a: kotlin.Int): p.foo.<anonymous>.A.B
+    private fun foo(): p.foo.<anonymous>.A.B
+    private fun foo(/*0*/ a: kotlin.Int): p.foo.<anonymous>.A.B
     public fun </*0*/ T> run(/*0*/ f: () -> T): T
     public fun test(): kotlin.Unit
 }
diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/JetDiagnosticsTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/checkers/JetDiagnosticsTestGenerated.java
index 3e5d6e79b4e..6282c1b1867 100644
--- a/compiler/tests/org/jetbrains/kotlin/checkers/JetDiagnosticsTestGenerated.java
+++ b/compiler/tests/org/jetbrains/kotlin/checkers/JetDiagnosticsTestGenerated.java
@@ -5760,6 +5760,24 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest {
                 doTest(fileName);
             }
 
+            @TestMetadata("localInFunReturnType.kt")
+            public void testLocalInFunReturnType() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/exposed/localInFunReturnType.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("localInMemberType.kt")
+            public void testLocalInMemberType() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/exposed/localInMemberType.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("localInPropertyType.kt")
+            public void testLocalInPropertyType() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/exposed/localInPropertyType.kt");
+                doTest(fileName);
+            }
+
             @TestMetadata("nested.kt")
             public void testNested() throws Exception {
                 String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/exposed/nested.kt");
diff --git a/idea/testData/intentions/convertToBlockBody/valueIsAnonymousObject4.kt b/idea/testData/intentions/convertToBlockBody/valueIsAnonymousObject4.kt
index 23082e4560f..4aabbaf1457 100644
--- a/idea/testData/intentions/convertToBlockBody/valueIsAnonymousObject4.kt
+++ b/idea/testData/intentions/convertToBlockBody/valueIsAnonymousObject4.kt
@@ -2,4 +2,4 @@
 
 interface I
 
-fun f() = <caret>listOf(object : I { })
+private fun f() = <caret>listOf(object : I { })
diff --git a/idea/testData/intentions/replaceExplicitFunctionLiteralParamWithIt/notApplicable_notFunctionLiteralParameter.kt b/idea/testData/intentions/replaceExplicitFunctionLiteralParamWithIt/notApplicable_notFunctionLiteralParameter.kt
index b7fb3a3c8e6..88710a364ab 100644
--- a/idea/testData/intentions/replaceExplicitFunctionLiteralParamWithIt/notApplicable_notFunctionLiteralParameter.kt
+++ b/idea/testData/intentions/replaceExplicitFunctionLiteralParamWithIt/notApplicable_notFunctionLiteralParameter.kt
@@ -1,6 +1,6 @@
 // IS_APPLICABLE: false
 
-val foo = { x: Int ->
+private val foo = { x: Int ->
     class Inner() {
       fun temp(<caret>y: Int) : Int { return x + y }
     }