Merge pull request #928 from nasa/issue-927-implied-string-deps

Implied uses for strings

Author: bocchino

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

@@ -11,7 +11,7 @@ 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)
 
@@ -33,6 +33,37 @@ trait BasicUseAnalyzer extends TypeExpressionAnalyzer {
   /** A use of a state machine definition*/
   def stateMachineUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified): Result = default(a)
 
+  /** An implied constant use */
+  def impliedConstantUse(a: Analysis, iu: ImpliedUse) = {
+    val result = for {
+      a <- exprNode(a, iu.asExprNode)
+      a <- impliedUse(a, iu, ImpliedUse.Kind.Constant)
+    } yield a
+    iu.annotateResult(result)
+  }
+
+  /** An implied port use */
+  def impliedPortUse(a: Analysis, iu: ImpliedUse) = {
+    val result = for {
+      a <- portUse(a, iu.asQualIdentNode, iu.name)
+      a <- impliedUse(a, iu, ImpliedUse.Kind.Port)
+    } yield a
+    iu.annotateResult(result)
+  }
+
+  /** An implied type use */
+  def impliedTypeUse(a: Analysis, iu: ImpliedUse) = {
+    val result = for {
+      a <- typeUse(a, iu.asTypeNameNode, iu.name)
+      a <- impliedUse(a, iu, ImpliedUse.Kind.Type)
+    } yield a
+    iu.annotateResult(result)
+  }
+
+  /** An implied use */
+  def impliedUse(a: Analysis, iu: ImpliedUse, kind: ImpliedUse.Kind): Result =
+    Right(a)
+
   override def defComponentInstanceAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefComponentInstance]]) = {
     val (_, node1, _) = node
     val data = node1.data
@@ -165,11 +196,23 @@ trait BasicUseAnalyzer extends TypeExpressionAnalyzer {
     typeUse(a, node, use)
   }
 
+  override def typeNameStringNode(
+    a: Analysis,
+    node: AstNode[Ast.TypeName],
+    tn: Ast.TypeNameString
+  ) = {
+    val id = node.id
+    for {
+      a <- visitImpliedUses(a, id)
+      a <- super.typeNameStringNode(a, node, tn)
+    } yield a
+  }
+
   private def portInstanceIdentifierNode(a: Analysis, node: AstNode[Ast.PortInstanceIdentifier]): Result =
     qualIdentNode (componentInstanceUse) (a, node.data.componentInstance)
 
   private def qualIdentNode
-    (f: (Analysis, AstNode[Ast.QualIdent], Name.Qualified) => Result) 
+    (f: (Analysis, AstNode[Ast.QualIdent], Name.Qualified) => Result)
     (a: Analysis, qualIdent: AstNode[Ast.QualIdent]): Result = {
     val use = Name.Qualified.fromQualIdent(qualIdent.data)
     f(a, qualIdent, use)
@@ -190,20 +233,17 @@ trait BasicUseAnalyzer extends TypeExpressionAnalyzer {
 
   private def visitImpliedConstantUses(a: Analysis, id: AstNode.Id) = {
     val uses = a.getImpliedUses(ImpliedUse.Kind.Constant, id).toList
-    def visit(a: Analysis, iu: ImpliedUse) = exprNode(a, iu.asExprNode)
-    visitList(a, uses, visit)
+    visitList(a, uses, impliedConstantUse)
   }
 
   private def visitImpliedPortUses(a: Analysis, id: AstNode.Id) = {
     val uses = a.getImpliedUses(ImpliedUse.Kind.Port, id).toList
-    def visit(a: Analysis, iu: ImpliedUse) = portUse(a, iu.asQualIdentNode, iu.name)
-    visitList(a, uses, visit)
+    visitList(a, uses, impliedPortUse)
   }
 
   private def visitImpliedTypeUses(a: Analysis, id: AstNode.Id) = {
     val uses = a.getImpliedUses(ImpliedUse.Kind.Type, id).toList
-    def visit(a: Analysis, iu: ImpliedUse) = typeUse(a, iu.asTypeNameNode, iu.name)
-    visitList(a, uses, visit)
+    visitList(a, uses, impliedTypeUse)
   }
 
   private def visitImpliedUses(a: Analysis, id: AstNode.Id) = {

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

@@ -100,7 +100,7 @@ object CheckUseDefCycles extends UseAnalyzer {
     val symbol = a.useDefMap(node.id)
     val m = UseDefMatching(node.id, use, symbol)
     val a1 = a.copy(useDefMatchingList = m :: a.useDefMatchingList)
-    visitDefPre(a1, symbol)
+    for (_ <- visitDefPre(a1, symbol)) yield a
   }
 
 }

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

@@ -81,6 +81,33 @@ object CheckUses extends BasicUseAnalyzer {
     visitExprNode(a, node)
   }
 
+  // Check that an implied use (a) is not a member
+  // of a def and (b) does not shadow the required def
+  override def impliedUse(a: Analysis, iu: ImpliedUse, kind: ImpliedUse.Kind) = {
+    val sym = a.useDefMap(iu.id)
+    val symQualifiedName = a.getQualifiedName(sym).toString
+    val iuName = iu.name.toString
+    // Check that the name of the def matches the name of the use
+    if symQualifiedName == iuName
+    // OK, they match
+    then Right(a)
+    else {
+      val msg = if symQualifiedName.length < iuName.length
+      // Definition has a shorter name: the use is a member of the definition
+      then s"it has $iuName as a member"
+      // Definition has a longer name: it shadows the required definition
+      else s"it shadows $iuName here"
+      Left(
+        SemanticError.InvalidSymbol(
+          symQualifiedName,
+          Locations.get(iu.id),
+          msg,
+          sym.getLoc
+        )
+      )
+    }
+  }
+
   override def defComponentAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.DefComponent]]) = {
     val (_, node, _) = aNode
     val data = node.data
@@ -146,30 +173,6 @@ object CheckUses extends BasicUseAnalyzer {
     } yield a.copy(nestedScope = a.nestedScope.pop)
   }
 
