Add formatter for the parse AST (#820)

* First version of reformatter

* Don't translate macros when reformatting

* Refine expressions further

* Update comment

* Fix spacing

* Change PForAll

* more

* Tweak formatting of let and if statements

* First version of better trivia fetching

* More broken now but still more progress

* Make reformatter context implicit

* Remove unused method

* roll back to looking back for trivia

* Fix issue with missing indent after comment

* Everything works as initially

* Simplify code a bit

* next attempt

* Good progress towards better formatting!

* Fix spacing in pre and post conditions

* Improve showBody method

* more

* Create ReformatterPrettyPrinterBase

* More progress

* more progress towards new reformatter

* First seeminly working prototype

* First working version, more or less back to where we started

* Add short circuit

* Add hack for decreases keyword

* Only reformat on leaf nodes

* Fix trailing whitespaces

* Fix whitespace bug

* Add a couple of tests for reformatting

* Remove POther

* Add a test case for not working snippets

* Add some license headers

* Revert some unnecessary changes

* Remove trailing whitespaces

* Remove parseResult variable

* Whitespaces and other small changes

* Rearrange some imports

* Rename trivia to PTrivia

* Remove LeftLineIndent

* Readd newlines

* Add some comments and improve code formatting

* Add another case for showAny

* Fix whitespaces and imports

* Add brackets to method calls

* Fix some whitespace issues and similar

* Move tests from viperserver to silver

* Avoid arbitrary whitespace changes

* Fix whitespaces in PProgram constructors

* Make expandMacros the last argument and assign true by default

* Avoid another arbitrary whitespace change

* Fix compilation

* Deduplicate comment and whitespace parsing

* Reduce the number of imports

* Fix compiler warnings

* Improve whitespace handling again

* Deduplicate other whitespace, too

* Fix wrong expandMacros

* Undo newline

* Reduce the number of `reformat` and `reformatExp` implementations

* Remove one more reformat override

* More improvements

* Fix issue with empty assignments

* Fix inhale exhale exp

* Add manual override for package wand

* Simplify and remove some reformat overrides

* Don't group expressions

* Try to fix CI failure

* Revert "Try to fix CI failure"

This reverts commit ae824da.

* Revert "Revert "Try to fix CI failure""

This reverts commit 053cdde.

* Maybe fix Carbon CI?

* Re-run CI

* Re-run CI

---------

Co-authored-by: Jonáš Fiala <jonas.fiala@inf.ethz.ch>
Co-authored-by: Nicolas Klose <nicolas.rayklose@gmail.com>

Author: 3 people

src/main/scala/viper/silver/frontend/ReformatterAstProvider.scala

@@ -0,0 +1,26 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+//
+// Copyright (c) 2011-2024 ETH Zurich.
+
+package viper.silver.frontend
+import viper.silver.parser.PProgram
+import viper.silver.reporter.Reporter
+import viper.silver.verifier.{Failure, Success, VerificationResult}
+
+class ReformatterAstProvider(override val reporter: Reporter) extends ViperAstProvider(reporter) {
+  override val phases: Seq[Phase] = Seq(Parsing)
+
+  override def doParsing(input: String): Result[PProgram] = parsingInner(input, false)
+
+  override def result: VerificationResult = {
+    if (_errors.isEmpty) {
+      require(state >= DefaultStates.Parsing)
+      Success
+    }
+    else {
+      Failure(_errors)
+    }
+  }
+}

src/main/scala/viper/silver/frontend/SilFrontend.scala

@@ -323,11 +323,11 @@ trait SilFrontend extends DefaultFrontend {
     _config = configureVerifier(args)
   }
 
-  override def doParsing(input: String): Result[PProgram] = {
+  def parsingInner(input: String, expandMacros: Boolean): Result[PProgram] = {
     val file = _inputFile.get
     plugins.beforeParse(input, isImported = false) match {
       case Some(inputPlugin) =>
-        val result = fp.parse(inputPlugin, file, Some(plugins), _loader)
+        val result = fp.parse(inputPlugin, file, Some(plugins), _loader, expandMacros)
         if (result.errors.forall(p => p.isInstanceOf[ParseWarning])) {
           reporter report WarningsDuringParsing(result.errors)
           Succ({
@@ -340,6 +340,8 @@ trait SilFrontend extends DefaultFrontend {
     }
   }
 
+  override def doParsing(input: String): Result[PProgram] = parsingInner(input, true)
+
   override def doSemanticAnalysis(input: PProgram): Result[PProgram] = {
     plugins.beforeResolve(input) match {
       case Some(inputPlugin) =>

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

@@ -27,13 +27,26 @@ object FastParserCompanion {
   val whitespaceWithoutNewlineOrComments = {
     import NoWhitespace._
     implicit ctx: ParsingRun[_] =>
-      NoTrace((" " | "\t").rep)
+      NoTrace(space.rep)
   }
 
+  def blockComment[$: P] = {
+    import NoWhitespace._
+    "/*" ~ (!StringIn("*/") ~ AnyChar).rep ~ "*/"
+  }
+
+  def lineComment[$: P] = {
+    import NoWhitespace._
+    "//" ~ CharsWhile(_ != '\n').? ~ ("\n" | End)
+  }
+
+  def space[$: P] = " " | "\t"
+  def newline[$: P] = StringIn("\r\n") | "\n" | "\r"
+
   implicit val whitespace = {
     import NoWhitespace._
     implicit ctx: ParsingRun[_] =>
-      NoTrace((("/*" ~ (!StringIn("*/") ~ AnyChar).rep ~ "*/") | ("//" ~ CharsWhile(_ != '\n').? ~ ("\n" | End)) | " " | "\t" | "\n" | "\r").rep)
+      NoTrace((blockComment | lineComment | space | newline).rep)
   }
 
   def identStarts[$: P] = CharIn("A-Z", "a-z", "$_")
@@ -95,15 +108,37 @@ object FastParserCompanion {
         .map { case (first, inner) => PDelimited(first, inner, None)(_) }
     ).pos
 
-    def delimitedTrailing[$: P, U](sep: => P[U], min: Int = 0, max: Int = Int.MaxValue, exactly: Int = -1)(implicit lineCol: LineCol, _file: Path): P[PDelimited[T, Option[U]]] =
+    def delimitedTrailing[$: P, U, V](sep: => P[U], map: Option[U] => V = (u: Option[U]) => u, min: Int = 0, max: Int = Int.MaxValue, exactly: Int = -1)(implicit lineCol: LineCol, _file: Path): P[PDelimited[T, V]] =
       P((p().lw ~~~ sep.lw.?./).repX(min = min, max = max, exactly = exactly)
         .map(seq => {
           val (ts, us) = seq.unzip
-          PDelimited(ts.headOption, us.zip(ts.drop(1)), us.lastOption)(_)
+          val usm = us.map(map)
+          PDelimited(ts.headOption, usm.zip(ts.drop(1)), usm.lastOption)(_)
         })
       ).pos
   }
 
+  /* These special parser methods are only used in the reformatter
+  to parse and interpret the whitespaces and comments between two AST nodes.
+  */
+  def pSpace[$: P]: P[PSpace] = P(space map (_ => PSpace()))
+
+  def pNewline[$: P]: P[PNewLine] = P(newline map (_ => PNewLine()))
+
+  def pLineComment[$: P]: P[PComment] = P(lineComment.!.map { content =>
+    PComment(content)
+  })
+
+  def pBlockComment[$: P]: P[PComment] = P(blockComment.!.map { content =>
+    PComment(content)
+  })
+
+  def pComment[$: P]: P[PComment] = pLineComment | pBlockComment
+
+  def pTrivia[$: P]: P[Seq[PTrivia]] = {
+    P((pSpace | pNewline | pComment).repX)
+  }
+
   /**
     * A parser which matches leading whitespaces. See `LeadingWhitespace.lw` for more info. Can only be operated on in
     * restricted ways (e.g. `?`, `rep`, `|` or `map`), requiring that it is eventually appended to a normal parser (of type `P[V]`).
@@ -167,7 +202,7 @@ object FastParserCompanion {
 }
 
 class FastParser {
-  def parse(s: String, f: Path, plugins: Option[SilverPluginManager] = None, loader: FileLoader = DiskLoader) = {
+  def parse(s: String, f: Path, plugins: Option[SilverPluginManager] = None, loader: FileLoader = DiskLoader, expandMacros: Boolean = true) = {
     // Strategy to handle imports
     // Idea: Import every import reference and merge imported methods, functions, imports, .. into current program
     //       iterate until no new imports are present.
@@ -179,7 +214,11 @@ class FastParser {
     val file = f.toAbsolutePath().normalize()
     val data = ParserData(plugins, loader, mutable.HashSet(file))
     val program = RecParser(file, data, false).parses(s)
-    MacroExpander.expandDefines(program)
+    if (expandMacros) {
+      MacroExpander.expandDefines(program)
+    } else  {
+      program
+    }
   }
 
   case class ParserData(plugins: Option[SilverPluginManager], loader: FileLoader, local: mutable.HashSet[Path], std: mutable.HashSet[Path] = mutable.HashSet.empty)
@@ -312,13 +351,13 @@ class FastParser {
   //////////////////////////
 
   import fastparse._
-  import FastParserCompanion.{ExtendedParsing, identContinues, identStarts, LeadingWhitespace, Pos, PositionParsing, reservedKw, reservedSym}
+  import FastParserCompanion.{ExtendedParsing, identContinues, identStarts, LeadingWhitespace, Pos, PositionParsing, reservedKw, reservedSym, blockComment, lineComment, newline, space}
 
 
   implicit val whitespace = {
     import NoWhitespace._
     implicit ctx: ParsingRun[_] =>
-      NoTrace((("/*" ~ (!StringIn("*/") ~ AnyChar).rep ~ "*/") | ("//" ~ CharsWhile(_ != '\n').? ~ ("\n" | End)) | " " | "\t" | "\n" | "\r").rep)
+      NoTrace((blockComment | lineComment | space | newline).rep)
   }
 
   implicit val lineCol: LineCol = new LineCol(this)
@@ -357,7 +396,7 @@ class FastParser {
   def typeList[$: P, T](p: => P[T]) = p.delimited(PSym.Comma).brackets
 
   /** ...`;`? ...`;`? ...`;`? */
-  def semiSeparated[$: P, T](p: => P[T]) = p.delimitedTrailing(PSym.Semi)
+  def semiSeparated[$: P, T](p: => P[T]): P[PDelimited[T, PSym.OptionSemi]] = p.delimitedTrailing(PSym.Semi, map = ND.apply)
 
   def foldPExp[E <: PExp](e: E, es: Seq[SuffixedExpressionGenerator[E]]): E =
     es.foldLeft(e) { (t, a) => a(t) }
@@ -426,7 +465,7 @@ class FastParser {
 
   def ident[$: P]: P[String] = identifier.!.filter(a => !keywords.contains(a)).opaque("identifier")
 
-  def idnuse[$: P]: P[PIdnUseExp] = P(ident map (PIdnUseExp.apply _)).pos
+  def idnuse[$: P]: P[PIdnUseExp] = P(idnref[$, PTypedVarDecl] map (PIdnUseExp.apply _))
 
   def idnref[$: P, T <: PDeclarationInner](implicit ctag: scala.reflect.ClassTag[T]): P[PIdnRef[T]] = P(ident map (PIdnRef.apply[T] _)).pos
 
@@ -640,7 +679,7 @@ class FastParser {
   def trigger[$: P]: P[PTrigger] = P(exp.delimited(PSym.Comma).braces map (PTrigger.apply _)).pos
 
   def forperm[$: P]: P[PKw.Forperm => Pos => PExp] = P(nonEmptyIdnTypeList(PLogicalVarDecl(_)) ~ resAcc.brackets ~ PSym.ColonColon ~ exp).map {
-    case (args, res, op, body) => PForPerm(_, args, res, op, body)
+    case (args, res, op, body) => PForPerm(_, args, PPermTrigger(res), op, body)
   }
 
   def unfolding[$: P]: P[PKwOp.Unfolding => Pos => PExp] = P(predicateAccessAssertion ~ PKwOp.In ~ exp).map {
@@ -767,7 +806,7 @@ class FastParser {
   // delimited sequence of field access, function application or identifier)
   def assign[$: P]: P[PAssign] = P(
     (assignTarget.delimited(PSym.Comma, min = 1) ~~~ (P(PSymOp.Assign).map(Some(_)) ~ exp).lw.?)
-      filter (a => a._2.isDefined || (a._1.length == 1 && (a._1.head.isInstanceOf[PIdnUse] || a._1.head.isInstanceOf[PCall])))
+      filter (a => a._2.isDefined || (a._1.length == 1 && !a._1.head.isInstanceOf[PFieldAccess]))
       map (a => if (a._2.isDefined) PAssign(a._1, a._2.get._1, a._2.get._2) _ else PAssign(PDelimited.empty, None, a._1.head) _)
     ).pos
 
@@ -812,7 +851,7 @@ class FastParser {
     P((P(PKw.Else) ~ stmtBlock()) map (PElse.apply _).tupled).pos
 
   def whileStmt[$: P]: P[PKw.While => Pos => PWhile] =
-    P((parenthesizedExp ~~ semiSeparated(invariant) ~ stmtBlock()) map { case (cond, invs, body) => PWhile(_, cond, invs, body) })
+    P((parenthesizedExp ~~ specifications(invariant) ~ stmtBlock()) map { case (cond, invs, body) => PWhile(_, cond, invs, body) })
 
   def invariant(implicit ctx : P[_]) : P[PSpecification[PKw.InvSpec]] = P((P(PKw.Invariant) ~ exp).map((PSpecification.apply _).tupled).pos | ParserExtension.invSpecification(ctx))
 
@@ -821,7 +860,7 @@ class FastParser {
 
   def defineDecl[$: P]: P[PKw.Define => PAnnotationsPosition => PDefine] =
     P((idndef ~~~/ NoCut(argList((idndef map PDefineParam.apply).pos)).lw.? ~ (stmtBlock(false) | exp)) map {
-      case (idn, args, body) => k => ap: PAnnotationsPosition => PDefine(ap.annotations, k, idn, args, body)(ap.pos)
+      case (idn, args, body) => k => ap: PAnnotationsPosition => PDefine(ap.annotations, k, idn, args, PDefineInner(body))(ap.pos)
     })
 
   def defineDeclStmt[$: P]: P[PKw.Define => Pos => PDefine] = P(defineDecl.map { f => k => pos: Pos => f(k)(PAnnotationsPosition(Nil, pos)) })
@@ -859,7 +898,7 @@ class FastParser {
     P(programMember.rep map (members => {
       val warnings = _warnings
       _warnings = Seq()
-      PProgram(Nil, members)(_, warnings)
+      PProgram(Nil, members)(_, warnings, Nil, "")
     })).pos
 
   def preambleImport[$: P]: P[PKw.Import => PAnnotationsPosition => PImport] = P(
@@ -879,28 +918,22 @@ class FastParser {
     P((P(PKw.Interpretation) ~ argList(domainInterp)) map (PDomainInterpretations.apply _).tupled).pos
 
   def domainDecl[$: P]: P[PKw.Domain => PAnnotationsPosition => PDomain] = P(idndef ~~~ typeList(domainTypeVarDecl).lw.? ~~~ domainInterps.lw.? ~
-    annotated(domainFunctionDecl | axiomDecl).rep.map(PDomainMembers1.apply _).pos.braces).map {
+    semiSeparated(annotated(domainFunctionDecl | axiomDecl)).braces).map {
     case (name, typparams, interpretations, block) =>
-      val members = block.inner.members
-      val funcs1 = members collect { case m: PDomainFunction1 => m }
-      val axioms1 = members collect { case m: PAxiom1 => m }
-      val funcs = funcs1 map (f => (PDomainFunction(f.annotations, f.unique, f.function, f.idndef, f.args, f.c, f.typ, f.interpretation)(f.pos), f.s))
-      val axioms = axioms1 map (a => (PAxiom(a.annotations, a.axiom, a.idndef, a.exp)(a.pos), a.s))
-      val allMembers = block.update(PDomainMembers(PDelimited(funcs)(NoPosition, NoPosition), PDelimited(axioms)(NoPosition, NoPosition))(block.pos))
       k => ap: PAnnotationsPosition => PDomain(
         ap.annotations,
         k,
         name,
         typparams,
         interpretations,
-        allMembers)(ap.pos)
+        block)(ap.pos)
   }
 
   def domainTypeVarDecl[$: P]: P[PTypeVarDecl] = P(idndef map (PTypeVarDecl.apply _)).pos
 
   def domainFunctionInterpretation[$: P]: P[PDomainFunctionInterpretation] = P((P(PKw.Interpretation) ~ stringLiteral) map (PDomainFunctionInterpretation.apply _).tupled).pos
-  def domainFunctionDecl[$: P]: P[PAnnotationsPosition => PDomainFunction1] = P(P(PKw.Unique).? ~ domainFunctionSignature ~ domainFunctionInterpretation.? ~~~ P(PSym.Semi).lw.?).map {
-    case (unique, (function, idn, args, c, typ), interpretation, s) => ap: PAnnotationsPosition => PDomainFunction1(ap.annotations, unique, function, idn, args, c, typ, interpretation, s)(ap.pos)
+  def domainFunctionDecl[$: P]: P[PAnnotationsPosition => PDomainFunction] = P(P(PKw.Unique).? ~ domainFunctionSignature ~ domainFunctionInterpretation.?).map {
+    case (unique, (function, idn, args, c, typ), interpretation) => ap: PAnnotationsPosition => PDomainFunction(ap.annotations, unique, function, idn, args, c, typ, interpretation)(ap.pos)
   }
 
   def domainFunctionSignature[$: P] = P(P(PKw.FunctionD) ~ idndef ~ argList(domainFunctionArg) ~ PSym.Colon ~ typ)
@@ -911,20 +944,21 @@ class FastParser {
 
   def bracedExp[$: P]: P[PBracedExp] = P(exp.braces map (PBracedExp(_) _)).pos
 
-  def axiomDecl[$: P]: P[PAnnotationsPosition => PAxiom1] = P(P(PKw.Axiom) ~ idndef.? ~ bracedExp ~~~ P(PSym.Semi).lw.?).map { case (k, a, b, s) =>
-    ap: PAnnotationsPosition => PAxiom1(ap.annotations, k, a, b, s)(ap.pos)
+  def axiomDecl[$: P]: P[PAnnotationsPosition => PAxiom] = P(P(PKw.Axiom) ~ idndef.? ~ bracedExp).map { case (k, a, b) =>
+    ap: PAnnotationsPosition => PAxiom(ap.annotations, k, a, b)(ap.pos)
   }
 
   def fieldDecl[$: P]: P[PKw.Field => PAnnotationsPosition => PFields] = P((nonEmptyIdnTypeList(PFieldDecl(_)) ~~~ P(PSym.Semi).lw.?) map {
     case (a, s) => k => ap: PAnnotationsPosition => PFields(ap.annotations, k, a, s)(ap.pos)
   })
 
   def functionDecl[$: P]: P[PKw.Function => PAnnotationsPosition => PFunction] = P((idndef ~ argList(formalArg) ~ PSym.Colon ~ typ
-    ~~ semiSeparated(precondition) ~~ semiSeparated(postcondition) ~~~ bracedExp.lw.?
+    ~~ specifications(precondition) ~~ specifications(postcondition) ~~~ bracedExp.lw.?
   ) map { case (idn, args, c, typ, d, e, f) => k =>
       ap: PAnnotationsPosition => PFunction(ap.annotations, k, idn, args, c, typ, d, e, f)(ap.pos)
   })
 
+  def specifications[$: P, T <: PKw.Spec](kw: => P[PSpecification[T]]): P[PSpecs[T]] = P(semiSeparated(kw) map (PSpecs.apply _)).pos
 
   def precondition(implicit ctx : P[_]) : P[PSpecification[PKw.PreSpec]] = P((P(PKw.Requires) ~ exp).map((PSpecification.apply _).tupled).pos | ParserExtension.preSpecification(ctx))
 
@@ -936,7 +970,7 @@ class FastParser {
   }
 
   def methodDecl[$: P]: P[PKw.Method => PAnnotationsPosition => PMethod] =
-    P((idndef ~ argList(formalArg) ~~~ methodReturns.lw.? ~~ semiSeparated(precondition) ~~ semiSeparated(postcondition) ~~~ stmtBlock().lw.?) map {
+    P((idndef ~ argList(formalArg) ~~~ methodReturns.lw.? ~~ specifications(precondition) ~~ specifications(postcondition) ~~~ stmtBlock().lw.?) map {
         case (idn, args, rets, pres, posts, body) => k =>
           ap: PAnnotationsPosition => PMethod(ap.annotations, k, idn, args, rets, pres, posts, body)(ap.pos)
     })
@@ -970,7 +1004,11 @@ class FastParser {
 
     // Assume entire file is correct and try parsing it quickly
     fastparse.parse(s, entireProgram(_)) match {
-      case Parsed.Success(value, _) => return value
+      case Parsed.Success(value, _) => {
+        value.offsets = _line_offset;
+        value.rawProgram = s;
+        return value;
+      }
       case _: Parsed.Failure =>
     }
     // There was a parsing error, parse member by member to get all errors
@@ -1018,7 +1056,7 @@ class FastParser {
     val warnings = _warnings
     _warnings = Nil
     val pos = (FilePosition(lineCol.getPos(0)), FilePosition(lineCol.getPos(res.get.index)))
-    PProgram(Nil, members)(pos, errors ++ warnings)
+    PProgram(Nil, members)(pos, errors ++ warnings, Nil, "");
   }
 
   object ParserExtension extends ParserPluginTemplate {

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

@@ -82,7 +82,7 @@ object MacroExpander {
     reports ++= globalMacros.flatMap(allParametersUsedInBody)
 
     def linearizeMethod(method: PMethod): PMethod = {
-      def linearizeSeqOfNestedStmt(ss: PGrouped[PSym.Brace, PDelimited[PStmt, Option[PSym.Semi]]]): PGrouped[PSym.Brace, PDelimited[PStmt, Option[PSym.Semi]]] = {
+      def linearizeSeqOfNestedStmt(ss: PDelimited.Block[PStmt]): PDelimited.Block[PStmt] = {
         def linearizeSeqn(s: PSeqn): PSeqn = PSeqn(linearizeSeqOfNestedStmt(s.ss))(s.pos)
         def linearizeIf(i: PIf): PIf = i match {
           case PIf(k, cond, thn, None) => PIf(k, cond, linearizeSeqn(thn), None)(i.pos)
@@ -91,7 +91,7 @@ object MacroExpander {
           case PIf(k, cond, thn, Some(e@PElse(ek, els))) =>
             PIf(k, cond, linearizeSeqn(thn), Some(PElse(ek, linearizeSeqn(els))(e.pos)))(i.pos)
         }
-        var stmts = Seq.empty[(PStmt, Option[PSym.Semi])]
+        var stmts = Seq.empty[(PStmt, PSym.OptionSemi)]
         (ss.inner.toSeq.zip(ss.inner.delimiters)).foreach {
           case (n: PMacroSeqn, _) =>
             val lin = linearizeSeqOfNestedStmt(n.ss)
@@ -156,9 +156,9 @@ object MacroExpander {
                 pos._1
             }
           }
-          return PProgram(newImported, program.members)(program.pos, program.localErrors ++ reports :+ ParseError(msg, location))
+          return PProgram(newImported, program.members)(program.pos, program.localErrors ++ reports :+ ParseError(msg, location), program.offsets, program.rawProgram)
       }
-      PProgram(newImported, newMembers)(program.pos, program.localErrors ++ reports)
+      PProgram(newImported, newMembers)(program.pos, program.localErrors ++ reports, program.offsets, program.rawProgram)
     }
 
     doExpandDefinesAll(p, reports)
@@ -236,8 +236,8 @@ object MacroExpander {
 
     val matchOnMacroCall: PartialFunction[PNode, MacroApp] = {
       // Macro references in statement position (without arguments)
-      case assign@PAssign(_, None, idnuse: PIdnUseExp) if getMacroPlain(idnuse).isDefined =>
-        MacroApp(assign, None, getMacroPlain(idnuse).get)
+      case assign@PAssign(_, None, idnuse: PIdnUseExp) if getMacroPlain(idnuse.idnref).isDefined =>
+        MacroApp(assign, None, getMacroPlain(idnuse.idnref).get)
       // Macro references in statement position (with arguments)
       case assign@PAssign(_, None, app: PCall) if getMacroArgs(app).isDefined =>
         MacroApp(assign, Some(app.args), getMacroArgs(app).get)
@@ -252,6 +252,8 @@ object MacroExpander {
       // Other macro refs (without arguments)
       case idnuse: PIdnUse if getMacroPlain(idnuse).isDefined =>
         MacroApp(idnuse, None, getMacroPlain(idnuse).get)
+      case idnuse: PIdnUseExp if getMacroPlain(idnuse.idnref).isDefined =>
+        MacroApp(idnuse, None, getMacroPlain(idnuse.idnref).get)
       // Other macro refs (with arguments)
       case app: PCall if getMacroArgs(app).isDefined =>
         MacroApp(app, Some(app.args), getMacroArgs(app).get)
@@ -262,7 +264,7 @@ object MacroExpander {
         matchOnMacroCall.andThen { case MacroApp(_, _, macroDefinition) =>
           seen.get(macroDefinition.idndef.name) match {
             case None => {
-              detectCyclicMacros(macroDefinition.body, seen + (macroDefinition.idndef.name -> macroDefinition))
+              detectCyclicMacros(macroDefinition.inner.seqnOrExp, seen + (macroDefinition.idndef.name -> macroDefinition))
             }
             case Some(macroDef) =>
               throw MacroException("Recursive macro declaration found: " + macroDef.idndef.name, macroDef.pos)
@@ -346,7 +348,7 @@ object MacroExpander {
       matchOnMacroCall.andThen {
         case MacroApp(call, arguments, macroDefinition) =>
           val parameters = macroDefinition.parameters.map(_.inner.toSeq)
-          val body = macroDefinition.body
+          val body = macroDefinition.inner.seqnOrExp
 
           if (arguments.isEmpty && parameters.isDefined) {
             // `arguments.isDefined && parameters.isEmpty` cannot happen, we rule this out in `getMacroArgs`
@@ -357,7 +359,7 @@ object MacroExpander {
             throw MacroException("Number of macro arguments does not match", call.pos)
 
           (call, body) match {
-            case (_: PStmt, _: PStmt) | (_: PExp, _: PExp) | (_: PType, _: PType) | (_: PIdnRef[_], _: PIdnUse) =>
+            case (_: PStmt, _: PStmt) | (_: PExp, _: PExp) | (_: PType, _: PType) | (_: PIdnUseExp, _: PIdnUse) =>
             case _ =>
               val expandedType = body match {
                 case _: PExp => "Expression"