Multipack support

compiler/src/main/scala/edg/EdgirUtils.scala

@@ -38,6 +38,13 @@ object EdgirUtils {
           case (true, true) => throw new IllegalArgumentException("exterior and interior both matched")
           case (false, false) => throw new IllegalArgumentException("neither interior nor exterior matched")
         }
+      case expr.ValueExpr.Expr.ExportedTunnel(exported) =>
+        (fn.isDefinedAt(exported.getExteriorPort), fn.isDefinedAt(exported.getInternalBlockPort)) match {
+          case (true, false) => fn(exported.getExteriorPort)
+          case (false, true) => fn(exported.getInternalBlockPort)
+          case (true, true) => throw new IllegalArgumentException("exterior and interior both matched")
+          case (false, false) => throw new IllegalArgumentException("neither interior nor exterior matched")
+        }
       case _ => throw new IllegalArgumentException
     }
 
@@ -57,6 +64,13 @@ object EdgirUtils {
           case (true, true) => throw new IllegalArgumentException("exterior and interior both matched")
           case (false, false) => throw new IllegalArgumentException("neither interior nor exterior matched")
         }
+      case expr.ValueExpr.Expr.ExportedTunnel(exported) =>
+        (fn.isDefinedAt(exported.getExteriorPort), fn.isDefinedAt(exported.getInternalBlockPort)) match {
+          case (true, false) => connection.update(_.exportedTunnel.exteriorPort := fn(exported.getExteriorPort))
+          case (false, true) => connection.update(_.exportedTunnel.internalBlockPort := fn(exported.getInternalBlockPort))
+          case (true, true) => throw new IllegalArgumentException("exterior and interior both matched")
+          case (false, false) => throw new IllegalArgumentException("neither interior nor exterior matched")
+        }
       case _ => throw new IllegalArgumentException
     }
 

compiler/src/main/scala/edg/ElemBuilder.scala

@@ -39,10 +39,19 @@ object ElemBuilder {
       expr=expr.ValueExpr.Expr.ExportedArray(expr.ExportedExpr(
         exteriorPort=Some(external), internalBlockPort=Some(ValueExpr.Ref(internal))))
     )
+    def ExportedTunnel(external: ref.LocalPath, internal: ref.LocalPath): expr.ValueExpr = expr.ValueExpr(
+      expr=expr.ValueExpr.Expr.ExportedTunnel(expr.ExportedExpr(
+        exteriorPort=Some(ValueExpr.Ref(external)), internalBlockPort=Some(ValueExpr.Ref(internal))))
+    )
+
     def Assign(dst: ref.LocalPath, assignExpr: expr.ValueExpr): expr.ValueExpr = expr.ValueExpr(
       expr=expr.ValueExpr.Expr.Assign(expr.AssignExpr(
         dst=Some(dst), src=Some(assignExpr)))
     )
+    def AssignTunnel(dst: ref.LocalPath, assignExpr: expr.ValueExpr): expr.ValueExpr = expr.ValueExpr(
+      expr=expr.ValueExpr.Expr.AssignTunnel(expr.AssignExpr(
+        dst=Some(dst), src=Some(assignExpr)))
+    )
   }
 
   object Block {

compiler/src/main/scala/edg/compiler/Compiler.scala

@@ -190,11 +190,13 @@ class Compiler(inputDesignPb: schema.Design, library: edg.wir.Library,
       elaboratePending.setValue(ElaborateRecord.ParamValue(param), null)
     }
   }
-  private[edg] def getValue(path: IndirectDesignPath): Option[ExprValue] = constProp.getValue(path)  // TODO clean up this API?
   for ((path, value) <- refinements.instanceValues) {  // seed const prop with path assertions
     constProp.setForcedValue(path.asIndirect, value, "path refinement")
   }
 
+  // Primarily used for unit tests, TODO clean up this API?
+  private[edg] def getValue(path: IndirectDesignPath): Option[ExprValue] = constProp.getValue(path)
+
   private val assertions = mutable.Buffer[(DesignPath, String, expr.ValueExpr, SourceLocator)]()  // containing block, name, expr
 
   // Supplemental elaboration data structures
