Make local copy of opaque type inaccessible for the outside

i5455.scala showed another misuse: One could get at the local copy
of an opaque type even though this type was not defined. This commit
closes that loophole.

Aside: It might be better to do the opaque type expansion in Namer
instead of in Desugar. This could let us use a synthetic name for
the local alias and thereby avoid namespace pollution. Right now one cannot
define a type with the same name as the opaque type alias in the
latter's companion object. It's a crazy thing to do, but still...

Author: odersky

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

@@ -8,6 +8,7 @@ import Symbols._, StdNames._, Trees._
 import Decorators._, transform.SymUtils._
 import NameKinds.{UniqueName, EvidenceParamName, DefaultGetterName}
 import typer.FrontEnd
+import util.Property
 import collection.mutable.ListBuffer
 import reporting.diagnostic.messages._
 import reporting.trace
@@ -18,6 +19,11 @@ object desugar {
   import untpd._
   import DesugarEnums._
 
+  /** If a Select node carries this attachment, suppress the check
+   *  that its type refers to an acessible symbol.
+   */
+  val SuppressAccessCheck = new Property.Key[Unit]
+
   /** Info of a variable in a pattern: The named tree and its type */
   private type VarInfo = (NameTree, Tree)
 
@@ -727,9 +733,11 @@ object desugar {
           fwd
       }
       val moduleName = tdef.name.toTermName
-      val aliasType = cpy.TypeDef(tdef)(
-        rhs = completeForwarder(Select(Ident(moduleName), tdef.name)))
-      val localType = tdef.withFlags(Synthetic | Opaque)
+      val localRef = Select(Ident(moduleName), tdef.name)
+      localRef.pushAttachment(SuppressAccessCheck, ())
+      val aliasType = cpy.TypeDef(tdef)(rhs = completeForwarder(localRef))
+      val localType = tdef.withMods(Modifiers(Synthetic | Opaque).withPrivateWithin(tdef.name))
+
       val companions = moduleDef(ModuleDef(
         moduleName, Template(emptyConstructor, Nil, EmptyValDef, localType :: Nil))
           .withFlags(Synthetic | Opaque))

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

@@ -259,7 +259,8 @@ trait TypeAssigner {
       qualType = errorType(em"$qualType takes type parameters", qual1.pos)
     else if (!qualType.isInstanceOf[TermType]) qualType = errorType(em"$qualType is illegal as a selection prefix", qual1.pos)
     val ownType = selectionType(qualType, tree.name, tree.pos)
-    ensureAccessible(ownType, qual1.isInstanceOf[Super], tree.pos)
+    if (tree.getAttachment(desugar.SuppressAccessCheck).isDefined) ownType
+    else ensureAccessible(ownType, qual1.isInstanceOf[Super], tree.pos)
   }
 
   /** Type assignment method. Each method takes as parameters

tests/neg/i5455.scala

@@ -0,0 +1,35 @@
+object Library {
+
+  opaque type Nat = Int
+
+  object Nat {
+    def apply(n: Int): Nat = {
+      require(n >= 0)
+      n
+    }
+    def times(x: Nat, y: Nat): Nat = x * y
+    def toInt(n: Nat): Int = n
+
+    implicit class NatOps(val self: Nat) extends AnyVal {
+      def *(other: Nat): Nat = self * other
+      def toInt: Int = self.asInstanceOf
+    }
+  }
+}
+
+object User extends App {
+  import Library._
+
+  val x = Nat(3)
+  val y = Nat(4)
+
+  val a = x * y
+  val b = double1(x)
+  val c = double2(x)
+
+  def double0(n: Nat): Nat = n * Nat(2) // ok
+
+  def double1(n: Nat.Nat): Nat = n * Nat(2)     // error
+
+  def double2(n: Nat.Nat): Nat.Nat = n * Nat(2)  // error // error
+}

tests/pos/i5455.scala

@@ -0,0 +1,36 @@
+object Library {
+
+  opaque type Nat = Int
+
+  object Nat {
+    def apply(n: Int): Nat = {
+      require(n >= 0)
+      n
+    }
+    def times(x: Nat, y: Nat): Nat = x * y
+    def toInt(n: Nat): Int = n
+
+    implicit class NatOps(val self: Nat) extends AnyVal {
+      def *(other: Nat): Nat = self * other
+      def toInt: Int = self.asInstanceOf
+    }
+  }
+}
+
+object Test extends App {
+  import Library._
+
+  val x = Nat(3)
+  val y = Nat(4)
+
+  val a = x * y
+  val b = double1(x)
+  val c = double2(x)
+
+  assert(a.toInt == 12)
+  assert(b.toInt == 6)
+  assert(c.toInt == 6)
+
+  def double1(n: Nat): Nat = n * Nat(2)
+  def double2(n: Nat): Nat = Nat.NatOps(n) * Nat(2)
+}