Improvements to typeclass derivation

 1. add a Generic instance only if the implementation of a derived
    typeclass mentions the type.

Author: odersky

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

@@ -666,7 +666,7 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
    *  Pre: `sym` must have a position.
    */
   def defPath(sym: Symbol, root: Tree)(implicit ctx: Context): List[Tree] = trace.onDebug(s"defpath($sym with position ${sym.span}, ${root.show})") {
-    require(sym.span.exists)
+    require(sym.span.exists, sym)
     object accum extends TreeAccumulator[List[Tree]] {
       def apply(x: List[Tree], tree: Tree)(implicit ctx: Context): List[Tree] = {
         if (tree.span.contains(sym.span))

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

@@ -32,6 +32,8 @@ trait Deriving { this: Typer =>
     /** A buffer for synthesized symbols */
     private var synthetics = new mutable.ListBuffer[Symbol]
 
+    private var derivesGeneric = false
+
     /** the children of `cls` ordered by textual occurrence */
     lazy val children: List[Symbol] = cls.children
 
@@ -170,7 +172,7 @@ trait Deriving { this: Typer =>
       val derivedType = checkClassType(underlyingType, derived.sourcePos, traitReq = false, stablePrefixReq = true)
       val nparams = derivedType.classSymbol.typeParams.length
       if (derivedType.isRef(defn.GenericClass))
-        () // do nothing, a Generic instance will be created anyway by `addGeneric`
+        derivesGeneric = true
       else if (nparams == 1) {
         val typeClass = derivedType.classSymbol
         val firstKindedParams = cls.typeParams.filterNot(_.info.isLambdaSub)
@@ -210,14 +212,33 @@ trait Deriving { this: Typer =>
       addDerivedInstance(defn.GenericType.name, genericCompleter, codePos, reportErrors = false)
     }
 
+    /** If any of the instances has a companion with a `derived` member
+     *  that refers to `scala.reflect.Generic`, add an implied instance
+     *  of `Generic`. Note: this is just an optimization to avoid possible
+     *  code duplication. Generic instances are created on the fly if they
+     *  are missing from the companion.
+     */
+    private def maybeAddGeneric(): Unit = {
+      val genericCls = defn.GenericClass
+      def refersToGeneric(sym: Symbol): Boolean = {
+        val companion = sym.info.finalResultType.classSymbol.companionModule
+        val derivd = companion.info.member(nme.derived)
+        derivd.hasAltWith(sd => sd.info.existsPart(p => p.typeSymbol == genericCls))
+      }
+      if (derivesGeneric || synthetics.exists(refersToGeneric)) {
+        derive.println(i"add generic infrastructure for $cls")
+        addGeneric()
+        addGenericClass()
+      }
+    }
+
     /** Create symbols for derived instances and infrastructure,
-     *  append them to `synthetics` buffer,
-     *  and enter them into class scope.
+     *  append them to `synthetics` buffer, and enter them into class scope.
+     *  Also, add generic instances if needed.
      */
     def enterDerived(derived: List[untpd.Tree]) = {
       derived.foreach(processDerivedInstance(_))
-      addGeneric()
-      addGenericClass()
+      maybeAddGeneric()
     }
 
     private def tupleElems(tp: Type): List[Type] = tp match {