Flag missing parent type of implicit object as error

Implicit objects should not allow parent types to be computed from argument
expressions of an application. This is analogous to demanding an explicit type
for implicit vals and defs.

Author: odersky

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

@@ -718,6 +718,11 @@ class Namer { typer: Typer =>
     localCtx
   }
 
+  def missingType(sym: Symbol, modifier: String)(implicit ctx: Context) = {
+    ctx.error(s"${modifier}type of implicit definition needs to be given explicitly", sym.pos)
+    sym.resetFlag(Implicit)
+  }
+
   /** The completer of a symbol defined by a member def or import (except ClassSymbols) */
   class Completer(val original: Tree)(implicit ctx: Context) extends LazyType {
 
@@ -851,7 +856,11 @@ class Namer { typer: Typer =>
           val targs1 = targs map (typedAheadType(_))
           val ptype = typedAheadType(tpt).tpe appliedTo targs1.tpes
           if (ptype.typeParams.isEmpty) ptype
-          else fullyDefinedType(typedAheadExpr(parent).tpe, "class parent", parent.pos)
+          else {
+            if (denot.is(ModuleClass) && denot.sourceModule.is(Implicit)) 
+              missingType(denot.symbol, "parent ")(creationContext)
+            fullyDefinedType(typedAheadExpr(parent).tpe, "class parent", parent.pos)
+          }
         }
 
       /* Check parent type tree `parent` for the following well-formedness conditions:
@@ -1080,14 +1089,10 @@ class Namer { typer: Typer =>
           lhsType // keep constant types that fill in for a non-constant (to be revised when inline has landed).
         else inherited
       else {
-        def missingType(modifier: String) = {
-          ctx.error(s"${modifier}type of implicit definition needs to be given explicitly", mdef.pos)
-          sym.resetFlag(Implicit)
-        }
         if (sym is Implicit)
           mdef match {
-            case _: DefDef => missingType("result")
-            case _: ValDef if sym.owner.isType => missingType("")
+            case _: DefDef => missingType(sym, "result ")
+            case _: ValDef if sym.owner.isType => missingType(sym, "")
             case _ =>
           }
         lhsType orElse WildcardType

tests/neg/i3067.scala

@@ -0,0 +1,11 @@
+class Test[T](f: List[String] => T)
+
+object o {
+
+  implicit val x = 3  // error
+
+  implicit def y = "abc"   // error
+
+  implicit object a extends Test(_ map identity)  // error
+  implicit object b extends Test(_ map identity)
+}