Use unreachable for match cases that are known to be unreachable

Author: odersky

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -200,7 +200,7 @@ object desugar {
     paramss.mapConserve {
       case TypeDefs(tparams) => tparams.mapConserve(mapTypeParam)
       case ValDefs(vparams) => vparams.mapConserve(mapTermParam)
-      case _ => ??? // impossible
+      case _ => unreachable()
     }
 
   /** 1. Expand context bounds to evidence params. E.g.,

compiler/src/dotty/tools/dotc/ast/tpd.scala

@@ -215,7 +215,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
         paramss.map {
           case TypeSymbols(params) => params.map(param => TypeDef(param).withSpan(param.span))
           case TermSymbols(params) => params.map(param => ValDef(param).withSpan(param.span))
-          case _ => ???
+          case _ => unreachable()
         },
         TypeTree(resultType),
         rhs),

compiler/src/dotty/tools/dotc/transform/init/Potentials.scala

@@ -1,4 +1,5 @@
-package dotty.tools.dotc
+package dotty.tools
+package dotc
 package transform
 package init
 
@@ -101,7 +102,7 @@ object Potentials {
         case Some((parentCls, pots)) =>
           val rebased: Potentials = outerPots.flatMap { Potentials.asSeenFrom(pots, _) }
           resolveOuter(parentCls, rebased, cls)
-        case None => ??? // impossible
+        case None => unreachable()
       }
     }
   }

compiler/src/dotty/tools/package.scala

@@ -50,4 +50,7 @@ package object tools {
   type WrappedResult[T] = resultWrapper.WrappedResult[T]
   def WrappedResult[T](x: T) = resultWrapper.wrap(x)
   def result[T](using x: WrappedResult[T]): T = resultWrapper.unwrap(x)
+
+  def unreachable(x: Any = "<< this case was declared unreachable >>"): Nothing =
+    throw new MatchError(x)
 }