Added several changes to allow for FastParse 2.2.2.

Author: fabiopakk

src/main/scala/viper/silver/ast/Ast.scala

@@ -48,7 +48,7 @@ Some design choices:
   * Note that all but Program are transitive subtypes of `Node` via `Hashable`. The reason is
   * that AST node hashes may depend on the entire program, not just their sub-AST.
   */
-trait Node extends Traversable[Node] with Rewritable {
+trait Node extends Iterable[Node] with Rewritable {
 
   /** @see [[Nodes.subnodes()]] */
   def subnodes = Nodes.subnodes(this)
@@ -61,36 +61,54 @@ trait Node extends Traversable[Node] with Rewritable {
     Visitor.reduceWithContext(this, Nodes.subnodes)(context, enter, combine)
   }
 
+  override def iterator: Iterator[Node] = {
+    val iterator = new Iterator[Node] {
+      var remaining = Seq[Node]().empty
+
+      override def hasNext: Boolean = remaining.nonEmpty
+
+      override def next(): Node = {
+        val result = remaining.head
+        remaining = remaining.tail
+        result
+      }
+    }
+
+    Visitor.visit(this, Nodes.subnodes) { case n: Node => iterator.remaining ++= Seq(n) }
+
+    iterator
+  }
+
   /** Applies the function `f` to the AST node, then visits all subnodes. */
-  def foreach[A](f: Node => A) = Visitor.visit(this, Nodes.subnodes) { case a: Node => f(a) }
+  //? override def foreach[A](f: Node => A) = Visitor.visit(this, Nodes.subnodes) { case a: Node => f(a) }
 
   /** @see [[Visitor.visit()]] */
-  def visit[A](f: PartialFunction[Node, A]) {
+  def visit[A](f: PartialFunction[Node, A]): Unit = {
     Visitor.visit(this, Nodes.subnodes)(f)
   }
 
   /** @see [[Visitor.visitWithContext()]] */
-  def visitWithContext[C](c: C)(f: C => PartialFunction[Node, C]) {
+  def visitWithContext[C](c: C)(f: C => PartialFunction[Node, C]): Unit = {
     Visitor.visitWithContext(this, Nodes.subnodes, c)(f)
   }
 
   /** @see [[Visitor.visitWithContextManually()]] */
-  def visitWithContextManually[C, A](c: C)(f: C => PartialFunction[Node, A]) {
+  def visitWithContextManually[C, A](c: C)(f: C => PartialFunction[Node, A]): Unit = {
     Visitor.visitWithContextManually(this, Nodes.subnodes, c)(f)
   }
 
   /** @see [[Visitor.visit()]] */
-  def visit[A](f1: PartialFunction[Node, A], f2: PartialFunction[Node, A]) {
+  def visit[A](f1: PartialFunction[Node, A], f2: PartialFunction[Node, A]): Unit = {
     Visitor.visit(this, Nodes.subnodes, f1, f2)
   }
 
   /** @see [[Visitor.visitOpt()]] */
-  def visitOpt(f: Node => Boolean) {
+  def visitOpt(f: Node => Boolean): Unit = {
     Visitor.visitOpt(this, Nodes.subnodes)(f)
   }
 
   /** @see [[Visitor.visitOpt()]] */
-  def visitOpt[A](f1: Node => Boolean, f2: Node => A) {
+  def visitOpt[A](f1: Node => Boolean, f2: Node => A): Unit = {
     Visitor.visitOpt(this, Nodes.subnodes, f1, f2)
   }
 

src/main/scala/viper/silver/ast/utility/Consistency.scala

@@ -15,17 +15,17 @@ import viper.silver.{FastMessage, FastMessaging}
 /** An utility object for consistency checking. */
 object Consistency {
   var messages: FastMessaging.Messages = Nil
-  def recordIfNot(suspect: Positioned, property: Boolean, message: String) {
+  def recordIfNot(suspect: Positioned, property: Boolean, message: String): Unit = {
     if (!property) {
       val pos = suspect.pos
 
       this.messages ++= FastMessaging.aMessage(FastMessage(message,pos))  // this is the way to construct a message directly with a position (only).
     }
   }
 
-  def resetMessages() { this.messages = Nil }
+  def resetMessages(): Unit = { this.messages = Nil }
   @inline
-  def recordIf(suspect: Positioned, property: Boolean, message: String) =
+  def recordIf(suspect: Positioned, property: Boolean, message: String): Unit =
     recordIfNot(suspect, !property, message)
 
   /** Names that are not allowed for use in programs. */

src/main/scala/viper/silver/ast/utility/Functions.scala

@@ -35,7 +35,7 @@ object Functions {
       graph.addVertex(f)
     }
 
-    def process(f: Function, e: Exp) {
+    def process(f: Function, e: Exp): Unit = {
       e visit {
         case FuncApp(f2name, _) =>
           graph.addEdge(f, program.findFunction(f2name))
@@ -156,7 +156,7 @@ object Functions {
   def recursiveCallsAndSurroundingUnfoldings(f : Function) : Seq[(FuncApp,Seq[Unfolding])] = {
     var result: Seq[(FuncApp, Seq[Unfolding])] = Seq()
 
-    def recordCallsAndUnfoldings(e: Node, ufs: Seq[Unfolding]) {
+    def recordCallsAndUnfoldings(e: Node, ufs: Seq[Unfolding]): Unit = {
       e.shallowCollect {
       case Let(v, e, bod) => recordCallsAndUnfoldings(e.replace(e, bod), ufs)
       case uf@Unfolding (acc, body) =>

src/main/scala/viper/silver/ast/utility/GenericAxiomRewriter.scala

@@ -59,13 +59,10 @@ abstract class GenericAxiomRewriter[Type <: AnyRef,
 
   protected def fresh(name: String, typ: Type): Var
 
-  @scala.annotation.elidable(level = scala.annotation.elidable.ASSERTION)
   protected def log(message: String): Unit
 
-  @scala.annotation.elidable(level = scala.annotation.elidable.ASSERTION)
   protected def log(key: String, item: Any): Unit
 
-  @scala.annotation.elidable(level = scala.annotation.elidable.ASSERTION)
   protected def log(key: String, items: Iterable[Any]): Unit
 
   /*

src/main/scala/viper/silver/ast/utility/QuantifiedPermissions.scala

@@ -100,7 +100,7 @@ object QuantifiedPermissions {
   private def quantifiedFields(toVisit: mutable.Queue[Member],
                                collected: mutable.LinkedHashSet[Field],
                                visited: mutable.Set[Member],
-                               program: Program) {
+                               program: Program): Unit = {
 
     while (toVisit.nonEmpty) {
       val root = toVisit.dequeue()
@@ -121,7 +121,7 @@ object QuantifiedPermissions {
   private def quantifiedPredicates(toVisit: mutable.Queue[Member],
                                    collected: mutable.LinkedHashSet[Predicate],
                                    visited: mutable.Set[Member],
-                                   program: Program) {
+                                   program: Program): Unit = {
 
     while (toVisit.nonEmpty) {
       val root = toVisit.dequeue()

src/main/scala/viper/silver/ast/utility/Triggers.scala

@@ -107,9 +107,9 @@ object Triggers {
       LocalVar(s"__rw_$name$nextUniqueId", typ)()
     }
 
-    protected def log(message: String) {}
-    protected def log(key: String, item: Any) {}
-    protected def log(key: String, items: Iterable[Any]) {}
+    protected def log(message: String): Unit = {}
+    protected def log(key: String, item: Any): Unit = {}
+    protected def log(key: String, items: Iterable[Any]): Unit = {}
   }
 
   object SimpleArithmeticSolver extends GenericArithmeticSolver[Type, Exp, LocalVar, Add, Sub] {

src/main/scala/viper/silver/cfg/CfgTest.scala

@@ -13,9 +13,10 @@ import viper.silver.parser.{FastParser, PProgram, Resolver, Translator}
 import viper.silver.verifier.ParseWarning
 
 import scala.io.Source
+import fastparse._
 
 object CfgTest {
-  def main(args: Array[String]): Unit = {
+  def main[_: P](args: Array[String]): Unit = {
     if (args.isEmpty) throw new RuntimeException("No input file specified")
     val path = args(0)
 
@@ -35,7 +36,7 @@ object CfgTest {
     }
   }
 
-  private def parse(input: String, file: Path): Option[PProgram] = {
+  private def parse[_: P](input: String, file: Path): Option[PProgram] = {
     val result = FastParser.parse(input, file)
     result match {
       case Success(program@PProgram(_, _, _, _, _, _, _,_, errors), _) =>

src/main/scala/viper/silver/components/Components.scala

@@ -15,8 +15,8 @@ package viper.silver.components
   * expected sequence of events (start, stop).
   */
 trait LifetimeComponent {
-  def start()
-  def stop()
+  def start(): Unit
+  def stop(): Unit
 }
 
 /** Describes a component that potentially has state which must be taken care
@@ -29,5 +29,5 @@ trait LifetimeComponent {
   * expected sequence of events (start, reset, stop).
   */
 trait StatefulComponent extends LifetimeComponent {
-  def reset()
+  def reset(): Unit
 }

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

@@ -25,18 +25,18 @@ import viper.silver.verifier._
 trait Frontend {
 
   /** Initialize this translator with a given verifier. Only meant to be called once. */
-  protected def init(verifier: Verifier)
+  protected def init(verifier: Verifier): Unit
 
   /**
     * Reset the translator, and set the input program. Can be called many times to verify multiple programs
     * using the same verifier.
     */
-  def reset(input: Seq[Path])
+  def reset(input: Seq[Path]): Unit
 
   /**
     * Reset any messages recorded internally (errors from previous program translations, etc.)
     */
-  def resetMessages()
+  def resetMessages(): Unit
 
   /**
     * Reporter is the message interface which enables (potentially dynamic) feedback from the backend.
@@ -116,25 +116,25 @@ trait DefaultPhases extends Frontend {
   val phases = Seq(Parsing, SemanticAnalysis, Translation, ConsistencyCheck, Verification)
 
   /** Parse the program. */
-  def parsing()
+  def parsing(): Unit
 
   /** Perform semantic analysis in the program, such as type, names and scope checking. */
-  def semanticAnalysis()
+  def semanticAnalysis(): Unit
 
   /** Translate the program to Viper. */
-  def translation()
+  def translation(): Unit
 
   /** Perform a consistency check in Viper AST. */
-  def consistencyCheck()
+  def consistencyCheck(): Unit
 
   /** Verify the Viper program using a verifier. */
-  def verification()
+  def verification(): Unit
 }
 
 trait SingleFileFrontend {
-  def reset(file: Path)
+  def reset(file: Path): Unit
 
-  def reset(files: Seq[Path]) {
+  def reset(files: Seq[Path]): Unit = {
     files match {
       case f :: Nil => reset(f)
       case _ => sys.error("This frontend can only handle single files.")
@@ -185,12 +185,12 @@ trait DefaultFrontend extends Frontend with DefaultPhases with SingleFileFronten
 
   def getVerificationResult: Option[VerificationResult] = _verificationResult
 
-  override def init(verifier: Verifier) {
+  override def init(verifier: Verifier): Unit = {
     _state = DefaultStates.Initialized
     _verifier = Some(verifier)
   }
 
-  override def reset(input: Path) {
+  override def reset(input: Path): Unit = {
     if (state < DefaultStates.Initialized) sys.error("The translator has not been initialized.")
     _state = DefaultStates.InputSet
     _inputFile = Some(input)

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

@@ -106,7 +106,7 @@ abstract class SilFrontendConfig(args: Seq[String], private var projectName: Str
   )
 
   validateOpt(file, ignoreFile) {
-    case (_, Some(true)) => Right(Unit)
+    case (_, Some(true)) => Right(())
     case (Some(filepath), _) => validateFileOpt(file.name, filepath)
     case (optFile, optIgnoreFile) =>
       /* Since the file is a trailing argument and thus mandatory, this case
@@ -121,12 +121,12 @@ abstract class SilFrontendConfig(args: Seq[String], private var projectName: Str
     val file = new java.io.File(filepath)
     if (!file.isFile) Left(s"Cannot find file '$filepath' from '$optionName' argument")
     else if (!file.canRead) Left(s"Cannot read from file '$filepath' from '$optionName' argument'")
-    else Right(Unit)
+    else Right(())
   }
 
   protected def validateFileOpt(option: ScallopOption[String]): Unit = {
     validateOpt(option) {
-      case None => Right(Unit)
+      case None => Right(())
       case Some(filepath) => validateFileOpt(option.name, filepath)
     }
   }