Make implicit scope include companion objects of opaque types

Author: odersky

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

@@ -551,6 +551,11 @@ object SymDenotations {
     /** Is this symbol an abstract type or type parameter? */
     final def isAbstractOrParamType(implicit ctx: Context) = this is DeferredOrTypeParam
 
+    /** Can this symbol have a companion module?
+     *  This is the case if it is a class or an opaque type alias.
+     */
+    final def canHaveCompanion(implicit ctx: Context) = isClass || is(Opaque)
+
     /** Is this the denotation of a self symbol of some class?
      *  This is the case if one of two conditions holds:
      *  1. It is the symbol referred to in the selfInfo part of the ClassInfo

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

@@ -398,15 +398,15 @@ trait ImplicitRunInfo { self: Run =>
       override implicit protected val ctx: Context = liftingCtx
       override def stopAtStatic = true
       def apply(tp: Type) = tp match {
-        case tp: TypeRef if tp.symbol.isAbstractOrAliasType =>
+        case tp: TypeRef if !tp.symbol.canHaveCompanion =>
           val pre = tp.prefix
           def joinClass(tp: Type, cls: ClassSymbol) =
             AndType.make(tp, cls.typeRef.asSeenFrom(pre, cls.owner))
           val lead = if (tp.prefix eq NoPrefix) defn.AnyType else apply(tp.prefix)
           (lead /: tp.classSymbols)(joinClass)
         case tp: TypeVar =>
           apply(tp.underlying)
-        case tp: AppliedType if !tp.tycon.typeSymbol.isClass =>
+        case tp: AppliedType if !tp.tycon.typeSymbol.canHaveCompanion =>
           def applyArg(arg: Type) = arg match {
             case TypeBounds(lo, hi) => AndType.make(lo, hi)
             case WildcardType(TypeBounds(lo, hi)) => AndType.make(lo, hi)
@@ -444,21 +444,24 @@ trait ImplicitRunInfo { self: Run =>
           case tp: NamedType =>
             val pre = tp.prefix
             comps ++= iscopeRefs(pre)
-            def addClassScope(cls: ClassSymbol): Unit = {
-              def addRef(companion: TermRef): Unit = {
-                val compSym = companion.symbol
-                if (compSym is Package)
-                  addRef(companion.select(nme.PACKAGE))
-                else if (compSym.exists)
-                  comps += companion.asSeenFrom(pre, compSym.owner).asInstanceOf[TermRef]
-              }
-              def addParentScope(parent: Type): Unit =
-                iscopeRefs(tp.baseType(parent.typeSymbol)) foreach addRef
-              val companion = cls.companionModule
+            def addRef(companion: TermRef): Unit = {
+              val compSym = companion.symbol
+              if (compSym is Package)
+                addRef(companion.select(nme.PACKAGE))
+              else if (compSym.exists)
+                comps += companion.asSeenFrom(pre, compSym.owner).asInstanceOf[TermRef]
+            }
+            def addCompanionOf(sym: Symbol) = {
+              val companion = sym.companionModule
               if (companion.exists) addRef(companion.termRef)
-              cls.classParents foreach addParentScope
             }
-            tp.classSymbols(liftingCtx) foreach addClassScope
+            def addClassScope(cls: ClassSymbol): Unit = {
+              addCompanionOf(cls)
+              for (parent <- cls.classParents; ref <- iscopeRefs(tp.baseType(parent.typeSymbol)))
+                addRef(ref)
+            }
+            if (tp.widen.typeSymbol.is(Opaque)) addCompanionOf(tp.widen.typeSymbol)
+            else tp.classSymbols(liftingCtx).foreach(addClassScope)
           case _ =>
             for (part <- tp.namedPartsWith(_.isType)) comps ++= iscopeRefs(part)
         }

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

@@ -621,7 +621,7 @@ class Namer { typer: Typer =>
     def createLinks(classTree: TypeDef, moduleTree: TypeDef)(implicit ctx: Context) = {
       val claz = ctx.effectiveScope.lookup(classTree.name)
       val modl = ctx.effectiveScope.lookup(moduleTree.name)
-      if (modl.isClass && (claz.isClass || claz.is(Opaque))) {
+      if (modl.isClass && claz.canHaveCompanion) {
         modl.registerCompanion(claz)
         claz.registerCompanion(modl)
       }

tests/neg/tagging.scala

@@ -15,8 +15,6 @@ object tagging {
       ct
   }
 
-  import Tagged._
-
   type @@[S, T] = Tagged[S, T]
 
   implicit class UntagOps[S, T](st: S @@ T) extends AnyVal {

tests/pos/opaque.scala

@@ -23,10 +23,10 @@ object opaquetypes {
 }
 object usesites {
   import opaquetypes._
-  import Logarithm.LogarithmOps // todo: drop
   val l = Logarithm(1.0)
   val l2 = Logarithm(2.0)
-  val l3 = l + l2
+  val l3 = l * l2
+  val l4 = l * l2
   val d = l3.toDouble
   val l4: Logarithm = (1.0).asInstanceOf[Logarithm]
 }

tests/pos/tagging.scala

@@ -15,8 +15,6 @@ object tagging {
       ct
   }
 
-  import Tagged._
-
   type @@[S, T] = Tagged[S, T]
 
   implicit class UntagOps[S, T](st: S @@ T) extends AnyVal {