Merge branch 'master' of github.com:viperproject/silver

Author: Malte Schwerhoff

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

@@ -121,30 +121,37 @@ trait Node extends Iterable[Node] with Rewritable {
   /** @see [[viper.silver.ast.utility.ViperStrategy]] */
   def transform(pre: PartialFunction[Node, Node] = PartialFunction.empty,
                 recurse: Traverse = Traverse.Innermost)
-               : this.type =
+               : this.type = {
 
-  StrategyBuilder.Slim[Node](pre, recurse) execute[this.type] (this)
+    StrategyBuilder.Slim[Node](pre, recurse) execute[this.type] (this)
+  }
 
   def transformForceCopy(pre: PartialFunction[Node, Node] = PartialFunction.empty,
-                recurse: Traverse = Traverse.Innermost)
-  : this.type =
+                         recurse: Traverse = Traverse.Innermost)
+                         : this.type = {
 
     StrategyBuilder.Slim[Node](pre, recurse).forceCopy() execute[this.type] (this)
+  }
 
   /**
     * Allows a transformation with a custom context threaded through
     *
     * @see [[viper.silver.ast.utility.ViperStrategy]] */
   def transformWithContext[C](transformation: PartialFunction[(Node,C), (Node, C)] = PartialFunction.empty,
-                             initialContext: C,
-                recurse: Traverse = Traverse.Innermost)
-  : this.type =
+                              initialContext: C,
+                              recurse: Traverse = Traverse.Innermost)
+                             : this.type = {
+
     ViperStrategy.CustomContext[C](transformation, initialContext, recurse) execute[this.type] (this)
+  }
 
   def transformNodeAndContext[C](transformation: PartialFunction[(Node,C), (Node, C)],
                                  initialContext: C,
-                                 recurse: Traverse = Traverse.Innermost) : this.type =
+                                 recurse: Traverse = Traverse.Innermost)
+                                : this.type = {
+
     StrategyBuilder.RewriteNodeAndContext[Node, C](transformation, initialContext, recurse).execute[this.type](this)
+  }
 
   def replace(original: Node, replacement: Node): this.type =
     this.transform { case `original` => replacement }