-  override def defTopologyAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefTopology]]) = {
-    val impliedTypeUses = a.getImpliedUses(ImpliedUse.Kind.Type, node._2.id).toList
-    val impliedConstantUses = a.getImpliedUses(ImpliedUse.Kind.Constant, node._2.id).toList
-    for {
-      a <- Result.foldLeft (impliedConstantUses) (a) ((a, iu) => {
-        val exprNode = iu.asExprNode
-        for {
-          a <- Result.annotateResult(
-            constantUse(a, exprNode, iu.name),
-            s"when constructing a dictionary, the constant ${iu.name} must be defined"
-          )
-          _ <- checkImpliedUseIsConstantDef(a, iu, exprNode)
-        } yield a
-      })
-      a <- Result.foldLeft (impliedTypeUses) (a) ((a, iu) => {
-        Result.annotateResult(
-          typeUse(a, iu.asTypeNameNode, iu.name),
-          s"when constructing a dictionary, the type ${iu.name} must be defined"
-        )
-      })
-      a <- TopologyAnalyzer.visit(this, a, node)
-    } yield a
-  }
-
   override def portUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified) =
     helpers.visitQualIdentNode (NameGroup.Port) (a, node)
 
@@ -192,31 +195,4 @@ object CheckUses extends BasicUseAnalyzer {
     }
   }
 
-  // Check that an implied use is a constant def and not a member
-  // of a constant def
-  private def checkImpliedUseIsConstantDef(a: Analysis, iu: ImpliedUse, exprNode: AstNode[Ast.Expr]) = {
-    val sym = a.useDefMap(exprNode.id)
-    // Check that the name of the def matches the name of the use
-    if a.getQualifiedName(sym) == iu.name
-    // OK, they match
-    then Right(a)
-    // They don't match: the definition does not provide the required constant
-    else
-      val iuName = iu.name
-      val symName = sym.getUnqualifiedName
-      val error = Left(
-        SemanticError.InvalidSymbol(
-          symName,
-          Locations.get(exprNode.id),
-          s"it has $iuName as a member",
-          sym.getLoc
-        )
-      )
-      val notes = List(
-        s"$iuName is an F Prime framework constant",
-        "it must be a constant definition"
-      )
-      Result.annotateResult(error, notes)
-  }
-
 }

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

@@ -4,19 +4,17 @@ import fpp.compiler.ast._
 import fpp.compiler.util._
 
 /** Construct the implied use map */
