Merge pull request #940 from nasa/feature/topology-ports

Topology Ports

Author: Kronos3

compiler/lib/src/main/resources/META-INF/native-image/reflect-config.json

@@ -71,6 +71,9 @@ case class Analysis(
   interfaceMap: Map[Symbol.Interface, Interface] = Map(),
   /** The interface under construction */
   interface: Option[Interface] = None,
+  /** The map from topology symbols to 'partial' topologies
+   * with only port interface/instance information */
+  partialTopologyMap: Map[Symbol.Topology, Topology] = Map(),
   /** The map from topology symbols to topologies */
   topologyMap: Map[Symbol.Topology, Topology] = Map(),
   /** The topology under construction */
@@ -249,6 +252,29 @@ case class Analysis(
     for (cis <- getComponentInstanceSymbol(id))
       yield this.componentInstanceMap(cis)
 
+  /** Gets an interface instance symbol from the use-def map */
+  def getInterfaceInstanceSymbol(id: AstNode.Id): Result.Result[InterfaceInstanceSymbol] =
+    this.useDefMap(id) match {
+      case cis: Symbol.ComponentInstance => Right(cis)
+      case ts: Symbol.Topology => Right(ts)
+      case s => Left(
+        SemanticError.InvalidSymbol(
+          s.getUnqualifiedName,
+          Locations.get(id),
+          "not a component instance or topology symbol",
+          s.getLoc
+        )
+      )
+    }
+
+  /** Gets an interface instance from the topology or component instance map */
+  def getInterfaceInstance(id: AstNode.Id): Result.Result[InterfaceInstance] =
+    for (iis <- getInterfaceInstanceSymbol(id))
+      yield iis match {
+        case cis: Symbol.ComponentInstance => InterfaceInstance.fromComponentInstance(this.componentInstanceMap(cis))
+        case top: Symbol.Topology => InterfaceInstance.fromTopology(this.topologyMap(top))
+      }
+
   /** Gets an interface symbol from use-def map */
   def getInterfaceSymbol(id: AstNode.Id): Result.Result[Symbol.Interface] =
     this.useDefMap(id) match {

compiler/lib/src/main/scala/analysis/Analysis.scala

@@ -12,18 +12,15 @@ trait BasicUseAnalyzer extends TypeExpressionAnalyzer {
   /** A use of a component definition */
   def componentUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified): Result = default(a)
 
-  /** A use of a component instance definition */
-  def componentInstanceUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified): Result = default(a)
+  /** A use of a interface instance (topology def or component instance def) */
+  def interfaceInstanceUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified): Result = default(a)
 
   /** A use of a constant definition or enumerated constant definition */
   def constantUse(a: Analysis, node: AstNode[Ast.Expr], use: Name.Qualified): Result = default(a)
 
   /** A use of a port definition */
   def portUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified): Result = default(a)
 
-  /** A use of a topology definition */
-  def topologyUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified): Result = default(a)
-
   /** A use of an interface definition */
   def interfaceUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified): Result = default(a)
 
@@ -85,6 +82,13 @@ trait BasicUseAnalyzer extends TypeExpressionAnalyzer {
     val id = node._2.id
     for {
       a <- visitImpliedUses(a, id)
+
+      // Visit port interface uses in the implements clause
+      a <- {
+        Result.foldLeft (node._2.data.implements) (a) ((a, impl) =>
+          qualIdentNode(interfaceUse) (a, impl)
+      )}
+
       a <- super.defTopologyAnnotatedNode(a, node)
     } yield a
   }
@@ -116,10 +120,10 @@ trait BasicUseAnalyzer extends TypeExpressionAnalyzer {
     constantUse(a, node, use)
   }
 
