Allow toplevel opaque types

Author: odersky

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

@@ -1022,13 +1022,23 @@ object desugar {
     else Apply(ref(tupleTypeRef.classSymbol.companionModule.termRef), ts)
   }
 
-  /** Group all patterm, value and method definitions and all non-class type definitions
-   *  in an object named `<source>#object` where `<source>` is the name of the source file.
+  /** Group all definitions that can't be at the toplebel in
+   *  an object named `<source>#object` where `<source>` is the name of the source file.
+   *  Definitions that can't be at the toplevel are:
+   *
+   *   - all pattern, value and method definitions
+   *   - non-class type definitions
+   *   - implicit classes and objects
+   *   - companion objects of opaque types
    */
   def packageDef(pdef: PackageDef)(implicit ctx: Context): PackageDef = {
+    val opaqueNames = pdef.stats.collect {
+      case stat: TypeDef if stat.mods.is(Opaque) => stat.name
+    }
     def needsObject(stat: Tree) = stat match {
       case _: ValDef | _: PatDef | _: DefDef => true
-      case stat: ModuleDef => stat.mods.is(Implicit)
+      case stat: ModuleDef =>
+        stat.mods.is(Implicit) || opaqueNames.contains(stat.name.stripModuleClassSuffix.toTypeName)
       case stat: TypeDef => !stat.isClassDef || stat.mods.is(Implicit)
       case _ => false
     }

tests/neg/toplevel-opaque/Test.scala

@@ -0,0 +1,6 @@
+object Test {
+  val x: T[Int] = 2      // error
+  val y: Int = x         // error
+  val a: Int = T.f(x)    // ok
+  val b: T[Int] = T.g(y) // ok
+}

tests/neg/toplevel-opaque/opaque-id.scala

@@ -0,0 +1,5 @@
+opaque type T[X] = X
+object T {
+  def f(x: T[Int]): Int = x // OK
+  def g(x: Int): T[Int] = x // OK
+}

tests/pos/toplevel-opaque-xm/Logarithm_1.scala

@@ -0,0 +1,22 @@
+package logs
+
+opaque type Logarithm = Double
+
+implicit object Logarithm {
+
+  // These are the ways to lift to the logarithm type
+  def apply(d: Double): Logarithm = math.log(d)
+
+  def safe(d: Double): Option[Logarithm] =
+    if (d > 0.0) Some(math.log(d)) else None
+
+  // This is the first way to unlift the logarithm type
+  def exponent(l: Logarithm): Double = l
+
+  // Extension methods define opaque types' public APIs
+
+  // This is the second way to unlift the logarithm type
+  def (x: Logarithm) toDouble: Double = math.exp(x)
+  def (x: Logarithm) + (y: Logarithm) = Logarithm(math.exp(x) + math.exp(y))
+  def (x: Logarithm) * (y: Logarithm): Logarithm = Logarithm(x + y)
+}

tests/pos/toplevel-opaque-xm/Test_2.scala

@@ -0,0 +1,15 @@
+package logs
+
+import Predef.{any2stringadd => _, _}
+
+object Test {
+  val l = Logarithm(1.0)
+  val l2 = Logarithm(2.0)
+  val l3 = l * l2
+  val l4 = l + l2  // currently requires any2stringadd to be disabled because
+                   // as a contextual implicit this takes precedence over the
+                   // implicit scope implicit LogarithmOps.
+                   // TODO: Remove any2stringadd
+  val d = Logarithm.toDouble(l3)
+  val l5: Logarithm = (1.0).asInstanceOf[Logarithm]
+}

tests/pos/toplevel-opaque/Test.scala

@@ -0,0 +1,6 @@
+object Test {
+  val x: T[Int] = ??? //2      // error
+  val y: Int = 1 // x         // error
+  val a: Int = T.f(x)    // ok
+  val b: T[Int] = T.g(y) // ok
+}

tests/pos/toplevel-opaque/opaque-id.scala

@@ -0,0 +1,5 @@
+opaque type T[X] = X
+object T {
+  def f(x: T[Int]): Int = x // OK
+  def g(x: Int): T[Int] = x // OK
+}