-object ConstructImpliedUseMap
-  extends Analyzer
-  with ComponentAnalyzer
-  with InterfaceAnalyzer
-  with ModuleAnalyzer
-{
+object ConstructImpliedUseMap extends TypeExpressionAnalyzer {
 
-  override def specPortInstanceAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecPortInstance]]) = {
+  override def specPortInstanceAnnotatedNode(
+    a: Analysis,
+    aNode: Ast.Annotated[AstNode[Ast.SpecPortInstance]]
+  ) = {
     val (_, node, _) = aNode
     val data = node.data
     val id = node.id
-    data match {
-      case _ : Ast.SpecPortInstance.General => Right(a)
+    val a1 = data match {
+      case _ : Ast.SpecPortInstance.General => a
       case special : Ast.SpecPortInstance.Special =>
         // Construct the port use implied by the special port instance
         val name = special.kind match {
@@ -37,8 +35,9 @@ object ConstructImpliedUseMap
         val identList = List("Fw", name)
         val impliedUse = ImpliedUse.fromIdentListAndId(identList, node.id)
         val map = Map(ImpliedUse.Kind.Port -> Set(impliedUse))
-        Right(a.copy(impliedUseMap = a.impliedUseMap + (id -> map)))
+        a.copy(impliedUseMap = a.impliedUseMap + (id -> map))
     }
+    super.specPortInstanceAnnotatedNode(a1, aNode)
   }
 
   override def defTopologyAnnotatedNode(
@@ -48,21 +47,53 @@ object ConstructImpliedUseMap
     val id = aNode._2.id
     val typeNames = ImpliedUse.getTopologyTypes(a)
     val empty: ImpliedUse.Uses = Map()
+    val annotations = List("this implied use occurs when constructing a dictionary")
     val typeMap = typeNames.foldLeft (empty) ((m, tn) => {
       val id1 = ImpliedUse.replicateId(id)
-      val impliedUse = ImpliedUse.fromIdentListAndId(tn, id1)
+      val impliedUse = ImpliedUse.fromIdentListAndId(tn, id1, annotations)
       val set = m.get(ImpliedUse.Kind.Type).getOrElse(Set())
       m + (ImpliedUse.Kind.Type -> (set + impliedUse))
     })
-
     val constants = ImpliedUse.getTopologyConstants(a)
     val map = constants.foldLeft (typeMap) ((m, c) => {
       val id1 = ImpliedUse.replicateId(id)
-      val impliedUse = ImpliedUse.fromIdentListAndId(c, id1)
+      val impliedUse = ImpliedUse.fromIdentListAndId(c, id1, annotations)
       val set = m.get(ImpliedUse.Kind.Constant).getOrElse(Set())
       m + (ImpliedUse.Kind.Constant -> (set + impliedUse))
     })
-    Right(a.copy(impliedUseMap = a.impliedUseMap + (id -> map)))
+    val a1 = a.copy(impliedUseMap = a.impliedUseMap + (id -> map))
+    super.defTopologyAnnotatedNode(a1, aNode)
+  }
+
+  override def typeNameStringNode(
+    a: Analysis, 
+    node: AstNode[Ast.TypeName],
+    tn: Ast.TypeNameString
+  ) = {
+    val id = node.id
+    def getImpliedUses(name: String, annotation: String) = {
+      val il = List(name)
+      val id1 = ImpliedUse.replicateId(id)
+      Set(ImpliedUse.fromIdentListAndId(il, id1, List(annotation)))
+    }
+    val map = {
+      val uses = getImpliedUses(
+        "FwSizeStoreType",
+        "use of a string type requires this definition"
+      )
+      Map(ImpliedUse.Kind.Type -> uses)
+    }
+    val map1 = if tn.size.isDefined
+      then map
+      else {
+        val uses = getImpliedUses(
+          "FW_FIXED_LENGTH_STRING_SIZE",
+          "use of a string type with default size requires this definition"
+        )
+        map + (ImpliedUse.Kind.Constant -> uses)
+      }
+    val a1 = a.copy(impliedUseMap = a.impliedUseMap + (id -> map1))
+    super.typeNameStringNode(a1, node, tn)
   }
 
 }

compiler/lib/src/main/scala/analysis/Semantics/ImpliedUse.scala

@@ -8,7 +8,9 @@ case class ImpliedUse(
   /** The fully-qualified name of the implied use */
   name: Name.Qualified,
   /** The AST node id associated with the implied use */
-  id: AstNode.Id
+  id: AstNode.Id,
+  /** Optional annotations for error reporting */
+  annotations: List[String] = Nil
 ) {
 
   def asExprNode: AstNode[Ast.Expr] = {
@@ -20,18 +22,6 @@ case class ImpliedUse(
     AstNode.create(expr, id)
   }
 
-  def asUniqueExprNode: AstNode[Ast.Expr] = {
-    val Name.Qualified(qualifier, base) = name
-    val head :: tail = name.toIdentList
-    val expr = tail.foldLeft (Ast.ExprIdent(head): Ast.Expr) ((e1, s) =>
-      Ast.ExprDot(
-        AstNode.create(e1, ImpliedUse.replicateId(id)),
-        AstNode.create(s, ImpliedUse.replicateId(id))
-      )
-    )
-    AstNode.create(expr, ImpliedUse.replicateId(id))
-  }
-
   def asQualIdentNode: AstNode[Ast.QualIdent] = {
     val nodeList = name.toIdentList.map(AstNode.create(_, id))
     val qualIdent = Ast.QualIdent.fromNodeList(nodeList)
@@ -43,6 +33,11 @@ case class ImpliedUse(
     AstNode.create(typeName, id)
   }
 
+  def annotateResult[T](r: Result.Result[T]) = {
+    val as = s"the symbol $name has an implied use at the point of the error" :: annotations
+    Result.annotateResult(r, as)
+  }
+
 }
 
 object ImpliedUse {
@@ -82,14 +77,18 @@ object ImpliedUse {
     )
     else Nil
 
+  /** Create a new ID at the same location as id */
   def replicateId(id: AstNode.Id) = {
     val loc = Locations.get(id)
     val id1 = AstNode.getId
     Locations.put(id1, loc)
     id1
   }
 
-  def fromIdentListAndId(identList: List[Name.Unqualified], id: AstNode.Id) =
-    ImpliedUse(Name.Qualified.fromIdentList(identList), id)
+  def fromIdentListAndId(
+    identList: List[Name.Unqualified],
+    id: AstNode.Id,
+    annotations: List[String] = Nil
+  ) = ImpliedUse(Name.Qualified.fromIdentList(identList), id, annotations)
 
 }

compiler/lib/src/main/scala/util/Error.scala

@@ -238,7 +238,7 @@ sealed trait Error {
       case SemanticError.InvalidTypeForMemberSelection(memberName, loc, typeName) =>
         Error.print (Some(loc)) (s"no member $memberName in value of type $typeName")
       case SemanticError.InvalidSymbol(name, loc, msg, defLoc) =>
-        Error.print (Some(loc)) (s"invalid symbol $name: $msg")
+        Error.print (Some(loc)) (s"invalid use of symbol $name: $msg")
         System.err.println("symbol is defined here:")
         System.err.println(defLoc)
       case SemanticError.InvalidTlmChannelName(loc, channelName, componentName) =>

compiler/lib/src/main/scala/util/Result.scala

@@ -9,9 +9,10 @@ object Result {
 
   /** Wraps error as an AnnotatedError with notes */
   def annotateResult[A](r: Result[A], notes: List[String]): Result[A] =
-    r match {
-      case Right(v) => Right(v)
-      case Left(e: Error) => Left(AnnotatedError(e, notes))
+    (r, notes) match {
+      case (Right(_), _) => r
+      case (_, Nil) => r
+      case (Left(e: Error), _) => Left(AnnotatedError(e, notes))
     }
 
   /** Wraps error as an AnnotatedError with a single note */

compiler/tools/fpp-check/test/array/format_alias_not_numeric.fpp

@@ -1,2 +1,5 @@
+type FwSizeStoreType = U16
+constant FW_FIXED_LENGTH_STRING_SIZE = 256
+
 type T = string
 array A = [3] T format "{.3f}"

compiler/tools/fpp-check/test/array/format_alias_not_numeric.ref.txt

@@ -1,5 +1,5 @@
 fpp-check
-[ local path prefix ]/compiler/tools/fpp-check/test/array/format_alias_not_numeric.fpp:2.24
+[ local path prefix ]/compiler/tools/fpp-check/test/array/format_alias_not_numeric.fpp:5.24
 array A = [3] T format "{.3f}"
                        ^
 error: invalid format string: T is not a floating-point type