Fix a small issue with statement macros

Author: JonasAlaif

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

@@ -596,7 +596,7 @@ class FastParser {
 
     val matchOnMacroCall: PartialFunction[PNode, MacroApp] = {
       case app: PMacroRef => MacroApp(app.idnuse.name, Nil, app)
-      case app: PMethodCall if isMacro(app.method.name) => MacroApp(app.method.name, app.args, 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)
     }
@@ -766,7 +766,8 @@ class FastParser {
           }
           case target => target
         }
-        (PAssign(expandedTargets, rhs)(assign.pos), ctx)
+        val expandedLhs = PAssign(expandedTargets, rhs)(assign.pos)
+        (ExpandMacroIfValid(expandedLhs, ctx), ctx)
 
       // Handles all other calls to macros
       case (node, ctx) => (ExpandMacroIfValid(node, ctx), ctx)
@@ -778,7 +779,6 @@ class FastParser {
        * Recursing into such PIdnUse nodes caused Silver issue #205.
        */
       case PMacroRef(_) => Seq.empty
-      case PMethodCall(targets, _, args) => Seq(targets, args)
       case PCall(_, args, typeAnnotated) => Seq(args, typeAnnotated)
     }.repeat
 
@@ -1090,7 +1090,7 @@ class FastParser {
 
   def newExp[$: P]: P[PNewExp] = FP("new" ~ "(" ~ newExpFields ~ ")").map { case (pos, fields) => PNewExp(fields)(pos) }
 
-  def newExpFields[$: P]: P[Option[Seq[PIdnUse]]] = P(idnuse.rep(sep = ",")).map(Some(_)) | P("*").map(_ => None)
+  def newExpFields[$: P]: P[Option[Seq[PIdnUse]]] = P(P("*").map(_ => None) | P(idnuse.rep(sep = ",")).map(Some(_)))
 
   def fapp[$: P]: P[PCall] = FP(idnuse ~ parens(actualArgList)).map {
     case (pos, (func, args)) =>
@@ -1113,7 +1113,7 @@ class FastParser {
 
   def macroref[$: P]: P[PMacroRef] = FP(idnuse).map { case (pos, a) => PMacroRef(a)(pos) }
 
-  def assignTarget[$: P]: P[PAssignTarget] = fieldAcc | NoCut(fapp) | idnuse
+  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

@@ -1234,8 +1234,6 @@ case class PLocalVarDecl(vars: Seq[PFormalArgDecl], init: Option[PAssign])(val p
 
 case class PGlobalVarDecl(idndef: PIdnDef, typ: PType)(val pos: (Position, Position)) extends PTypedDeclaration with PUniversalDeclaration
 
-case class PMethodCall(targets: Seq[PIdnUse], method: PIdnUse, args: Seq[PExp])(val pos: (Position, Position)) extends PStmt
-
 case class PLabel(idndef: PIdnDef, invs: Seq[PExp])(val pos: (Position, Position)) extends PStmt with PLocalDeclaration
 
 case class PGoto(targets: PIdnUse)(val pos: (Position, Position)) extends PStmt
@@ -1485,7 +1483,6 @@ object Nodes {
       case PInhale(exp) => Seq(exp)
       case PAssume(exp) => Seq(exp)
       case PNewExp(fields) => fields.getOrElse(Seq())
-      case PMethodCall(targets, method, args) => targets ++ Seq(method) ++ args
       case PLabel(name, invs) => Seq(name) ++ invs
       case PGoto(label) => Seq(label)
       case PAssign(targets, rhs) => targets ++ Seq(rhs)

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

@@ -136,7 +136,6 @@ object Transformer {
         case p@PIf(cond, thn, els) => PIf(go(cond), go(thn), go(els))(p.pos)
         case p@PWhile(cond, invs, body) => PWhile(go(cond), invs map go, go(body))(p.pos)
         case p@PLocalVarDecl(vars, init) => PLocalVarDecl(vars map go, init map go)(p.pos)
-        case p@PMethodCall(targets, method, args) => PMethodCall(targets map go, go(method), args map go)(p.pos)
         case p@PLabel(idndef, invs) => PLabel(go(idndef), invs map go)(p.pos)
         case p@PGoto(target) => PGoto(go(target))(p.pos)
         case p@PDefine(idndef, optArgs, exp) => PDefine(go(idndef), optArgs map (_ map go) , go(exp))(p.pos)

src/main/scala/viper/silver/verifier/VerificationError.scala

@@ -273,27 +273,16 @@ object errors {
   def Internal(offendingNode: ErrorNode = DummyNode): PartialVerificationError =
     PartialVerificationError((reason: ErrorReason) => Internal(offendingNode, reason))
 
-  case class AssignmentTargetFailed(offendingNode: Lhs, reason: ErrorReason, override val cached: Boolean = false) extends AbstractVerificationError {
-    val id = "assignment.target.failed"
-    val text = "Assignment target might fail."
+  case class AssignmentFailed(offendingNode: Stmt, reason: ErrorReason, override val cached: Boolean = false) extends AbstractVerificationError {
+    val id = "assignment.failed"
+    val text = "Assignment might fail."
 
-    def withNode(offendingNode: errors.ErrorNode = this.offendingNode) = AssignmentTargetFailed(offendingNode.asInstanceOf[Lhs], this.reason, this.cached)
-    def withReason(r: ErrorReason) = AssignmentTargetFailed(offendingNode, r, cached)
+    def withNode(offendingNode: errors.ErrorNode = this.offendingNode) = AssignmentFailed(offendingNode.asInstanceOf[Stmt], this.reason, this.cached)
+    def withReason(r: ErrorReason) = AssignmentFailed(offendingNode, r, cached)
   }
 
-  def AssignmentTargetFailed(offendingNode: Lhs): PartialVerificationError =
-    PartialVerificationError((reason: ErrorReason) => AssignmentTargetFailed(offendingNode, reason))
-
-  case class AssignmentValueFailed(offendingNode: Exp, reason: ErrorReason, override val cached: Boolean = false) extends AbstractVerificationError {
-    val id = "assignment.value.failed"
-    val text = "Assignment value might fail."
-
-    def withNode(offendingNode: errors.ErrorNode = this.offendingNode) = AssignmentValueFailed(offendingNode.asInstanceOf[Exp], this.reason, this.cached)
-    def withReason(r: ErrorReason) = AssignmentValueFailed(offendingNode, r, cached)
-  }
-
-  def AssignmentValueFailed(offendingNode: Exp): PartialVerificationError =
-    PartialVerificationError((reason: ErrorReason) => AssignmentValueFailed(offendingNode, reason))
+  def AssignmentFailed(offendingNode: Stmt): PartialVerificationError =
+    PartialVerificationError((reason: ErrorReason) => AssignmentFailed(offendingNode, reason))
 
   case class CallFailed(offendingNode: MethodCall, reason: ErrorReason, override val cached: Boolean = false) extends AbstractVerificationError {
     val id = "call.failed"