Skip to content

Commit 554e4ad

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 554e4ad

File tree

11 files changed

+141
-147
lines changed

11 files changed

+141
-147
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: 8 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -50,9 +50,7 @@ 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-
}
53+
case class ArrayNew[T](n: Exp[Int], m: Manifest[T]) extends Def[Array[T]]
5654
case class ArrayFromSeq[T:Manifest](xs: Seq[Exp[T]]) extends Def[Array[T]] {
5755
val m = manifest[T]
5856
}
@@ -74,7 +72,7 @@ trait ArrayOpsExp extends ArrayOps with EffectExp with VariablesExp {
7472
case class ArrayToSeq[A:Manifest](x: Exp[Array[A]]) extends Def[Seq[A]]
7573
case class ArraySlice[A:Manifest](a: Exp[Array[A]], s:Exp[Int], e:Exp[Int]) extends Def[Array[A]]
7674

77-
def array_obj_new[T:Manifest](n: Exp[Int]) = reflectMutable(ArrayNew(n))
75+
def array_obj_new[T:Manifest](n: Exp[Int]) = reflectMutable(ArrayNew(n, manifest[T]))
7876
def array_obj_fromseq[T:Manifest](xs: Seq[Exp[T]]) = /*reflectMutable(*/ ArrayFromSeq(xs) /*)*/
7977
def array_apply[T:Manifest](x: Exp[Array[T]], n: Exp[Int])(implicit pos: SourceContext): Exp[T] = ArrayApply(x, n)
8078
def array_update[T:Manifest](x: Exp[Array[T]], n: Exp[Int], y: Exp[T])(implicit pos: SourceContext) = reflectWrite(x)(ArrayUpdate(x,n,y))
@@ -104,7 +102,7 @@ trait ArrayOpsExp extends ArrayOps with EffectExp with VariablesExp {
104102
case ArrayLength(x) => array_length(f(x))
105103
case e@ArraySort(x) => array_sort(f(x))(e.m,pos)
106104
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)
105+
case Reflect(ArrayNew(n, m), u, es) => reflectMirrored(Reflect(ArrayNew(f(n), m), mapOver(f,u), f(es)))(mtype(manifest[A]), pos)
108106
case Reflect(e@ArrayLength(x), u, es) => reflectMirrored(Reflect(ArrayLength(f(x))(e.m), mapOver(f,u), f(es)))(mtype(manifest[A]), pos)
109107
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)
110108
case Reflect(e@ArraySort(x), u, es) => reflectMirrored(Reflect(ArraySort(f(x))(e.m), mapOver(f,u), f(es)))(mtype(manifest[A]), pos)
@@ -139,11 +137,11 @@ trait ArrayOpsExpOpt extends ArrayOpsExp {
139137
* @author Alen Stojanov ([email protected])
140138
*/
141139
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
140+
case Def(ArrayNew(n, _)) => n
143141
case Def(ArrayFromSeq(xs)) => Const(xs.size)
144142
case Def(ArraySort(x)) => array_length(x)
145143
case Def(ArrayMap(x, _, _)) => array_length(x)
146-
case Def(Reflect(ArrayNew(n: Exp[Int]), _, _)) => n
144+
case Def(Reflect(ArrayNew(n, _), _, _)) => n
147145
case Def(Reflect(ArrayFromSeq(xs), _, _)) => Const(xs.size)
148146
case Def(Reflect(ArraySort(x), _, _)) => array_length(x)
149147
case Def(Reflect(ArrayMap(x, _, _), _, _)) => array_length(x)
@@ -158,7 +156,7 @@ trait ArrayOpsExpOpt extends ArrayOpsExp {
158156
//TODO: could use calculateDependencies?
159157

160158
val rhs = context.reverse.collectFirst {
161-
//case w @ Def(Reflect(ArrayNew(sz: Exp[T]), _, _)) if w == x => Some(Const(0)) // FIXME: bounds check!
159+
//case w @ Def(Reflect(ArrayNew(sz, _), _, _)) if w == x => Some(Const(0)) // FIXME: bounds check!
162160
case Def(Reflect(ArrayUpdate(`x`, `n`, rhs: Exp[T]), _, _)) => Some(rhs)
163161
case Def(Reflect(_, u, _)) if mayWrite(u, List(vs)) => None // not a simple assignment
164162
}
@@ -176,7 +174,7 @@ trait ArrayOpsExpOpt extends ArrayOpsExp {
176174
//TODO: could use calculateDependencies?
177175

178176
val rhs = context.reverse.collectFirst {
179-
//case w @ Def(Reflect(ArrayNew(sz: Exp[T]), _, _)) if w == x => Some(Const(())) // FIXME: bounds check!
177+
//case w @ Def(Reflect(ArrayNew(sz, _), _, _)) if w == x => Some(Const(())) // FIXME: bounds check!
180178
case Def(Reflect(ArrayUpdate(`x`, `n`, `y`), _, _)) => Some(Const(()))
181179
case Def(Reflect(_, u, _)) if mayWrite(u, List(vs)) => None // not a simple assignment
182180
}
@@ -204,7 +202,7 @@ trait ScalaGenArrayOps extends BaseGenArrayOps with ScalaGenBase {
204202
val ARRAY_LITERAL_MAX_SIZE = 1000
205203

206204
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)")
205+
case ArrayNew(n, m) => emitValDef(sym, src"new Array[${remap(m)}]($n)")
208206
case e@ArrayFromSeq(xs) => {
209207
emitData(sym, xs)
210208
emitValDef(sym,

‎src/common/ListOps.scala

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -50,7 +50,7 @@ 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]]
@@ -67,7 +67,7 @@ trait ListOpsExp extends ListOps with EffectExp with VariablesExp {
6767
case class ListTail[A:Manifest](xs: Rep[List[A]]) extends Def[List[A]]
6868
case class ListIsEmpty[A:Manifest](xs: Rep[List[A]]) extends Def[Boolean]
6969

70-
def list_new[A:Manifest](xs: Seq[Rep[A]])(implicit pos: SourceContext) = ListNew(xs)
70+
def list_new[A:Manifest](xs: Seq[Rep[A]])(implicit pos: SourceContext) = ListNew(xs, manifest[A])
7171
def list_fromseq[A:Manifest](xs: Rep[Seq[A]])(implicit pos: SourceContext) = ListFromSeq(xs)
7272
def list_map[A:Manifest,B:Manifest](l: Exp[List[A]], f: Exp[A] => Exp[B])(implicit pos: SourceContext) = {
7373
val a = fresh[A]
@@ -102,7 +102,7 @@ trait ListOpsExp extends ListOps with EffectExp with VariablesExp {
102102

103103
override def mirror[A:Manifest](e: Def[A], f: Transformer)(implicit pos: SourceContext): Exp[A] = {
104104
(e match {
105-
case ListNew(xs) => list_new(f(xs))
105+
case ListNew(xs, m) => list_new(f(xs))(m, pos)
106106
case _ => super.mirror(e,f)
107107
}).asInstanceOf[Exp[A]] // why??
108108
}
@@ -134,9 +134,9 @@ trait ListOpsExp extends ListOps with EffectExp with VariablesExp {
134134

135135
trait ListOpsExpOpt extends ListOpsExp {
136136
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
137+
case (Def(ListNew(xs1, _)), Def(ListNew(xs2, _))) => list_new(xs1 ++ xs2)
138+
case (Def(ListNew(Seq(), _)), xs2) => xs2
139+
case (xs1, Def(ListNew(Seq(), _))) => xs1
140140
case _ => super.list_concat(xs1, xs2)
141141
}
142142
}
@@ -152,7 +152,7 @@ trait ScalaGenListOps extends BaseGenListOps with ScalaGenEffect {
152152
import IR._
153153

154154
override def emitNode(sym: Sym[Any], rhs: Def[Any]) = rhs match {
155-
case ListNew(xs) => emitValDef(sym, src"List(${(xs map {quote}).mkString(",")})")
155+
case ListNew(xs, _) => emitValDef(sym, src"List(${xs.map(quote).mkString(",")})")
156156
case ListConcat(xs,ys) => emitValDef(sym, src"$xs ::: $ys")
157157
case ListCons(x, xs) => emitValDef(sym, src"$x :: $xs")
158158
case ListHead(xs) => emitValDef(sym, src"$xs.head")

‎src/common/SeqOps.scala

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -26,27 +26,27 @@ trait SeqOps extends Variables {
2626
}
2727

2828
trait SeqOpsExp extends SeqOps with EffectExp {
29-
case class SeqNew[A:Manifest](xs: List[Rep[A]]) extends Def[Seq[A]]
29+
case class SeqNew[A](xs: Seq[Rep[A]], m: Manifest[A]) extends Def[Seq[A]]
3030
case class SeqLength[T:Manifest](a: Exp[Seq[T]]) extends Def[Int]
3131
case class SeqApply[T:Manifest](x: Exp[Seq[T]], n: Exp[Int]) extends Def[T]
3232

33-
def seq_new[A:Manifest](xs: Seq[Rep[A]])(implicit pos: SourceContext) = SeqNew(xs.toList)
33+
def seq_new[A:Manifest](xs: Seq[Rep[A]])(implicit pos: SourceContext) = SeqNew(xs, manifest[A])
3434
def seq_apply[T:Manifest](x: Exp[Seq[T]], n: Exp[Int])(implicit pos: SourceContext): Exp[T] = SeqApply(x, n)
3535
def seq_length[T:Manifest](a: Exp[Seq[T]])(implicit pos: SourceContext): Exp[Int] = SeqLength(a)
3636

3737
override def mirror[A:Manifest](e: Def[A], f: Transformer)(implicit pos: SourceContext): Exp[A] = (e match {
38-
case SeqNew(xs) => seq_new(f(xs))
38+
case SeqNew(xs, m) => seq_new(f(xs))(m, pos)
3939
case _ => super.mirror(e,f)
4040
}).asInstanceOf[Exp[A]]
4141

4242
// TODO: need override? (missing data dependency in delite kernel without it...)
4343
override def syms(e: Any): List[Sym[Any]] = e match {
44-
case SeqNew(xs) => (xs flatMap { syms }).toList
44+
case SeqNew(xs, _) => (xs flatMap { syms }).toList
4545
case _ => super.syms(e)
4646
}
4747

4848
override def symsFreq(e: Any): List[(Sym[Any], Double)] = e match {
49-
case SeqNew(xs) => (xs flatMap { freqNormal }).toList
49+
case SeqNew(xs, _) => (xs flatMap { freqNormal }).toList
5050
case _ => super.symsFreq(e)
5151
}
5252
}
@@ -62,7 +62,7 @@ trait ScalaGenSeqOps extends BaseGenSeqOps with ScalaGenEffect {
6262
import IR._
6363

6464
override def emitNode(sym: Sym[Any], rhs: Def[Any]) = rhs match {
65-
case SeqNew(xs) => emitValDef(sym, src"Seq($xs)")
65+
case SeqNew(xs, _) => emitValDef(sym, src"Seq($xs)")
6666
case SeqLength(x) => emitValDef(sym, src"$x.length")
6767
case SeqApply(x,n) => emitValDef(sym, src"$x($n)")
6868
case _ => super.emitNode(sym, rhs)

‎src/common/SetOps.scala

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -34,7 +34,7 @@ trait SetOps extends Base {
3434
}
3535

3636
trait SetOpsExp extends SetOps with ArrayOps with EffectExp {
37-
case class SetNew[A:Manifest](xs: Seq[Exp[A]], mA: Manifest[A]) extends Def[Set[A]]
37+
case class SetNew[A](xs: Seq[Exp[A]], mA: Manifest[A]) extends Def[Set[A]]
3838
case class SetContains[A:Manifest](s: Exp[Set[A]], i: Exp[A]) extends Def[Boolean]
3939
case class SetAdd[A:Manifest](s: Exp[Set[A]], i: Exp[A]) extends Def[Unit]
4040
case class SetRemove[A:Manifest](s: Exp[Set[A]], i: Exp[A]) extends Def[Unit]
@@ -67,7 +67,7 @@ trait ScalaGenSetOps extends BaseGenSetOps with ScalaGenEffect {
6767
import IR._
6868

6969
override def emitNode(sym: Sym[Any], rhs: Def[Any]) = rhs match {
70-
case SetNew(xs, mA) => emitValDef(sym, src"collection.mutable.HashSet[$mA](" + (xs map {quote}).mkString(",") + ")")
70+
case SetNew(xs, mA) => emitValDef(sym, src"collection.mutable.HashSet[$mA](" + xs.map(quote).mkString(",") + ")")
7171
case SetContains(s,i) => emitValDef(sym, src"$s.contains($i)")
7272
case SetAdd(s,i) => emitValDef(sym, src"$s.add($i)")
7373
case SetRemove(s,i) => emitValDef(sym, src"$s.remove($i)")

‎src/common/SynchronizedArrayBufferOps.scala

Lines changed: 4 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -17,13 +17,11 @@ trait SynchronizedArrayBufferOps extends ArrayBufferOps {
1717
}
1818

1919
trait SynchronizedArrayBufferOpsExp extends SynchronizedArrayBufferOps with ArrayBufferOpsExp {
20-
case class SyncArrayBufferNew[A:Manifest](xs: Seq[Exp[A]]) extends Def[ArrayBuffer[A]] {
21-
val mA = manifest[A]
22-
}
20+
case class SyncArrayBufferNew[A:Manifest](xs: Seq[Exp[A]], mA: Manifest[A]) extends Def[ArrayBuffer[A]]
2321

24-
// all array buffers are synchronized (nackward compat). TODO: separate constructor
22+
// all array buffers are synchronized (backward compat). TODO: separate constructor
2523

26-
override def arraybuffer_new[A:Manifest](xs: Seq[Exp[A]])(implicit pos: SourceContext) = reflectMutable(SyncArrayBufferNew(xs))
24+
override def arraybuffer_new[A:Manifest](xs: Seq[Exp[A]])(implicit pos: SourceContext) = reflectMutable(SyncArrayBufferNew(xs, manifest[A]))
2725
}
2826

2927
trait BaseGenSynchronizedArrayBufferOps extends BaseGenArrayBufferOps {
@@ -36,7 +34,7 @@ trait ScalaGenSynchronizedArrayBufferOps extends BaseGenSynchronizedArrayBufferO
3634
import IR._
3735

3836
override def emitNode(sym: Sym[Any], rhs: Def[Any]) = rhs match {
39-
case a@SyncArrayBufferNew(xs) => emitValDef(sym, src"(new scala.collection.mutable.ArrayBuffer[${a.mA}] with scala.collection.mutable.SynchronizedBuffer[${a.mA}]) ++= List(${(xs map {quote}).mkString(",")})")
37+
case SyncArrayBufferNew(xs, mA) => emitValDef(sym, src"(new scala.collection.mutable.ArrayBuffer[$mA] with scala.collection.mutable.SynchronizedBuffer[$mA]) ++= List(${xs.map(quote).mkString(",")})")
4038
case _ => super.emitNode(sym, rhs)
4139
}
4240
}

‎test-out/epfl/test14-queries2.check

Lines changed: 28 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -6,39 +6,39 @@ nVars=2000
66
import scala.lms.epfl.test14.Schema
77
class staged$0 extends ((Unit)=>(Unit)) {
88
def apply(x0:Unit): Unit = {
9-
val x2550 = println("rangeFromNames(\"Edna\",\"Bert\"):")
10-
val x617 = Schema.db.people.flatMap { x111 =>
11-
val x616 = Schema.db.people.flatMap { x435 =>
12-
val x615 = Schema.db.people.flatMap { x598 =>
13-
val x112 = x111.name
14-
val x113 = x112 == "Edna"
15-
val x438 = x435.name
16-
val x439 = x438 == "Bert"
17-
val x116 = x111.age
18-
val x602 = x598.age
19-
val x603 = x116 <= x602
20-
val x441 = x435.age
21-
val x604 = x602 < x441
22-
val x605 = x603 && x604
23-
val x611 = x439 && x605
24-
val x613 = x113 && x611
25-
val x614 = if (x613) {
26-
val x607 = x598.name
27-
val x608 = new Schema.Record { val name = x607 }
28-
val x609 = List(x608)
29-
x609
9+
val x2673 = println("rangeFromNames(\"Edna\",\"Bert\"):")
10+
val x723 = Schema.db.people.flatMap { x112 =>
11+
val x722 = Schema.db.people.flatMap { x489 =>
12+
val x721 = Schema.db.people.flatMap { x697 =>
13+
val x113 = x112.name
14+
val x114 = x113 == "Edna"
15+
val x492 = x489.name
16+
val x493 = x492 == "Bert"
17+
val x117 = x112.age
18+
val x701 = x697.age
19+
val x702 = x117 <= x701
20+
val x496 = x489.age
21+
val x703 = x701 < x496
22+
val x704 = x702 && x703
23+
val x715 = x493 && x704
24+
val x719 = x114 && x715
25+
val x720 = if (x719) {
26+
val x707 = x697.name
27+
val x708 = new Schema.Record { val name = x707 }
28+
val x713 = List(x708)
29+
x713
3030
} else {
31-
val x19 = List()
32-
x19
31+
val x228 = List()
32+
x228
3333
}
34-
x614
34+
x720
3535
}
36-
x615
36+
x721
3737
}
38-
x616
38+
x722
3939
}
40-
val x2551 = println(x617)
41-
x2551
40+
val x2674 = println(x723)
41+
x2674
4242
}
4343
}
4444
/*****************************************

‎test-out/epfl/test14-queries3.check

Lines changed: 40 additions & 40 deletions
Original file line numberDiff line numberDiff line change
@@ -6,55 +6,55 @@ nVars=2000
66
import scala.lms.epfl.test14.Schema
77
class staged$0 extends ((Unit)=>(Unit)) {
88
def apply(x0:Unit): Unit = {
9-
val x2550 = println("expertise(\"abstract\"):")
10-
val x800 = Schema.org.departments.flatMap { x732 =>
11-
val x792 = Schema.org.employees.flatMap { x763 =>
12-
val x734 = x732.dpt
13-
val x764 = x763.dpt
14-
val x765 = x734 == x764
15-
val x785 = Schema.org.tasks.flatMap { x776 =>
16-
val x767 = x763.emp
17-
val x777 = x776.emp
18-
val x778 = x767 == x777
19-
val x779 = x776.tsk
20-
val x780 = x779 == "abstract"
21-
val x781 = x778 && x780
22-
val x784 = if (x781) {
23-
val x661 = new Schema.Record { val ignore = () }
24-
val x688 = List(x661)
25-
x688
9+
val x2673 = println("expertise(\"abstract\"):")
10+
val x906 = Schema.org.departments.flatMap { x838 =>
11+
val x898 = Schema.org.employees.flatMap { x869 =>
12+
val x840 = x838.dpt
13+
val x870 = x869.dpt
14+
val x871 = x840 == x870
15+
val x891 = Schema.org.tasks.flatMap { x882 =>
16+
val x873 = x869.emp
17+
val x883 = x882.emp
18+
val x884 = x873 == x883
19+
val x885 = x882.tsk
20+
val x886 = x885 == "abstract"
21+
val x887 = x884 && x886
22+
val x890 = if (x887) {
23+
val x767 = new Schema.Record { val ignore = () }
24+
val x794 = List(x767)
25+
x794
2626
} else {
27-
val x19 = List()
28-
x19
27+
val x34 = List()
28+
x34
2929
}
30-
x784
30+
x890
3131
}
32-
val x786 = x785.isEmpty
33-
val x788 = x765 && x786
34-
val x791 = if (x788) {
35-
val x661 = new Schema.Record { val ignore = () }
36-
val x688 = List(x661)
37-
x688
32+
val x892 = x891.isEmpty
33+
val x894 = x871 && x892
34+
val x897 = if (x894) {
35+
val x767 = new Schema.Record { val ignore = () }
36+
val x794 = List(x767)
37+
x794
3838
} else {
39-
val x19 = List()
40-
x19
39+
val x34 = List()
40+
x34
4141
}
42-
x791
42+
x897
4343
}
44-
val x793 = x792.isEmpty
45-
val x799 = if (x793) {
46-
val x734 = x732.dpt
47-
val x797 = new Schema.Record { val dpt = x734 }
48-
val x798 = List(x797)
49-
x798
44+
val x899 = x898.isEmpty
45+
val x905 = if (x899) {
46+
val x840 = x838.dpt
47+
val x903 = new Schema.Record { val dpt = x840 }
48+
val x904 = List(x903)
49+
x904
5050
} else {
51-
val x19 = List()
52-
x19
51+
val x34 = List()
52+
x34
5353
}
54-
x799
54+
x905
5555
}
56-
val x2551 = println(x800)
57-
x2551
56+
val x2674 = println(x906)
57+
x2674
5858
}
5959
}
6060
/*****************************************

0 commit comments

Comments
 (0)