nit: added spaces between cases

ochafik · ochafik · commit f564d493d3d4 · 2014-12-24T18:32:58.000+01:00
diff --git a/src/main/scala/scalacl/impl/OpenCLCodeFlattening.scala b/src/main/scala/scalacl/impl/OpenCLCodeFlattening.scala
@@ -92,8 +92,12 @@ trait OpenCLCodeFlattening
       override def traverse(tree: Tree): Unit = {
         if (tree.symbol != null && tree.symbol != NoSymbol)
           tree match {
-            case dt: DefTree => defTrees += dt
-            case rt: RefTree => refTrees += rt
+            case dt: DefTree =>
+              defTrees += dt
+
+            case rt: RefTree =>
+              refTrees += rt
+
             case _ =>
           }
         super.traverse(tree)
@@ -103,11 +107,23 @@ trait OpenCLCodeFlattening
   }
   def renameDefinedSymbolsUniquely(tree: Tree) = {
     val (defTrees, refTrees) = getDefAndRefTrees(tree)
-    val definedSymbols = defTrees.collect { case d if d.name != null => d.symbol -> d.name }.toMap
-    val usedIdentSymbols = refTrees.collect { case ident @ Ident(name) => ident.symbol -> name }.toMap
 
-    val outerSymbols = usedIdentSymbols.keys.toSet.diff(definedSymbols.keys.toSet)
-    val nameCollisions = (definedSymbols ++ usedIdentSymbols).groupBy(_._2).filter(_._2.size > 1)
+    val definedSymbols = defTrees.collect {
+      case d if d.name != null =>
+        d.symbol -> d.name
+    }.toMap
+
+    val usedIdentSymbols = refTrees.collect {
+      case ident @ Ident(name) =>
+        ident.symbol -> name
+    }.toMap
+
+    val outerSymbols =
+      usedIdentSymbols.keys.toSet.diff(definedSymbols.keys.toSet)
+
+    val nameCollisions =
+      (definedSymbols ++ usedIdentSymbols).groupBy(_._2).filter(_._2.size > 1)
+
     val renamings = (nameCollisions.flatMap(_._2) map {
       case (sym, name) => //if !internal.isFreeTerm(sym) =>
         val newName: Name = N(fresh(name.toString))
@@ -136,10 +152,13 @@ trait OpenCLCodeFlattening
             tree match {
               case ValDef(mods, name, tpt, rhs) =>
                 check(treeCopy.ValDef(tree, mods, newName, super.transform(tpt), super.transform(rhs)))
+
               case DefDef(mods, name, tparams, vparams, tpt, rhs) =>
                 check(treeCopy.DefDef(tree, mods, newName, tparams, vparams, super.transform(tpt), super.transform(rhs)))
+
               case Ident(name) =>
                 check(treeCopy.Ident(tree, newName))
+
               case _ =>
                 super.transform(tree)
             }
@@ -183,6 +202,7 @@ trait OpenCLCodeFlattening
     def unapply(tree: Tree): Option[(Tree, String)] = tree match {
       case Select(expr, n) =>
         namesToTypes.get(n.toString).map(expr -> _)
+
       case _ =>
         None
     }
@@ -195,6 +215,7 @@ trait OpenCLCodeFlattening
       components.size match {
         case 2 | 4 | 8 | 16 =>
           components.distinct.size == 1
+
         case _ =>
           false
       }
@@ -213,6 +234,7 @@ trait OpenCLCodeFlattening
             // special case for non-double math :
             // exp(20: Float).toFloat
             (Seq(), value)
+
           case ScalaMathFunction(_, _, _) => //Apply(f @ Select(left, name), args) if left.toString == "scala.math.package" =>
             // TODO this is not fair : ScalaMathFunction should have worked here !!!
             (Seq(), value)
@@ -225,11 +247,14 @@ trait OpenCLCodeFlattening
               false
         } =>
           (Seq(), value)*/
+
           case Ident(_) | Select(_, _) | ValDef(_, _, _, _) | Literal(_) | NumberConversion(_, _) | Typed(_, _) | Apply(_, List(_)) =>
             // already side-effect-free (?)
             (Seq(), value)
+
           case _ if isUnitOrNoType(getType(value)) =>
             (Seq(), value)
+
           case _ =>
             assert(getType(value) != NoType, value + ": " + value.getClass.getName) // + " = " + nodeToString(value) + ")")
             // val tempVar = q"var tmp: ${value.tpe} = $value" // TODO fresh
@@ -277,6 +302,7 @@ trait OpenCLCodeFlattening
     def replaceValues(tree: Tree): Seq[Tree] = tree match {
       case ValDef(_, _, _, _) =>
         Seq(tree)
+
       case _ =>
         try {
           getTreeSlice(tree, recursive = true) match {
@@ -290,6 +316,7 @@ trait OpenCLCodeFlattening
                   //   id: ${identGen()}
                   // """)
                   Seq(identGen())
+
                 case None =>
                   val subs = for (i <- 0 until slice.sliceLength) yield {
                     Ident(fiberVariableName(slice.baseSymbol.name, List(i))
@@ -304,6 +331,7 @@ trait OpenCLCodeFlattening
                   // """)
                   subs
               }
+
             case _ =>
               Seq(tree)
           }
@@ -329,22 +357,27 @@ trait OpenCLCodeFlattening
             sub.flatMap(_.statements),
             sub.flatMap(_.values)
           )
+
         case TupleComponent(target, i) => //if getTreeSlice(target).collect(sliceReplacements) != None =>
           getTreeSlice(target, recursive = true) match {
             case Some(slice) =>
               sliceReplacements.get(slice) match {
                 case Some(rep) =>
                   FlatCode[Tree](Seq(), Seq(), Seq(rep()))
+
                 case None =>
                   FlatCode[Tree](Seq(), Seq(), Seq(tree))
               }
+
             case _ =>
               FlatCode[Tree](Seq(), Seq(), Seq(tree))
           }
+
         case Ident(name: TermName) =>
           val tpe = normalize(tree.tpe) match {
             case typeRef @ TypeRef(_, _, List(elementType)) if typeRef <:< typeOf[scalacl.CLArray[_]] =>
               elementType
+
             case t => t
           }
           if (isTupleType(tpe)) {
@@ -355,15 +388,18 @@ trait OpenCLCodeFlattening
           } else {
             FlatCode[Tree](Seq(), Seq(), Seq(tree))
           }
+
         case Literal(_) =>
           // TODO?
           FlatCode[Tree](Seq(), Seq(), Seq(tree))
+
         case s @ Select(This(targetClass), name) =>
           FlatCode[Tree](
             Seq(),
             Seq(),
             Seq(Ident(name))
           )
+
         case Select(target, name) =>
           //println("CONVERTING select " + tree)
           val FlatCode(defs, stats, vals) = flattenTuplesAndBlocks(target, sideEffectFree = getType(target) != NoType)
@@ -372,11 +408,13 @@ trait OpenCLCodeFlattening
             stats,
             vals.map(v => Select(v, TermName(decode(name.toString))))
           )
+
         case Assign(lhs, rhs) =>
           merge(Seq(lhs, rhs).map(flattenTuplesAndBlocks(_)): _*) {
             case Seq(l, r) =>
               Seq(Assign(l, r))
           }
+
         case Apply(Select(target, N("update")), List(index, value)) if isTupleType(getType(value)) =>
           val targetTpe = normalize(target.tpe).asInstanceOf[TypeRef]
           // val indexVal = q"val index: ${index.tpe} = $index" // TODO fresh
@@ -393,6 +431,7 @@ trait OpenCLCodeFlattening
           )
           // println("UPDATE TUP(" + getType(value) + ") tree = " + tree + ", res = " + res)
           res
+
         case Apply(ident @ Ident(functionName), args) =>
           val f = args.map(flattenTuplesAndBlocks(_))
           // TODO assign vals to new vars before the calls, to ensure a correct evaluation order !
@@ -410,6 +449,7 @@ trait OpenCLCodeFlattening
               )
             )
           )
