Merge pull request #6721 from dotty-staging/fix-opaque

 Handle opaque types in computeAsSeenFrom

Author: odersky

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

@@ -1118,8 +1118,31 @@ object Denotations {
         case thisd: SymDenotation => thisd.owner
         case _ => if (symbol.exists) symbol.owner else NoSymbol
       }
-      if (!owner.membersNeedAsSeenFrom(pre) || symbol.is(NonMember)) this
-      else derivedSingleDenotation(symbol, symbol.info.asSeenFrom(pre, owner))
+      def derived(info: Type) = derivedSingleDenotation(symbol, info.asSeenFrom(pre, owner))
+      pre match {
+        case pre: ThisType if symbol.isOpaqueAlias && pre.cls == symbol.owner =>
+          // This code is necessary to compensate for a "window of vulnerability" with
+          // opaque types. The problematic sequence is as follows.
+          //  1. Type a selection  `m.this.T` where `T` is an opaque type alias in `m`
+          //     and this is the first access
+          //  2. `T` will normalize to an abstract type on completion.
+          //  3. At that time, the default logic in the second case is wrong: `T`'s new info
+          //     is now an abstract type and running it through an asSeenFrom gives nothing.
+          //  We fix this as follows:
+          //  1. Force opaque normalization as first step
+          //  2. Read the info from the enclosing object's refinement
+          symbol.normalizeOpaque()
+          def findRefined(tp: Type, name: Name): Type = tp match {
+            case RefinedType(parent, rname, rinfo) =>
+              if (rname == name) rinfo else findRefined(parent, name)
+            case _ =>
+              symbol.info
+          }
+          derived(findRefined(pre.underlying, symbol.name))
+        case _ =>
+          if (!owner.membersNeedAsSeenFrom(pre) || symbol.is(NonMember)) this
+          else derived(symbol.info)
+      }
     }
 
     /** Does this denotation have all the `required` flags but none of the `excluded` flags?

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

@@ -1891,10 +1891,8 @@ object Types {
             finish(memberDenot(symd.initial.name, allowPrivate = false))
           else if (prefix.isArgPrefixOf(symd))
             finish(argDenot(sym.asType))
-          else if (infoDependsOnPrefix(symd, prefix)) {
-            if (!symd.isClass && symd.is(Opaque, butNot = Deferred)) symd.normalizeOpaque()
+          else if (infoDependsOnPrefix(symd, prefix))
             finish(memberDenot(symd.initial.name, allowPrivate = symd.is(Private)))
-          }
           else
             finish(symd.current)
       }

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -317,6 +317,20 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       case _ => tree
     }
 
+    def importText(deleg: Boolean, expr: Tree, selectors: List[Tree]) = {
+      def selectorText(sel: Tree): Text = sel match {
+        case Thicket(l :: r :: Nil) => toTextGlobal(l) ~ " => " ~ toTextGlobal(r)
+        case _: Ident => toTextGlobal(sel)
+        case TypeBoundsTree(_, tpt) => "for " ~ toTextGlobal(tpt)
+      }
+      val selectorsText: Text = selectors match {
+        case id :: Nil => toText(id)
+        case _ => "{" ~ Text(selectors map selectorText, ", ") ~ "}"
+      }
+      (keywordText("delegate ") provided deleg) ~
+      toTextLocal(expr) ~ "." ~ selectorsText
+    }
+
     tree match {
       case id: Trees.BackquotedIdent[_] if !homogenizedView =>
         "`" ~ toText(id.name) ~ "`"
@@ -499,18 +513,10 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
             typeDefText(tparamsTxt, optText(rhs)(" = " ~ _))
         }
         recur(rhs, "")
-      case Import(importImplied, expr, selectors) =>
-        def selectorText(sel: Tree): Text = sel match {
-          case Thicket(l :: r :: Nil) => toTextGlobal(l) ~ " => " ~ toTextGlobal(r)
-          case _: Ident => toTextGlobal(sel)
-          case TypeBoundsTree(_, tpt) => "for " ~ toTextGlobal(tpt)
-        }
-        val selectorsText: Text = selectors match {
-          case id :: Nil => toText(id)
-          case _ => "{" ~ Text(selectors map selectorText, ", ") ~ "}"
-        }
-        keywordText("import ") ~ (keywordText("delegate ") provided importImplied) ~
-        toTextLocal(expr) ~ "." ~ selectorsText
+      case Import(deleg, expr, selectors) =>
+        keywordText("import ") ~ importText(deleg, expr, selectors)
+      case Export(deleg, expr, selectors) =>
+        keywordText("export ") ~ importText(deleg, expr, selectors)
       case packageDef: PackageDef =>
         packageDefText(packageDef)
       case tree: Template =>

tests/pos/export-opaque.scala

@@ -0,0 +1,11 @@
+object A {
+
+  object opaques {
+    opaque type FlagSet = Long
+    def FlagSet(bits: Long): FlagSet = bits
+  }
+  //type FlagSet = opaques.FlagSet
+  //def FlagSet(bits: Long): FlagSet = opaques.FlagSet(bits)
+  export opaques.FlagSet
+
+}

tests/pos/implicit-scope.scala

@@ -2,7 +2,7 @@ object A {
 
   object opaques {
     opaque type FlagSet = Long
-    def FlagSet(bits: Long): FlagSet = bits.asInstanceOf // !!!
+    def FlagSet(bits: Long): FlagSet = bits
     def toBits(fs: FlagSet): Long = fs
   }
   val someFlag = FlagSet(1)