Skip to content

Commit 2433087

Browse files
author
Alexey Romanov
committed
Include Manifest as part of ArrayNew and similar classes
This avoids incorrectly considering instances with different types to be equal.
1 parent 0350d71 commit 2433087

25 files changed

+211
-212
lines changed

‎src/common/ArrayBufferOps.scala

Lines changed: 3 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -45,16 +45,14 @@ trait ArrayBufferOps extends Base {
4545
}
4646

4747
trait ArrayBufferOpsExp extends ArrayBufferOps with EffectExp {
48-
case class ArrayBufferNew[A:Manifest](xs: Seq[Exp[A]]) extends Def[ArrayBuffer[A]] {
49-
val mA = manifest[A]
50-
}
48+
case class ArrayBufferNew[A](xs: Seq[Exp[A]], mA: Manifest[A]) extends Def[ArrayBuffer[A]]
5149
case class ArrayBufferMkString[A:Manifest](l: Exp[ArrayBuffer[A]], sep: Exp[String]) extends Def[String]
5250
case class ArrayBufferAppend[A:Manifest](l: Exp[ArrayBuffer[A]], e: Exp[A]) extends Def[Unit]
5351
case class ArrayBufferClear[A:Manifest](l: Exp[ArrayBuffer[A]]) extends Def[Unit]
5452
case class ArrayBufferToArray[A:Manifest](x: Exp[ArrayBuffer[A]]) extends Def[Array[A]]
5553
case class ArrayBufferToSeq[A:Manifest](x: Exp[ArrayBuffer[A]]) extends Def[Seq[A]]
5654

57-
def arraybuffer_new[A:Manifest](xs: Seq[Exp[A]])(implicit pos: SourceContext) = reflectMutable(ArrayBufferNew(xs))
55+
def arraybuffer_new[A:Manifest](xs: Seq[Exp[A]])(implicit pos: SourceContext) = reflectMutable(ArrayBufferNew(xs, manifest[A]))
5856
def arraybuffer_mkstring[A:Manifest](l: Exp[ArrayBuffer[A]], sep: Exp[String])(implicit pos: SourceContext) = ArrayBufferMkString(l, sep)
5957
def arraybuffer_append[A:Manifest](l: Exp[ArrayBuffer[A]], e: Exp[A])(implicit pos: SourceContext) = reflectWrite(l)(ArrayBufferAppend(l, e))
6058
def arraybuffer_clear[A:Manifest](l: Exp[ArrayBuffer[A]]) = reflectWrite(l)(ArrayBufferClear(l))
@@ -89,7 +87,7 @@ trait ScalaGenArrayBufferOps extends BaseGenArrayBufferOps with ScalaGenEffect {
8987
import IR._
9088

9189
override def emitNode(sym: Sym[Any], rhs: Def[Any]) = rhs match {
92-
case a@ArrayBufferNew(xs) => emitValDef(sym, src"scala.collection.mutable.ArrayBuffer[${a.mA}](${(xs map {quote}).mkString(",")})")
90+
case ArrayBufferNew(xs, mA) => emitValDef(sym, src"scala.collection.mutable.ArrayBuffer[$mA](${xs.map(quote).mkString(",")})")
9391
case ArrayBufferMkString(l, sep) => emitValDef(sym, src"$l.mkString($sep)")
9492
case ArrayBufferAppend(l, e) => emitValDef(sym, src"$l += $e")
9593
case ArrayBufferClear(l) => emitValDef(sym, src"$l.clear()")

‎src/common/ArrayOps.scala

Lines changed: 22 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -50,12 +50,8 @@ trait ArrayOps extends Variables {
5050
}
5151

5252
trait ArrayOpsExp extends ArrayOps with EffectExp with VariablesExp {
53-
case class ArrayNew[T:Manifest](n: Exp[Int]) extends Def[Array[T]] {
54-
val m = manifest[T]
55-
}
56-
case class ArrayFromSeq[T:Manifest](xs: Seq[Exp[T]]) extends Def[Array[T]] {
57-
val m = manifest[T]
58-
}
53+
case class ArrayNew[T](n: Exp[Int], m: Manifest[T]) extends Def[Array[T]]
54+
case class ArrayFromSeq[T](xs: Seq[Exp[T]], m: Manifest[T]) extends Def[Array[T]]
5955
case class ArrayApply[T:Manifest](a: Exp[Array[T]], n: Exp[Int]) extends Def[T]
6056
case class ArrayUpdate[T:Manifest](a: Exp[Array[T]], n: Exp[Int], y: Exp[T]) extends Def[Unit]
6157
case class ArrayLength[T:Manifest](a: Exp[Array[T]]) extends Def[Int] {
@@ -74,8 +70,8 @@ trait ArrayOpsExp extends ArrayOps with EffectExp with VariablesExp {
7470
case class ArrayToSeq[A:Manifest](x: Exp[Array[A]]) extends Def[Seq[A]]
7571
case class ArraySlice[A:Manifest](a: Exp[Array[A]], s:Exp[Int], e:Exp[Int]) extends Def[Array[A]]
7672

77-
def array_obj_new[T:Manifest](n: Exp[Int]) = reflectMutable(ArrayNew(n))
78-
def array_obj_fromseq[T:Manifest](xs: Seq[Exp[T]]) = /*reflectMutable(*/ ArrayFromSeq(xs) /*)*/
73+
def array_obj_new[T:Manifest](n: Exp[Int]) = reflectMutable(ArrayNew(n, manifest[T]))
74+
def array_obj_fromseq[T:Manifest](xs: Seq[Exp[T]]) = /*reflectMutable(*/ ArrayFromSeq(xs, manifest[T]) /*)*/
7975
def array_apply[T:Manifest](x: Exp[Array[T]], n: Exp[Int])(implicit pos: SourceContext): Exp[T] = ArrayApply(x, n)
8076
def array_update[T:Manifest](x: Exp[Array[T]], n: Exp[Int], y: Exp[T])(implicit pos: SourceContext) = reflectWrite(x)(ArrayUpdate(x,n,y))
8177
def array_unsafe_update[T:Manifest](x: Rep[Array[T]], n: Rep[Int], y: Rep[T])(implicit pos: SourceContext) = ArrayUpdate(x,n,y)
@@ -104,7 +100,7 @@ trait ArrayOpsExp extends ArrayOps with EffectExp with VariablesExp {
104100
case ArrayLength(x) => array_length(f(x))
105101
case e@ArraySort(x) => array_sort(f(x))(e.m,pos)
106102
case e@ArrayCopy(a,ap,d,dp,l) => toAtom(ArrayCopy(f(a),f(ap),f(d),f(dp),f(l))(e.m))(mtype(manifest[A]),pos)
107-
case Reflect(e@ArrayNew(n), u, es) => reflectMirrored(Reflect(ArrayNew(f(n))(e.m), mapOver(f,u), f(es)))(mtype(manifest[A]), pos)
103+
case Reflect(ArrayNew(n, m), u, es) => reflectMirrored(Reflect(ArrayNew(f(n), m), mapOver(f,u), f(es)))(mtype(manifest[A]), pos)
108104
case Reflect(e@ArrayLength(x), u, es) => reflectMirrored(Reflect(ArrayLength(f(x))(e.m), mapOver(f,u), f(es)))(mtype(manifest[A]), pos)
109105
case Reflect(ArrayApply(l,r), u, es) => reflectMirrored(Reflect(ArrayApply(f(l),f(r))(mtype(manifest[A])), mapOver(f,u), f(es)))(mtype(manifest[A]), pos)
110106
case Reflect(e@ArraySort(x), u, es) => reflectMirrored(Reflect(ArraySort(f(x))(e.m), mapOver(f,u), f(es)))(mtype(manifest[A]), pos)
@@ -139,12 +135,12 @@ trait ArrayOpsExpOpt extends ArrayOpsExp {
139135
* @author Alen Stojanov ([email protected])
140136
*/
141137
override def array_length[T:Manifest](a: Exp[Array[T]])(implicit pos: SourceContext) : Rep[Int] = a match {
142-
case Def(ArrayNew(n: Exp[Int])) => n
143-
case Def(ArrayFromSeq(xs)) => Const(xs.size)
138+
case Def(ArrayNew(n, _)) => n
139+
case Def(ArrayFromSeq(xs, _)) => Const(xs.size)
144140
case Def(ArraySort(x)) => array_length(x)
145141
case Def(ArrayMap(x, _, _)) => array_length(x)
146-
case Def(Reflect(ArrayNew(n: Exp[Int]), _, _)) => n
147-
case Def(Reflect(ArrayFromSeq(xs), _, _)) => Const(xs.size)
142+
case Def(Reflect(ArrayNew(n, _), _, _)) => n
143+
case Def(Reflect(ArrayFromSeq(xs, _), _, _)) => Const(xs.size)
148144
case Def(Reflect(ArraySort(x), _, _)) => array_length(x)
149145
case Def(Reflect(ArrayMap(x, _, _), _, _)) => array_length(x)
150146
case _ => super.array_length(a)
@@ -158,7 +154,7 @@ trait ArrayOpsExpOpt extends ArrayOpsExp {
158154
//TODO: could use calculateDependencies?
159155

160156
val rhs = context.reverse.collectFirst {
161-
//case w @ Def(Reflect(ArrayNew(sz: Exp[T]), _, _)) if w == x => Some(Const(0)) // FIXME: bounds check!
157+
//case w @ Def(Reflect(ArrayNew(sz, _), _, _)) if w == x => Some(Const(0)) // FIXME: bounds check!
162158
case Def(Reflect(ArrayUpdate(`x`, `n`, rhs: Exp[T]), _, _)) => Some(rhs)
163159
case Def(Reflect(_, u, _)) if mayWrite(u, List(vs)) => None // not a simple assignment
164160
}
@@ -176,7 +172,7 @@ trait ArrayOpsExpOpt extends ArrayOpsExp {
176172
//TODO: could use calculateDependencies?
177173

178174
val rhs = context.reverse.collectFirst {
179-
//case w @ Def(Reflect(ArrayNew(sz: Exp[T]), _, _)) if w == x => Some(Const(())) // FIXME: bounds check!
175+
//case w @ Def(Reflect(ArrayNew(sz, _), _, _)) if w == x => Some(Const(())) // FIXME: bounds check!
180176
case Def(Reflect(ArrayUpdate(`x`, `n`, `y`), _, _)) => Some(Const(()))
181177
case Def(Reflect(_, u, _)) if mayWrite(u, List(vs)) => None // not a simple assignment
182178
}
@@ -204,8 +200,8 @@ trait ScalaGenArrayOps extends BaseGenArrayOps with ScalaGenBase {
204200
val ARRAY_LITERAL_MAX_SIZE = 1000
205201

206202
override def emitNode(sym: Sym[Any], rhs: Def[Any]) = rhs match {
207-
case a@ArrayNew(n) => emitValDef(sym, src"new Array[${remap(a.m)}]($n)")
208-
case e@ArrayFromSeq(xs) => {
203+
case ArrayNew(n, m) => emitValDef(sym, src"new Array[${remap(m)}]($n)")
204+
case ArrayFromSeq(xs, m) => {
209205
emitData(sym, xs)
210206
emitValDef(sym,
211207
if(xs.size > ARRAY_LITERAL_MAX_SIZE) {
@@ -217,10 +213,17 @@ trait ScalaGenArrayOps extends BaseGenArrayOps with ScalaGenBase {
217213
}
218214
val numBlocks = Math.ceil(xs.size / ARRAY_LITERAL_MAX_SIZE).intValue
219215
"{val buf=new Array[" + remap(e.mt) + "](" + xs.size + ")\n" + ((0 until numBlocks).map(append)).mkString("\n") + "buf}" */
220-
"{import scala.io.Source;(Source.fromFile(\"" + symDataPath(sym) + "\").getLines.map{Integer.parseInt(_)}).toArray}"
216+
val parsingMethod = m.asInstanceOf[Manifest[_]] match {
217+
case Manifest.Int => "Integer.parseInt"
218+
case Manifest.Long => "java.lang.Long.parseLong"
219+
case Manifest.Float => "java.lang.Float.parseFloat"
220+
case Manifest.Double => "java.lang.Double.parseDouble"
221+
case _ if m.runtimeClass == classOf[String] => "x => x"
222+
}
223+
s"""scala.io.Source.fromFile("${symDataPath(sym)}").getLines.map($parsingMethod).toArray}"""
221224
}
222225
else {
223-
"Array(" + (xs map quote).mkString(",") + ")"
226+
s"Array[${remap(m)}](" + (xs map quote).mkString(",") + ")"
224227
}
225228
)
226229
}

‎src/common/HashMapOps.scala

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -42,7 +42,7 @@ trait HashMapOpsExp extends HashMapOps with EffectExp {
4242
val mK = manifest[K]
4343
val mV = manifest[V]
4444
}
45-
case class HashMapNew[K:Manifest,V:Manifest]() extends HashMapDef[K,V,HashMap[K,V]]
45+
case class HashMapNew[K,V](override val mK: Manifest[K], override val mV: Manifest[V]) extends HashMapDef[K,V,HashMap[K,V]]()(mK, mV, Manifest.classType(classOf[HashMap[_, _]], mK, mV).asInstanceOf[Manifest[HashMap[K, V]]])
4646
case class HashMapApply[K:Manifest,V:Manifest](m: Exp[HashMap[K,V]], k: Exp[K]) extends HashMapDef[K,V,V]
4747
case class HashMapUpdate[K:Manifest,V:Manifest](m: Exp[HashMap[K,V]], k: Exp[K], v: Exp[V]) extends HashMapDef[K,V,Unit]
4848
case class HashMapContains[K:Manifest,V:Manifest](m: Exp[HashMap[K,V]], i: Exp[K]) extends HashMapDef[K,V,Boolean]
@@ -52,7 +52,7 @@ trait HashMapOpsExp extends HashMapOps with EffectExp {
5252
case class HashMapKeySet[K:Manifest,V:Manifest](m: Exp[HashMap[K,V]]) extends HashMapDef[K,V,Set[K]]
5353
case class HashMapKeys[K:Manifest,V:Manifest](m: Exp[HashMap[K,V]]) extends HashMapDef[K,V,Iterable[K]]
5454

55-
def hashmap_new[K:Manifest,V:Manifest]()(implicit pos: SourceContext) = reflectMutable(HashMapNew[K,V]())
55+
def hashmap_new[K:Manifest,V:Manifest]()(implicit pos: SourceContext) = reflectMutable(HashMapNew[K,V](manifest[K], manifest[V]))
5656
def hashmap_apply[K:Manifest,V:Manifest](m: Exp[HashMap[K,V]], k: Exp[K])(implicit pos: SourceContext) = HashMapApply(m,k)
5757
def hashmap_update[K:Manifest,V:Manifest](m: Exp[HashMap[K,V]], k: Exp[K], v: Exp[V])(implicit pos: SourceContext) = reflectWrite(m)(HashMapUpdate(m,k,v))
5858
def hashmap_unsafe_update[K:Manifest,V:Manifest](m: Exp[HashMap[K,V]], k: Exp[K], v: Exp[V])(implicit pos: SourceContext) = reflectEffect(HashMapUpdate(m,k,v))
@@ -75,7 +75,7 @@ trait HashMapOpsExp extends HashMapOps with EffectExp {
7575
case Reflect(e@HashMapValues(m), u, es) => reflectMirrored(Reflect(HashMapValues(f(m))(e.mK,e.mV), mapOver(f,u), f(es)))(mtype(manifest[A]), pos)
7676
case Reflect(e@HashMapContains(m,k), u, es) => reflectMirrored(Reflect(HashMapContains(f(m),f(k))(e.mK,e.mV), mapOver(f,u), f(es)))(mtype(manifest[A]), pos)
7777
case Reflect(e@HashMapSize(m), u, es) => reflectMirrored(Reflect(HashMapSize(f(m))(e.mK,e.mV), mapOver(f,u), f(es)))(mtype(manifest[A]), pos)
78-
case Reflect(e@HashMapNew(), u, es) => reflectMirrored(Reflect(HashMapNew()(e.mK,e.mV), mapOver(f,u), f(es)))(mtype(manifest[A]), pos)
78+
case Reflect(HashMapNew(mK, mV), u, es) => reflectMirrored(Reflect(HashMapNew(mK,mV), mapOver(f,u), f(es)))(mtype(manifest[A]), pos)
7979
case Reflect(e@HashMapUpdate(m,k,v), u, es) => reflectMirrored(Reflect(HashMapUpdate(f(m),f(k),f(v))(e.mK,e.mV), mapOver(f,u), f(es)))(mtype(manifest[A]), pos)
8080
case _ => super.mirror(e,f)
8181
}).asInstanceOf[Exp[A]] // why??
@@ -96,7 +96,7 @@ trait ScalaGenHashMapOps extends BaseGenHashMapOps with ScalaGenEffect {
9696
// TODO: have two versions for generating Scala/Java versions
9797

9898
override def emitNode(sym: Sym[Any], rhs: Def[Any]) = rhs match {
99-
case m@HashMapNew() => emitValDef(sym, "new java.util.HashMap[" + remap(m.mK) + "," + remap(m.mV) + "]()")
99+
case HashMapNew(mK, mV) => emitValDef(sym, "new java.util.HashMap[" + remap(mK) + "," + remap(mV) + "]()")
100100
case HashMapApply(m,k) => emitValDef(sym, quote(m) + ".get(" + quote(k) + ")")
101101
case HashMapUpdate(m,k,v) => emitValDef(sym, quote(m) + ".put(" + quote(k) + ", " + quote(v) + ")")
102102
case HashMapContains(m,i) => emitValDef(sym, quote(m) + ".containsKey(" + quote(i) + ")")

‎src/common/ImplicitOps.scala

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -15,14 +15,14 @@ trait ImplicitOps extends Base {
1515
}
1616

1717
trait ImplicitOpsExp extends ImplicitOps with BaseExp {
18-
case class ImplicitConvert[X,Y](x: Exp[X])(implicit val mX: Manifest[X], val mY: Manifest[Y]) extends Def[Y]
18+
case class ImplicitConvert[X,Y](x: Exp[X], mY: Manifest[Y])(implicit val mX: Manifest[X]) extends Def[Y]
1919

2020
def implicit_convert[X,Y](x: Exp[X])(implicit c: X => Y, mX: Manifest[X], mY: Manifest[Y], pos: SourceContext) : Rep[Y] = {
21-
if (mX == mY) x.asInstanceOf[Rep[Y]] else ImplicitConvert[X,Y](x)
21+
if (mX == mY) x.asInstanceOf[Rep[Y]] else ImplicitConvert[X,Y](x, mY)
2222
}
2323

2424
override def mirror[A:Manifest](e: Def[A], f: Transformer)(implicit pos: SourceContext): Exp[A] = (e match {
25-
case im@ImplicitConvert(x) => toAtom(ImplicitConvert(f(x))(im.mX,im.mY))(mtype(manifest[A]),pos)
25+
case im@ImplicitConvert(x, mY) => toAtom(ImplicitConvert(f(x), mY)(im.mX))(mtype(manifest[A]),pos)
2626
case _ => super.mirror(e,f)
2727
}).asInstanceOf[Exp[A]]
2828

@@ -35,7 +35,7 @@ trait ScalaGenImplicitOps extends ScalaGenBase {
3535
override def emitNode(sym: Sym[Any], rhs: Def[Any]) = rhs match {
3636
// TODO: this valDef is redundant; we really just want the conversion to be a no-op in the generated code.
3737
// TODO: but we still need to link the defs together
38-
case ImplicitConvert(x) => emitValDef(sym, quote(x))
38+
case ImplicitConvert(x, _) => emitValDef(sym, quote(x))
3939
case _ => super.emitNode(sym, rhs)
4040
}
4141
}
@@ -46,8 +46,8 @@ trait CLikeGenImplicitOps extends CLikeGenBase {
4646

4747
override def emitNode(sym: Sym[Any], rhs: Def[Any]) = {
4848
rhs match {
49-
case im@ImplicitConvert(x) =>
50-
gen"${im.mY} $sym = (${im.mY})$x;"
49+
case ImplicitConvert(x, mY) =>
50+
gen"$mY $sym = ($mY)$x;"
5151
case _ => super.emitNode(sym, rhs)
5252
}
5353
}

‎src/common/ListOps.scala

Lines changed: 8 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -50,13 +50,12 @@ trait ListOps extends Variables {
5050
}
5151

5252
trait ListOpsExp extends ListOps with EffectExp with VariablesExp {
53-
case class ListNew[A:Manifest](xs: Seq[Rep[A]]) extends Def[List[A]]
53+
case class ListNew[A](xs: Seq[Rep[A]], m: Manifest[A]) extends Def[List[A]]
5454
case class ListFromSeq[A:Manifest](xs: Rep[Seq[A]]) extends Def[List[A]]
5555
case class ListMap[A:Manifest,B:Manifest](l: Exp[List[A]], x: Sym[A], block: Block[B]) extends Def[List[B]]
5656
case class ListFlatMap[A:Manifest, B:Manifest](l: Exp[List[A]], x: Sym[A], block: Block[List[B]]) extends Def[List[B]]
5757
case class ListFilter[A : Manifest](l: Exp[List[A]], x: Sym[A], block: Block[Boolean]) extends Def[List[A]]
5858
case class ListSortBy[A:Manifest,B:Manifest:Ordering](l: Exp[List[A]], x: Sym[A], block: Block[B]) extends Def[List[A]]
59-
case class ListPrepend[A:Manifest](x: Exp[List[A]], e: Exp[A]) extends Def[List[A]]
6059
case class ListToArray[A:Manifest](x: Exp[List[A]]) extends Def[Array[A]]
6160
case class ListToSeq[A:Manifest](x: Exp[List[A]]) extends Def[Seq[A]]
6261
case class ListConcat[A:Manifest](xs: Rep[List[A]], ys: Rep[List[A]]) extends Def[List[A]]
@@ -67,7 +66,7 @@ trait ListOpsExp extends ListOps with EffectExp with VariablesExp {
6766
case class ListTail[A:Manifest](xs: Rep[List[A]]) extends Def[List[A]]
6867
case class ListIsEmpty[A:Manifest](xs: Rep[List[A]]) extends Def[Boolean]
6968

70-
def list_new[A:Manifest](xs: Seq[Rep[A]])(implicit pos: SourceContext) = ListNew(xs)
69+
def list_new[A:Manifest](xs: Seq[Rep[A]])(implicit pos: SourceContext) = ListNew(xs, manifest[A])
7170
def list_fromseq[A:Manifest](xs: Rep[Seq[A]])(implicit pos: SourceContext) = ListFromSeq(xs)
7271
def list_map[A:Manifest,B:Manifest](l: Exp[List[A]], f: Exp[A] => Exp[B])(implicit pos: SourceContext) = {
7372
val a = fresh[A]
@@ -91,7 +90,7 @@ trait ListOpsExp extends ListOps with EffectExp with VariablesExp {
9190
}
9291
def list_toarray[A:Manifest](l: Exp[List[A]])(implicit pos: SourceContext) = ListToArray(l)
9392
def list_toseq[A:Manifest](l: Exp[List[A]])(implicit pos: SourceContext) = ListToSeq(l)
94-
def list_prepend[A:Manifest](l: Exp[List[A]], e: Exp[A])(implicit pos: SourceContext) = ListPrepend(l,e)
93+
def list_prepend[A:Manifest](l: Exp[List[A]], e: Exp[A])(implicit pos: SourceContext) = list_cons(e,l)
9594
def list_concat[A:Manifest](xs: Rep[List[A]], ys: Rep[List[A]])(implicit pos: SourceContext) = ListConcat(xs,ys)
9695
def list_cons[A:Manifest](x: Rep[A], xs: Rep[List[A]])(implicit pos: SourceContext) = ListCons(x,xs)
9796
def list_mkString[A:Manifest](l: Exp[List[A]])(implicit pos: SourceContext) = ListMkString(l)
@@ -102,7 +101,7 @@ trait ListOpsExp extends ListOps with EffectExp with VariablesExp {
102101

103102
override def mirror[A:Manifest](e: Def[A], f: Transformer)(implicit pos: SourceContext): Exp[A] = {
104103
(e match {
105-
case ListNew(xs) => list_new(f(xs))
104+
case ListNew(xs, m) => list_new(f(xs))(m, pos)
106105
case _ => super.mirror(e,f)
107106
}).asInstanceOf[Exp[A]] // why??
108107
}
@@ -134,9 +133,9 @@ trait ListOpsExp extends ListOps with EffectExp with VariablesExp {
134133

135134
trait ListOpsExpOpt extends ListOpsExp {
136135
override def list_concat[A : Manifest](xs1: Exp[List[A]], xs2: Exp[List[A]])(implicit pos: SourceContext): Exp[List[A]] = (xs1, xs2) match {
137-
case (Def(ListNew(xs1)), Def(ListNew(xs2))) => ListNew(xs1 ++ xs2)
138-
case (Def(ListNew(Seq())), xs2) => xs2
139-
case (xs1, Def(ListNew(Seq()))) => xs1
136+
case (Def(ListNew(xs1, _)), Def(ListNew(xs2, _))) => list_new(xs1 ++ xs2)
137+
case (Def(ListNew(Seq(), _)), xs2) => xs2
138+
case (xs1, Def(ListNew(Seq(), _))) => xs1
140139
case _ => super.list_concat(xs1, xs2)
141140
}
142141
}
@@ -152,7 +151,7 @@ trait ScalaGenListOps extends BaseGenListOps with ScalaGenEffect {
152151
import IR._
153152

154153
override def emitNode(sym: Sym[Any], rhs: Def[Any]) = rhs match {
155-
case ListNew(xs) => emitValDef(sym, src"List(${(xs map {quote}).mkString(",")})")
154+
case ListNew(xs, _) => emitValDef(sym, src"List(${xs.map(quote).mkString(",")})")
156155
case ListConcat(xs,ys) => emitValDef(sym, src"$xs ::: $ys")
157156
case ListCons(x, xs) => emitValDef(sym, src"$x :: $xs")
158157
case ListHead(xs) => emitValDef(sym, src"$xs.head")
@@ -181,7 +180,6 @@ trait ScalaGenListOps extends BaseGenListOps with ScalaGenEffect {
181180
|${nestedBlock(blk)}
182181
|$blk
183182
|}"""
184-
case ListPrepend(l,e) => emitValDef(sym, src"$e :: $l")
185183
case ListToArray(l) => emitValDef(sym, src"$l.toArray")
186184
case ListToSeq(l) => emitValDef(sym, src"$l.toSeq")
187185
case _ => super.emitNode(sym, rhs)

0 commit comments

Comments
 (0)