Prohibit local objects and enum classes

#KT-5402 Fixed
  #KT-4838 Fixed

Resolve type of object inside local object as special, not supertype('Any').
Changed visibility of constructor of anonymous object to 'internal' to be able to resolve the following:
fun box(): String {
    var foo = object {
        val bar = object {
            val baz = "ok"
        }
    }
    return foo.bar.baz
}
The containing declaration of property initializers is constructor, so 'baz' was invisible inside private constructor.

compiler/testData/diagnostics/tests/FunctionReturnTypes.kt

@@ -193,7 +193,7 @@ fun testFunctionLiterals() {
     val <!UNUSED_VARIABLE!>endsWithObjectDeclaration<!> : () -> Int = {
         var <!ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE!>x<!> = 1
         x = <!UNUSED_VALUE!>333<!>
-        <!EXPECTED_TYPE_MISMATCH!>object A {}<!>
+        <!EXPECTED_TYPE_MISMATCH!><!LOCAL_OBJECT_NOT_ALLOWED!>object A<!> {}<!>
     }
 
     val <!UNUSED_VARIABLE!>expectedUnitReturnType1<!> = { () : Unit ->
@@ -202,7 +202,7 @@ fun testFunctionLiterals() {
 
     val <!UNUSED_VARIABLE!>expectedUnitReturnType2<!> = { () : Unit ->
         fun meow() : Unit {}
-        object A {}
+        <!LOCAL_OBJECT_NOT_ALLOWED!>object A<!> {}
     }
 
-}
+}

compiler/testData/diagnostics/tests/enum/localEnums.kt

@@ -0,0 +1,18 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+
+fun foo() {
+    <!LOCAL_ENUM_NOT_ALLOWED!>enum class A<!> {
+        FOO
+        BAR
+    }
+    val foo = A.FOO
+    val b = object {
+        <!LOCAL_ENUM_NOT_ALLOWED!>enum class B<!> {}
+    }
+    class C {
+        <!LOCAL_ENUM_NOT_ALLOWED!>enum class D<!> {}
+    }
+    val f = {
+        <!LOCAL_ENUM_NOT_ALLOWED!>enum class E<!> {}
+    }
+}

compiler/testData/diagnostics/tests/inline/unsupportedConstruction.kt

@@ -8,9 +8,9 @@ inline fun unsupported() {
         }
     }<!>
 
-    <!NOT_YET_SUPPORTED_IN_INLINE!>object B{
-        object BInner {}
-    }<!>
+    <!LOCAL_OBJECT_NOT_ALLOWED!>object B<!>{
+        <!LOCAL_OBJECT_NOT_ALLOWED!>object BInner<!> {}
+    }
 
     <!NOT_YET_SUPPORTED_IN_INLINE!>fun local() {
         fun localInner() {}

compiler/testData/diagnostics/tests/inner/referenceToSelfInLocal.kt

@@ -11,7 +11,7 @@ fun f() {
         }
     }
 
-    object MyObject {
+    <!LOCAL_OBJECT_NOT_ALLOWED!>object MyObject<!> {
         {
             val <!UNUSED_VARIABLE!>obj<!>: MyObject = MyObject
         }

compiler/testData/diagnostics/tests/objects/ObjectsLocal.kt

@@ -14,7 +14,7 @@ fun test() {
     }
     b.foo()
 
-    object B {
+    <!LOCAL_OBJECT_NOT_ALLOWED!>object B<!> {
         fun foo() {}
     }
     B.foo()

compiler/testData/diagnostics/tests/objects/localObjects.kt

@@ -0,0 +1,15 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+
+fun foo() {
+    <!LOCAL_OBJECT_NOT_ALLOWED!>object a<!> {}
+    val b = object {
+        <!LOCAL_OBJECT_NOT_ALLOWED!>object c<!> {}
+    }
+    b.<!NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>c<!>
+    class A {
+        <!LOCAL_OBJECT_NOT_ALLOWED!>object d<!> {}
+    }
+    val f = {
+        <!LOCAL_OBJECT_NOT_ALLOWED!>object e<!> {}
+    }
+}