some cleanup

Author: TiarkRompf

src/common/Base.scala

@@ -40,17 +40,8 @@ trait BaseExp extends Base with Expressions with Blocks with Transforming {
   protected def unit[T:Manifest](x: T) = Const(x)
 }
 
-trait BlockExp extends BaseExp
+trait BlockExp extends BaseExp with Blocks
 
-/*
-trait BlockExp extends BaseExp with Blocks {
-  
-  implicit object CanTransformBlock extends CanTransform[Block] {
-    def transform[A](x: Block[A], t: Transformer): Block[A] = Block(t(x.res))
-  }
-  
-}
-*/
 
 trait EffectExp extends BaseExp with Effects {
 
@@ -66,17 +57,8 @@ trait EffectExp extends BaseExp with Effects {
   }
 
   override def mirror[A:Manifest](e: Def[A], f: Transformer)(implicit pos: SourceContext): Exp[A] = e match {
-/*
-    case Reflect(x, u, es) =>
-      reifyEffects {
-        context = f(es)
-        mirror(x)
-      }
-    
-*/    
-//    case Reflect(Print(x), u, es) => Reflect(Print(f(x)), es map (e => f(e)))
     case Reflect(x, u, es) => reflectMirrored(mirrorDef(e,f).asInstanceOf[Reflect[A]])
-    case Reify(x, u, es) => Reify(f(x), mapOver(f,u), f(es)) //TODO: u
+    case Reify(x, u, es) => Reify(f(x), mapOver(f,u), f(es))
     case _ => super.mirror(e,f)
   }
 
@@ -85,7 +67,7 @@ trait EffectExp extends BaseExp with Effects {
 trait BaseFatExp extends BaseExp with FatExpressions with FatTransforming
 
 
-// The traits below provide an interface to codegen so that client do
+// The traits below provide an interface to codegen so that clients do
 // not need to depend on internal._
 
 trait ScalaGenBase extends ScalaCodegen

src/internal/Expressions.scala

@@ -45,48 +45,6 @@ trait Expressions extends Utils {
     cs.map(c => all(c).reverse.map(c => c.fileName.split("/").last + ":" + c.line).mkString("//")).mkString(";")
   }
 
-/*
-  def fresh[T:Manifest] = {
-    val (name, id, nameId) = nextName("x")
-    val sym = Sym[T](id)
-    sym.name = name
-    sym.nameId = nameId
-    sym
-  }
-
-  def fresh[T:Manifest](d: Def[T], ctx: Option[SourceContext]) = {
-    def enclosingNamedContext(sc: SourceContext): Option[SourceContext] = sc.bindings match {
-      case (null, _) :: _ =>
-        if (!sc.parent.isEmpty) enclosingNamedContext(sc.parent.get)
-        else None
-      case (name, line) :: _ =>
-        Some(sc)
-    }
-
-    // create base name from source context
-    val (basename, line, srcCtx) = if (!ctx.isEmpty) {
-      enclosingNamedContext(ctx.get) match {
-        case None =>
-          // no enclosing context has variable assignment
-          var outermost = ctx.get
-          while (!outermost.parent.isEmpty) {
-            outermost = outermost.parent.get
-          }
-          ("x", 0, Some(outermost))
-        case Some(sc) => sc.bindings match {
-          case (n, l) :: _ =>
-            (n, l, Some(sc))
-        }
-      }
-    } else ("x", 0, None)
-    val (name, id, nameId) = nextName(basename)
-    val sym = Sym[T](id)
-    sym.name = name
-    sym.nameId = nameId
-    sym.sourceContext = srcCtx
-    sym
-  }
-*/
 
   abstract class Def[+T] { // operations (composite)
     override final lazy val hashCode = scala.runtime.ScalaRunTime._hashCode(this.asInstanceOf[Product])
@@ -136,7 +94,8 @@ trait Expressions extends Utils {
   def reflectSubGraph(ds: List[Stm]): Unit = {
     val lhs = ds.flatMap(_.lhs)
     assert(lhs.length == lhs.distinct.length, "multiple defs: " + ds)
-    val existing = lhs flatMap (globalDefsCache get _)//globalDefs filter (_.lhs exists (lhs contains _))
+    // equivalent to: globalDefs filter (_.lhs exists (lhs contains _))
+    val existing = lhs flatMap (globalDefsCache get _)
     assert(existing.isEmpty, "already defined: " + existing + " for " + ds)
     localDefs = localDefs ::: ds
     globalDefs = globalDefs ::: ds
@@ -172,7 +131,7 @@ trait Expressions extends Utils {
   }
 
   object Def {
-    def unapply[T](e: Exp[T]): Option[Def[T]] = e match { // really need to test for sym?
+    def unapply[T](e: Exp[T]): Option[Def[T]] = e match {
       case s @ Sym(_) =>
         findDefinition(s).flatMap(_.defines(s))
       case _ =>
@@ -189,8 +148,9 @@ trait Expressions extends Utils {
     case ss: Iterable[Any] => ss.toList.flatMap(syms(_))
     // All case classes extend Product!
     case p: Product => 
-      //return p.productIterator.toList.flatMap(syms(_))
-      /* performance hotspot */
+      // performance hotspot: this is the same as
+      // p.productIterator.toList.flatMap(syms(_))
+      // but faster
       val iter = p.productIterator
       val out = new ListBuffer[Sym[Any]]
       while (iter.hasNext) {
@@ -232,7 +192,7 @@ trait Expressions extends Utils {
     case _ => Nil
   }
 
-
+  // generic symbol traversal: f is expected to call rsyms again
   def rsyms[T](e: Any)(f: Any=>List[T]): List[T] = e match {
     case s: Sym[Any] => f(s)
     case ss: Iterable[Any] => ss.toList.flatMap(f)
@@ -255,25 +215,6 @@ trait Expressions extends Utils {
   def freqCold(e: Any) = symsFreq(e).map(p=>(p._1,p._2*0.5))
 
 
-
-/*
-  def symsFreq(e: Any): List[(Sym[Any], Double)] = e match {
-    case s: Sym[Any] => List((s,1.0))
-    case p: Product => p.productIterator.toList.flatMap(symsFreq(_))
-    case _ => Nil
-  }
-*/
-
-/*
-  def symsShare(e: Any): List[(Sym[Any], Int)] = {
-    case s: Sym[Any] => List(s)
-    case p: Product => p.productIterator.toList.flatMap(symsShare(_))
-    case _ => Nil
-  }
-*/
-
-
-
   // bookkeeping
 
   def reset { // used by delite?