@@ -323,6 +325,10 @@ class Compiler(inputDesignPb: schema.Design, library: edg.wir.Library,
           constProp.addDirectedEquality(containerPath.asIndirect ++ portPostfix + IndirectStep.IsConnected,
             containerPath.asIndirect ++ exported.getExteriorPort.getRef + IndirectStep.IsConnected,
             containerPath, s"$containerPath.$constrName")
+        case Some((constrName, expr.ValueExpr.Expr.ExportedTunnel(exported))) =>  // same as exported case
+          constProp.addDirectedEquality(containerPath.asIndirect ++ portPostfix + IndirectStep.IsConnected,
+            containerPath.asIndirect ++ exported.getExteriorPort.getRef + IndirectStep.IsConnected,
+            containerPath, s"$containerPath.$constrName")
         case None =>
           recursiveSetNotConnected(containerPath ++ portPostfix, port)
         case Some((_, _)) => throw new IllegalArgumentException
@@ -392,6 +398,12 @@ class Compiler(inputDesignPb: schema.Design, library: edg.wir.Library,
         blockPath.asIndirect ++ assign.dst.get,
         blockPath, assign.src.get, constrName) // TODO add sourcelocators
       true
+    case expr.ValueExpr.Expr.AssignTunnel(assign) =>
+      // same as normal assign case, but would not enforce locality of references
+      constProp.addAssignment(
+        blockPath.asIndirect ++ assign.dst.get,
+        blockPath, assign.src.get, constrName) // TODO add sourcelocators
+      true
     case expr.ValueExpr.Expr.Binary(_) | expr.ValueExpr.Expr.BinarySet(_) |
         expr.ValueExpr.Expr.Unary(_) | expr.ValueExpr.Expr.UnarySet(_) |
         expr.ValueExpr.Expr.IfThenElse(_) =>  // raw ValueExprs interpreted as assertions
@@ -436,6 +448,16 @@ class Compiler(inputDesignPb: schema.Design, library: edg.wir.Library,
           true
         case _ => false  // anything with allocates is not processed
       }
+      case expr.ValueExpr.Expr.ExportedTunnel(exported) => (exported.getExteriorPort, exported.getInternalBlockPort) match {
+        case (ValueExpr.Ref(extPort), ValueExpr.Ref(intPort)) =>
+          require(!isInLink)
+          elaboratePending.addNode(
+            ElaborateRecord.Connect(blockPath ++ extPort, blockPath ++ intPort),
+            Seq(ElaborateRecord.ConnectedLink(blockPath ++ extPort))
+          )
+          true
+        case _ => false  // anything with allocates is not processed
+      }
       case _ => false  // not defined
     }
   }