@@ -155,11 +162,11 @@ trait Node extends Iterable[Node] with Rewritable {
 
   /** @see [[Visitor.deepCollect()]] */
   def deepCollect[A](f: PartialFunction[Node, A]): Seq[A] =
-  Visitor.deepCollect(Seq(this), Nodes.subnodes)(f)
+    Visitor.deepCollect(Seq(this), Nodes.subnodes)(f)
 
   /** @see [[Visitor.shallowCollect()]] */
   def shallowCollect[R](f: PartialFunction[Node, R]): Seq[R] =
-  Visitor.shallowCollect(Seq(this), Nodes.subnodes)(f)
+    Visitor.shallowCollect(Seq(this), Nodes.subnodes)(f)
 
   def contains(n: Node): Boolean = this.existsDefined {
     case `n` =>

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

@@ -55,6 +55,7 @@ object FastMessaging {
     */
   def message (value : Any, msg : String, cond : Boolean = true, error : Boolean = true) : Messages =
     if (cond) {
+      // Warning: Potential scala.MatchError here if position info is lost!
       val valuePos: SourcePosition = value.asInstanceOf[PNode].pos._1 match {
         case slc: FilePosition => {
           value.asInstanceOf[PNode].pos._2 match {

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

@@ -145,7 +145,7 @@ object FastParser {
             j += 1
           }
         }
-      PProgram(Seq(), macros, domains, fields, functions, predicates, methods, extensions, errors)()
+      PProgram(Seq(), macros, domains, fields, functions, predicates, methods, extensions, errors)(p.pos)
     }
 
 
@@ -474,7 +474,7 @@ object FastParser {
       linearizeMethod(doExpandDefines(localMacros ++ globalMacros, methodWithoutMacros, p))
     })
 
-    PProgram(p.imports, p.macros, domains, p.fields, functions, predicates, methods, p.extensions, p.errors ++ warnings)()
+    PProgram(p.imports, p.macros, domains, p.fields, functions, predicates, methods, p.extensions, p.errors ++ warnings)(p.pos)
   }
 
 
@@ -1017,43 +1017,51 @@ object FastParser {
 
   def setTypedEmpty[_: P]: P[PExp] = collectionTypedEmpty("Set", (a, b) => PEmptySet(a)(b))
 
-  def explicitSetNonEmpty[_: P]: P[PExp] = P("Set" ~ "(" ~/ exp.rep(sep = ",", min = 1) ~ ")").map(PExplicitSet(_)())
+  def explicitSetNonEmpty[_: P]: P[PExp] = P(FP("Set" ~ "(" ~/ exp.rep(sep = ",", min = 1) ~ ")").map {
+    case (pos, exps) => PExplicitSet(exps)(pos)
+  })
 
-  def explicitMultisetNonEmpty[_: P]: P[PExp] = P("Multiset" ~ "(" ~/ exp.rep(min = 1, sep = ",") ~ ")").map(PExplicitMultiset(_)())
+  def explicitMultisetNonEmpty[_: P]: P[PExp] = P(FP("Multiset" ~ "(" ~/ exp.rep(min = 1, sep = ",") ~ ")").map {
+    case (pos, exps) => PExplicitMultiset(exps)(pos)
+  })
 
   def multiSetTypedEmpty[_: P]: P[PExp] = collectionTypedEmpty("Multiset", (a, b) => PEmptyMultiset(a)(b))
 
   def seqTypedEmpty[_: P]: P[PExp] = collectionTypedEmpty("Seq", (a, b) => PEmptySeq(a)(b))
 
-  //HEAD: def seqLength[_: P]: P[PExp] = P("|" ~ exp ~ "|").map(PSize(_)())
-  def size[_: P]: P[PExp] = P("|" ~ exp ~ "|").map(PSize(_)())
-  //MAP: lazy val size: P[PExp] = P("|" ~ exp ~ "|").map(PSize)
+  def size[_: P]: P[PExp] = P(FP("|" ~ exp ~ "|").map {
+    case (pos, e) => PSize(e)(pos)
+  })
 
-  def explicitSeqNonEmpty[_: P]: P[PExp] = P("Seq" ~ "(" ~/ exp.rep(min = 1, sep = ",") ~ ")").map(PExplicitSeq(_)())
+  def explicitSeqNonEmpty[_: P]: P[PExp] = P(FP("Seq" ~ "(" ~/ exp.rep(min = 1, sep = ",") ~ ")").map {
+    case (pos, exps) => PExplicitSeq(exps)(pos)
+  })
 
   private def collectionTypedEmpty[_: P](name: String, typeConstructor: (PType, (Position, Position)) => PExp): P[PExp] =
     FP(`name` ~ ("[" ~/ typ ~ "]").? ~ "(" ~ ")").map{ case (pos, typ) => typeConstructor(typ.getOrElse(PTypeVar("#E")), pos)}
 
   def seqRange[_: P]: P[PExp] = FP("[" ~ exp ~ ".." ~ exp ~ ")").map { case (pos, (a, b)) => PRangeSeq(a, b)(pos) }
-  // MAPS: lazy val seqRange: P[PExp] = P("[" ~ exp ~ ".." ~ exp ~ ")").map { case (a, b) => PRangeSeq(a, b) }
 
-  def mapTypedEmpty[_: P] : P[PMapLiteral] = P("Map" ~ ("[" ~/ typ ~ "," ~ typ ~ "]").? ~ "(" ~ ")").map {
-    case Some((keyType, valueType)) => PEmptyMap(keyType, valueType)()
-    case None => PEmptyMap(PTypeVar("#K"), PTypeVar("#E"))()
-  }
+  def mapTypedEmpty[_: P] : P[PMapLiteral] = P(FP("Map" ~ ("[" ~/ typ ~ "," ~ typ ~ "]").? ~ "(" ~ ")").map {
+    case (pos, Some((keyType, valueType))) => PEmptyMap(keyType, valueType)(pos)
+    case (pos, None) => PEmptyMap(PTypeVar("#K"), PTypeVar("#E"))(pos)
+  })
 
-  def maplet[_: P]: P[PMaplet] = P(exp ~ ":=" ~ exp).map {
-    case (key, value) => PMaplet(key, value)()
-  }
+  def maplet[_: P]: P[PMaplet] = P(FP(exp ~ ":=" ~ exp).map {
+    case (pos, (key, value)) => PMaplet(key, value)(pos)
+  })
 
-  // MAPS: lazy val explicitMapNonEmpty : P[PMapLiteral] = P("Map" ~ "(" ~/ maplet.rep(min = 1, sep = ",") ~ ")").map(PExplicitMap)
-  def explicitMapNonEmpty[_: P]: P[PMapLiteral] = P("Map" ~ "(" ~/ maplet.rep(sep = ",", min = 1) ~ ")").map(PExplicitMap(_)())
+  def explicitMapNonEmpty[_: P]: P[PMapLiteral] = P(FP("Map" ~ "(" ~/ maplet.rep(sep = ",", min = 1) ~ ")").map {
+    case (pos, maplets) => PExplicitMap(maplets)(pos)
+  })
 
-  //lazy val mapDomain : P[PExp] = P("domain" ~ "(" ~ exp ~ ")").map(PMapDomain)
-  def mapDomain[_: P]: P[PExp] = P("domain" ~ "(" ~ exp ~ ")").map(PMapDomain(_)())
-  //def size[_: P]: P[PExp] = P("|" ~ exp ~ "|").map(PSize(_))
+  def mapDomain[_: P]: P[PExp] = P(FP("domain" ~ "(" ~ exp ~ ")").map {
+    case (pos, e) => PMapDomain(e)(pos)
+  })
 
-  def mapRange[_: P] : P[PExp] = P("range" ~ "(" ~ exp ~ ")").map(PMapRange(_)())
+  def mapRange[_: P] : P[PExp] = P(FP("range" ~ "(" ~ exp ~ ")").map {
+    case (pos, e) => PMapRange(e)(pos)
+  })
 
   def fapp[_: P]: P[PCall] = FP(idnuse ~ parens(actualArgList)).map {
     case (pos, (func, args)) =>
@@ -1105,9 +1113,9 @@ object FastParser {
     case (pos, (cond, thn, ele)) => PSeqn(Seq(PIf(cond, thn, ele)(pos)))(pos)
   }
 
-  def els[_: P]: LW[PSeqn] = ((keyword("else") ~/ block) | FP(Pass)).lw.map {
-    case block: PSeqn => block
-    case (pos, _) => PSeqn(Nil)() }
+  def els[_: P]: LW[PSeqn] = ((keyword("else") ~/ block) | FP(Pass).map {
+    case (pos, _) => PSeqn(Nil)(pos)
+  }).lw
 
   def whle[_: P]: P[PWhile] = FP(keyword("while") ~/ "(" ~ exp ~ ")" ~ inv.rep ~ block).map {
     case (pos, (cond, invs, body)) =>
@@ -1156,8 +1164,8 @@ object FastParser {
 
   def applying[_: P]: P[PExp] = FP(keyword("applying") ~/ "(" ~ magicWandExp ~ ")" ~ "in" ~ exp).map { case (pos, (a, b)) => PApplying(a, b)(pos) }
 
-  def programDecl(implicit ctx : P[_]) : P[PProgram] = P((ParserExtension.newDeclAtStart(ctx) | preambleImport | defineDecl | domainDecl | fieldDecl | functionDecl | predicateDecl | methodDecl | ParserExtension.newDeclAtEnd(ctx)).rep).map {
-    decls => {
+  def programDecl(implicit ctx : P[_]) : P[PProgram] = P(FP((ParserExtension.newDeclAtStart(ctx) | preambleImport | defineDecl | domainDecl | fieldDecl | functionDecl | predicateDecl | methodDecl | ParserExtension.newDeclAtEnd(ctx)).rep).map {
+    case (pos, decls) => {
       PProgram(
         decls.collect { case i: PImport => i }, // Imports
         decls.collect { case d: PDefine => d }, // Macros
@@ -1168,9 +1176,9 @@ object FastParser {
         decls.collect { case m: PMethod => m }, // Methods
         decls.collect { case e: PExtender => e }, // Extensions
         Seq() // Parse Errors
-      )()
+      )(pos)
     }
-  }
+  })
 
   def preambleImport[_: P]: P[PImport] = FP(keyword("import") ~/ (
       P(quoted(relativeFilePath.!)).map{ filename => pos: (Position, Position) => PLocalImport(filename)(pos) } |