-  override def specCompInstanceAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecCompInstance]]) = {
+  override def specInstanceAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecInstance]]) = {
     val (_, node1, _) = node
     val data = node1.data
-    qualIdentNode (componentInstanceUse) (a, data.instance)
+    qualIdentNode (interfaceInstanceUse) (a, data.instance)
   }
 
   override def specStateMachineInstanceAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecStateMachineInstance]]) = {
@@ -146,8 +150,8 @@ trait BasicUseAnalyzer extends TypeExpressionAnalyzer {
     data match {
       case direct : Ast.SpecConnectionGraph.Direct => visitList(a, direct.connections, connection)
       case pattern : Ast.SpecConnectionGraph.Pattern => for {
-        a <- qualIdentNode (componentInstanceUse) (a, pattern.source)
-        a <- visitList(a, pattern.targets, qualIdentNode(componentInstanceUse))
+        a <- qualIdentNode (interfaceInstanceUse) (a, pattern.source)
+        a <- visitList(a, pattern.targets, qualIdentNode(interfaceInstanceUse))
       } yield a
     }
   }
@@ -187,16 +191,16 @@ trait BasicUseAnalyzer extends TypeExpressionAnalyzer {
     a <- visitList(a, aNode._2.data.omitted, tlmChannelIdentifierNode)
   } yield a
 
-  override def specTopImportAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecImport]]) = {
+  override def specInterfaceImportAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecImport]]) = {
     val (_, node1, _) = node
     val data = node1.data
-    qualIdentNode(topologyUse)(a, data.sym)
+    qualIdentNode(interfaceUse)(a, data.sym)
   }
 
