add EPhysAccess to the AST. Only allowed for code gen purposes

src/main/scala/Compiler.scala

@@ -39,7 +39,7 @@ object Compiler {
   }
 
   def codegen(ast: Prog, c: Config = emptyConf) = {
-    val rast = passes.RewriteView.rewriteProg(ast);
+    val rast = passes.RewriteView.rewrite(ast);
     showDebug(rast, "Rewrite Views", c)
 
     // Perform program lowering if needed.

src/main/scala/backends/CppLike.scala

@@ -99,6 +99,8 @@ object Cpp {
       case EArrAccess(id, idxs) =>
         id <> ssep(idxs.map(idx => brackets(emitExpr(idx))), emptyDoc)
       case EArrLiteral(idxs) => braces(commaSep(idxs.map(idx => emitExpr(idx))))
+      case _: EPhysAccess =>
+        throw NotImplemented("Physical access code gen for cpp-like backends.")
       case ERecAccess(rec, field) => rec <> dot <> field
       case ERecLiteral(fs) =>
         scope {

src/main/scala/common/Checker.scala

@@ -76,6 +76,8 @@ object Checker {
       case ECast(e, _) => checkE(e)
       case ERecAccess(rec, _) => checkE(rec)
       case EArrAccess(_, idxs) => checkESeq(idxs)
+      case EPhysAccess(_, bankIdxs) =>
+        checkESeq(bankIdxs.flatMap({ case (bank, idx) => List(bank, idx) }))
     }
 
     def checkLVal(e: Expr)(implicit env: Env): Env = checkE(e)

src/main/scala/common/EnvHelpers.scala

@@ -49,4 +49,12 @@ object EnvHelpers {
     def get(k: K): Option[V]
   }
 
+  /**
+    * Definition of a trivial environment that doesn't track any
+    * information.
+    */
+  final case class UnitEnv() extends ScopeManager[UnitEnv] {
+    def merge(that: UnitEnv) = this
+  }
+
 }

src/main/scala/common/Pretty.scala

@@ -72,6 +72,22 @@ object Pretty {
         )
       else doc
     }
+    case acc @ EPhysAccess(id, idxs) => {
+      val doc = id <>
+        ssep(
+          idxs.map({
+            case (bank, idx) =>
+              braces(emitExpr(bank)) <> brackets(emitExpr(idx))
+          }),
+          emptyDoc
+        )
+
+      if (debug)
+        brackets(
+          doc <> colon <+> acc.consumable.map(emitConsume).getOrElse(emptyDoc)
+        )
+      else doc
+    }
     case EArrLiteral(idxs) => braces(commaSep(idxs.map(idx => emitExpr(idx))))
     case ERecAccess(rec, field) => rec <> dot <> field
     case ERecLiteral(fs) =>

src/main/scala/common/Syntax.scala

@@ -126,7 +126,7 @@ object Syntax {
   case class EArrAccess(id: Id, idxs: List[Expr])
       extends Expr
       with ConsumableAnnotation
-  case class EPhsAccess(id: Id, bankIdxs: List[(Expr, Expr)])
+  case class EPhysAccess(id: Id, bankIdxs: List[(Expr, Expr)])
       extends Expr
       with ConsumableAnnotation
   case class EArrLiteral(idxs: List[Expr]) extends Expr

src/main/scala/common/Transformer.scala

@@ -115,6 +115,16 @@ object Transformer {
         val (nidxs, env1) = rewriteESeq(idxs)
         acc.copy(idxs = nidxs.toList) -> env1
       }
+      case acc @ EPhysAccess(_, bankIdxs) => {
+        val init = (List[(Expr, Expr)](), env)
+        val (nBankIdxsReversed, nEnv) = bankIdxs.foldLeft(init)({
+          case ((nBankIdxs, env), (bank, idx)) =>
+            val (nBank, env1) = rewriteE(bank)(env)
+            val (nIdx, env2) = rewriteE(idx)(env1)
+            ((nBank, nIdx) :: nBankIdxs, env2)
+        })
+        acc.copy(bankIdxs = nBankIdxsReversed.reverse.toList) -> nEnv
+      }
     }
 
     def rewriteLVal(e: Expr)(implicit env: Env): (Expr, Env) = rewriteE(e)
@@ -206,12 +216,4 @@ object Transformer {
     def partialRewriteC: PF[(Command, Env), (Command, Env)] =
       asPartial(super.rewriteC(_: Command)(_: Env))
   }
-
-  /**
-    * Definition of a trivial environment that doesn't track any
-    * information.
-    */
-  final case class UnitEnv() extends ScopeManager[UnitEnv] {
-    def merge(that: UnitEnv) = this
-  }
 }

src/main/scala/passes/BoundsCheck.scala

@@ -16,18 +16,11 @@ object BoundsChecker {
 
   def check(p: Prog) = BCheck.check(p)
 
-  // Bounds checker environment doesn't need to track any information. Empty
-  // environment that just runs the commands.
-  private case class BEnv() extends ScopeManager[BEnv] {
-    // Neither environment contains anything.
-    def merge(that: BEnv): BEnv = this
-  }
-
   private final case object BCheck extends PartialChecker {
 
-    type Env = BEnv
+    type Env = UnitEnv
 
-    val emptyEnv = BEnv()
+    val emptyEnv = UnitEnv()
 
     /**
       * Given a view with a known prefix length, check if it **might** cause an

src/main/scala/passes/LowerForLoops.scala

@@ -3,6 +3,7 @@ package fuselang.passes
 import scala.{PartialFunction => PF}
 import fuselang.common._
 import Transformer._
+import EnvHelpers._
 import Syntax._
 import CompilerError._
 

src/main/scala/typechecker/AffineCheck.scala

@@ -289,6 +289,9 @@ object AffineChecker {
           }
         }
       }
+      case (_: EPhysAccess, _) => {
+        throw NotImplemented("Affine checking for physical accesses.")
+      }
     }
   }
 }

src/main/scala/typechecker/CapabilityChecker.scala

@@ -6,6 +6,7 @@ import fuselang.common._
 import Syntax._
 import Syntax.Annotations._
 import Errors._
+import CompilerError._
 import CapabilityEnv._
 import Checker._
 
@@ -34,6 +35,9 @@ object CapabilityChecker {
         acc.consumable = Some(consumableAnn)
         nEnv.add(acc, cap)
       }
+      case (_: EPhysAccess, _) => {
+        throw NotImplemented("Capability checking for physical accesses.")
+      }
     }
 
     override def myCheckC: PF[(Command, Env), Env] = {

src/main/scala/typechecker/TypeCheck.scala

@@ -209,7 +209,7 @@ object TypeChecker {
           typ -> env
         }
       }
-    case EPhsAccess(id, bankIdxs) =>
+    case EPhysAccess(id, bankIdxs) =>
       env(id).matchOrError(expr.pos, "array access", s"array type") {
         case TArray(typ, dims, _) => {
           if (dims.length != bankIdxs.length) {