Interfaces syntax

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

@@ -149,10 +149,10 @@ trait UseAnalyzer extends TypeExpressionAnalyzer {
     a <- visitList(a, aNode._2.data.omitted, tlmChannelIdentifierNode)
   } yield a
 
-  override def specTopImportAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecTopImport]]) = {
+  override def specTopImportAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecImport]]) = {
     val (_, node1, _) = node
     val data = node1.data
-    qualIdentNode(topologyUse)(a, data.top)
+    qualIdentNode(topologyUse)(a, data.sym)
   }
 
   override def typeNameQualIdentNode(a: Analysis, node: AstNode[Ast.TypeName], tn: Ast.TypeNameQualIdent) = {

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

@@ -81,10 +81,10 @@ object CheckTopologyDefs
 
   override def specTopImportAnnotatedNode(
     a: Analysis,
-    aNode: Ast.Annotated[AstNode[Ast.SpecTopImport]]
+    aNode: Ast.Annotated[AstNode[Ast.SpecImport]]
   ) = {
     val node = aNode._2
-    val topNode = node.data.top
+    val topNode = node.data.sym
     for {
       ts <- a.getTopologySymbol(topNode.id)
       topology <- a.topology.get.addImportedTopology(

compiler/lib/src/main/scala/ast/Ast.scala

@@ -69,6 +69,7 @@ object Ast {
     final case class SpecRecord(node: AstNode[Ast.SpecRecord]) extends Node
     final case class SpecStateMachineInstance(node: AstNode[Ast.SpecStateMachineInstance]) extends Node
     final case class SpecTlmChannel(node: AstNode[Ast.SpecTlmChannel]) extends Node
+    final case class SpecImportInterface(node: AstNode[Ast.SpecImport]) extends Node
   }
 
   /** Abstract type definition */
@@ -144,6 +145,7 @@ object Ast {
     final case class DefComponentInstance(node: AstNode[Ast.DefComponentInstance]) extends Node
     final case class DefConstant(node: AstNode[Ast.DefConstant]) extends Node
     final case class DefEnum(node: AstNode[Ast.DefEnum]) extends Node
+    final case class DefInterface(node: AstNode[Ast.DefInterface]) extends Node
     final case class DefModule(node: AstNode[Ast.DefModule]) extends Node
     final case class DefPort(node: AstNode[Ast.DefPort]) extends Node
     final case class DefStateMachine(node: AstNode[Ast.DefStateMachine]) extends Node
@@ -259,6 +261,20 @@ object Ast {
     final case class Do(actions: List[AstNode[Ident]]) extends TransitionOrDo
   }
 
+  /** Interface member */
+  final case class InterfaceMember(node: Annotated[InterfaceMember.Node])
+  object InterfaceMember {
+    sealed trait Node
+    final case class SpecPortInstance(node: AstNode[Ast.SpecPortInstance]) extends Node
+    final case class SpecImportInterface(node: AstNode[Ast.SpecImport]) extends Node
+  }
+
+  /** Interface definition */
+  final case class DefInterface(
+    name: Ident,
+    members: List[InterfaceMember]
+  )
+
   /** Struct definition */
   final case class DefStruct(
     name: Ident,
@@ -294,7 +310,7 @@ object Ast {
     final case class SpecConnectionGraph(node: AstNode[Ast.SpecConnectionGraph]) extends Node
     final case class SpecInclude(node: AstNode[Ast.SpecInclude]) extends Node
     final case class SpecTlmPacketSet(node: AstNode[Ast.SpecTlmPacketSet]) extends Node
-    final case class SpecTopImport(node: AstNode[Ast.SpecTopImport]) extends Node
+    final case class SpecTopImport(node: AstNode[Ast.SpecImport]) extends Node
   }
 
   /** Formal parameter */
@@ -582,6 +598,9 @@ object Ast {
     case object Type extends Kind {
       override def toString = "type"
     }
+    case object Interface extends Kind {
+      override def toString = "interface"
+    }
   }
 
   /** Parameter specifier */
@@ -764,8 +783,8 @@ object Ast {
     omitted: List[AstNode[TlmChannelIdentifier]]
   )
 
-  /** Topology import specifier */
-  final case class SpecTopImport(top: AstNode[QualIdent])
+  /** Import specifier */
+  final case class SpecImport(sym: AstNode[QualIdent])
 
   /** Struct member */
   final case class StructMember(name: Ident, value: AstNode[Expr])

compiler/lib/src/main/scala/ast/AstTransformer.scala

@@ -40,6 +40,9 @@ trait AstTransformer {
     node: Ast.Annotated[AstNode[Ast.DefComponentInstance]]
   ): ResultAnnotatedNode[Ast.DefComponentInstance] = Right(default(in), node)
 
+  def defInterfaceAnnotatedNode(in: In, node: Ast.Annotated[AstNode[Ast.DefInterface]]): ResultAnnotatedNode[Ast.DefInterface] =
+    Right(default(in), node)
+
   def defConstantAnnotatedNode(
     in: In,
     node: Ast.Annotated[AstNode[Ast.DefConstant]]
@@ -195,8 +198,13 @@ trait AstTransformer {
 
   def specTopImportAnnotatedNode(
     in: In,
-    node: Ast.Annotated[AstNode[Ast.SpecTopImport]]
-  ): ResultAnnotatedNode[Ast.SpecTopImport] = Right(default(in), node)
+    node: Ast.Annotated[AstNode[Ast.SpecImport]]
+  ): ResultAnnotatedNode[Ast.SpecImport] = Right(default(in), node)
+
+  def specInterfaceImportAnnotatedNode(
+    in: In,
+    node: Ast.Annotated[AstNode[Ast.SpecImport]]
+  ): ResultAnnotatedNode[Ast.SpecImport] = Right(default(in), node)
 
   def transUnit(in: In, tu: Ast.TransUnit): Result[Ast.TransUnit] =
     Right(default(in), tu)
@@ -264,6 +272,27 @@ trait AstTransformer {
         transform(specStateMachineInstanceAnnotatedNode(in, (pre, node1, post)), Ast.ComponentMember.SpecStateMachineInstance(_))
       case Ast.ComponentMember.SpecTlmChannel(node1) =>
         transform(specTlmChannelAnnotatedNode(in, (pre, node1, post)), Ast.ComponentMember.SpecTlmChannel(_))
+      case Ast.ComponentMember.SpecImportInterface(node1) =>
+        transform(specInterfaceImportAnnotatedNode(in, (pre, node1, post)), Ast.ComponentMember.SpecImportInterface(_))
+    }
+  }
+
+  final def matchInterfaceMember(in: In, member: Ast.InterfaceMember): Result[Ast.InterfaceMember] = {
+    def transform[T](
+      result: ResultAnnotatedNode[T],
+      f: AstNode[T] => Ast.InterfaceMember.Node
+    ) = {
+      for { pair <- result } yield {
+        val (out, (pre, node, post)) = pair
+        (out, Ast.InterfaceMember(pre, f(node), post))
+      }
+    }
+    val (pre, node, post) =  member.node
+    node match {
+      case Ast.InterfaceMember.SpecPortInstance(node1) =>
+        transform(specPortInstanceAnnotatedNode(in, (pre, node1, post)), Ast.InterfaceMember.SpecPortInstance(_))
+      case Ast.InterfaceMember.SpecImportInterface(node1) =>
+        transform(specInterfaceImportAnnotatedNode(in, (pre, node1, post)), Ast.InterfaceMember.SpecImportInterface(_))
     }
   }
 
@@ -304,6 +333,8 @@ trait AstTransformer {
         transform(defComponentAnnotatedNode(in, (pre, node1, post)), Ast.ModuleMember.DefComponent(_))
       case Ast.ModuleMember.DefComponentInstance(node1) =>
         transform(defComponentInstanceAnnotatedNode(in, (pre, node1, post)), Ast.ModuleMember.DefComponentInstance(_))
+      case Ast.ModuleMember.DefInterface(node1) =>
+        transform(defInterfaceAnnotatedNode(in, (pre, node1, post)), Ast.ModuleMember.DefInterface(_))
       case Ast.ModuleMember.DefConstant(node1) =>
         transform(defConstantAnnotatedNode(in, (pre, node1, post)), Ast.ModuleMember.DefConstant(_))
       case Ast.ModuleMember.DefEnum(node1) =>

compiler/lib/src/main/scala/ast/AstVisitor.scala

@@ -21,6 +21,8 @@ trait AstVisitor {
 
   def defComponentAnnotatedNode(in: In, node: Ast.Annotated[AstNode[Ast.DefComponent]]): Out = default(in)
 
+  def defInterfaceAnnotatedNode(in: In, node: Ast.Annotated[AstNode[Ast.DefInterface]]): Out = default(in)
+
   def defComponentInstanceAnnotatedNode(in: In, node: Ast.Annotated[AstNode[Ast.DefComponentInstance]]): Out = default(in)
 
   def defConstantAnnotatedNode(in: In, node: Ast.Annotated[AstNode[Ast.DefConstant]]): Out = default(in)
@@ -122,7 +124,9 @@ trait AstVisitor {
 
   def specTlmPacketSetAnnotatedNode(in: In, node: Ast.Annotated[AstNode[Ast.SpecTlmPacketSet]]): Out = default(in)
 
-  def specTopImportAnnotatedNode(in: In, node: Ast.Annotated[AstNode[Ast.SpecTopImport]]): Out = default(in)
+  def specTopImportAnnotatedNode(in: In, node: Ast.Annotated[AstNode[Ast.SpecImport]]): Out = default(in)
+
+  def specInterfaceImportAnnotatedNode(in: In, node: Ast.Annotated[AstNode[Ast.SpecImport]]): Out = default(in)
 
   def transUnit(in: In, tu: Ast.TransUnit): Out = default(in)
 
@@ -157,6 +161,15 @@ trait AstVisitor {
       case Ast.ComponentMember.SpecRecord(node1) => specRecordAnnotatedNode(in, (pre, node1, post))
       case Ast.ComponentMember.SpecStateMachineInstance(node1) => specStateMachineInstanceAnnotatedNode(in, (pre, node1, post))
       case Ast.ComponentMember.SpecTlmChannel(node1) => specTlmChannelAnnotatedNode(in, (pre, node1, post))
+      case Ast.ComponentMember.SpecImportInterface(node1) => specInterfaceImportAnnotatedNode(in, (pre, node1, post))
+    }
+  }
+
+  final def matchInterfaceMember(in: In, member: Ast.InterfaceMember): Out = {
+    val (pre, node, post) =  member.node
+    node match {
+      case Ast.InterfaceMember.SpecPortInstance(node1) => specPortInstanceAnnotatedNode(in, (pre, node1, post))
+      case Ast.InterfaceMember.SpecImportInterface(node1) => specInterfaceImportAnnotatedNode(in, (pre, node1, post))
     }
   }
 
@@ -182,6 +195,7 @@ trait AstVisitor {
       case Ast.ModuleMember.DefAliasType(node1) => defAliasTypeAnnotatedNode(in, (pre, node1, post))
       case Ast.ModuleMember.DefArray(node1) => defArrayAnnotatedNode(in, (pre, node1, post))
       case Ast.ModuleMember.DefComponent(node1) => defComponentAnnotatedNode(in, (pre, node1, post))
+      case Ast.ModuleMember.DefInterface(node1) => defInterfaceAnnotatedNode(in, (pre, node1, post))
       case Ast.ModuleMember.DefComponentInstance(node1) => defComponentInstanceAnnotatedNode(in, (pre, node1, post))
       case Ast.ModuleMember.DefConstant(node1) => defConstantAnnotatedNode(in, (pre, node1, post))
       case Ast.ModuleMember.DefEnum(node1) => defEnumAnnotatedNode(in, (pre, node1, post))

compiler/lib/src/main/scala/codegen/AstWriter.scala

@@ -88,6 +88,19 @@ object AstWriter extends AstVisitor with LineUtils {
     ).map(indentIn)
   }
 
+  override def defInterfaceAnnotatedNode(
+    in: In,
+    aNode: Ast.Annotated[AstNode[Ast.DefInterface]]
+  ) = {
+    val (_, node, _) = aNode
+    val data = node.data
+    lines("def interface") ++
+    (
+      ident(data.name) ++
+      data.members.flatMap(interfaceMember)
+    ).map(indentIn)
+  }
+
   override def defComponentInstanceAnnotatedNode(
     in: In,
     aNode: Ast.Annotated[AstNode[Ast.DefComponentInstance]]
@@ -668,12 +681,22 @@ object AstWriter extends AstVisitor with LineUtils {
 
   override def specTopImportAnnotatedNode(
     in: In,
-    aNode: Ast.Annotated[AstNode[Ast.SpecTopImport]]
+    aNode: Ast.Annotated[AstNode[Ast.SpecImport]]
   ) = {
     val (_, node, _) = aNode
     val data = node.data
     lines("spec top import") ++
-    qualIdent(data.top.data).map(indentIn)
+    qualIdent(data.sym.data).map(indentIn)
+  }
+
+  override def specInterfaceImportAnnotatedNode(
+    in: In,
+    aNode: Ast.Annotated[AstNode[Ast.SpecImport]]
+  ) = {
+    val (_, node, _) = aNode
+    val data = node.data
+    lines("spec interface import") ++
+    qualIdent(data.sym.data).map(indentIn)
   }
 
   override def transUnit(in: In, tu: Ast.TransUnit) =
@@ -755,6 +778,12 @@ object AstWriter extends AstVisitor with LineUtils {
     annotate(a1, l, a2)
   }
 
+  private def interfaceMember(member: Ast.InterfaceMember) = {
+    val (a1, _, a2) = member.node
+    val l = matchInterfaceMember((), member)
+    annotate(a1, l, a2)
+  }
+
   private def actionList(actions: List[AstNode[Ast.Ident]]): List[Line] =
     actions.map(node => line(s"action ident ${node.data}"))
 

compiler/lib/src/main/scala/codegen/FppWriter.scala

@@ -62,6 +62,12 @@ object FppWriter extends AstVisitor with LineUtils {
     annotate(a1, l, a2)
   }
 
+  def interfaceMember(member: Ast.InterfaceMember): Out = {
+    val (a1, _, a2) = member.node
+    val l = matchInterfaceMember((), member)
+    annotate(a1, l, a2)
+  }
+
   def transitionExpr(transition: Ast.TransitionExpr): Out = {
     val sep = if transition.actions.isEmpty then "enter " else " enter "
     actionList(transition.actions).
@@ -200,6 +206,17 @@ object FppWriter extends AstVisitor with LineUtils {
       joinWithBreak ("") (initSpecs(data.initSpecs))
   }
 
+  override def defInterfaceAnnotatedNode(
+    in: In,
+    aNode: Ast.Annotated[AstNode[Ast.DefInterface]]
+  ) = {
+    val (_, node, _) = aNode
+    val data = node.data
+    List(line(s"interface ${ident(data.name)} {"), Line.blank) ++
+    (Line.blankSeparated (interfaceMember) (data.members)).map(indentIn) ++
+    List(Line.blank, line("}"))
+  }
+
   override def defConstantAnnotatedNode(
     in: In,
     aNode: Ast.Annotated[AstNode[Ast.DefConstant]]
@@ -694,11 +711,20 @@ object FppWriter extends AstVisitor with LineUtils {
 
   override def specTopImportAnnotatedNode(
     in: In,
-    aNode: Ast.Annotated[AstNode[Ast.SpecTopImport]]
+    aNode: Ast.Annotated[AstNode[Ast.SpecImport]]
+  ) = {
+    val (_, node, _) = aNode
+    val data = node.data
+    Line.addPrefix("import ", qualIdent(data.sym.data))
+  }
+
+  override def specInterfaceImportAnnotatedNode(
+    in: In,
+    aNode: Ast.Annotated[AstNode[Ast.SpecImport]]
   ) = {
     val (_, node, _) = aNode
     val data = node.data
-    Line.addPrefix("import ", qualIdent(data.top.data))
+    Line.addPrefix("import ", qualIdent(data.sym.data))
   }
 
   override def transUnit(

compiler/lib/src/main/scala/syntax/Lexer.scala

@@ -73,6 +73,7 @@ object Lexer {
     ("initial", INITIAL),
     ("input", INPUT),
     ("instance", INSTANCE),
+    ("interface", INTERFACE),
     ("internal", INTERNAL),
     ("locate", LOCATE),
     ("low", LOW),
@@ -273,6 +274,7 @@ object Lexer {
         case INITIAL => Token.INITIAL()
         case INPUT => Token.INPUT()
         case INSTANCE => Token.INSTANCE()
+        case INTERFACE => Token.INTERFACE()
         case INTERNAL => Token.INTERNAL()
         case CHOICE => Token.CHOICE()
         case LBRACE => Token.LBRACE()

compiler/lib/src/main/scala/syntax/Parser.scala

@@ -51,6 +51,8 @@ object Parser extends Parsers {
         Ast.ComponentMember.SpecStateMachineInstance(n)) |
       node(specTlmChannel) ^^ (n =>
         Ast.ComponentMember.SpecTlmChannel(n)) |
+      node(specImport) ^^ (n =>
+        Ast.ComponentMember.SpecImportInterface(n)) |
       failure("component member expected")
   }
 
@@ -152,6 +154,23 @@ object Parser extends Parsers {
     }
   }
 
+  private def interfaceMemberNode: Parser[Ast.InterfaceMember.Node] = {
+      node(specPortInstance) ^^ (n =>
+        Ast.InterfaceMember.SpecPortInstance(n)) |
+      node(specImport) ^^ (n =>
+        Ast.InterfaceMember.SpecImportInterface(n)) |
+      failure("component member expected")
+  }
+
+  def interfaceMembers: Parser[List[Ast.InterfaceMember]] =
+    annotatedElementSequence(interfaceMemberNode, semi, Ast.InterfaceMember(_))
+
+  def defInterface: Parser[Ast.DefInterface] = {
+    (interface ~>! ident) ~! (lbrace ~>! interfaceMembers <~! rbrace) ^^ {
+      case name ~ members => Ast.DefInterface(name, members)
+    }
+  }
+
   def defConstant: Parser[Ast.DefConstant] = {
     (constant ~>! ident) ~! (equals ~>! exprNode) ^^ { case id ~ e =>
       Ast.DefConstant(id, e)
@@ -393,6 +412,7 @@ object Parser extends Parsers {
       node(defAbsType) ^^ (n => Ast.ModuleMember.DefAbsType(n)) |
       node(defArray) ^^ (n => Ast.ModuleMember.DefArray(n)) |
       node(defComponent) ^^ (n => Ast.ModuleMember.DefComponent(n)) |
+      node(defInterface) ^^ (n => Ast.ModuleMember.DefInterface(n)) |
       node(defComponentInstance) ^^ (n =>
         Ast.ModuleMember.DefComponentInstance(n)) |
       node(defConstant) ^^ (n => Ast.ModuleMember.DefConstant(n)) |
@@ -822,8 +842,8 @@ object Parser extends Parsers {
     }
   }
 
-  def specTopImport: Parser[Ast.SpecTopImport] =
-    importToken ~>! node(qualIdent) ^^ (top => Ast.SpecTopImport(top))
+  def specImport: Parser[Ast.SpecImport] =
+    importToken ~>! node(qualIdent) ^^ (top => Ast.SpecImport(top))
 
   private def specStateTransition: Parser[Ast.SpecStateTransition] = {
     (on ~> node(ident)) ~! opt(ifToken ~> node(ident)) ~ transitionOrDo ^^ {
@@ -914,7 +934,7 @@ object Parser extends Parsers {
       node(specInclude) ^^ (n => Ast.TopologyMember.SpecInclude(n)) |
       node(specTlmPacketSet) ^^ (n =>
         Ast.TopologyMember.SpecTlmPacketSet(n)) |
-      node(specTopImport) ^^ (n => Ast.TopologyMember.SpecTopImport(n)) |
+      node(specImport) ^^ (n => Ast.TopologyMember.SpecTopImport(n)) |
       failure("topology member expected")
   }
 
@@ -1151,6 +1171,8 @@ object Parser extends Parsers {
 
   private def internal = accept("internal", { case t: Token.INTERNAL => t })
 
+  private def interface = accept("interface", { case t: Token.INTERFACE => t })
+
   private def lbracket = accept("[", { case t: Token.LBRACKET => t })
 
   private def literalFloat: Parser[String] =