Adapt to latest scalaxy changes (newVariable -> newVal + newVar)

Author: ochafik

.gitignore

@@ -15,3 +15,4 @@ Akkhack
 velocity.log*
 tmpTestClasses*
 *.marks
+.ensime

src/main/scala/scalacl/impl/CLFunctionMacros.scala

@@ -45,7 +45,7 @@ private[impl] object CLFunctionMacros {
 
     val outputSymbol = Option(c.enclosingMethod).map(_.symbol).getOrElse(NoSymbol).newTermSymbol(newTermName(c.fresh("out")))
 
-    WithResult(
+    val func = WithResult(
       new CodeGeneration with WithMacroContext with WithResult[c.Expr[FunctionKernel /*[A, B]*/ ]] {
         override val context = c
         import global._
@@ -56,30 +56,47 @@ private[impl] object CLFunctionMacros {
           outputSymbol = castSymbol(outputSymbol)).asInstanceOf[Result]
       }
     )
-
+    try {
+      c.Expr[FunctionKernel](c.typeCheck(func.tree))
+    } catch {
+      case ex: Throwable =>
+        ex.printStackTrace()
+        println("ERROR WITH: " + func)
+        throw ex
+    }
   }
 
   private[impl] def convertTask(c: Context)(block: c.Expr[Unit]): c.Expr[CLFunction[Unit, Unit]] = {
     import c.universe._
     import definitions._
 
-    WithResult(
+    val func = WithResult(
       new CodeGeneration with WithMacroContext with WithResult[c.Expr[CLFunction[Unit, Unit]]] {
         override val context = c
 
         // Create a fake Unit => Unit function.
-        val typedBlock = c.typeCheck(block.tree)
+
+        //var typedBlock = newStreamTransformer(false) transform cleanTypeCheck(block.tree)
+        // val typedBlock = c.typeCheck(block.tree)
         val functionKernelExpr = generateFunctionKernel[Unit, Unit](
           kernelSalt = KernelDef.nextKernelSalt,
-          body = castTree(typedBlock),
+          body = castTree(block.tree),
           paramDescs = Seq()
         )
 
-        val f = blockToUnitFunction(castTree(typedBlock))
+        val f = blockToUnitFunction(castTree(block.tree))
         val result = reify(
           new CLFunction[Unit, Unit](f.splice, functionKernelExpr.splice)
         ).asInstanceOf[Result]
       }
     )
+    try {
+      c.Expr[CLFunction[Unit, Unit]](c.typeCheck(func.tree))
+    } catch {
+      case ex: Throwable =>
+        ex.printStackTrace()
+        println("ERROR WITH: " + func)
+        throw ex
+    }
   }
 }

src/main/scala/scalacl/impl/CodeGeneration.scala

@@ -56,7 +56,8 @@ trait CodeGeneration extends CodeConversion with StreamTransformers {
     expr[Unit => Unit](
       Function(
         List(
-          ValDef(NoMods, newTermName(fresh("noarg")), TypeTree(UnitTpe), EmptyTree)
+          ValDef(
+            NoMods, newTermName(fresh("noarg")), TypeTree(UnitTpe), EmptyTree)
         ),
         block
       )
@@ -99,6 +100,7 @@ trait CodeGeneration extends CodeConversion with StreamTransformers {
           ParamDesc(
             symbol = castSymbol(param.symbol),
             tpe = castType(inputTpe),
+            output = false,
             mode = ParamKind.ImplicitArrayElement,
             usage = UsageKind.Input,
             implicitIndexDimension = Some(0)))
@@ -111,6 +113,7 @@ trait CodeGeneration extends CodeConversion with StreamTransformers {
           ParamDesc(
             symbol = castSymbol(outputSymbol),
             tpe = castType(outputTpe),
+            output = true,
             mode = ParamKind.ImplicitArrayElement,
             usage = UsageKind.Output,
             implicitIndexDimension = Some(0)))
@@ -167,18 +170,13 @@ trait CodeGeneration extends CodeConversion with StreamTransformers {
     body: Tree,
     paramDescs: Seq[ParamDesc]): Expr[FunctionKernel /*[A, B]*/ ] = {
 
-    // println(s"""
-    //   Generating CL function for:
-    //     f = $f
-    //     paramDescs = $paramDescs
-    // """)
-    val transformedBody = newStreamTransformer(false) transform body
-
     val cr @ CodeConversionResult(code, capturedInputs, capturedOutputs, capturedConstants) = convertCode(
-      transformedBody,
+      body,
       paramDescs
     )
 
+    // resetAllAttrs(body)
+
     val codeExpr = expr[String](Literal(Constant(code)))
     val kernelSaltExpr = expr[Long](Literal(Constant(kernelSalt)))
 

src/main/scala/scalacl/impl/KernelSymbolsAnalysis.scala

@@ -39,6 +39,7 @@ import scala.reflect.NameTransformer
 
 trait KernelSymbolsAnalysis
     extends CommonScalaNames
+    with CodeConversionResults
     with MiscMatchers
     with SymbolKinds {
   val global: reflect.api.Universe

src/main/scala/scalacl/impl/OpenCLCodeFlattening.scala

@@ -207,7 +207,7 @@ trait OpenCLCodeFlattening
             (Seq(), value)
           case _ =>
             assert(getType(value) != NoType, value + ": " + value.getClass.getName) // + " = " + nodeToString(value) + ")")
-            val tempVar = newVariable("tmp", symbolOwner, value.pos, false, value, value.tpe)
+            val tempVar = newVal("tmp", value, value.tpe)
             //println("Creating temp variable " + tempVar.symbol + " for " + value)
             hasNewStatements = true
             for (slice <- getTreeSlice(value))
@@ -355,7 +355,7 @@ trait OpenCLCodeFlattening
         case Apply(Select(target, updateName()), List(index, value)) if isTupleType(getType(value)) =>
           val targetTpe = normalize(target.tpe).asInstanceOf[TypeRef]
           setType(target, targetTpe)
-          val indexVal = newVariable("index", symbolOwner, tree.pos, false, index, index.tpe)
+          val indexVal = newVal("index", index, index.tpe)
 
           val flatTarget = flattenTuplesAndBlocks(target)
           val flatValue = flattenTuplesAndBlocks(value)
@@ -398,8 +398,6 @@ trait OpenCLCodeFlattening
             flatCondition.statements ++
               Seq(
                 whileLoop(
-                  symbolOwner,
-                  tree,
                   flatConditionValue,
                   Block(flatContent.statements.toList ++ flatContent.values, newUnit)
                 )
@@ -415,7 +413,7 @@ trait OpenCLCodeFlattening
           // val b = if (condition) d else 0
           val FlatCode(dc, sc, Seq(vc)) = flattenTuplesAndBlocks(condition)
           assert(getType(vc) != NoType, vc)
-          val conditionVar = newVariable("condition", symbolOwner, tree.pos, false, vc, vc.tpe)
+          val conditionVar = newVal("condition", vc, vc.tpe)
 
           val fct @ FlatCode(Seq(), st, vt) = flattenTuplesAndBlocks(thenDo)
           val fco @ FlatCode(Seq(), so, vo) = flattenTuplesAndBlocks(otherwise)

src/main/scala/scalacl/impl/SymbolKinds.scala

@@ -55,7 +55,7 @@ trait SymbolKinds extends Tuploids with CommonScalaNames {
   }
 
   def kindOf(symbol: Symbol, tpe: Type): SymbolKind = {
-    if (tpe <:< typeOf[CLArray[_]] || tpe <:< typeOf[CLFilteredArray[_]])
+    if (tpe != null && (tpe <:< typeOf[CLArray[_]] || tpe <:< typeOf[CLFilteredArray[_]]))
       SymbolKind.ArrayLike
     else if (isTuploidType(tpe))
       SymbolKind.Tuploid

src/main/scala/scalacl/impl/TupleDataIO.scala

@@ -43,6 +43,10 @@ private[impl] abstract class TupleDataIO[T: Manifest] extends DataIO[T] {
     CLEvent.waitFor(eventsToWaitFor.toArray: _*)
     (0 until length.toInt).par.map(i => get(i, pointers, 0)).toArray // TODO check
   }
+
+  // def ios: Array[DataIO[_]]
+  // def mkTuple(values: Array[Any]): T
+  // 
 }
 
 class Tuple2DataIO[T1: Manifest: DataIO, T2: Manifest: DataIO]
@@ -71,4 +75,4 @@ class Tuple2DataIO[T1: Manifest: DataIO, T2: Manifest: DataIO]
     io1.set(index, buffers, bufferOffset, v1)
     io2.set(index, buffers, bufferOffset + io1.bufferCount, v2)
   }
-}
+}

src/main/scala/scalacl/impl/Vectorization.scala

@@ -72,6 +72,7 @@ trait Vectorization extends CodeGeneration with MiscMatchers {
           ParamDesc(
             symbol = param.symbol,
             tpe = numTpe,
+            output = false,
             mode = ParamKind.RangeIndex,
             usage = UsageKind.Input,
             implicitIndexDimension = Some(0),

src/test/scala/scalacl/impl/ConversionTest.scala

@@ -63,7 +63,20 @@ class ConversionTest
     val in: CLArray[Int] = null
     val out: CLArray[Int] = null
     val f = 10
-    val c = conv(reify { out(1) = in(2) * f })
+    val c = conv(reify { out(1) = in(2) * f }, List(
+      ParamDesc(
+        symbol = NoSymbol.newTermSymbol("out"),
+        output = true,
+        tpe = typeOf[CLArray[Int]],
+        mode = ParamKind.Normal,
+        usage = UsageKind.Output),
+      ParamDesc(
+        symbol = NoSymbol.newTermSymbol("in"),
+        output = false,
+        tpe = typeOf[CLArray[Int]],
+        mode = ParamKind.Normal,
+        usage = UsageKind.Input)))
+
     assertEquals(
       "kernel void f(global const int* in, global int* out, int f) {\n" +
         "\tout[1] = (in[2] * f);\n" +

src/test/scala/scalacl/impl/VectorizationTest.scala

@@ -69,7 +69,7 @@ class VectorizationTest
     )
   }
 
-  @Ignore
+  // @Ignore
   @Test
   def notVectorizable2D {
     assertThat(