+
         case Apply(target, args) =>
           //println("CONVERTING apply " + tree)
           val fc1 @ FlatCode(defs1, stats1, vals1) =
@@ -430,8 +470,10 @@ trait OpenCLCodeFlattening
           )
           // println(s"CONVERTED apply $tree\n\tresult = $result, \n\ttpes = $tpes, \n\targs = $args, \n\targsConv = $argsConv, \n\tvals1 = $vals1, fc1 = $fc1")
           result
+
         case f @ DefDef(_, _, _, _, _, _) =>
           FlatCode[Tree](Seq(f), Seq(), Seq())
+
         case WhileLoop(condition, content) =>
           // TODO clean this up !!!
           val flatCondition = flattenTuplesAndBlocks(condition)
@@ -448,6 +490,7 @@ trait OpenCLCodeFlattening
               ),
             Seq()
           )
+
         case If(condition, thenDo, otherwise) =>
           // val (a, b) = if ({ val d = 0 ; d != 0 }) (1, d) else (2, 0)
           // ->
@@ -468,6 +511,7 @@ trait OpenCLCodeFlattening
             (st, so) match {
               case (Seq(), Seq()) =>
                 vt.zip(vo).map { case (t, o) => If(conditionVar(), t, o) } // pure (cond ? then : otherwise) form, possibly with tuple values
+
               case _ =>
                 Seq(
                   If(
@@ -478,8 +522,10 @@ trait OpenCLCodeFlattening
                 )
             }
           )
