Fix types of implicit definitions in transparent closure

We need the type of the reference, not the type of the symbol.
With this change, the code specialization example compiles and
runs correctly.

Author: odersky

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

@@ -265,19 +265,19 @@ object PrepareTransparent {
     object referenced extends TreeTraverser {
       val typeAtPos = mutable.Map[Position, Type]()
       val accessorAtPos = mutable.Map[Position, Symbol]()
-      val implicitSyms = mutable.Set[Symbol]()
+      val implicitRefTypes = mutable.Set[Type]()
       val implicitRefs = new mutable.ListBuffer[Tree]
 
       def registerIfContextualImplicit(tree: Tree) = tree match {
         case tree: RefTree
         if tree.removeAttachment(ContextualImplicit).isDefined &&
            tree.symbol.exists &&
            !isLocalOrParam(tree.symbol, inlineMethod) &&
-           !implicitSyms.contains(tree.symbol) =>
+           !implicitRefTypes.contains(tree.tpe) =>
           if (tree.existsSubTree(t => isLocal(tree.symbol, inlineMethod)))
             ctx.warning("implicit reference $tree is dropped at inline site because it refers to local symbol(s)", tree.pos)
           else {
-            implicitSyms += tree.symbol
+            implicitRefTypes += tree.tpe
             implicitRefs += tree
           }
         case _ =>
@@ -386,7 +386,7 @@ object PrepareTransparent {
           owner = inlineMethod,
           name = UniqueInlineName.fresh(iref.symbol.name.asTermName),
           flags = Implicit | Method | Stable,
-          info = iref.symbol.info.ensureMethodic,
+          info = iref.tpe.widen.ensureMethodic,
           coord = inlineMethod.pos).asTerm
         polyDefDef(localImplicit, tps => vrefss =>
             iref.appliedToTypes(tps).appliedToArgss(vrefss))

tests/run/typelevel-numeric.check

@@ -0,0 +1 @@
+-1.0

tests/run/typelevel-numeric.scala

@@ -0,0 +1,33 @@
+
+import math.Numeric
+
+abstract class MathLib[N : Numeric] {
+  def dotProduct(xs: Array[N], ys: Array[N]): N
+}
+
+object MathLib {
+
+  transparent def apply[N](implicit n: Numeric[N]) = new MathLib[N] {
+    import n._
+    def dotProduct(xs: Array[N], ys: Array[N]): N = {
+      require(xs.length == ys.length)
+      var i = 0
+      var s: N = n.zero
+      while (i < xs.length) {
+        s = s + xs(i) * ys(i)
+        i += 1
+      }
+      s
+    }
+  }
+}
+
+object Test extends App {
+
+  val mlib = MathLib.apply[Double](scala.math.Numeric.DoubleIsFractional)
+
+  val xs = Array(1.0, 1.0)
+  val ys = Array(2.0, -3.0)
+  val p = mlib.dotProduct(xs, ys)
+  println(p)
+}