3 files changed, 28 insertions, 36 deletions
diff --git a/src/main/scala/Chisel/Builder.scala b/src/main/scala/Chisel/Builder.scala
index 9a469149..0d25b177 100644
--- a/src/main/scala/Chisel/Builder.scala
+++ b/src/main/scala/Chisel/Builder.scala
@@ -67,30 +67,14 @@ private class DynamicContext {
   val globalNamespace = new FIRRTLNamespace
   val globalRefMap = new RefMap
   val components = ArrayBuffer[Component]()
-  val currentModuleVar = new DynamicVariable[Option[Module]](None)
-  val currentParamsVar = new DynamicVariable[Parameters](Parameters.empty)
+  var currentModule: Option[Module] = None
   val parameterDump = new ParameterDump
-
-  def getCurrentModule = currentModuleVar.value
-  def moduleScope[T](body: => T): T = {
-    currentModuleVar.withValue(getCurrentModule)(body)
-  }
-  def forceCurrentModule[T](m: Module) { // Used in Module constructor
-    currentModuleVar.value = Some(m)
-  }
-  def pushCommand(c: Command) {
-    currentModuleVar.value.foreach(_._commands += c)
-  }
-
-  def getParams: Parameters = currentParamsVar.value
-  def paramsScope[T](p: Parameters)(body: => T): T = {
-    currentParamsVar.withValue(p)(body)
-  }
 }
 
 private object Builder {
   // All global mutable state must be referenced via dynamicContextVar!!
   private val dynamicContextVar = new DynamicVariable[Option[DynamicContext]](None)
+  private val currentParamsVar = new DynamicVariable[Parameters](Parameters.empty)
 
   def dynamicContext = dynamicContextVar.value.get
   def idGen = dynamicContext.idGen
@@ -99,12 +83,19 @@ private object Builder {
   def components = dynamicContext.components
   def parameterDump = dynamicContext.parameterDump
 
-  def pushCommand(c: Command) = dynamicContext.pushCommand(c)
+  def pushCommand(c: Command) {
+    dynamicContext.currentModule.foreach(_._commands += c)
+  }
   def pushOp[T <: Data](cmd: DefPrim[T]) = {
     pushCommand(cmd)
     cmd.id
   }
 
+  def getParams: Parameters = currentParamsVar.value
+  def paramsScope[T](p: Parameters)(body: => T): T = {
+    currentParamsVar.withValue(p)(body)
+  }
+
   def build[T <: Module](f: => T): Circuit = {
     dynamicContextVar.withValue(Some(new DynamicContext)) {
       val mod = f
diff --git a/src/main/scala/Chisel/Core.scala b/src/main/scala/Chisel/Core.scala
index 9838554e..a8e270f6 100644
--- a/src/main/scala/Chisel/Core.scala
+++ b/src/main/scala/Chisel/Core.scala
@@ -38,7 +38,7 @@ object debug {
 }
 
 abstract class Data(dirArg: Direction) extends HasId {
-  private[Chisel] val _mod: Module = dynamicContext.getCurrentModule.getOrElse(null)
+  private[Chisel] val _mod: Module = dynamicContext.currentModule.getOrElse(null)
   if (_mod ne null)
     _mod.addNode(this)
 
@@ -645,11 +645,11 @@ object Bundle {
   private val keywords =
     HashSet[String]("flip", "asInput", "asOutput", "cloneType", "toBits")
   def apply[T <: Bundle](b: => T)(implicit p: Parameters): T = {
-    dynamicContext.paramsScope(p.push){ b }
+    Builder.paramsScope(p.push){ b }
   }
   //TODO @deprecated("Use Chisel.paramsScope object","08-01-2015")
   def apply[T <: Bundle](b: => T,  f: PartialFunction[Any,Any]): T = {
-    val q = dynamicContext.getParams.alterPartial(f)
+    val q = Builder.getParams.alterPartial(f)
     apply(b)(q)
   }
 }
@@ -712,9 +712,11 @@ class Bundle extends Aggregate(NO_DIR) {
 }
 
 object Module {
-  def apply[T <: Module](bc: => T)(implicit currParams: Parameters = dynamicContext.getParams.push): T = {
-    dynamicContext.paramsScope(currParams) {
-      val m = dynamicContext.moduleScope{ bc.setRefs() }
+  def apply[T <: Module](bc: => T)(implicit currParams: Parameters = Builder.getParams.push): T = {
+    paramsScope(currParams) {
+      val parent = dynamicContext.currentModule
+      val m = bc.setRefs()
+      dynamicContext.currentModule = parent
       val ports = m.computePorts
       Builder.components += Component(m, m.name, ports, m._commands)
       pushCommand(DefInstance(m, ports))
@@ -723,7 +725,7 @@ object Module {
   }
   //TODO @deprecated("Use Chisel.paramsScope object","08-01-2015")
   def apply[T <: Module](m: => T, f: PartialFunction[Any,Any]): T = {
-    apply(m)(dynamicContext.getParams.alterPartial(f))
+    apply(m)(Builder.getParams.alterPartial(f))
   }
 }
 
@@ -732,9 +734,8 @@ abstract class Module(_clock: Clock = null, _reset: Bool = null) extends HasId {
   private[Chisel] val _commands = ArrayBuffer[Command]()
   private[Chisel] val _nodes = ArrayBuffer[Data]()
   private[Chisel] val _children = ArrayBuffer[Module]()
-  private[Chisel] val _parent = dynamicContext.getCurrentModule
-
-  dynamicContext.forceCurrentModule(this)
+  private[Chisel] val _parent = dynamicContext.currentModule
+  dynamicContext.currentModule = Some(this)
   _parent match {
     case Some(p) => p._children += this
     case _ =>
diff --git a/src/main/scala/Chisel/Parameters.scala b/src/main/scala/Chisel/Parameters.scala
index d5b0a46f..ca2bcebd 100644
--- a/src/main/scala/Chisel/Parameters.scala
+++ b/src/main/scala/Chisel/Parameters.scala
@@ -71,25 +71,25 @@ import scala.collection.mutable
 abstract trait UsesParameters { }
 
 object params {
-  def apply[T](field:Any):T = Builder.dynamicContext.getParams.apply(field)
-  def apply[T](field:Field[T]):T = Builder.dynamicContext.getParams.apply(field)
+  def apply[T](field:Any):T = Builder.getParams.apply(field)
+  def apply[T](field:Field[T]):T = Builder.getParams.apply(field)
   // TODO: provide other mutators of Parameters? or @deprecate this and make
   // Parameters private, only mutateable through paramsScope?
   def alterPartial[T](mask: PartialFunction[Any,Any]): Parameters = {
-    Builder.dynamicContext.getParams.alterPartial(mask)
+    Builder.getParams.alterPartial(mask)
   }
-  def constrain(gen:ViewSym=>Ex[Boolean]) = Builder.dynamicContext.getParams.constrain(gen)
+  def constrain(gen:ViewSym=>Ex[Boolean]) = Builder.getParams.constrain(gen)
 }
 
 object paramsScope {
   def apply[T](p: Parameters)(body: => T): T = {
-    Builder.dynamicContext.paramsScope(p)(body)
+    Builder.paramsScope(p)(body)
   }
   def apply[T,S](mask: Map[S,Any])(body: => T): T = {
-    apply(Builder.dynamicContext.getParams.alter(mask))(body)
+    apply(Builder.getParams.alter(mask))(body)
   }
   def apply[T](mask: PartialFunction[Any,Any])(body: => T): T = {
-    apply(Builder.dynamicContext.getParams.alterPartial(mask))(body)
+    apply(Builder.getParams.alterPartial(mask))(body)
   }
 }