+
         case Typed(expr, tpt) =>
           flattenTuplesAndBlocks(expr).mapValues(_.map(Typed(_, tpt)))
+
         case ValDef(paramMods, paramName, tpt, rhs) =>
           // val isVal = !paramMods.hasFlag(MUTABLE)
           // val p = {
@@ -513,9 +559,14 @@ trait OpenCLCodeFlattening
 
         case Match(selector, List(CaseDef(pat, guard, body))) =>
           def extract(tree: Tree): Tree = tree match {
-            case Typed(expr, tpt) => extract(expr)
-            case Annotated(annot, arg) => extract(arg)
-            case _ => tree
+            case Typed(expr, tpt) =>
+              extract(expr)
+
+            case Annotated(annot, arg) =>
+              extract(arg)
+
+            case _ =>
+              tree
           }
           getTreeSlice(selector, recursive = true).orElse(getTreeSlice(extract(selector), recursive = true)) match {
             case Some(slice) =>
@@ -530,14 +581,16 @@ trait OpenCLCodeFlattening
                 if (subSlice.sliceLength == 1)
                   sliceReplacements ++= Seq(boundSlice -> subSlice.toTreeGen(tupleAnalyzer))
               }
-
               flattenTuplesAndBlocks(body)
+
             case _ =>
               throw new RuntimeException("Unable to connect the matched pattern with its corresponding single case")
           }
+
         case EmptyTree =>
           // println("CodeFlattening  -  WARNING EmptyTree! Should this ever happen?")
           FlatCode[Tree](Seq(), Seq(), Seq())
+
         case _ =>
           // new RuntimeException().printStackTrace()
           assert(assertion = false, "Case not handled in tuples and blocks flattening : " + tree + ": " + tree.getClass.getName)
diff --git a/src/main/scala/scalacl/impl/OpenCLConverter.scala b/src/main/scala/scalacl/impl/OpenCLConverter.scala
@@ -141,16 +141,21 @@ trait OpenCLConverter
             sc ++ rs,
             rv
           )
+
         case Apply(Select(target, N("apply")), List(singleArg)) =>
           merge(Seq(target, singleArg).map(convert): _*) { case Seq(t, a) => Seq(t + "[" + a + "]") }
