Swap over to new macro-based `DefCtx` injection, rather than relying on `StaticContext`

This should let us avoid the same `StaticContext` being re-used by multiple implicit use-sites within a block, causing confusion.

`ForgeTests.evaluate.anonTriple` still doesn't pass for unrelated reasons

3 files changed, 27 insertions, 28 deletions

diff --git a/src/main/scala/forge/DefCtx.scala b/src/main/scala/forge/DefCtx.scala
index 251e671b..b9c02602 100644
--- a/src/main/scala/forge/DefCtx.scala
+++ b/src/main/scala/forge/DefCtx.scala
@@ -5,31 +5,30 @@ import scala.language.experimental.macros
 import scala.reflect.macros._
 
 
-case class DefCtx(staticEnclosing: Option[String])
+sealed abstract class DefCtx(val value: Option[String])
 object DefCtx{
-  case class StaticContext(value: Boolean)
-  object StaticContext {
-    implicit def default: StaticContext = macro applyImpl
-    def rec(c: Context)(expr: c.Symbol): Boolean = {
-      import c.universe._
-      // Classes and traits and such
-      if(!expr.isModuleClass && expr.isClass) false
-      // Method contents
-      else if(expr.isMethod) false
-      else if(expr.owner == NoSymbol) true
-      else rec(c)(expr.owner)
-    }
+  implicit object Anonymous extends DefCtx(None)
+  case class Labeled(label: String) extends DefCtx(Some(label))
+}
 
-    def applyImpl(c: Context): c.Expr[StaticContext] = {
-      import c.universe._
-      val staticContext = rec(c)(c.internal.enclosingOwner)
-      c.Expr[StaticContext](q"forge.DefCtx.StaticContext($staticContext)")
-    }
-  }
+object T{
+  def apply[T](expr: T): T = macro applyImpl[T]
 
-  implicit def default(implicit enc: sourcecode.Enclosing,
-                       sc: StaticContext) = {
-    if (sc.value) DefCtx(Some(enc.value))
-    else DefCtx(None)
+  def applyImpl[T: c.WeakTypeTag](c: Context)(expr: c.Expr[T]): c.Expr[T] = {
+    import c.universe._
+    val transformed = expr.tree match{
+      case Apply(fun, args) =>
+        var transformed = false
+        val newArgs = args.map{
+          case x if x.tpe == weakTypeOf[DefCtx.Anonymous.type] =>
+            transformed = true
+            q"forge.DefCtx.Labeled(sourcecode.Enclosing())"
+          case x => x
+        }
+        assert(transformed)
+        Apply(fun, newArgs)
+      case _ => ???
+    }
+    c.Expr[T](transformed)
   }
 }
\ No newline at end of file
diff --git a/src/main/scala/forge/Evaluator.scala b/src/main/scala/forge/Evaluator.scala
index f341c9cb..d6ff39a2 100644
--- a/src/main/scala/forge/Evaluator.scala
+++ b/src/main/scala/forge/Evaluator.scala
@@ -20,10 +20,10 @@ class Evaluator(workspacePath: jnio.Path,
     for (target <- sortedTargets){
       val inputResults = target.inputs.map(results).toIndexedSeq
 
-      val targetDestPath = target.defCtx.staticEnclosing match{
+      val targetDestPath = target.defCtx.value match{
         case Some(enclosingStr) =>
           val targetDestPath = workspacePath.resolve(
-            jnio.Paths.get(enclosingStr.stripSuffix(enclosingBase.staticEnclosing.getOrElse("")))
+            jnio.Paths.get(enclosingStr.stripSuffix(enclosingBase.value.getOrElse("")))
           )
           deleteRec(targetDestPath)
           targetDestPath
@@ -32,13 +32,13 @@ class Evaluator(workspacePath: jnio.Path,
       }
 
       val inputsHash = inputResults.hashCode
-      target.defCtx.staticEnclosing.flatMap(resultCache.get) match{
+      target.defCtx.value.flatMap(resultCache.get) match{
         case Some((hash, res)) if hash == inputsHash && !target.dirty =>
           results(target) = res
         case _ =>
           evaluated.append(target)
           val res = target.evaluate(new Args(inputResults, targetDestPath))
-          for(label <- target.defCtx.staticEnclosing) {
+          for(label <- target.defCtx.value) {
             resultCache(label) = (inputsHash, res)
           }
           results(target) = res
diff --git a/src/main/scala/forge/Target.scala b/src/main/scala/forge/Target.scala
index acbb8449..d7edc188 100644
--- a/src/main/scala/forge/Target.scala
+++ b/src/main/scala/forge/Target.scala
@@ -14,7 +14,7 @@ trait TargetOps[T]{ this: Target[T] =>
     this.zip(other).map(s.apply _ tupled)
   }
 
-  override def toString = defCtx.staticEnclosing match{
+  override def toString = defCtx.value match{
     case None => this.getClass.getSimpleName + "@" + Integer.toHexString(System.identityHashCode(this))
     case Some(s) => this.getClass.getName + "@" + s
   }