State Machine/State Include Specifiers

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

@@ -186,10 +186,11 @@ object Ast {
     final case class DefChoice(node: AstNode[Ast.DefChoice]) 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 DefStruct(node: AstNode[Ast.DefStruct]) extends Node
     final case class DefGuard(node: AstNode[Ast.DefGuard]) extends Node
     final case class DefSignal(node: AstNode[Ast.DefSignal]) extends Node
     final case class DefState(node: AstNode[Ast.DefState]) extends Node
+    final case class DefStruct(node: AstNode[Ast.DefStruct]) extends Node
+    final case class SpecInclude(node: AstNode[Ast.SpecInclude]) extends Node
     final case class SpecInitialTransition(node: AstNode[Ast.SpecInitialTransition]) extends Node
   }
 
@@ -237,6 +238,7 @@ object Ast {
     sealed trait Node
     final case class DefChoice(node: AstNode[Ast.DefChoice]) extends Node
     final case class DefState(node: AstNode[Ast.DefState]) extends Node
+    final case class SpecInclude(node: AstNode[Ast.SpecInclude]) extends Node
     final case class SpecInitialTransition(node: AstNode[Ast.SpecInitialTransition]) extends Node
     final case class SpecStateEntry(node: AstNode[Ast.SpecStateEntry]) extends Node
     final case class SpecStateExit(node: AstNode[Ast.SpecStateExit]) extends Node

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

@@ -23,6 +23,12 @@ trait AstTransformer {
   ): ResultAnnotatedNode[Ast.DefAbsType] =
     Right(default(in), node)
 
+  def defActionAnnotatedNode(
+    in: In,
+    node: Ast.Annotated[AstNode[Ast.DefAction]]
+  ): ResultAnnotatedNode[Ast.DefAction] =
+    Right(default(in), node)
+
   def defAliasTypeAnnotatedNode(
     in: In,
     node: Ast.Annotated[AstNode[Ast.DefAliasType]]
@@ -32,6 +38,12 @@ trait AstTransformer {
   def defArrayAnnotatedNode(in: In, node: Ast.Annotated[AstNode[Ast.DefArray]]): ResultAnnotatedNode[Ast.DefArray] =
     Right(default(in), node)
 
+  def defChoiceAnnotatedNode(
+    in: In,
+    node: Ast.Annotated[AstNode[Ast.DefChoice]]
+  ): ResultAnnotatedNode[Ast.DefChoice] =
+    Right(default(in), node)
+
   def defComponentAnnotatedNode(in: In, node: Ast.Annotated[AstNode[Ast.DefComponent]]): ResultAnnotatedNode[Ast.DefComponent] =
     Right(default(in), node)
 
@@ -40,9 +52,6 @@ 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]]
@@ -53,6 +62,15 @@ trait AstTransformer {
     node: Ast.Annotated[AstNode[Ast.DefEnum]]
   ): ResultAnnotatedNode[Ast.DefEnum] = Right(default(in), node)
 
+  def defGuardAnnotatedNode(
+    in: In,
+    node: Ast.Annotated[AstNode[Ast.DefGuard]]
+  ): ResultAnnotatedNode[Ast.DefGuard] =
+    Right(default(in), node)
+
+  def defInterfaceAnnotatedNode(in: In, node: Ast.Annotated[AstNode[Ast.DefInterface]]): ResultAnnotatedNode[Ast.DefInterface] =
+    Right(default(in), node)
+
   def defModuleAnnotatedNode(
     in: In,
     node: Ast.Annotated[AstNode[Ast.DefModule]]
@@ -63,6 +81,18 @@ trait AstTransformer {
     node: Ast.Annotated[AstNode[Ast.DefPort]]
   ): ResultAnnotatedNode[Ast.DefPort] = Right(default(in), node)
 
+  def defSignalAnnotatedNode(
+    in: In,
+    node: Ast.Annotated[AstNode[Ast.DefSignal]]
+  ): ResultAnnotatedNode[Ast.DefSignal] =
+    Right(default(in), node)
+
+  def defStateAnnotatedNode(
+    in: In,
+    node: Ast.Annotated[AstNode[Ast.DefState]]
+  ): ResultAnnotatedNode[Ast.DefState] =
+    Right(default(in), node)
+
   def defStateMachineAnnotatedNode(
     in: In,
     node: Ast.Annotated[AstNode[Ast.DefStateMachine]]
@@ -149,6 +179,17 @@ trait AstTransformer {
     node: Ast.Annotated[AstNode[Ast.SpecInit]]
   ): ResultAnnotatedNode[Ast.SpecInit] = Right(default(in), node)
 
+  def specInitialTransitionAnnotatedNode(
+    in: In,
+    node: Ast.Annotated[AstNode[Ast.SpecInitialTransition]]
+  ): ResultAnnotatedNode[Ast.SpecInitialTransition] =
+    Right(default(in), node)
+
+  def specInterfaceImportAnnotatedNode(
+    in: In,
+    node: Ast.Annotated[AstNode[Ast.SpecImport]]
+  ): ResultAnnotatedNode[Ast.SpecImport] = Right(default(in), node)
+
   def specInternalPortAnnotatedNode(
     in: In,
     node: Ast.Annotated[AstNode[Ast.SpecInternalPort]]
@@ -179,11 +220,29 @@ trait AstTransformer {
     node: Ast.Annotated[AstNode[Ast.SpecRecord]]
   ): ResultAnnotatedNode[Ast.SpecRecord] = Right(default(in), node)
 
+  def specStateEntryAnnotatedNode(
+    in: In,
+    node: Ast.Annotated[AstNode[Ast.SpecStateEntry]]
+  ): ResultAnnotatedNode[Ast.SpecStateEntry] =
+    Right(default(in), node)
+
+  def specStateExitAnnotatedNode(
+    in: In,
+    node: Ast.Annotated[AstNode[Ast.SpecStateExit]]
+  ): ResultAnnotatedNode[Ast.SpecStateExit] =
+    Right(default(in), node)
+
   def specStateMachineInstanceAnnotatedNode(
     in: In,
     node: Ast.Annotated[AstNode[Ast.SpecStateMachineInstance]]
   ): ResultAnnotatedNode[Ast.SpecStateMachineInstance] = Right(default(in), node)
 
+  def specStateTransitionAnnotatedNode(
+    in: In,
+    node: Ast.Annotated[AstNode[Ast.SpecStateTransition]]
+  ): ResultAnnotatedNode[Ast.SpecStateTransition] =
+    Right(default(in), node)
+
   def specTlmChannelAnnotatedNode(
     in: In,
     node: Ast.Annotated[AstNode[Ast.SpecTlmChannel]]
@@ -204,11 +263,6 @@ trait AstTransformer {
     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)
 
@@ -315,6 +369,76 @@ trait AstTransformer {
       case e : Ast.ExprUnop => exprUnopNode(in, node, e)
     }
 
+  final def matchStateMember(in: In, member: Ast.StateMember): Result[Ast.StateMember] = {
+    def transform[T](
+      result: ResultAnnotatedNode[T],
+      f: AstNode[T] => Ast.StateMember.Node
+    ) = {
+      for { pair <- result } yield {
+        val (out, (pre, node, post)) = pair
+        (out, Ast.StateMember(pre, f(node), post))
+      }
+    }
+    val (pre, node, post) =  member.node
+    node match {
+      case Ast.StateMember.DefChoice(node1) =>
+        transform(defChoiceAnnotatedNode(in, (pre, node1, post)), Ast.StateMember.DefChoice(_))
+      case Ast.StateMember.DefState(node1) =>
+        transform(defStateAnnotatedNode(in, (pre, node1, post)), Ast.StateMember.DefState(_))
+      case Ast.StateMember.SpecInclude(node1) =>
+        transform(specIncludeAnnotatedNode(in, (pre, node1, post)), Ast.StateMember.SpecInclude(_))
+      case Ast.StateMember.SpecInitialTransition(node1) =>
+        transform(specInitialTransitionAnnotatedNode(in, (pre, node1, post)), Ast.StateMember.SpecInitialTransition(_))
+      case Ast.StateMember.SpecStateEntry(node1) =>
+        transform(specStateEntryAnnotatedNode(in, (pre, node1, post)), Ast.StateMember.SpecStateEntry(_))
+      case Ast.StateMember.SpecStateExit(node1) =>
+        transform(specStateExitAnnotatedNode(in, (pre, node1, post)), Ast.StateMember.SpecStateExit(_))
+      case Ast.StateMember.SpecStateTransition(node1) =>
+        transform(specStateTransitionAnnotatedNode(in, (pre, node1, post)), Ast.StateMember.SpecStateTransition(_))
+    }
+  }
+
+  final def matchStateMachineMember(in: In, member: Ast.StateMachineMember): Result[Ast.StateMachineMember] = {
+    def transform[T](
+      result: ResultAnnotatedNode[T],
+      f: AstNode[T] => Ast.StateMachineMember.Node
+    ) = {
+      for { pair <- result } yield {
+        val (out, (pre, node, post)) = pair
+        (out, Ast.StateMachineMember(pre, f(node), post))
+      }
+    }
+    val (pre, node, post) =  member.node
+    node match {
+      case Ast.StateMachineMember.DefAbsType(node1) =>
+        transform(defAbsTypeAnnotatedNode(in, (pre, node1, post)), Ast.StateMachineMember.DefAbsType(_))
+      case Ast.StateMachineMember.DefAction(node1) =>
+        transform(defActionAnnotatedNode(in, (pre, node1, post)), Ast.StateMachineMember.DefAction(_))
+      case Ast.StateMachineMember.DefAliasType(node1) =>
+        transform(defAliasTypeAnnotatedNode(in, (pre, node1, post)), Ast.StateMachineMember.DefAliasType(_))
+      case Ast.StateMachineMember.DefArray(node1) =>
+        transform(defArrayAnnotatedNode(in, (pre, node1, post)), Ast.StateMachineMember.DefArray(_))
+      case Ast.StateMachineMember.DefChoice(node1) =>
+        transform(defChoiceAnnotatedNode(in, (pre, node1, post)), Ast.StateMachineMember.DefChoice(_))
+      case Ast.StateMachineMember.DefConstant(node1) =>
+        transform(defConstantAnnotatedNode(in, (pre, node1, post)), Ast.StateMachineMember.DefConstant(_))
+      case Ast.StateMachineMember.DefEnum(node1) =>
+        transform(defEnumAnnotatedNode(in, (pre, node1, post)), Ast.StateMachineMember.DefEnum(_))
+      case Ast.StateMachineMember.DefGuard(node1) =>
+        transform(defGuardAnnotatedNode(in, (pre, node1, post)), Ast.StateMachineMember.DefGuard(_))
+      case Ast.StateMachineMember.DefSignal(node1) =>
+        transform(defSignalAnnotatedNode(in, (pre, node1, post)), Ast.StateMachineMember.DefSignal(_))
+      case Ast.StateMachineMember.DefState(node1) =>
+        transform(defStateAnnotatedNode(in, (pre, node1, post)), Ast.StateMachineMember.DefState(_))
+      case Ast.StateMachineMember.DefStruct(node1) =>
+        transform(defStructAnnotatedNode(in, (pre, node1, post)), Ast.StateMachineMember.DefStruct(_))
+      case Ast.StateMachineMember.SpecInclude(node1) =>
+        transform(specIncludeAnnotatedNode(in, (pre, node1, post)), Ast.StateMachineMember.SpecInclude(_))
+      case Ast.StateMachineMember.SpecInitialTransition(node1) =>
+        transform(specInitialTransitionAnnotatedNode(in, (pre, node1, post)), Ast.StateMachineMember.SpecInitialTransition(_))
+    }
+  }
+
   final def matchModuleMember(in: In, member: Ast.ModuleMember): Result[Ast.ModuleMember] = {
     def transform[T](
       result: ResultAnnotatedNode[T],

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

@@ -198,10 +198,10 @@ 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))
+      case Ast.ModuleMember.DefInterface(node1) => defInterfaceAnnotatedNode(in, (pre, node1, post))
       case Ast.ModuleMember.DefModule(node1) => defModuleAnnotatedNode(in, (pre, node1, post))
       case Ast.ModuleMember.DefPort(node1) => defPortAnnotatedNode(in, (pre, node1, post))
       case Ast.ModuleMember.DefStateMachine(node1) => defStateMachineAnnotatedNode(in, (pre, node1, post))
@@ -226,6 +226,7 @@ trait AstVisitor {
       case Ast.StateMachineMember.DefSignal(node1) => defSignalAnnotatedNode(in, (pre, node1, post))
       case Ast.StateMachineMember.DefState(node1) => defStateAnnotatedNode(in, (pre, node1, post))
       case Ast.StateMachineMember.DefStruct(node1) => defStructAnnotatedNode(in, (pre, node1, post))
+      case Ast.StateMachineMember.SpecInclude(node1) => specIncludeAnnotatedNode(in, (pre, node1, post))
       case Ast.StateMachineMember.SpecInitialTransition(node1) => specInitialTransitionAnnotatedNode(in, (pre, node1, post))
     }
   }
@@ -235,6 +236,7 @@ trait AstVisitor {
     node match {
       case Ast.StateMember.DefChoice(node1) => defChoiceAnnotatedNode(in, (pre, node1, post))
       case Ast.StateMember.DefState(node1) => defStateAnnotatedNode(in, (pre, node1, post))
+      case Ast.StateMember.SpecInclude(node1) => specIncludeAnnotatedNode(in, (pre, node1, post))
       case Ast.StateMember.SpecInitialTransition(node1) => specInitialTransitionAnnotatedNode(in, (pre, node1, post))
       case Ast.StateMember.SpecStateEntry(node1) => specStateEntryAnnotatedNode(in, (pre, node1, post))
       case Ast.StateMember.SpecStateExit(node1) => specStateExitAnnotatedNode(in, (pre, node1, post))

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

@@ -888,30 +888,32 @@ object Parser extends Parsers {
     node(defSignal) ^^ (n => Ast.StateMachineMember.DefSignal(n)) |
     node(defState) ^^ (n => Ast.StateMachineMember.DefState(n)) |
     node(defStruct) ^^ (n => Ast.StateMachineMember.DefStruct(n)) |
+    node(specInclude) ^^ (n => Ast.StateMachineMember.SpecInclude(n)) |
     node(specInitialTransition) ^^ (n => Ast.StateMachineMember.SpecInitialTransition(n)) |
     failure("state machine member expected")
   }
 
-  private def stateMachineMembers: Parser[List[Ast.StateMachineMember]] =
+  def stateMachineMembers: Parser[List[Ast.StateMachineMember]] =
     annotatedElementSequence(
       stateMachineMemberNode,
       semi,
       Ast.StateMachineMember(_)
     )
 
   private def stateMemberNode: Parser[Ast.StateMember.Node] = {
-    node(defChoice) ^^ (n => Ast.StateMember.DefChoice(n)) |
+      node(defChoice) ^^ (n => Ast.StateMember.DefChoice(n)) |
       node(defState) ^^ (n => Ast.StateMember.DefState(n)) |
       node(specInitialTransition) ^^ (n =>
         Ast.StateMember.SpecInitialTransition(n)) |
       node(specStateEntry) ^^ (n => Ast.StateMember.SpecStateEntry(n)) |
       node(specStateExit) ^^ (n => Ast.StateMember.SpecStateExit(n)) |
+      node(specInclude) ^^ (n => Ast.StateMember.SpecInclude(n)) |
       node(specStateTransition) ^^ (n =>
         Ast.StateMember.SpecStateTransition(n)) |
       failure("state member expected")
   }
 
-  private def stateMembers: Parser[List[Ast.StateMember]] =
+  def stateMembers: Parser[List[Ast.StateMember]] =
     annotatedElementSequence(stateMemberNode, semi, Ast.StateMember(_))
 
   def structTypeMember: Parser[Ast.StructTypeMember] = {

compiler/lib/src/main/scala/transform/ResolveSpecInclude.scala

@@ -42,6 +42,41 @@ object ResolveSpecInclude extends AstStateTransformer {
     }
   }
 
+  override def defStateAnnotatedNode(
+    a: Analysis,
+    node: Ast.Annotated[AstNode[Ast.DefState]]
+  ) = {
+    val (pre, node1, post) = node
+    val Ast.DefState(name, members) = node1.data
+    for { result <- transformList(a, members, stateMember) }
+    yield {
+      val (a1, members1) = result
+      val defStateMachine = Ast.DefState(name, members1.flatten)
+      val node2 = AstNode.create(defStateMachine, node1.id)
+      (a1, (pre, node2, post))
+    }
+  }
+
+  override def defStateMachineAnnotatedNode(
+    a: Analysis,
+    node: Ast.Annotated[AstNode[Ast.DefStateMachine]]
+  ) = {
+    val (pre, node1, post) = node
+    val Ast.DefStateMachine(name, members) = node1.data
+    members match {
+      case None => Right((a, node))
+      case Some(members) => {
+        for { result <- transformList(a, members, stateMachineMember) }
+        yield {
+          val (a1, members1) = result
+          val defStateMachine = Ast.DefStateMachine(name, Some(members1.flatten))
+          val node2 = AstNode.create(defStateMachine, node1.id)
+          (a1, (pre, node2, post))
+        }
+      }
+    }
+  }
+
   override def defTopologyAnnotatedNode(
     a: Analysis,
     node: Ast.Annotated[AstNode[Ast.DefTopology]]
@@ -161,6 +196,34 @@ object ResolveSpecInclude extends AstStateTransformer {
     }
   }
 
+  private def stateMachineMember(a: Analysis, member: Ast.StateMachineMember): Result[List[Ast.StateMachineMember]] = {
+    val (_, node, _) = member.node
+    node match {
+      case Ast.StateMachineMember.SpecInclude(node1) => resolveSpecInclude(
+        a,
+        node1,
+        Parser.stateMachineMembers,
+        stateMachineMember
+      )
+      case _ => for { result <- matchStateMachineMember(a, member) }
+        yield (result._1, List(result._2))
+    }
+  }
+
+  private def stateMember(a: Analysis, member: Ast.StateMember): Result[List[Ast.StateMember]] = {
+    val (_, node, _) = member.node
+    node match {
+      case Ast.StateMember.SpecInclude(node1) => resolveSpecInclude(
+        a,
+        node1,
+        Parser.stateMembers,
+        stateMember
+      )
+      case _ => for { result <- matchStateMember(a, member) }
+        yield (result._1, List(result._2))
+    }
+  }
+
   private def tlmPacketMember(
     a: Analysis,
     member: Ast.TlmPacketMember

compiler/tools/fpp-syntax/test/include-state-machine.fpp

@@ -0,0 +1,12 @@
+state machine M {@ Action a1
+  action a1
+
+  @ Action a2
+  action a2
+
+  include "subdir/state.fppi"
+
+  state S2 {
+    include "subdir/state.fppi"
+  }
+}