Update docs

Author: odersky

docs/docs/reference/enums/adts.md

@@ -52,11 +52,15 @@ Note that the type of the expressions above is always `Option`. That
 is, the implementation case classes are not visible in the result
 types of their `apply` methods. This is a subtle difference with
 respect to normal case classes. The classes making up the cases do
-exist, and can be unveiled by constructing them directly with a `new`.
+exist, and can be unveiled, either by constructing them directly with a `new`,
+or by explicitly providing an expected type.
+
 
 ```scala
 scala> new Option.Some(2)
-val res3: t2.Option.Some[Int] = Some(2)
+val res3: Option.Some[Int] = Some(2)
+scala> val x: Option.Some[Int] = Option.Some(3)
+val res4: Option.Some[Int] = Some(3)
 ```
 
 As all other enums, ADTs can define methods. For instance, here is `Option` again, with an

docs/docs/reference/enums/desugarEnums.md

@@ -139,10 +139,7 @@ map into `case class`es or `val`s.
    ```scala
    final case class C <params> extends <parents>
    ```
-   However, unlike for a regular case class, the return type of the associated
-   `apply` method is a fully parameterized type instance of the enum class `E`
-   itself instead of `C`.  Also the enum case defines an `ordinal` method of
-   the form
+   The enum case defines an `ordinal` method of the form
    ```scala
    def ordinal = n
    ```
@@ -153,6 +150,14 @@ map into `case class`es or `val`s.
    in a parameter type in `<params>` or in a type argument of `<parents>`, unless that parameter is already
    a type parameter of the case, i.e. the parameter name is defined in `<params>`.
 
+   The compiler-generated `apply` and `copy` methods of an enum case
+   ```scala
+   case C(ps) extends P1, ..., Pn
+   ```
+   are treated specially. A call `C(ts)` of the apply method is ascribed the underlying type
+   `P1 & ... & Pn` (dropping any [super traits](../other-new-features/super-traits.html))
+   as long as that type is still compatible with the expected type at the point of application.
+   A call `t.copy(ts)` of `C`'s `copy` method is treated in the same way.
 
 ### Translation of Enums with Singleton Cases