Don't treat default classes as sum types

Classes representing sum types need to be be abstract, which default classes are not.

This partially reverts "Treat non-open classes as effectively sealed."
d98c2d6.

Author: odersky

compiler/src/dotty/tools/dotc/core/SymDenotations.scala

@@ -1077,7 +1077,7 @@ object SymDenotations {
     final def isEffectivelySealed(given Context): Boolean =
       isOneOf(FinalOrSealed) || isClass && !isOneOf(EffectivelyOpenFlags)
 
-      /** The class containing this denotation which has the given effective name. */
+    /** The class containing this denotation which has the given effective name. */
     final def enclosingClassNamed(name: Name)(implicit ctx: Context): Symbol = {
       val cls = enclosingClass
       if (cls.effectiveName == name || !cls.exists) cls else cls.owner.enclosingClassNamed(name)

compiler/src/dotty/tools/dotc/transform/SymUtils.scala

@@ -91,10 +91,8 @@ class SymUtils(val self: Symbol) extends AnyVal {
    *   - all of its children are generic products or singletons
    */
   def whyNotGenericSum(implicit ctx: Context): String =
-    if !self.isEffectivelySealed then
+    if (!self.is(Sealed))
       s"it is not a sealed ${self.kindString}"
-    else if self.is(Final) then
-      s"it is a final class"
     else {
       val children = self.children
       val companion = self.linkedClass

compiler/src/dotty/tools/dotc/transform/SyntheticMembers.scala

@@ -509,7 +509,7 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
       if (clazz.is(Case)) makeSingletonMirror()
       else if (linked.isGenericProduct) makeProductMirror(linked)
       else if (linked.isGenericSum) makeSumMirror(linked)
-      else if linked.isEffectivelySealed then
+      else if (linked.is(Sealed))
         derive.println(i"$linked is not a sum because ${linked.whyNotGenericSum}")
     }
     else if (impl.removeAttachment(ExtendsSingletonMirror).isDefined)

compiler/src/dotty/tools/dotc/transform/patmat/Space.scala

@@ -550,7 +550,7 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
   def canDecompose(tp: Type): Boolean = {
     val dealiasedTp = tp.dealias
     val res =
-      (tp.classSymbol.isEffectivelySealed &&
+      (tp.classSymbol.is(Sealed) &&
         tp.classSymbol.isOneOf(AbstractOrTrait) &&
         !tp.classSymbol.hasAnonymousChild &&
         tp.classSymbol.children.nonEmpty ) ||
@@ -672,7 +672,7 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
           if (mergeList) "_: _*" else "_: List"
         else if (scalaConsType.isRef(sym))
           if (mergeList) "_, _: _*"  else "List(_, _: _*)"
-        else if (tp.classSymbol.isEffectivelySealed && tp.classSymbol.hasAnonymousChild)
+        else if (tp.classSymbol.is(Sealed) && tp.classSymbol.hasAnonymousChild)
           "_: " + showType(tp) + " (anonymous)"
         else if (tp.classSymbol.is(CaseClass) && !hasCustomUnapply(tp.classSymbol))
         // use constructor syntax for case class

compiler/src/dotty/tools/dotc/typer/Namer.scala

@@ -874,19 +874,18 @@ class Namer { typer: Typer =>
     def registerIfChild(denot: SymDenotation)(implicit ctx: Context): Unit = {
       val sym = denot.symbol
 
-      def register(child: Symbol, parent: Type) =
+      def register(child: Symbol, parent: Type) = {
         val cls = parent.classSymbol
-        if cls.isEffectivelySealed
-           && child.associatedFile == cls.associatedFile // don't register ad-hoc extensions as children
-        then
-          if (child.isInaccessibleChildOf(cls) || child.isAnonymousClass) && !sym.hasAnonymousChild then
+        if (cls.is(Sealed))
+          if ((child.isInaccessibleChildOf(cls) || child.isAnonymousClass) && !sym.hasAnonymousChild)
             addChild(cls, cls)
-          else if !cls.is(ChildrenQueried) then
+          else if (!cls.is(ChildrenQueried))
             addChild(cls, child)
           else
             ctx.error(em"""children of $cls were already queried before $sym was discovered.
                           |As a remedy, you could move $sym on the same nesting level as $cls.""",
                       child.sourcePos)
+      }
 
       if (denot.isClass && !sym.isEnumAnonymClass && !sym.isRefinementClass)
         denot.asClass.classParents.foreach { parent =>

docs/docs/reference/other-new-features/open-classes.md

@@ -16,6 +16,7 @@ open class Writer[T] with
   /** Send all arguments using `send` */
   def sendAll(xs: T*) = xs.foreach(send)
 
+
 // File EncryptedWriter.scala
 package p
 
@@ -29,12 +30,11 @@ Classes that are not open can still be extended, but only if one of two alternat
 
  - The extending class is in the same source file as the extended class. In this case, the extension is usually an internal implementation matter.
 
- - The language feature `adhocExtensions` is enabled for the extending class. This is typically enabled by an import statement
+ - The language feature `adhocExtensions` is enabled for the extending class. This is typically enabled by an import statement in the source file of the extension:
    ```scala
    import scala.language.adhocExtensions
    ```
-   in the source file of the extension, but can alternatively be provided
-   by a command line option `-language:adhocExtensions`.
+   Alternatively, the feature can be enabled by the command line option `-language:adhocExtensions`.
    If the feature is not enabled, the compiler will issue a "feature" warning. For instance, if the `open` modifier on class `Writer` is dropped, compiling `EncryptedWriter` would produce a warning:
    ```
    -- Feature Warning: EncryptedWriter.scala:6:14 ----
@@ -69,9 +69,9 @@ to mock classes in tests, or to apply temporary patches that add features or fix
  - An `open` class cannot be `final` or `sealed`.
  - Traits or `abstract` classes are always `open`, so `open` is redundant for them.
 
-### Relatinship with `sealed`
+### Relationship with `sealed`
 
-A class that is neither `abstract` nor `open` is similar to a `sealed` class`: it can still be extended, but only in the same compilation unit. The difference is what happens if an extension of the class is attempted in a different compilation unit. For a `sealed` class, this is an error, whereas for a simple non-open class, this is still permitted provided the `adhocExtensions` feature is enabled, and gives a warning otherwise.
+A class that is neither `abstract` nor `open` is similar to a `sealed` class: it can still be extended, but only in the same compilation unit. The difference is what happens if an extension of the class is attempted in another compilation unit. For a `sealed` class, this is an error, whereas for a simple non-open class, this is still permitted provided the `adhocExtensions` feature is enabled, and it gives a warning otherwise.
 
 ### Migration