@@ -706,6 +728,16 @@ class Compiler(inputDesignPb: schema.Design, library: edg.wir.Library,
                 val resolveConnectedTask = ElaborateRecord.ResolveArrayIsConnected(path, portPostfix, singleConnects.map(_._2), arrayConnects.map(_._2), false)
                 elaboratePending.addNode(resolveConnectedTask, Seq(resolveAllocateTask))
 
+              case PortConnections.AllocatedTunnelExport(connects) =>
+                // similar to AllocateDConnect case, except only with single-element connects
+                val setAllocatedTask = ElaborateRecord.ResolveArrayAllocated(path, portPostfix, connects.map(_._2), Seq(), false)
+                elaboratePending.addNode(setAllocatedTask, Seq())
+                val resolveAllocateTask = ElaborateRecord.RewriteConnectAllocate(path, portPostfix, connects.map(_._2), Seq(), false)
+                elaboratePending.addNode(resolveAllocateTask,
+                  Seq(ElaborateRecord.ElaboratePortArray(path ++ portPostfix)) :+ setAllocatedTask)
+                val resolveConnectedTask = ElaborateRecord.ResolveArrayIsConnected(path, portPostfix, connects.map(_._2), Seq(), false)
+                elaboratePending.addNode(resolveConnectedTask, Seq(resolveAllocateTask))
+
               case PortConnections.NotConnected =>
                 constProp.setValue(path.asIndirect ++ portPostfix + IndirectStep.Allocated, ArrayValue(Seq()))
                 val resolveConnectedTask = ElaborateRecord.ResolveArrayIsConnected(path, portPostfix, Seq(), Seq(), false)
@@ -719,6 +751,8 @@ class Compiler(inputDesignPb: schema.Design, library: edg.wir.Library,
             connectedConstraints.connectionsByBlockPort(portPostfix) match {
               case PortConnections.SingleConnect(constrName, constr) =>
                 resolvePortConnectivity(path, portPostfix, Some(constrName, constr))
+              case PortConnections.TunnelExport(constrName, constr) =>
+                resolvePortConnectivity(path, portPostfix, Some(constrName, constr))
               case PortConnections.NotConnected =>
                 resolvePortConnectivity(path, portPostfix, None)
               case connects => throw new IllegalArgumentException(s"invalid connections to element $connects")

compiler/src/main/scala/edg/compiler/DesignRefsValidate.scala

@@ -31,6 +31,10 @@ object CollectExprRefs extends ValueExprMap[Seq[ref.LocalPath]] {
   override def mapUnarySet(unarySet: expr.UnarySetExpr, vals: Seq[ref.LocalPath]): Seq[ref.LocalPath] = {
     vals
   }
+  override def mapArray(array: expr.ArrayExpr,
+                        vals: Seq[Seq[ref.LocalPath]]): Seq[ref.LocalPath] = {
+    vals.flatten
+  }
   override def mapStruct(struct: expr.StructExpr,
                          vals: Map[String, Seq[ref.LocalPath]]): Seq[ref.LocalPath] = {
     vals.values.foldLeft(Seq[ref.LocalPath]()) { _ ++ _ }
@@ -66,9 +70,16 @@ object CollectExprRefs extends ValueExprMap[Seq[ref.LocalPath]] {
                                 internalBlockPort: Seq[ref.LocalPath]): Seq[ref.LocalPath] = {
     exteriorPort ++ internalBlockPort
   }
+  override def mapExportedTunnel(exported: expr.ExportedExpr, exteriorPort: Seq[ref.LocalPath],
+                                 internalBlockPort: Seq[ref.LocalPath]): Seq[ref.LocalPath] = {
+    exteriorPort ++ internalBlockPort
+  }
   override def mapAssign(assign: expr.AssignExpr, src: Seq[ref.LocalPath]): Seq[ref.LocalPath] = {
     assign.dst.toSeq ++ src
   }
+  override def mapAssignTunnel(assign: expr.AssignExpr, src: Seq[ref.LocalPath]): Seq[ref.LocalPath] = {
+    assign.dst.toSeq ++ src
+  }
   override def mapRef(path: ref.LocalPath): Seq[ref.LocalPath] =
     Seq(path)
 }

compiler/src/main/scala/edg/compiler/ExprEvaluate.scala

@@ -302,6 +302,7 @@ object ExprEvaluate {
         case ArrayValue.UnpackRange.RangeWithEmpty(valMins, valMaxs) => RangeValue(valMins.min, valMaxs.max)
         case _ => RangeEmpty
       }
+      case (Op.HULL, ArrayValue.ExtractFloat(vals)) => RangeValue(vals.min, vals.max)
 
       case (Op.NEGATE, vals) => vals match {
         case ArrayValue.ExtractRange(arrayElts) =>
@@ -325,6 +326,8 @@ object ExprEvaluate {
     }
   }
 
+  def evalArray(array: expr.ArrayExpr, vals: Seq[ExprValue]): ExprValue = ArrayValue(vals)
+
   def evalStruct(struct: expr.StructExpr, vals: Map[String, ExprValue]): ExprValue = ???
 
   def evalRange(range: expr.RangeExpr, minimum: ExprValue, maximum: ExprValue): ExprValue = (minimum, maximum) match {
@@ -367,6 +370,9 @@ class ExprEvaluate(refs: ConstProp, root: DesignPath) extends ValueExprMap[ExprV
   override def mapUnarySet(unarySet: expr.UnarySetExpr, vals: ExprValue): ExprValue =
     ExprEvaluate.evalUnarySet(unarySet, vals)
 
+  override def mapArray(array: expr.ArrayExpr, vals: Seq[ExprValue]): ExprValue =
+    ExprEvaluate.evalArray(array, vals)
+
   override def mapStruct(struct: expr.StructExpr, vals: Map[String, ExprValue]): ExprValue =
     ExprEvaluate.evalStruct(struct, vals)
 

compiler/src/main/scala/edg/compiler/ExprEvaluatePartial.scala

@@ -46,6 +46,16 @@ class ExprEvaluatePartial(refs: ConstProp, root: DesignPath) extends ValueExprMa
     case ExprResult.Result(vals) => ExprResult.Result(ExprEvaluate.evalUnarySet(unarySet, vals))
   }
 
+  override def mapArray(array: expr.ArrayExpr, vals: Seq[ExprResult]): ExprResult = {
+    val missing = vals collect {
+      case ExprResult.Missing(missing) => missing
+    }
+    missing match {
+      case Seq() => ExprResult.Result(ExprEvaluate.evalArray(array, vals.map(_.asInstanceOf[ExprResult.Result].value)))
+      case missing => ExprResult.Missing(missing.flatten.toSet)
+    }
+  }
+
   override def mapStruct(struct: expr.StructExpr, vals: Map[String, ExprResult]): ExprResult =
     ???
 

compiler/src/main/scala/edg/compiler/ExprToString.scala

@@ -149,6 +149,10 @@ class ExprToString() extends ValueExprMap[String] {
     case op => s"unknown[$op](${vals})"
   }
 
+  override def mapArray(array: expr.ArrayExpr, vals: Seq[String]): String = {
+    s"array(${vals.mkString(", ")})"
+  }
+
   override def mapStruct(struct: expr.StructExpr, vals: Map[String, String]): String = {
     val valsStr = vals.map { case (k, v) => s"$k: $v" }
     s"struct(${valsStr.mkString(", ")})"
@@ -181,9 +185,16 @@ class ExprToString() extends ValueExprMap[String] {
     s"exported($exteriorPort, $internalBlockPort)"
   }
 
+  override def mapExportedTunnel(exported: expr.ExportedExpr, exteriorPort: String, internalBlockPort: String): String = {
+    s"exportedTunnel($exteriorPort, $internalBlockPort)"
+  }
+
   override def mapAssign(assign: expr.AssignExpr, src: String): String =
     s"${mapRef(assign.getDst)} ⇐ $src"
 
+  override def mapAssignTunnel(assign: expr.AssignExpr, src: String): String =
+    s"${mapRef(assign.getDst)} ⇐() $src"
+
   override def mapRef(path: ref.LocalPath): String = {
     path.steps.map { _.step match {
       case ref.LocalStep.Step.Name(name) => name

compiler/src/main/scala/edg/compiler/ValueExprMap.scala

@@ -18,6 +18,7 @@ trait ValueExprMap[OutputType] {
       case expr.ValueExpr.Expr.BinarySet(valueExpr) => wrapBinarySet(valueExpr)
       case expr.ValueExpr.Expr.Unary(valueExpr) => wrapUnary(valueExpr)
       case expr.ValueExpr.Expr.UnarySet(valueExpr) => wrapUnarySet(valueExpr)
+      case expr.ValueExpr.Expr.Array(valueExpr) => wrapArray(valueExpr)
       case expr.ValueExpr.Expr.Struct(valueExpr) => wrapStruct(valueExpr)
       case expr.ValueExpr.Expr.Range(valueExpr) => wrapRange(valueExpr)
       case expr.ValueExpr.Expr.IfThenElse(valueExpr) => wrapIfThenElse(valueExpr)
@@ -27,7 +28,9 @@ trait ValueExprMap[OutputType] {
       case expr.ValueExpr.Expr.Exported(valueExpr) => wrapExported(valueExpr)
       case expr.ValueExpr.Expr.ConnectedArray(valueExpr) => wrapConnectedArray(valueExpr)
       case expr.ValueExpr.Expr.ExportedArray(valueExpr) => wrapExportedArray(valueExpr)
+      case expr.ValueExpr.Expr.ExportedTunnel(valueExpr) => wrapExportedTunnel(valueExpr)
       case expr.ValueExpr.Expr.Assign(valueExpr) => wrapAssign(valueExpr)
+      case expr.ValueExpr.Expr.AssignTunnel(valueExpr) => wrapAssignTunnel(valueExpr)
       case expr.ValueExpr.Expr.Ref(valueExpr) => mapRef(valueExpr)
       case _ => throw new NotImplementedError(s"Unknown valueExpr $valueExpr")
     }
@@ -45,6 +48,8 @@ trait ValueExprMap[OutputType] {
     throw new NotImplementedError(s"Undefined mapUnary for $unary")
   def mapUnarySet(unarySet: expr.UnarySetExpr, vals: OutputType): OutputType =
     throw new NotImplementedError(s"Undefined mapBinarySet for $unarySet")
+  def mapArray(array: expr.ArrayExpr, vals: Seq[OutputType]): OutputType =
+    throw new NotImplementedError(s"Undefined mapArray for $array")
   def mapStruct(struct: expr.StructExpr, vals: Map[String, OutputType]): OutputType =
     throw new NotImplementedError(s"Undefined mapStruct for $struct")
   def mapRange(range: expr.RangeExpr, minimum: OutputType, maximum: OutputType): OutputType =
@@ -63,8 +68,12 @@ trait ValueExprMap[OutputType] {
     throw new NotImplementedError(s"Undefined mapConnectedArray for $connected")
   def mapExportedArray(exported: expr.ExportedExpr, exteriorPort: OutputType, internalBlockPort: OutputType): OutputType =
     throw new NotImplementedError(s"Undefined mapExportedArray for $exported")
+  def mapExportedTunnel(exported: expr.ExportedExpr, exteriorPort: OutputType, internalBlockPort: OutputType): OutputType =
+    throw new NotImplementedError(s"Undefined mapExportedTunnel for $exported")
   def mapAssign(assign: expr.AssignExpr, src: OutputType): OutputType =
     throw new NotImplementedError(s"Undefined mapAssign for $assign")
+  def mapAssignTunnel(assign: expr.AssignExpr, src: OutputType): OutputType =
+    throw new NotImplementedError(s"Undefined mapAssignTunnel for $assign")
   def mapRef(path: ref.LocalPath): OutputType =
     throw new NotImplementedError(s"Undefined mapRef for $path")
 
@@ -81,6 +90,9 @@ trait ValueExprMap[OutputType] {
   def wrapUnarySet(unarySet: expr.UnarySetExpr): OutputType = {
     mapUnarySet(unarySet, map(unarySet.vals.get))
   }
+  def wrapArray(array: expr.ArrayExpr): OutputType = {
+    mapArray(array, array.vals.map(value => map(value)))
+  }
   def wrapStruct(struct: expr.StructExpr): OutputType = {
     mapStruct(struct, struct.vals.view.mapValues(value => map(value)).toMap)
   }
@@ -108,7 +120,13 @@ trait ValueExprMap[OutputType] {
   def wrapExportedArray(exported: expr.ExportedExpr): OutputType = {
     mapExportedArray(exported, map(exported.exteriorPort.get), map(exported.internalBlockPort.get))
   }
+  def wrapExportedTunnel(exported: expr.ExportedExpr): OutputType = {
+    mapExportedTunnel(exported, map(exported.exteriorPort.get), map(exported.internalBlockPort.get))
+  }
   def wrapAssign(assign: expr.AssignExpr): OutputType = {
     mapAssign(assign, map(assign.src.get))
   }
+  def wrapAssignTunnel(assign: expr.AssignExpr): OutputType = {
+    mapAssign(assign, map(assign.src.get))
+  }
 }