+
         case Apply(Select(target, N("update")), List(index, value)) =>
           val convs = Seq(target, index, value).map(convert)
           merge(convs: _*) { case Seq(t, i, v) => Seq(t + "[" + i + "] = " + v + ";") }
+
         case Assign(lhs, rhs) =>
           merge(Seq(lhs, rhs).map(convert): _*) { case Seq(l, r) => Seq(l + " = " + r + ";") }
+
         case Typed(expr, tpt) =>
           val t = convertTpe(tpt.tpe)
           convert(expr).mapValues(_.map(v => "((" + t + ")" + v + ")"))
+
         case DefDef(mods, name, tparams, vparamss, tpt, body) =>
           val b = new StringBuilder
           b ++= convertTpe(body.tpe) + " " + name + "("
@@ -175,6 +180,7 @@ trait OpenCLConverter
             Seq(),
             Seq()
           )
+
         case vd @ ValDef(paramMods, paramName, tpt: TypeTree, rhs) =>
           val convValue = convert(rhs)
           // println("VD: " + vd)
@@ -194,6 +200,7 @@ trait OpenCLConverter
           )
         //case Typed(expr, tpe) =>
         //  out(expr)
+
         case Match(ma @ Ident(matchName), List(CaseDef(pat, guard, body))) =>
           //for ()
           //x0$1 match {
@@ -206,8 +213,9 @@ trait OpenCLConverter
           cast(expr, typeName)
 
         // TODO
-        //case ScalaMathFunction(functionType, funName, args) =>
-        //  convertMathFunction(functionType, funName, args)
+        case ScalaMathFunction(functionType, funName, args) =>
+          convertMathFunction(functionType, funName, args)
+
         case Apply(s @ Select(left, name), args) =>
           val List(right) = args
           NameTransformer.decode(name.toString) match {
@@ -217,8 +225,7 @@ trait OpenCLConverter
                 //case e =>
                 //  throw new RuntimeException("ugh : " + e + ", op = " + op + ", body = " + body + ", left = " + left + ", right = " + right)
               }
-            case n if left.symbol == ScalaMathPackage => //isPackageReference(left, "scala.math") =>
-              convertMathFunction(s.tpe, name, args)
+
             //merge(Seq(right).map(convert):_*) { case Seq(v) => Seq(n + "(" + v + ")") }
             case n =>
               throw new RuntimeException(
@@ -230,6 +237,7 @@ trait OpenCLConverter
                   s"\ttree: ${body.getClass.getName}")
               valueCode("/* Error: failed to convert " + body + " */")
           }
+
         case s @ Select(expr, fun) =>
           convert(expr).mapEachValue(v => {
             val fn = fun.toString
@@ -240,6 +248,7 @@ trait OpenCLConverter
               Seq("/* Error: failed to convert " + body + " */")
             }
           })
+
         case WhileLoop(condition, content) =>
           val FlatCode(dcont, scont, vcont) = content.map(convert).reduceLeft(_ >> _)
           val FlatCode(dcond, scond, Seq(vcond)) = convert(condition)
@@ -253,16 +262,19 @@ trait OpenCLConverter
               ),
             Seq()
           )
+
         case Apply(target, args) =>
           merge((target :: args).map(convert): _*)(seq => {
             val t :: a = seq.toList
             Seq(t + "(" + a.mkString(", ") + ")")
           })
+
         case Block(statements, Literal(Constant(empty))) =>
           // assert(value == Literal(Constant(UNIT)),
           assert(empty == UNIT,
             s"Valued blocks should have been flattened in a previous phase!\n$empty : ${empty.getClass}")
           statements.map(convert).map(_.noValues).reduceLeft(_ >> _)
+
         case _ =>
           //println(nodeToStringNoComment(body))
           throw new RuntimeException("Failed to convert " + body.getClass.getName + ": \n" + body + " : \n" + nodeToStringNoComment(body))
