Refine atoms computation some more.

If we have `x: 0 | 1` then `x.type` should have atoms {`0`, `1`} only if widening is allowed.
On the other hand, if `x: 0` then `x` has atoms `{0}`irrespective of widening.

Author: odersky

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

@@ -1157,7 +1157,7 @@ object Types {
      *  these types as a set, otherwise the empty set.
      *  Overridden and cached in OrType.
      *  @param widenOK  If type proxies that are upperbounded by types with atoms
-     *                  have the same atoms. 
+     *                  have the same atoms.
      */
     def atoms(widenOK: Boolean = false)(implicit ctx: Context): Set[Type] = dealias match {
       case tp: SingletonType =>
@@ -1174,8 +1174,9 @@ object Types {
           case _ => tp
         }
         val underlyingAtoms = tp.underlying.atoms(widenOK)
-        if (underlyingAtoms.isEmpty && tp.isStable) Set.empty + normalize(tp)
-        else underlyingAtoms
+        if underlyingAtoms.isEmpty && tp.isStable then Set.empty + normalize(tp)
+        else if underlyingAtoms.size == 1 || widenOK then underlyingAtoms
+        else Set.empty
       case tp: ExprType => tp.resType.atoms(widenOK)
       case tp: OrType => tp.atoms(widenOK) // `atoms` overridden in OrType
       case tp: AndType => tp.tp1.atoms(widenOK) & tp.tp2.atoms(widenOK)

tests/pos/i8128.scala

@@ -1,11 +1,11 @@
 object Test {
-  def id: (x: 1 | 0) => x.type = x => x
-  id(0): 0   // fails
+  def id: (x: 1 | 0) => x.type = ???
+  id(0): 0   // ok
 
   def id2: Function1[1 | 0, 1 | 0] {
     def apply(x: 1 | 0): x.type
   } = ???
-  id2(0): 0  // fails
+  id2(0): 0  // ok
 
   def id3: Function1[1 | 0, Int] {
     def apply(x: 1 | 0): x.type