-  override def specInterfaceImportAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecImport]]) = {
+  override def specTopPortAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecTopPort]]) = {
     val (_, node1, _) = node
     val data = node1.data
-    qualIdentNode(interfaceUse)(a, data.sym)
+    portInstanceIdentifierNode(a, data.underlyingPort)
   }
 
   override def typeNameQualIdentNode(a: Analysis, node: AstNode[Ast.TypeName], tn: Ast.TypeNameQualIdent) = {
@@ -217,7 +221,7 @@ trait BasicUseAnalyzer extends TypeExpressionAnalyzer {
   }
 
   private def portInstanceIdentifierNode(a: Analysis, node: AstNode[Ast.PortInstanceIdentifier]): Result =
-    qualIdentNode (componentInstanceUse) (a, node.data.componentInstance)
+    qualIdentNode (interfaceInstanceUse) (a, node.data.interfaceInstance)
 
   private def qualIdentNode
     (f: (Analysis, AstNode[Ast.QualIdent], Name.Qualified) => Result)
@@ -230,7 +234,7 @@ trait BasicUseAnalyzer extends TypeExpressionAnalyzer {
     a: Analysis,
     node: AstNode[Ast.TlmChannelIdentifier]
   ): Result =
-    qualIdentNode (componentInstanceUse) (a, node.data.componentInstance)
+    qualIdentNode (interfaceInstanceUse) (a, node.data.componentInstance)
 
   private def tlmPacketMember(a: Analysis, member: Ast.TlmPacketMember) =
     member match {

compiler/lib/src/main/scala/analysis/Analyzers/BasicUseAnalyzer.scala

@@ -21,7 +21,7 @@ object TopologyAnalyzer {
     node: Ast.Annotated[AstNode[Ast.DefTopology]]
   ) = {
     val (_, node1, _) = node
-    val Ast.DefTopology(name, members) = node1.data
+    val Ast.DefTopology(name, members, _) = node1.data
     val a1 = a.copy(scopeNameList = name :: a.scopeNameList)
     for { a2 <- analyzer.visitList(a1, members, analyzer.matchTopologyMember) }
     yield a2.copy(scopeNameList = a.scopeNameList)

compiler/lib/src/main/scala/analysis/Analyzers/TopologyAnalyzer.scala

@@ -1,7 +1,9 @@
 package fpp.compiler.analysis
 
-import fpp.compiler.ast._
-import fpp.compiler.util._
+import fpp.compiler.ast.*
+import fpp.compiler.util.*
+
+import scala.annotation.tailrec
 
 /**
  * Analyze uses
@@ -10,6 +12,7 @@ import fpp.compiler.util._
 trait UseAnalyzer extends BasicUseAnalyzer {
 
   /** Gets a qualified name from a dot expression */
+  @tailrec
   private def getQualifiedName(
     e: Ast.Expr,
     qualifier: List[Name.Unqualified] = Nil
@@ -18,7 +21,7 @@ trait UseAnalyzer extends BasicUseAnalyzer {
       Name.Qualified.fromIdentList(id :: qualifier)
     case Ast.ExprDot(e1, id) =>
       getQualifiedName(e1.data, id.data :: qualifier)
-    case _ => throw new InternalError("expected a qualified name")
+    case _ => throw InternalError("expected a qualified name")
   }
 
   override def exprDotNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprDot) =
@@ -29,7 +32,7 @@ trait UseAnalyzer extends BasicUseAnalyzer {
         constantUse(a, node, use)
       case Some(_) =>
         // This is some other type of symbol, which it shouldn't be
-        throw new InternalError("expected a constant use")
+        throw InternalError("expected a constant use")
       case None =>
         // e is not a use, so it selects a member of a struct value
         // Analyze the left-hand expression representing the struct value

compiler/lib/src/main/scala/analysis/Analyzers/UseAnalyzer.scala

@@ -25,6 +25,7 @@ object CheckSemantics {
       a <- CheckComponentInstanceDefs.visitList(a, tul, CheckComponentInstanceDefs.transUnit)
       _ <- CheckComponentInstanceDefs.checkIdRanges(a)
       a <- CheckStateMachineDefs.visitList(a, tul, CheckStateMachineDefs.transUnit)
+      a <- CheckTopologyInstances.visitList(a, tul, CheckTopologyInstances.transUnit)
       a <- CheckTopologyDefs.visitList(a, tul, CheckTopologyDefs.transUnit)
       a <- BuildSpecLocMap.visitList(a, tul, BuildSpecLocMap.transUnit)
       a <- CheckSpecLocs.visitList(a, tul, CheckSpecLocs.transUnit)

compiler/lib/src/main/scala/analysis/CheckSemantics/CheckSemantics.scala

@@ -32,7 +32,7 @@ object CheckSpecLocs
   override def defComponentInstanceAnnotatedNode(
     a: Analysis,
     aNode: Ast.Annotated[AstNode[Ast.DefComponentInstance]]
-  ) = checkSpecLoc(a, Ast.SpecLoc.ComponentInstance, Symbol.ComponentInstance(aNode))
+  ) = checkSpecLoc(a, Ast.SpecLoc.Instance, Symbol.ComponentInstance(aNode))
 
   override def defConstantAnnotatedNode(
     a: Analysis,
@@ -67,7 +67,7 @@ object CheckSpecLocs
   override def defTopologyAnnotatedNode(
     a: Analysis,
     aNode: Ast.Annotated[AstNode[Ast.DefTopology]]
-  ) = checkSpecLoc(a, Ast.SpecLoc.Topology, Symbol.Topology(aNode))
+  ) = checkSpecLoc(a, Ast.SpecLoc.Instance, Symbol.Topology(aNode))
 
   private def checkSpecLoc(
     a: Analysis,

compiler/lib/src/main/scala/analysis/CheckSemantics/CheckSpecLocs.scala

@@ -5,7 +5,7 @@ import fpp.compiler.util._
 
 /** Check topology definitions */
 object CheckTopologyDefs
-  extends Analyzer 
+  extends Analyzer
   with ModuleAnalyzer
   with TopologyAnalyzer
 {
@@ -18,19 +18,22 @@ object CheckTopologyDefs
     a.topologyMap.get(symbol) match {
       case None =>
         // Topology is not in the map: visit it
-        val a1 = a.copy(topology = Some(Topology(aNode)))
         for {
-          // Visit topology members and compute unresolved top
-          a <- super.defTopologyAnnotatedNode(a1, aNode)
-          top <- Right(a.topology.get)
+          // Resolve connections on topologies directly imported into this topology
           a <- {
             // Resolve topologies directly imported by top, updating a
-            val tops = top.directImportMap.toList
+            val top = a.partialTopologyMap(symbol)
+            val tops = top.directTopologies.toList
             Result.foldLeft (tops) (a) ((a, tl) => {
               defTopologyAnnotatedNode(a, tl._1.node)
             })
           }
+
+          // Visit topology members and compute unresolved top
+          a <- Right(a.copy(topology = Some(a.partialTopologyMap(symbol))))
+          a <- super.defTopologyAnnotatedNode(a, aNode)
           // Use the updated analysis to resolve top
+          top <- Right(a.topology.get)
           top <- ResolveTopology.resolve(a, top)
         }
         yield a.copy(topologyMap = a.topologyMap + (symbol -> top))
@@ -41,24 +44,6 @@ object CheckTopologyDefs
     }
   }
 
-  override def specCompInstanceAnnotatedNode(
-    a: Analysis,
-    aNode: Ast.Annotated[AstNode[Ast.SpecCompInstance]]
-  ) = {
-    val node = aNode._2
-    val visibility = node.data.visibility
-    val instanceNode = node.data.instance
-    for {
-      instance <- a.getComponentInstance(instanceNode.id)
-      topology <- a.topology.get.addUniqueInstance(
-        instance,
-        visibility,
-        Locations.get(node.id)
-      )
-    }
-    yield a.copy(topology = Some(topology))
-  }
-
   override def specConnectionGraphAnnotatedNode(
     a: Analysis,
     aNode: Ast.Annotated[AstNode[Ast.SpecConnectionGraph]]
@@ -79,20 +64,4 @@ object CheckTopologyDefs
     } yield a.copy(topology = Some(topology))
   }
 
-  override def specTopImportAnnotatedNode(
-    a: Analysis,
-    aNode: Ast.Annotated[AstNode[Ast.SpecImport]]
-  ) = {
-    val node = aNode._2
-    val topNode = node.data.sym
-    for {
-      ts <- a.getTopologySymbol(topNode.id)
-      topology <- a.topology.get.addImportedTopology(
-        ts,
-        Locations.get(node.id)
-      )
-    }
-    yield a.copy(topology = Some(topology))
-  }
-
 }

compiler/lib/src/main/scala/analysis/CheckSemantics/CheckTopologyDefs.scala

@@ -0,0 +1,64 @@
+package fpp.compiler.analysis
+
+import fpp.compiler.ast._
+import fpp.compiler.util._
+
+/** Check topology instances */
+object CheckTopologyInstances
+  extends Analyzer
+  with ModuleAnalyzer
+  with TopologyAnalyzer
+{
+
+  override def defTopologyAnnotatedNode(
+    a: Analysis,
+    aNode: Ast.Annotated[AstNode[Ast.DefTopology]]
+  ) = {
+    val symbol = Symbol.Topology(aNode)
+    a.partialTopologyMap.get(symbol) match {
+      case None =>
+        // Topology is not in the map: visit it
+        val a1 = a.copy(topology = Some(Topology(aNode, a.getQualifiedName(symbol))))
+        for {
+          // Visit topology members and compute unresolved top
+          a <- super.defTopologyAnnotatedNode(a1, aNode)
+          top <- Right(a.topology.get)
+          a <- {
+            // Resolve topologies directly imported by top, updating a
+            val tops = top.directTopologies.toList
+            Result.foldLeft (tops) (a) ((a, tl) => {
+              defTopologyAnnotatedNode(a, tl._1.node)
+            })
+          }
+        }
+        yield a.copy(
+          partialTopologyMap = a.partialTopologyMap + (symbol -> top)
+        )
+      case _ => {
+        // Topology is already in the map: nothing to do
+        Right(a)
+      }
+    }
+  }
+
+  override def specTopPortAnnotatedNode(
+    a: Analysis,
+    aNode: Ast.Annotated[AstNode[Ast.SpecTopPort]]
+  ) = {
+    Right(a.copy(topology = Some(a.topology.get.addPortNode(aNode))))
+  }
+
+  override def specInstanceAnnotatedNode(
+    a: Analysis,
+    aNode: Ast.Annotated[AstNode[Ast.SpecInstance]]
+  ) = {
+    val node = aNode._2
+    val instanceNode = node.data.instance
+    for {
+      symbol <- a.getInterfaceInstanceSymbol(instanceNode.id)
+      topology <- a.topology.get.addInstanceSymbol(symbol, Locations.get(node.id))
+    }
+    yield a.copy(topology = Some(topology))
+  }
+
+}

compiler/lib/src/main/scala/analysis/CheckSemantics/CheckTopologyInstances.scala

@@ -52,7 +52,7 @@ object CheckUseDefCycles extends UseAnalyzer {
   override def interfaceUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified) =
     visitUse(a, node, use)
 
-  override def topologyUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified) =
+  override def interfaceInstanceUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified) =
     visitUse(a, node, use)
 
   override def typeUse(a: Analysis, node: AstNode[Ast.TypeName], use: Name.Qualified) =