Include the type converted to as part of ImplicitConvert

src/common/ImplicitOps.scala

@@ -15,14 +15,14 @@ trait ImplicitOps extends Base {
 }
 
 trait ImplicitOpsExp extends ImplicitOps with BaseExp {
-  case class ImplicitConvert[X,Y](x: Exp[X])(implicit val mX: Manifest[X], val mY: Manifest[Y]) extends Def[Y]
+  case class ImplicitConvert[X,Y](x: Exp[X], mY: Manifest[Y])(implicit val mX: Manifest[X]) extends Def[Y]
 
   def implicit_convert[X,Y](x: Exp[X])(implicit c: X => Y, mX: Manifest[X], mY: Manifest[Y], pos: SourceContext) : Rep[Y] = {
-    if (mX == mY) x.asInstanceOf[Rep[Y]] else ImplicitConvert[X,Y](x)
+    if (mX == mY) x.asInstanceOf[Rep[Y]] else ImplicitConvert[X,Y](x, mY)
   }
 
   override def mirror[A:Manifest](e: Def[A], f: Transformer)(implicit pos: SourceContext): Exp[A] = (e match {
-    case im@ImplicitConvert(x) => toAtom(ImplicitConvert(f(x))(im.mX,im.mY))(mtype(manifest[A]),pos)
+    case im@ImplicitConvert(x, mY) => toAtom(ImplicitConvert(f(x), mY)(im.mX))(mtype(manifest[A]),pos)
     case _ => super.mirror(e,f)
   }).asInstanceOf[Exp[A]]
 
@@ -33,9 +33,9 @@ trait ScalaGenImplicitOps extends ScalaGenBase {
   import IR._
 
   override def emitNode(sym: Sym[Any], rhs: Def[Any]) = rhs match {
-    // TODO: this valDef is redundant; we really just want the conversion to be a no-op in the generated code.
-    // TODO: but we still need to link the defs together
-    case ImplicitConvert(x) => emitValDef(sym, quote(x))
+    // Make sure it's typed to trigger the implicit conversion
+    // Otherwise we can get type mismatch in generated code
+    case ImplicitConvert(x, mY) => emitTypedValDef(sym, quote(x))
     case _ => super.emitNode(sym, rhs)
   }
 }
@@ -46,8 +46,8 @@ trait CLikeGenImplicitOps extends CLikeGenBase {
 
   override def emitNode(sym: Sym[Any], rhs: Def[Any]) = {
       rhs match {
-        case im@ImplicitConvert(x) =>
-          gen"${im.mY} $sym = (${im.mY})$x;"
+        case ImplicitConvert(x, mY) =>
+          gen"$mY $sym = ($mY)$x;"
         case _ => super.emitNode(sym, rhs)
       }
     }

src/internal/ScalaCodegen.scala

@@ -90,12 +90,20 @@ trait ScalaCodegen extends GenericCodegen with Config {
     fileName.substring(i + 1)
   }
 
-  def emitValDef(sym: Sym[Any], rhs: String): Unit = {
-    val extra = if ((sourceinfo < 2) || sym.pos.isEmpty) "" else {
-      val context = sym.pos(0)
-      "      // " + relativePath(context.fileName) + ":" + context.line
+  private def valDefExtra(sym: IR.Sym[Any]): String = {
+    sym.pos.headOption match {
+      case Some(context) if sourceinfo >= 2 =>
+        "      // " + relativePath(context.fileName) + ":" + context.line
+      case _ => ""
     }
-    stream.println("val " + quote(sym) + " = " + rhs + extra)
+  }
+
+  def emitValDef(sym: Sym[Any], rhs: String): Unit = {
+    stream.println("val " + quote(sym) + " = " + rhs + valDefExtra(sym))
+  }
+
+  def emitTypedValDef(sym: Sym[Any], rhs: String): Unit = {
+    stream.println(src"val $sym: ${sym.tp} = $rhs" + valDefExtra(sym))
   }
 
   def emitVarDef(sym: Sym[Variable[Any]], rhs: String): Unit = {
@@ -132,7 +140,14 @@ trait ScalaNestedCodegen extends GenericNestedCodegen with ScalaCodegen {
     else
       super.emitValDef(sym,rhs)
   }
-
+
+  // special case for recursive vals
+  override def emitTypedValDef(sym: Sym[Any], rhs: String): Unit = {
+    if (recursive contains sym)
+      stream.println(quote(sym) + " = " + rhs) // we have a forward declaration above.
+    else
+      super.emitTypedValDef(sym,rhs)
+  }
 }