Fix macro issue and add support for macros as types

Author: JonasAlaif

src/main/scala/viper/silver/parser/FastParser.scala

@@ -595,10 +595,9 @@ class FastParser {
     case class MacroApp(name: String, arguments: Seq[PExp], node: PNode)
 
     val matchOnMacroCall: PartialFunction[PNode, MacroApp] = {
-      case app: PMacroRef => MacroApp(app.idnuse.name, Nil, app)
-      case app@PAssign(_, call: PCall) if isMacro(call.func.name) => MacroApp(call.func.name, call.args, app)
-      case app: PCall if isMacro(app.func.name) => MacroApp(app.func.name, app.args, app)
-      case app: PIdnUse if isMacro(app.name) => MacroApp(app.name, Nil, app)
+      case assign@PAssign(Seq(), app: PMacro) if isMacro(app.name) => MacroApp(app.name, app.args, assign)
+      case app: PMacro if isMacro(app.name) => MacroApp(app.name, app.args, app)
+      case app: PMacroType[_] => MacroApp(app.use.name, app.use.args, app)
     }
 
     def detectCyclicMacros(start: PNode, seen: Set[String]): Unit = {
@@ -706,11 +705,21 @@ class FastParser {
             throw ParseException("Number of macro arguments does not match", call.pos._1)
 
           (call, body) match {
-            case (_: PStmt, _: PExp) =>
-              throw ParseException("Expression macro used in statement position", call.pos._1)
-            case (_: PExp, _: PStmt) =>
-              throw ParseException("Statement macro used in expression position", call.pos._1)
+            case (_: PStmt, _: PStmt) | (_: PExp, _: PExp) | (_: PType, _: PType) =>
             case _ =>
+              val expandedType = body match {
+                case _: PExp => "Expression"
+                case _: PStmt => "Statement"
+                case _: PType => "Type"
+                case _ => "Unknown"
+              }
+              val callType = call match {
+                case _: PExp => "expression"
+                case _: PStmt => "statement"
+                case _: PType => "type"
+                case _ => "unknown"
+              }
+              throw ParseException(s"$expandedType macro used in $callType position", call.pos._1)
           }
 
           /* TODO: The current unsupported position detection is probably not exhaustive.
@@ -778,7 +787,6 @@ class FastParser {
        * to construct invalid AST nodes.
        * Recursing into such PIdnUse nodes caused Silver issue #205.
        */
-      case PMacroRef(_) => Seq.empty
       case PCall(_, args, typeAnnotated) => Seq(args, typeAnnotated)
     }.repeat
 
@@ -997,28 +1005,29 @@ class FastParser {
 
   def formalArg[$: P]: P[PFormalArgDecl] = FP(idndef ~ ":" ~ typ).map { case (pos, (a, b)) => PFormalArgDecl(a, b)(pos) }
 
-  def typ[$: P]: P[PType] = P(primitiveTyp | domainTyp | seqType | setType | multisetType | mapType)
-  // Maps: lazy val typ: P[PType] = P(primitiveTyp | domainTyp | seqType | setType | multisetType | mapType)
+  def typ[$: P]: P[PType] = P(primitiveTyp | domainTyp | seqType | setType | multisetType | mapType | macroType)
 
   def domainTyp[$: P]: P[PDomainType] = P(FP(idnuse ~ "[" ~ typ.rep(sep = ",") ~ "]").map { case (pos, (a, b)) => PDomainType(a, b)(pos) } |
     // domain type without type arguments (might also be a type variable)
     idnuse.map(name => {
       PDomainType(name, Nil)(name.pos)
     }))
 
-  def seqType[$: P]: P[PType] = FP(keyword("Seq") ~ "[" ~ typ ~ "]").map{ case (pos, t) => PSeqType(t)(pos)}
+  def seqType[$: P]: P[PSeqType] = FP(keyword("Seq") ~ "[" ~ typ ~ "]").map{ case (pos, t) => PSeqType(t)(pos)}
 
-  def setType[$: P]: P[PType] = FP(keyword("Set") ~ "[" ~ typ ~ "]").map{ case (pos, t) => PSetType(t)(pos)}
+  def setType[$: P]: P[PSetType] = FP(keyword("Set") ~ "[" ~ typ ~ "]").map{ case (pos, t) => PSetType(t)(pos)}
 
-  def multisetType[$: P]: P[PType] = FP(keyword("Multiset") ~ "[" ~ typ ~ "]").map{ case (pos, t) => PMultisetType(t)(pos)}
+  def multisetType[$: P]: P[PMultisetType] = FP(keyword("Multiset") ~ "[" ~ typ ~ "]").map{ case (pos, t) => PMultisetType(t)(pos)}
 
   //def mapType[$: P]: P[PType] = FP(keyword("Map") ~ "[" ~ typ ~ "," ~ typ ~ "]").map{ case (pos, t) => PSeqType(t._3)(pos)}
   // Maps:
-  def mapType[$: P] : P[PType] = FP(keyword("Map") ~ "[" ~ typ ~ "," ~ typ ~ "]").map {
+  def mapType[$: P] : P[PMapType] = FP(keyword("Map") ~ "[" ~ typ ~ "," ~ typ ~ "]").map {
    case (pos, (keyType, valueType)) => PMapType(keyType, valueType)(pos)
   }
 
-  def primitiveTyp[$: P]: P[PType] = P(FP(keyword("Rational")).map{ case (pos, _) => PPrimitiv("Perm")(pos)}
+  def macroType[$: P] : P[PMacroType[_]] = idnuse.map(PMacroType(_)) | fapp.map(PMacroType(_))
+
+  def primitiveTyp[$: P]: P[PPrimitiv] = P(FP(keyword("Rational")).map{ case (pos, _) => PPrimitiv("Perm")(pos)}
     | FP((StringIn("Int", "Bool", "Perm", "Ref") ~~ !identContinues).!).map{ case (pos, name) => PPrimitiv(name)(pos)})
 /* Maps:
   lazy val primitiveTyp: P[PType] = P(keyword("Rational").map(_ => PPrimitiv("Perm"))
@@ -1101,18 +1110,16 @@ class FastParser {
     case (pos, (func, args, typeGiven)) => PCall(func, args, Some(typeGiven))(pos)
   }
 
-  def stmt(implicit ctx : P[_]) : P[PStmt] = P(ParserExtension.newStmtAtStart(ctx) | fold | unfold | exhale | assertP |
+  def stmt(implicit ctx : P[_]) : P[PStmt] = P(ParserExtension.newStmtAtStart(ctx) | assign | fold | unfold | exhale | assertP |
     inhale | assume | ifthnels | whle | varDecl | defineDecl | 
-    goto | lbl | packageWand | applyWand | assign | macroref | block |
+    goto | lbl | packageWand | applyWand | block |
     quasihavoc | quasihavocall | ParserExtension.newStmtAtEnd(ctx))
 
-  def nodefinestmt(implicit ctx : P[_]) : P[PStmt] = P(ParserExtension.newStmtAtStart(ctx) | fold | unfold | exhale | assertP |
+  def nodefinestmt(implicit ctx : P[_]) : P[PStmt] = P(ParserExtension.newStmtAtStart(ctx) | assign | fold | unfold | exhale | assertP |
     inhale | assume | ifthnels | whle | varDecl |
-    goto | lbl | packageWand | applyWand | assign | macroref | block |
+    goto | lbl | packageWand | applyWand | block |
     quasihavoc | quasihavocall | ParserExtension.newStmtAtEnd(ctx))
 
-  def macroref[$: P]: P[PMacroRef] = FP(idnuse).map { case (pos, a) => PMacroRef(a)(pos) }
-
   def assignTarget[$: P]: P[PAssignTarget] = P(fieldAcc | NoCut(fapp) | idnuse)
 
   def assign[$: P]: P[PAssign] = FP((assignTarget.rep(min = 1, sep = ",") ~ ":=").? ~ exp).map { case (pos, (targets, rhs)) => PAssign(targets.getOrElse(Seq()), rhs)(pos) }

src/main/scala/viper/silver/parser/ParseAst.scala

@@ -149,8 +149,9 @@ trait PIdentifier {
 
 case class PIdnDef(name: String)(val pos: (Position, Position)) extends PNode with PIdentifier
 
-case class PIdnUse(name: String)(val pos: (Position, Position)) extends PExp with PIdentifier with PAssignTarget {
+case class PIdnUse(name: String)(val pos: (Position, Position)) extends PExp with PIdentifier with PAssignTarget with PMacro {
   var decl: PDeclaration = null
+  override def args: Seq[PExp] = Seq()
   /* Should be set during resolving. Intended to preserve information
    * that is needed by the translator.
    */
@@ -366,6 +367,16 @@ case class PMapType(keyType: PType, valueType: PType)(val pos: (Position, Positi
   override def withTypeArguments(s: Seq[PType]): PMapType = copy(keyType = s.head, valueType = s(1))(pos)
 }
 
+case class PMacroType[T <: PMacro](use: T) extends PType {
+  override val pos: (Position, Position) = use.pos
+
+  override def isValidOrUndeclared: Boolean = ???
+
+  override def substitute(ts: PTypeSubstitution): PType = ???
+
+  override def subNodes: Seq[PType] = ???
+}
+
 /** Type used for internal nodes (e.g. typing predicate accesses) - should not be
   * the type of any expression whose value is meaningful in the translation.
   */
@@ -569,9 +580,10 @@ object POpApp {
   def pRes = PTypeVar(pResS)
 }
 
-case class PCall(func: PIdnUse, args: Seq[PExp], typeAnnotated: Option[PType] = None)(val pos: (Position, Position)) extends POpApp with PLocationAccess with PAssignTarget {
+case class PCall(func: PIdnUse, args: Seq[PExp], typeAnnotated: Option[PType] = None)(val pos: (Position, Position)) extends POpApp with PLocationAccess with PAssignTarget with PMacro {
   override val idnuse = func
   override val opName = func.name
+  override def name = func.name
 
   override def signatures = if (function != null && function.formalArgs.size == args.size) (function match {
     case _: PFunction => List(
@@ -1224,6 +1236,7 @@ case class PAssume(e: PExp)(val pos: (Position, Position)) extends PStmt
 
 case class PInhale(e: PExp)(val pos: (Position, Position)) extends PStmt
 
+/** Can also represent a method call or statement macro with no `:=` when `targets` is empty. */
 case class PAssign(targets: Seq[PAssignTarget], rhs: PExp)(val pos: (Position, Position)) extends PStmt
 
 case class PIf(cond: PExp, thn: PSeqn, els: PSeqn)(val pos: (Position, Position)) extends PStmt
@@ -1240,8 +1253,6 @@ case class PGoto(targets: PIdnUse)(val pos: (Position, Position)) extends PStmt
 
 case class PTypeVarDecl(idndef: PIdnDef)(val pos: (Position, Position)) extends PLocalDeclaration
 
-case class PMacroRef(idnuse: PIdnUse)(val pos: (Position, Position)) extends PStmt
-
 case class PDefine(idndef: PIdnDef, parameters: Option[Seq[PIdnDef]], body: PNode)(val pos: (Position, Position)) extends PStmt with PLocalDeclaration
 
 case class PSkip()(val pos: (Position, Position)) extends PStmt
@@ -1272,6 +1283,12 @@ object PScope {
   }
 }
 
+// Macros
+sealed trait PMacro extends PExp {
+  def name: String
+  def args: Seq[PExp]
+}
+
 // Assignments
 sealed trait PAssignTarget extends PExp
 
@@ -1467,7 +1484,6 @@ object Nodes {
       case PExplicitSet(elems) => elems
       case PEmptyMultiset(t) => Seq(t)
       case PExplicitMultiset(elems) => elems
-      case PMacroRef(_) => Nil
       case PEmptyMap(k, v) => Seq(k, v)
       case PExplicitMap(elems) => elems
       case PMapRange(base) => Seq(base)

src/main/scala/viper/silver/parser/Resolver.scala

@@ -172,8 +172,6 @@ case class TypeChecker(names: NameAnalyser) {
 
   def check(stmt: PStmt): Unit = {
     stmt match {
-      case PMacroRef(id) =>
-        messages ++= FastMessaging.message(stmt, "unknown macro used: " + id.name)
       case s@PSeqn(ss) =>
         checkMember(s) {
           ss foreach check

src/main/scala/viper/silver/parser/Transformer.scala

@@ -22,7 +22,6 @@ object Transformer {
 
     def recurse(parent: PNode): PNode = {
       val newNode = parent match {
-        case p@PMacroRef(idnuse) => PMacroRef(go(idnuse))(p.pos)
         case _: PIdnDef => parent
         case _: PIdnUse => parent
         case p@PFormalArgDecl(idndef, typ) => PFormalArgDecl(go(idndef), go(typ))(p.pos)