Merge data-products branch into main

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

@@ -148,6 +148,18 @@ trait TypeExpressionAnalyzer
     }
   }
 
+  override def specContainerAnnotatedNode(
+    a: Analysis,
+    aNode: Ast.Annotated[AstNode[Ast.SpecContainer]]
+  ) = {
+    val (_, node, _) = aNode
+    val data = node.data
+    for {
+      a <- opt(exprNode)(a, data.id)
+      a <- opt(exprNode)(a, data.defaultPriority)
+    } yield a
+  }
+
   override def specEventAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecEvent]]) = {
     val (_, node1, _) = node
     val data = node1.data
@@ -193,10 +205,23 @@ trait TypeExpressionAnalyzer
           a <- opt(exprNode)(a, general.size)
           a <- opt(exprNode)(a, general.priority)
         } yield a
-      case _ => Right(a)
+      case special : Ast.SpecPortInstance.Special =>
+        opt(exprNode)(a, special.priority)
     }
   }
 
+  override def specRecordAnnotatedNode(
+    a: Analysis,
+    aNode: Ast.Annotated[AstNode[Ast.SpecRecord]]
+  ) = {
+    val (_, node, _) = aNode
+    val data = node.data
+    for {
+      a <- typeNameNode(a, data.recordType)
+      a <- opt(exprNode)(a, data.id)
+    } yield a
+  }
+
   override def specTlmChannelAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecTlmChannel]]) = {
     def limit(a: Analysis, value: Ast.SpecTlmChannel.Limit) = {
       val (_, e) = value

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

@@ -93,7 +93,7 @@ trait UseAnalyzer extends TypeExpressionAnalyzer {
           a <- opt(qualIdentNode(portUse))(a, general.port)
           a <- opt(exprNode)(a, general.priority)
         } yield a
-      case special : Ast.SpecPortInstance.Special => {
+      case special : Ast.SpecPortInstance.Special =>
         // Construct the use implied by the special port
         val name = special.kind match {
           case Ast.SpecPortInstance.CommandRecv => "Cmd"
@@ -102,6 +102,10 @@ trait UseAnalyzer extends TypeExpressionAnalyzer {
           case Ast.SpecPortInstance.Event => "Log"
           case Ast.SpecPortInstance.ParamGet => "PrmGet"
           case Ast.SpecPortInstance.ParamSet => "PrmSet"
+          case Ast.SpecPortInstance.ProductGet => "DpGet"
+          case Ast.SpecPortInstance.ProductRecv => "DpResponse"
+          case Ast.SpecPortInstance.ProductRequest => "DpRequest"
+          case Ast.SpecPortInstance.ProductSend => "DpSend"
           case Ast.SpecPortInstance.Telemetry => "Tlm"
           case Ast.SpecPortInstance.TextEvent => "LogText"
           case Ast.SpecPortInstance.TimeGet => "Time"
@@ -110,8 +114,10 @@ trait UseAnalyzer extends TypeExpressionAnalyzer {
         val nodeList = identList.map(AstNode.create(_, node.id))
         val qualIdent = Ast.QualIdent.fromNodeList(nodeList)
         val impliedUse = AstNode.create(qualIdent, node.id)
-        qualIdentNode(portUse)(a, impliedUse)
-      }
+        for {
+          a <- opt(exprNode)(a, special.priority)
+          a <- qualIdentNode(portUse)(a, impliedUse)
+        } yield a
     }
   }
 

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

@@ -38,6 +38,19 @@ object CheckComponentDefs
     yield a.copy(component = Some(component))
   }
 
+  override def specContainerAnnotatedNode(
+    a: Analysis,
+    aNode: Ast.Annotated[AstNode[Ast.SpecContainer]]
+  ) = {
+    val data = aNode._2.data
+    for {
+      idOpt <- a.getNonnegativeBigIntValueOpt(data.id)
+      container <- Container.fromSpecContainer(a, aNode)
+      component <- a.component.get.addContainer(idOpt, container)
+    }
+    yield a.copy(component = Some(component))
+  }
+
   override def specEventAnnotatedNode(
     a: Analysis,
     aNode: Ast.Annotated[AstNode[Ast.SpecEvent]]
@@ -101,6 +114,19 @@ object CheckComponentDefs
     Right(a.copy(component = Some(component1)))
   }
 
+  override def specRecordAnnotatedNode(
+    a: Analysis,
+    aNode: Ast.Annotated[AstNode[Ast.SpecRecord]]
+  ) = {
+    val data = aNode._2.data
+    val record = Record.fromSpecRecord(a, aNode)
+    for {
+      idOpt <- a.getNonnegativeBigIntValueOpt(data.id)
+      component <- a.component.get.addRecord(idOpt, record)
+    }
+    yield a.copy(component = Some(component))
+  }
+
   override def specTlmChannelAnnotatedNode(
     a: Analysis,
     aNode: Ast.Annotated[AstNode[Ast.SpecTlmChannel]]

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

@@ -116,7 +116,7 @@ object CheckExprTypes extends UseAnalyzer {
 
   override def exprLiteralIntNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprLiteralInt) =
     Right(a.assignType(node -> Type.Integer))
-  
+
   override def exprLiteralStringNode(a: Analysis, node: AstNode[Ast.Expr], e: Ast.ExprLiteralString) =
     Right(a.assignType(node -> Type.String(None)))
 
@@ -130,7 +130,7 @@ object CheckExprTypes extends UseAnalyzer {
     for {
       _ <- Analysis.checkForDuplicateStructMember(getName)(e.members)
       a <- super.exprStructNode(a, node, e)
-    } 
+    }
     yield {
       def visitor(members: Type.Struct.Members, node: AstNode[Ast.StructMember]): Type.Struct.Members = {
         val data = node.data
@@ -165,6 +165,20 @@ object CheckExprTypes extends UseAnalyzer {
     yield a
   }
 
+  override def specContainerAnnotatedNode(
+    a: Analysis,
+    aNode: Ast.Annotated[AstNode[Ast.SpecContainer]]
+  ) = {
+    val (_, node, _) = aNode
+    val data = node.data
+    for {
+      a <- super.specContainerAnnotatedNode(a, aNode)
+      _ <- convertNodeToNumericOpt(a, data.id)
+      _ <- convertNodeToNumericOpt(a, data.defaultPriority)
+    }
+    yield a
+  }
+
   override def specEventAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecEvent]]) = {
     val (_, node, _) = aNode
     val data = node.data
@@ -226,8 +240,25 @@ object CheckExprTypes extends UseAnalyzer {
           _ <- convertNodeToNumericOpt(a, general.priority)
         }
         yield a
-      case _ => Right(a)
+      case special : Ast.SpecPortInstance.Special =>
+        for {
+          a <- super.specPortInstanceAnnotatedNode(a, aNode)
+          _ <- convertNodeToNumericOpt(a, special.priority)
+        } yield a
+    }
+  }
+
+  override def specRecordAnnotatedNode(
+    a: Analysis,
+    aNode: Ast.Annotated[AstNode[Ast.SpecRecord]]
+  ) = {
+    val (_, node, _) = aNode
+    val data = node.data
+    for {
+      a <- super.specRecordAnnotatedNode(a, aNode)
+      _ <- convertNodeToNumericOpt(a, data.id)
     }
+    yield a
   }
 
   override def specTlmChannelAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecTlmChannel]]) = {
@@ -281,7 +312,7 @@ object CheckExprTypes extends UseAnalyzer {
         // Unqualified constant symbol: visit the constant definition
         // to ensure it has a type
         case Symbol.Constant(node) => defConstantAnnotatedNode(a, node)
-        // Unqualified enum symbol: if this is in scope, then we are in 
+        // Unqualified enum symbol: if this is in scope, then we are in
         // the enum definition, so it already has a type
         case Symbol.EnumConstant(node) => Right(a)
         // Invalid use of a symbol in an expression
@@ -312,7 +343,7 @@ object CheckExprTypes extends UseAnalyzer {
     }
 
   private def convertToNumeric(loc: Location, t: Type): Result.Result[Type] = {
-    if (t.isNumeric) Right(t) 
+    if (t.isNumeric) Right(t)
     else if (t.isConvertibleTo(Type.Integer)) Right(Type.Integer)
     else {
       val error = SemanticError.InvalidType(loc, s"cannot convert $t to a numeric type")