Some parser revisions

(1) Added markup parsers
(2) Syntax change relating to modifiers and annotations of primary constructor
(3) Review of parsing with bug fixes and simplifications.

1 files changed, 451 insertions, 525 deletions

diff --git a/src/dotty/tools/dotc/parsing/Parsers.scala b/src/dotty/tools/dotc/parsing/Parsers.scala
index 12a828300..d88d9afab 100644
--- a/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -7,6 +7,7 @@ import scala.collection.immutable.BitSet
 import util.{ SourceFile, FreshNameCreator }
 import Tokens._
 import Scanners._
+import MarkupParsers._
 import core._
 import Flags._
 import Contexts._
@@ -20,44 +21,9 @@ import Types._
 import Constants._
 import NameOps._
 import scala.reflect.internal.Chars._
+import ScriptParsers._
 import annotation.switch
 
-
-/** <p>Performs the following context-free rewritings:</p>
- *  <ol>
- *    <li>
- *      Places all pattern variables in Bind nodes. In a pattern, for
- *      identifiers <code>x</code>:<pre>
- *                 x  => x @ _
- *               x:T  => x @ (_ : T)</pre>
- *    </li>
- *    <li>Removes pattern definitions (PatDef's) as follows:
- *      If pattern is a simple (typed) identifier:<pre>
- *        <b>val</b> x = e     ==>  <b>val</b> x = e
- *        <b>val</b> x: T = e  ==>  <b>val</b> x: T = e</pre>
- *
- *      if there are no variables in pattern<pre>
- *        <b>val</b> p = e  ==>  e match (case p => ())</pre>
- *
- *      if there is exactly one variable in pattern<pre>
- *        <b>val</b> x_1 = e <b>match</b> (case p => (x_1))</pre>
- *
- *      if there is more than one variable in pattern<pre>
- *        <b>val</b> p = e  ==>  <b>private synthetic val</b> t$ = e <b>match</b> (case p => (x_1, ..., x_N))
- *                        <b>val</b> x_1 = t$._1
- *                        ...
- *                        <b>val</b> x_N = t$._N</pre>
- *    </li>
- *    <li>
- *       Removes function types as follows:<pre>
- *        (argtpes) => restpe   ==>   scala.Function_n[argtpes, restpe]</pre>
- *    </li>
- *    <li>
- *      Wraps naked case definitions in a match as follows:<pre>
- *        { cases }   ==>   (x => x.match {cases})<span style="font-family:normal;">, except when already argument to match</span></pre>
- *    </li>
- *  </ol>
- */
 object Parsers {
 
   import UntypedTrees.{untpd, ugen}
@@ -73,147 +39,56 @@ object Parsers {
     def nonePositive: Boolean = parCounts forall (_ <= 0)
   }
 
+  object Location extends Enumeration {
+    val InParens, InBlock, ElseWhere = Value
+  }
 
-  class Parser(val source: SourceFile)(implicit ctx: Context) extends DotClass {
-
-//    def this(unit: CompilationUnit) = this(unit, List())
-
-    val in = new Scanner(source)
+  object ParamOwner extends Enumeration {
+    val Class, Type, TypeParam, Def = Value
+  }
 
-    /** The parse starting point depends on whether the source file is self-contained:
-     *  if not, the AST will be supplemented.
-     */
-    def parseStartRule =
-      if (source.isSelfContained) () => compilationUnit()
-      else () => scriptBody()
+  /** The parse starting point depends on whether the source file is self-contained:
+   *  if not, the AST will be supplemented.
+   */
+  def parser(source: SourceFile)(implicit ctx: Context) =
+    if (source.isSelfContained) new ScriptParser(source)
+    else new Parser(source)
 
-    def sourcePos(off: Int = in.offset): SourcePosition =
-      source atPos Position(off)
+  class Parser(val source: SourceFile)(implicit ctx: Context) extends DotClass {
 
-    /** the markup parser
-    lazy val xmlp = new MarkupParser(this, true)
+    val in = new Scanner(source)
 
-    object symbXMLBuilder extends SymbolicXMLBuilder(this, true) { // DEBUG choices
-      val global: self.global.type = self.global
-      def freshName(prefix: String): Name = SourceFileParser.this.freshName(prefix)
-    }
-    */
     val openParens = new ParensCounters
 
-    def xmlLiteral() : Tree = ??? // xmlp.xLiteral
-    def xmlLiteralPattern() : Tree = ??? // xmlp.xLiteralPattern
-
     /** This is the general parse entry point.
+     *  Overridden by ScriptParser
      */
     def parse(): Tree = {
-      val t = parseStartRule()
+      val t = compilationUnit()
       accept(EOF)
       t
     }
 
-    /** This is the parse entry point for code which is not self-contained, e.g.
-     *  a script which is a series of template statements.  They will be
-     *  swaddled in Trees until the AST is equivalent to the one returned
-     *  by compilationUnit().
-     */
-    def scriptBody(): Tree = unsupported("scriptBody")
-    /* TODO: reinstantiate
-      val stmts = templateStatSeq(false)._2
-      accept(EOF)
-
-      def mainModuleName = ctx.settings.script.value
-
-      /** If there is only a single object template in the file and it has a
-       *  suitable main method, we will use it rather than building another object
-       *  around it.  Since objects are loaded lazily the whole script would have
-       *  been a no-op, so we're not taking much liberty.
-       */
-      def searchForMain(): Option[Tree] = {
-        /** Have to be fairly liberal about what constitutes a main method since
-         *  nothing has been typed yet - for instance we can't assume the parameter
-         *  type will look exactly like "Array[String]" as it could have been renamed
-         *  via import, etc.
-         */
-        def isMainMethod(t: Tree) = t match {
-          case DefDef(_, nme.main, Nil, List(_), _, _)  => true
-          case _                                        => false
-        }
-        /** For now we require there only be one top level object. */
-        var seenModule = false
-        val newStmts = stmts collect {
-          case t @ Import(_, _) => t
-          case md @ ModuleDef(mods, name, template)
-            if !seenModule && (template.body exists isMainMethod) =>
-            seenModule = true
-            /** This slightly hacky situation arises because we have no way to communicate
-             *  back to the scriptrunner what the name of the program is.  Even if we were
-             *  willing to take the sketchy route of settings.script.value = progName, that
-             *  does not work when using fsc.  And to find out in advance would impose a
-             *  whole additional parse.  So instead, if the actual object's name differs from
-             *  what the script is expecting, we transform it to match.
-             */
-            md.derivedModuleDef(mods, mainModuleName.toTermName, template)
-          case _ =>
-            /** If we see anything but the above, fail. */
-            return None
-        }
-        Some(makePackaging(0, emptyPkg, newStmts))
-      }
-
-      if (mainModuleName == ScriptRunner.defaultScriptMain)
-        searchForMain() foreach { return _ }
-
-      /** Here we are building an AST representing the following source fiction,
-       *  where <moduleName> is from -Xscript (defaults to "Main") and <stmts> are
-       *  the result of parsing the script file.
-       *
-       *  object <moduleName> {
-       *    def main(argv: Array[String]): Unit = {
-       *      val args = argv
-       *      new AnyRef {
-       *        <stmts>
-       *      }
-       *    }
-       *  }
-       */
-      import definitions._
-
-      def emptyPkg    = atPos(0, 0, 0) { Ident(nme.EMPTY_PACKAGE_NAME) }
-      def emptyInit   = DefDef(
-        Modifiers(),
-        nme.CONSTRUCTOR,
-        Nil,
-        List(Nil),
-        TypeTree(),
-        Block(List(Apply(Select(Super(This(tpnme.EMPTY), tpnme.EMPTY), nme.CONSTRUCTOR), Nil)), Literal(Constant(())))
-      )
-
-      // def main
-      def mainParamType = AppliedTypeTree(Ident(tpnme.Array), List(Ident(tpnme.String)))
-      def mainParameter = List(ValDef(Modifiers(Param), "argv", mainParamType, EmptyTree))
-      def mainSetArgv   = List(ValDef(Modifiers(), "args", TypeTree(), Ident("argv")))
-      def mainNew       = makeNew(Nil, emptyValDef, stmts, List(Nil), NoPosition, NoPosition)
-      def mainDef       = DefDef(Modifiers(), nme.main, Nil, List(mainParameter), scalaDot(tpnme.Unit), Block(mainSetArgv, mainNew))
-
-      // object Main
-      def moduleName  = ScriptRunner scriptMain settings
-      def moduleBody  = Template(List(scalaScalaObjectConstr), emptyValDef, List(emptyInit, mainDef))
-      def moduleDef   = ModuleDef(Modifiers(), moduleName, moduleBody)
+/* -------------- TOKEN CLASSES ------------------------------------------- */
 
-      // package <empty> { ... }
-      makePackaging(0, emptyPkg, List(moduleDef))
-    }*/
+    def isIdent = in.token == IDENTIFIER || in.token == BACKQUOTED_IDENT
+    def isIdent(name: Name) = in.token == IDENTIFIER && in.name == name
+    def isLiteral = literalTokens contains in.token
+    def isNumericLit = numericLitTokens contains in.token
+    def isModifier = modifierTokens contains in.token
+    def isExprIntro = canStartExpressionTokens contains in.token
+    def isTemplateIntro = templateIntroTokens contains in.token
+    def isDclIntro = dclIntroTokens contains in.token
+    def isStatSeqEnd = in.token == RBRACE || in.token == EOF
+    def mustStartStat = mustStartStatTokens contains in.token
 
-    /* --------------- PLACEHOLDERS ------------------------------------------- */
+    def isDefIntro(allowedMods: BitSet) =
+      in.token == AT || (allowedMods contains in.token) || (defIntroTokens contains in.token)
 
-    def isWildcard(t: Tree): Boolean = t match {
-      case Ident(nme.WILDCARD) => true
-      case Typed(t1, _) => isWildcard(t1)
-      case Annotated(t1, _) => isWildcard(t1)
-      case _ => false
-    }
+    def isStatSep: Boolean =
+      in.token == NEWLINE || in.token == NEWLINES || in.token == SEMI
 
-    /* ------------- POSITIONS ------------------------------------------- */
+/* ------------- POSITIONS ------------------------------------------- */
 
     def atPos[T <: Positioned](start: Offset, point: Offset, end: Offset)(t: T): T =
       atPos(Position(start, end, point))(t)
@@ -227,30 +102,26 @@ object Parsers {
     def atPos[T <: Positioned](pos: Position)(t: T): T =
       if (t.pos.isSourceDerived) t else t.withPos(pos)
 
-    def here[T <: Positioned]: T => T = {
-      val start = in.offset
-      t => atPos(start, start)(t)
-    }
-
     def tokenRange = Position(in.offset, in.lastCharOffset)
 
-/* ------------- ERROR HANDLING ------------------------------------------- */
+    def sourcePos(off: Int = in.offset): SourcePosition =
+      source atPos Position(off)
 
-    private var inFunReturnType = false
-    private def fromWithinReturnType[T](body: => T): T = {
-      val saved = inFunReturnType
-      try {
-        inFunReturnType = true
-        body
-      } finally inFunReturnType = saved
-    }
+/* ------------- ERROR HANDLING ------------------------------------------- */
 
-    private var lastDefOffset = -1
+    /** The offset of the last time when a statement on a new line was definitely
+     *  encountered in the current scope or an outer scope\
+     */
+    private var lastStatOffset = -1
 
-    def setLastDefOffset() =
-      if ((mustStartStatTokens contains in.token) && in.isAfterLineEnd)
-        lastDefOffset = in.offset
+    def setLastStatOffset() =
+      if (mustStartStat && in.isAfterLineEnd)
+        lastStatOffset = in.offset
 
+    /** Is offset1 less or equally indented than offset2?
+     *  This is the case if the characters between the preceding end-of-line and offset1
+     *  are a prefix of the characters between the preceding end-of-line and offset2.
+     */
     def isLeqIndented(offset1: Int, offset2: Int): Boolean = {
       def lineStart(off: Int): Int =
         if (off > 0 && source(off) != LF) lineStart(off - 1)
@@ -261,7 +132,16 @@ object Parsers {
       recur(lineStart(offset1), lineStart(offset2))
     }
 
-    protected def skip(targetToken: Int = EOF) {
+    /** Skip on error to next safe point.
+     *  Safe points are:
+     *   - Closing braces, provided they match an opening brace before the error point.
+     *   - Closing parens and brackets, provided they match an opening parent or bracket
+     *     before the error point and there are no intervening other kinds of parens.
+     *   - Semicolons and newlines, provided there are no intervening braces.
+     *   - Definite statement starts on new lines, provided they are not more indented
+     *     than the last known statement start before the error point.
+     */
+    protected def skip() {
       val skippedParens = new ParensCounters
       while (true) {
         (in.token: @switch) match {
@@ -288,13 +168,11 @@ object Parsers {
           case LBRACKET=>
             skippedParens.change(LBRACKET, +1)
           case _ =>
+            if (mustStartStat &&
+                in.isAfterLineEnd() &&
+                isLeqIndented(in.offset, lastStatOffset))
+              return
         }
-        if (   (mustStartStatTokens contains in.token) &&
-               in.isAfterLineEnd() &&
-               isLeqIndented(in.offset, lastDefOffset)
-            || targetToken == in.token &&
-               skippedParens.nonePositive)
-          return
         in.nextToken()
       }
     }
@@ -305,26 +183,38 @@ object Parsers {
     def deprecationWarning(msg: String, offset: Int = in.offset) =
       ctx.deprecationWarning(msg, source atPos Position(offset))
 
-    /** whether a non-continuable syntax error has been seen */
+    /** The offset where the last syntax error was reported, or if a skip to a
+     *  safepoint occurred afterwards, the offset of the safe point.
+     */
     private var lastErrorOffset : Int = -1
 
+    /** Issue an error at given offset if beyond last error offset
+     *  and update lastErrorOffset.
+     */
     def syntaxError(msg: String, offset: Int = in.offset): Unit =
       if (offset > lastErrorOffset) {
         syntaxError(msg, Position(offset))
         lastErrorOffset = in.offset
       }
 
+    /** Unconditionally issue an error at given position, without
+     *  updating lastErrorOffset.
+     */
     def syntaxError(msg: String, pos: Position): Unit =
       ctx.error(msg, source atPos pos)
 
+    /** Issue an error at current offset taht input is incomplete */
     def incompleteInputError(msg: String) =
       ctx.reporter.incompleteInputError(msg, source atPos Position(in.offset))
 
+    /** If at end of file, issue an incompleteInputError.
+     *  Otherwise issue a syntax error and skip to next safe point.
+     */
     def syntaxErrorOrIncomplete(msg: String) =
       if (in.token == EOF) incompleteInputError(msg)
-      else { syntaxError(msg); skip() }
+      else { syntaxError(msg); skip(); lastErrorOffset = in.offset }
 
-    def expectedMsg(token: Int): String =
+    private def expectedMsg(token: Int): String =
       showToken(token) + " expected but " + showToken(in.token) + " found."
 
     /** Consume one token of the specified type, or
@@ -347,33 +237,19 @@ object Parsers {
       case _                  => accept(SEMI)
     }
 
-    def acceptStatSepOpt(altEnd: Token = EOF) =
-      if (!isStatSeqEnd) acceptStatSep()
-
-    def errorTermTree    = here(Literal(Constant(null)))
-
-    /** Check that type parameter is not by name or repeated */
-    def checkNotByNameArgs(tpt: Tree) =
-      if (TreeInfo.isByNameParamType(tpt))
-        syntaxError("no by-name parameter type allowed here", tpt.pos)
-
-/* -------------- TOKEN CLASSES ------------------------------------------- */
-
-    def isUnaryOp = isIdent && nme.raw.isUnary(in.name)
-    def isRawStar = isIdent && in.name == nme.raw.STAR
-    def isRawBar  = isIdent && in.name == nme.raw.BAR
-    def isIdent = in.token == IDENTIFIER || in.token == BACKQUOTED_IDENT
-    def isIdent(name: Name) = in.token == IDENTIFIER && in.name == name
-    def isLiteral = literalTokens contains in.token
-    def isExprIntro = canStartExpressionTokens contains in.token
-    def isTypeIntro: Boolean = canStartTypeTokens contains in.token
-    def isStatSeqEnd = in.token == RBRACE || in.token == EOF
+    def acceptStatSepUnlessAtEnd(altEnd: Token = EOF) =
+      if (!isStatSeqEnd && in.token != altEnd) acceptStatSep()
 
-    def isDefIntro(allowedMods: BitSet) =
-      in.token == AT || (allowedMods contains in.token) || (defIntroTokens contains in.token)
+    def errorTermTree    = atPos(in.offset) { Literal(Constant(null)) }
 
-    def isStatSep: Boolean =
-      in.token == NEWLINE || in.token == NEWLINES || in.token == SEMI
+    private var inFunReturnType = false
+    private def fromWithinReturnType[T](body: => T): T = {
+      val saved = inFunReturnType
+      try {
+        inFunReturnType = true
+        body
+      } finally inFunReturnType = saved
+    }
 
 /* ---------- TREE CONSTRUCTION ------------------------------------------- */
 
@@ -387,13 +263,13 @@ object Parsers {
 
     /** Convert tree to formal parameter
     */
-    def convertToParam(tree: Tree, mods: Modifiers = Modifiers()): ValDef = tree match {
+    def convertToParam(tree: Tree, mods: Modifiers = Modifiers(), expected: String = "formal parameter"): ValDef = tree match {
       case Ident(name) =>
         Parameter(name.asTermName, TypeTree(), mods) withPos tree.pos
       case Typed(Ident(name), tpt) if tpt.isType =>
         Parameter(name.asTermName, tpt, mods) withPos tree.pos
       case _ =>
-        syntaxError("not a legal formal parameter", tree.pos)
+        syntaxError(s"not a legal $expected", tree.pos)
         Parameter(nme.ERROR, tree, mods)
     }
 
@@ -409,13 +285,54 @@ object Parsers {
         tree
     }
 
-/* --------- OPERAND/OPERATOR STACK --------------------------------------- */
+/* -------------- XML ---------------------------------------------------- */
+
+    /** the markup parser */
+    lazy val xmlp = new MarkupParser(this, true)
 
-    object Location extends Enumeration {
-      val InParens, InBlock, ElseWhere = Value
+    object symbXMLBuilder extends SymbolicXMLBuilder(this, true) // DEBUG choices
+
+    def xmlLiteral() : Tree = xmlp.xLiteral
+    def xmlLiteralPattern() : Tree = xmlp.xLiteralPattern
+
+/* -------- COMBINATORS -------------------------------------------------------- */
+
+    def enclosed[T](tok: Token, body: => T): T = {
+      accept(tok)
+      openParens.change(tok, 1)
+      try body
+      finally {
+        accept(tok + 1)
+        openParens.change(tok, -1)
+      }
+    }
+
+    def inParens[T](body: => T): T = enclosed(LPAREN, body)
+    def inBraces[T](body: => T): T = enclosed(LBRACE, body)
+    def inBrackets[T](body: => T): T = enclosed(LBRACKET, body)
+
+    def inDefScopeBraces[T](body: => T): T = {
+      val saved = lastStatOffset
+      try inBraces(body)
+      finally lastStatOffset = saved
+    }
+
+    /** part { `separator` part }
+     */
+    def tokenSeparated[T](separator: Int, part: () => T): List[T] = {
+      val ts = new ListBuffer[T]
+      while (in.token == separator) {
+        in.nextToken()
+        ts += part()
+      }
+      ts.toList
     }
 
-    var opstack: List[OpInfo] = Nil
+    def commaSeparated[T](part: () => T): List[T] = tokenSeparated(COMMA, part)
+
+/* --------- OPERAND/OPERATOR STACK --------------------------------------- */
+
+    var opStack: List[OpInfo] = Nil
 
     def precedence(operator: Name): Int =
       if (operator eq nme.ERROR) -1
@@ -436,98 +353,67 @@ object Parsers {
         }
       }
 
-    def checkSize(kind: String, size: Int, max: Int) {
-      if (size > max) syntaxError("too many "+kind+", maximum = "+max)
-    }
-
     def checkAssoc(offset: Int, op: Name, leftAssoc: Boolean) =
       if (TreeInfo.isLeftAssoc(op) != leftAssoc)
         syntaxError(
           "left- and right-associative operators with same precedence may not be mixed", offset)
 
-    def reduceStack(base: List[OpInfo], top0: Tree, prec: Int, leftAssoc: Boolean): Tree = {
-      var top = top0
-      if (opstack != base && precedence(opstack.head.operator) == prec)
-        checkAssoc(opstack.head.offset, opstack.head.operator, leftAssoc)
-      while (opstack != base &&
-             (prec < precedence(opstack.head.operator) ||
-              leftAssoc && prec == precedence(opstack.head.operator))) {
-        val opinfo = opstack.head
-        opstack = opstack.tail
-        val opPos = Position(opinfo.offset, opinfo.offset + opinfo.operator.length)
-        val lPos = opinfo.operand.pos
-        val start = if (lPos.exists) lPos.start else opPos.start
-        val rPos = top.pos
-        val end = if (rPos.exists) rPos.end else opPos.end
-        top = atPos(start, opinfo.offset, end) {
-          InfixOp(opinfo.operand, opinfo.operator, top)
+    def reduceStack(base: List[OpInfo], top: Tree, prec: Int, leftAssoc: Boolean): Tree = {
+      if (opStack != base && precedence(opStack.head.operator) == prec)
+        checkAssoc(opStack.head.offset, opStack.head.operator, leftAssoc)
+      def recur(top: Tree): Tree = {
+        if (opStack == base) top
+        else {
+          val opInfo = opStack.head
+          val opPrec = precedence(opInfo.operator)
+          if (prec < opPrec || leftAssoc && prec == opPrec) {
+            opStack = opStack.tail
+            recur {
+              val opPos = Position(opInfo.offset, opInfo.offset + opInfo.operator.length)
+              atPos(opPos union opInfo.operand.pos union top.pos) {
+                InfixOp(opInfo.operand, opInfo.operator, top)
+              }
+            }
+          }
+          else top
         }
       }
-      top
+      recur(top)
     }
 
+    /** operand { infixop operand} [postfixop],
+     *  respecting rules of associativity and precedence.
+     *  @param notAnOperator  a token that does not count as operator.
+     *  @param maybePostfix   postfix operators are allowed.
+     */
     def infixOps(
-        first: Tree, canContinue: Token => Boolean, continue: () => Tree,
-        noOp: Name = nme.EMPTY,
+        first: Tree, canStartOperand: Token => Boolean, operand: () => Tree,
+        notAnOperator: Name = nme.EMPTY,
         maybePostfix: Boolean = false): Tree = {
-      val base = opstack
+      val base = opStack
       var top = first
-      while (isIdent && in.name != noOp) {
+      while (isIdent && in.name != notAnOperator) {
         val op = in.name
         top = reduceStack(base, top, precedence(op), TreeInfo.isLeftAssoc(op))
-        opstack = OpInfo(top, op, in.offset) :: opstack
+        opStack = OpInfo(top, op, in.offset) :: opStack
         ident()
-        newLineOptWhenFollowing(canContinue)
-        if (maybePostfix && !canContinue(in.token)) {
-          val topinfo = opstack.head
-          opstack = opstack.tail
-          val od = reduceStack(base, topinfo.operand, 0, true)
-          return atPos(od.pos.start, topinfo.offset) {
-            PostfixOp(od, topinfo.operator)
+        newLineOptWhenFollowing(canStartOperand)
+        if (maybePostfix && !canStartOperand(in.token)) {
+          val topInfo = opStack.head
+          opStack = opStack.tail
+          val od = reduceStack(base, topInfo.operand, 0, true)
+          return atPos(od.pos.start, topInfo.offset) {
+            PostfixOp(od, topInfo.operator)
           }
         }
-        top = continue()
+        top = operand()
       }
       reduceStack(base, top, 0, true)
     }
 
-/* -------- COMBINATORS -------------------------------------------------------- */
-
-    def enclosed[T](tok: Token, body: => T): T = {
-      accept(tok)
-      openParens.change(tok, 1)
-      try body
-      finally {
-        accept(tok + 1)
-        openParens.change(tok, -1)
-      }
-    }
-
-    def inParens[T](body: => T): T = enclosed(LPAREN, body)
-    def inBraces[T](body: => T): T = enclosed(LBRACE, body)
-    def inBrackets[T](body: => T): T = enclosed(LBRACKET, body)
-
-    def inDefScopeBraces[T](body: => T): T = {
-      val saved = lastDefOffset
-      try inBraces(body)
-      finally lastDefOffset = saved
-    }
-
-    /** part { `sep` part }
-     *  Or if sepFirst is true, { `sep` part }
-     */
-    def tokenSeparated[T](separator: Int, part: () => T): List[T] = {
-      val ts = new ListBuffer[T]
-      while (in.token == separator) {
-        in.nextToken()
-        ts += part()
-      }
-      ts.toList
-    }
-    def commaSeparated[T](part: () => T): List[T] = tokenSeparated(COMMA, part)
-
 /* -------- IDENTIFIERS AND LITERALS ------------------------------------------- */
 
+    /** Accept identifier and return its name as a term name. */
     def ident(): TermName =
       if (isIdent) {
         val name = in.name
@@ -538,10 +424,12 @@ object Parsers {
         nme.ERROR
       }
 
+    /** Accept identifier and return Ident with its name as a term name. */
     def termIdent(): Ident = atPos(in.offset) {
       makeIdent(in.token, ident())
     }
 
+    /** Accept identifier and return Ident with its name as a type name. */
     def typeIdent(): Ident = atPos(in.offset) {
       makeIdent(in.token, ident().toTypeName)
     }
@@ -550,6 +438,7 @@ object Parsers {
       if (tok == BACKQUOTED_IDENT) new BackquotedIdent(name)
       else Ident(name)
 
+    /** IdentOrWildcard ::= id | `_' */
     def identOrWildcard(): Name =
       if (in.token == USCORE) { in.nextToken(); nme.WILDCARD } else ident()
 
@@ -559,15 +448,28 @@ object Parsers {
     def termIdentOrWildcard(): Ident =
       if (in.token == USCORE) wildcardIdent() else termIdent()
 
+    /** Accept identifier acting as a selector on given tree `t`. */
     def selector(t: Tree): Tree =
       atPos(t.pos.start, in.offset) { Select(t, ident()) }
 
+    /** Selectors ::= ident { `.' ident()
+     *
+     *  Accept `.' separated identifiers acting as a selectors on given tree `t`.
+     *  @param finish   An alternative parse in case the next token is not an identifier.
+     *                  If the alternative does not apply, its tree argument is returned unchanged.
+     */
     def selectors(t: Tree, finish: Tree => Tree): Tree = {
       val t1 = finish(t)
       if (t1 ne t) t1 else dotSelectors(selector(t), finish)
     }
 
-    def dotSelectors(t: Tree, finish: Tree => Tree = id) =
+    /** Dotelectors ::= { `.' ident()
+     *
+     *  Accept `.' separated identifiers acting as a selectors on given tree `t`.
+     *  @param finish   An alternative parse in case the token following a `.' is not an identifier.
+     *                  If the alternative does not apply, its tree argument is returned unchanged.
+     */
+     def dotSelectors(t: Tree, finish: Tree => Tree = id) =
       if (in.token == DOT) { in.nextToken(); selectors(t, finish) }
       else t
 
@@ -575,14 +477,18 @@ object Parsers {
 
     /** Path       ::= StableId
      *              |  [Ident `.'] this
-     *  SimpleType ::= Path [`.' type]
+     *
+     *  @param thisOK   If true, [Ident `.'] this is acceptable as the path.
+     *                  If false, another selection is required aftre the `this`.
+     *  @param finish   An alternative parse in case the token following a `.' is not an identifier.
+     *                  If the alternative does not apply, its tree argument is returned unchanged.
      */
     def path(thisOK: Boolean, finish: Tree => Tree = id): Tree = {
       val start = in.offset
       def handleThis(name: TypeName) = {
         in.nextToken()
         val t = atPos(start) { This(name) }
-        if (in.token != DOT && !thisOK) syntaxError("'.' expected")
+        if (!thisOK && in.token != DOT) syntaxError("`.' expected")
         dotSelectors(t, finish)
       }
       def handleSuper(name: TypeName) = {
@@ -601,7 +507,8 @@ object Parsers {
           if (in.token == THIS) handleThis(t.name.toTypeName)
           else if (in.token == SUPER) handleSuper(t.name.toTypeName)
           else selectors(t, finish)
-        } else t
+        }
+        else t
       }
     }
 
@@ -626,29 +533,33 @@ object Parsers {
     /** SimpleExpr    ::= literal
      *                  | symbol
      *                  | null
-     *  @note  The returned tree does not yet have a position
+     *  @param negOffset   The offset of a preceding `-' sign, if any.
+     *                     If the literal is not negated, negOffset = in.offset.
      */
-    def literal(isNegated: Boolean = false): Tree = {
+    def literal(negOffset: Int = in.offset): Tree = {
       def finish(value: Any): Tree = {
-        val t = Literal(Constant(value))
+        val t = atPos(negOffset) { Literal(Constant(value)) }
         in.nextToken()
         t
       }
-      if (in.token == SYMBOLLIT) SymbolLit(in.strVal)
-      else finish(in.token match {
-        case CHARLIT               => in.charVal
-        case INTLIT                => in.intVal(isNegated).toInt
-        case LONGLIT               => in.intVal(isNegated)
-        case FLOATLIT              => in.floatVal(isNegated).toFloat
-        case DOUBLELIT             => in.floatVal(isNegated)
-        case STRINGLIT             => in.strVal
-        case TRUE                  => true
-        case FALSE                 => false
-        case NULL                  => null
-        case _                     =>
-          syntaxErrorOrIncomplete("illegal literal")
-          null
-      })
+      val isNegated = negOffset < in.offset
+      atPos(negOffset) {
+        if (in.token == SYMBOLLIT) SymbolLit(in.strVal)
+        else finish(in.token match {
+          case CHARLIT               => in.charVal
+          case INTLIT                => in.intVal(isNegated).toInt
+          case LONGLIT               => in.intVal(isNegated)
+          case FLOATLIT              => in.floatVal(isNegated).toFloat
+          case DOUBLELIT             => in.floatVal(isNegated)
+          case STRINGLIT             => in.strVal
+          case TRUE                  => true
+          case FALSE                 => false
+          case NULL                  => null
+          case _                     =>
+            syntaxErrorOrIncomplete("illegal literal")
+            null
+        })
+      }
     }
 
 /* ------------- NEW LINES ------------------------------------------------- */
@@ -672,10 +583,12 @@ object Parsers {
       if (in.token == NEWLINE && p(in.next.token)) newLineOpt()
     }
 
-    /* ------------- TYPES ---------------------------------------------------- */
+/* ------------- TYPES ------------------------------------------------------ */
 
-    /** Type ::= FunArgTypes `=>' Type
-     *         | InfixType
+    /** Type        ::= FunArgTypes `=>' Type
+     *                | InfixType
+     *  FunArgTypes ::=  InfixType
+     *                | `(' [ FunArgType {`,' FunArgType } ] `)'
      */
     def typ(): Tree = {
       val start = in.offset
@@ -685,18 +598,24 @@ object Parsers {
           if (in.token == RPAREN) {
             in.nextToken()
             atPos(start, accept(ARROW)) { Function(Nil, typ()) }
-          } else {
+          }
+          else {
+            openParens.change(LPAREN, 1)
             val ts = commaSeparated(funArgType)
+            openParens.change(LPAREN, -1)
             accept(RPAREN)
             if (in.token == ARROW)
               atPos(start, in.skipToken()) { Function(ts, typ()) }
             else {
-              ts foreach checkNotByNameArgs
+              for (t <- ts)
+                if (TreeInfo.isByNameParamType(t))
+                  syntaxError("no by-name parameter type allowed here", t.pos)
               val tuple = atPos(start) { ugen.mkTuple(ts) }
               infixTypeRest(refinedTypeRest(simpleTypeRest(tuple)))
             }
           }
-        } else infixType()
+        }
+        else infixType()
 
       in.token match {
         case ARROW => atPos(start, in.skipToken()) { Function(List(t), typ()) }
@@ -732,7 +651,7 @@ object Parsers {
      */
     def simpleType(): Tree = simpleTypeRest {
       if (in.token == LPAREN)
-        atPos(in.offset) { inParens(ugen.mkTuple(argTypes)) }
+        atPos(in.offset) { ugen.mkTuple(inParens(argTypes())) }
       else path(thisOK = false, handleSingletonType) match {
         case r @ SingletonTypeTree(_) => r
         case r => convertToTypeId(r)
@@ -759,7 +678,7 @@ object Parsers {
 
     /** ArgType      ::=  Type |  `_' TypeBounds
      */
-    def argType(): Tree =
+    val argType = () =>
       if (in.token == USCORE) {
         val start = in.skipToken()
         typeBounds().withPos(Position(start, in.offset))
@@ -772,7 +691,7 @@ object Parsers {
 
     /** FunArgType ::=  ArgType | `=>' ArgType
      */
-    def funArgType(): Tree =
+    val funArgType = () =>
       if (in.token == ARROW) atPos(in.skipToken()) { PrefixOp(nme.ARROWkw, argType()) }
       else argType()
 
@@ -784,7 +703,7 @@ object Parsers {
         val t = argType()
         if (isIdent(nme.raw.STAR)) {
           in.nextToken()
-          atPos(t.pos.start) { PostfixOp(typ(), nme.raw.STAR) }
+          atPos(t.pos.start) { PostfixOp(t, nme.raw.STAR) }
         } else t
       }
 
@@ -842,7 +761,7 @@ object Parsers {
 
     def condExpr(altToken: Token): Tree = {
       if (in.token == LPAREN) {
-        val t = atPos(in.offset) { inParens(Parens(exprInParens)) }
+        val t = atPos(in.offset) { Parens(inParens(exprInParens())) }
         if (in.token == altToken) in.nextToken()
         t
       } else {
@@ -868,11 +787,9 @@ object Parsers {
      *                      |  `do' Expr [semi] `while' Expr
      *                      |  `try' Expr Catches [`finally' Expr]
      *                      |  `try' Expr [`finally' Expr]
-     *                      |  `for' (`(' Enumerators `)' | `{' Enumerators `}')
-     *                         {nl} [`yield'] Expr
-     *                      |  `for' Enumerators (`do' Expr | `yield' Expr)
      *                      |  `throw' Expr
      *                      |  `return' [Expr]
+     *                      |  ForExpr
      *                      |  [SimpleExpr `.'] Id `=' Expr
      *                      |  SimpleExpr1 ArgumentExprs `=' Expr
      *                      |  PostfixExpr [Ascription]
@@ -883,8 +800,8 @@ object Parsers {
      *                      | `:' Annotation {Annotation}
      *                      | `:' `_' `*'
      */
-    def exprInParens(): Tree = expr(Location.InParens)
-    def exprInBlock(): Tree = expr(Location.InBlock)
+    val exprInParens = () => expr(Location.InParens)
+
     def expr(): Tree = expr(Location.ElseWhere)
 
     def expr(location: Location.Value): Tree = {
@@ -893,7 +810,7 @@ object Parsers {
       else t
     }
 
-    def expr1(location: Location.Value): Tree = in.token match {
+    def expr1(location: Location.Value = Location.ElseWhere): Tree = in.token match {
       case IF =>
         atPos(in.skipToken()) {
           val cond = condExpr(THEN)
@@ -931,40 +848,12 @@ object Parsers {
             else EmptyTree()
           Try(body, catches, finalizer)
         }
-     case FOR =>
-        atPos(in.skipToken()) {
-          var wrappedEnums = true
-          val enums =
-            if (in.token == LBRACE) inBraces(enumerators())
-            else if (in.token == LPAREN) {
-              val lparenOffset = in.skipToken()
-              val pats = patternsOpt()
-              val pat =
-                if (in.token == RPAREN) {
-                  wrappedEnums = false
-                  in.nextToken()
-                  atPos(lparenOffset) { ugen.mkTuple(pats) }
-                }
-                else if (pats.length == 1) pats.head
-                else errorTermTree
-              val res = generatorRest(pat) :: enumeratorsRest()
-              if (wrappedEnums) accept(RPAREN)
-              res
-            } else {
-              wrappedEnums = false
-              enumerators()
-            }
-          if (in.token == YIELD) ForYield(enums, expr())
-          else if (in.token == DO) ForDo(enums, expr())
-          else {
-            if (!wrappedEnums) syntaxErrorOrIncomplete("`yield' or `do' expected")
-            ForDo(enums, expr())
-          }
-        }
       case THROW =>
         atPos(in.skipToken()) { Throw(expr()) }
       case RETURN =>
         atPos(in.skipToken()) { Return(if (isExprIntro) expr() else EmptyTree(), EmptyTree()) }
+      case FOR =>
+        forExpr()
       case IMPLICIT =>
         atPos(in.skipToken()) { implicitClosure(in.skipToken(), location) }
       case _ =>
@@ -992,16 +881,16 @@ object Parsers {
     def ascription(t: Tree, location: Location.Value) = atPos(t.pos.start, in.skipToken()) {
       in.token match {
         case USCORE =>
-          val uscorePos = in.skipToken()
+          val uscoreStart = in.skipToken()
           if (isIdent(nme.raw.STAR)) {
             in.nextToken()
             if (in.token != RPAREN) syntaxError("`_*' can be used only for last argument")
-            Typed(t, atPos(uscorePos) { Ident(tpnme.WILDCARD_STAR) })
+            Typed(t, atPos(uscoreStart) { Ident(tpnme.WILDCARD_STAR) })
           } else {
             syntaxErrorOrIncomplete("`*' expected"); t
           }
         case AT =>
-          (t /: annotations(skipNewLines = false)) ((t, annot) => Annotated(annot, t))
+          (t /: annotations()) ((t, annot) => Annotated(annot, t))
         case _ =>
           Typed(t, typeOrInfixType(location))
       }
@@ -1011,13 +900,14 @@ object Parsers {
      *  BlockResult  ::= implicit Id [`:' InfixType] `=>' Block
      */
     def implicitClosure(start: Int, location: Location.Value): Tree = {
+      val mods = atPos(start) { Modifiers(Implicit) }
       val id = termIdent()
       val paramExpr =
         if (location == Location.InBlock && in.token == COLON)
           atPos(id.pos.start, in.skipToken()) { Typed(id, infixType()) }
         else
           id
-      val param = convertToParam(paramExpr, Modifiers(Implicit))
+      val param = convertToParam(paramExpr, mods)
       closureRest(start, location, param :: Nil)
     }
 
@@ -1037,14 +927,14 @@ object Parsers {
     /** PrefixExpr   ::= [`-' | `+' | `~' | `!'] SimpleExpr
     */
     val prefixExpr = () =>
-      if (isIdent && nme.raw.isUnary(in.name))
-        atPos(in.offset) {
-          val name = ident()
-          if (name == nme.raw.MINUS && (numericLitTokens contains in.token))
-            simpleExprRest(literal(isNegated = true), canApply = true)
-          else
-            PrefixOp(name, simpleExpr())
-        }
+      if (isIdent && nme.raw.isUnary(in.name)) {
+        val start = in.offset
+        val name = ident()
+        if (name == nme.raw.MINUS && isNumericLit)
+          simpleExprRest(literal(start), canApply = true)
+        else
+          atPos(start) { PrefixOp(name, simpleExpr()) }
+      }
       else simpleExpr()
 
     /** SimpleExpr    ::= new Template
@@ -1066,9 +956,9 @@ object Parsers {
         case IDENTIFIER | BACKQUOTED_IDENT | THIS | SUPER =>
           path(thisOK = true)
         case USCORE =>
-          atPos(in.skipToken()) { Ident(nme.WILDCARD) }
+          wildcardIdent()
         case LPAREN =>
-          atPos(in.offset) { inParens(ugen.mkTuple(commaSeparated(exprInParens))) }
+          atPos(in.offset) { ugen.mkTuple(inParens(exprsInParensOpt())) }
         case LBRACE =>
           canApply = false
           blockExpr()
@@ -1076,8 +966,7 @@ object Parsers {
           canApply = false
           atPos(in.skipToken()) { New(template()) }
         case _ =>
-          if (literalTokens contains in.token)
-            atPos(in.offset) { literal() }
+          if (isLiteral) literal()
           else {
             syntaxErrorOrIncomplete("illegal start of simple expression")
             errorTermTree
@@ -1105,38 +994,43 @@ object Parsers {
       }
     }
 
+    /**   ExprsInParens     ::=  ExprInParens {`,' ExprInParens}
+     */
+    def exprsInParensOpt(): List[Tree] =
+      if (in.token == RPAREN) Nil else commaSeparated(exprInParens)
+
     /** ArgumentExprs ::= `(' [ExprsInParens] `)'
      *                 |  `(' [ExprsInParens `,'] PostfixExpr `:' `_' `*' ')' \
      *                 |  [nl] BlockExpr
      */
-    def argumentExprs(): List[Tree] = {
-      def arg() = exprInParens() match {
-        case a @ Assign(Ident(id), rhs) => a.derivedNamedArg(id, rhs)
-        case e => e
-      }
-      in.token match {
-        case LBRACE   => List(blockExpr())
-        case LPAREN   => inParens(if (in.token == RPAREN) Nil else commaSeparated(arg))
-        case _        => Nil
-      }
+    def argumentExprs(): List[Tree] =
+      if (in.token == LBRACE) blockExpr() :: Nil
+      else inParens(if (in.token == RPAREN) Nil else commaSeparated(argumentExpr))
+
+    val argumentExpr = () => exprInParens() match {
+      case a @ Assign(Ident(id), rhs) => a.derivedNamedArg(id, rhs)
+      case e => e
     }
 
     /** ArgumentExprss ::= {ArgumentExprs}
      */
-    def argumentExprss(): List[List[Tree]] = {
+    def argumentExprss(fn: Tree): Tree = {
       newLineOptWhenFollowedBy(LBRACE)
-      if (in.token == LPAREN || in.token == LBRACE) argumentExprs() :: argumentExprss() else Nil
+      if (in.token == LPAREN || in.token == LBRACE) argumentExprss(Apply(fn, argumentExprs()))
+      else fn
     }
 
     /** BlockExpr ::= `{' (CaseClauses | Block) `}'
      */
-    def blockExpr(): Tree = inDefScopeBraces {
-      if (in.token == CASE) Match(EmptyTree(), caseClauses())
-      else block()
+    def blockExpr(): Tree = atPos(in.offset) {
+      inDefScopeBraces {
+        if (in.token == CASE) Match(EmptyTree(), caseClauses())
+        else block()
+      }
     }
 
     /** Block ::= BlockStatSeq
-     *  @note  Return tree does not carry position.
+     *  @note  Return tree does not carry source position.
      */
     def block(): Tree = {
       val stats = blockStatSeq()
@@ -1167,7 +1061,7 @@ object Parsers {
       if (in.token == IF) guard()
       else {
         val pat = pattern1()
-        if (in.token == EQUALS) atPos(pat.pos.start, in.skipToken()) { GenAlias(pat, expr) }
+        if (in.token == EQUALS) atPos(pat.pos.start, in.skipToken()) { GenAlias(pat, expr()) }
         else generatorRest(pat)
       }
 
@@ -1178,10 +1072,52 @@ object Parsers {
     def generatorRest(pat: Tree) =
       atPos(pat.pos.start, accept(LARROW)) { GenFrom(pat, expr()) }
 
-   /** CaseClauses ::= CaseClause {CaseClause}
+    /** ForExpr  ::= `for' (`(' Enumerators `)' | `{' Enumerators `}')
+     *                {nl} [`yield'] Expr
+     *            |  `for' Enumerators (`do' Expr | `yield' Expr)
+     */
+    def forExpr(): Tree = atPos(in.skipToken()) {
+      var wrappedEnums = true
+      val enums =
+        if (in.token == LBRACE) inBraces(enumerators())
+        else if (in.token == LPAREN) {
+          val lparenOffset = in.skipToken()
+          openParens.change(LPAREN, 1)
+          val pats = patternsOpt()
+          val pat =
+            if (in.token == RPAREN || pats.length > 1) {
+              wrappedEnums = false
+              accept(RPAREN)
+              openParens.change(LPAREN, -1)
+              atPos(lparenOffset) { ugen.mkTuple(pats) } // note: alternatives `|' need to be weeded out by typer.
+            }
+            else pats.head
+          val res = generatorRest(pat) :: enumeratorsRest()
+          if (wrappedEnums) {
+            accept(RPAREN)
+            openParens.change(LPAREN, -1)
+          }
+          res
+        } else {
+          wrappedEnums = false
+          enumerators()
+        }
+      if (in.token == YIELD) ForYield(enums, expr())
+      else if (in.token == DO) ForDo(enums, expr())
+      else {
+        if (!wrappedEnums) syntaxErrorOrIncomplete("`yield' or `do' expected")
+        ForDo(enums, expr())
+      }
+    }
+
+    /** CaseClauses ::= CaseClause {CaseClause}
     */
-    def caseClauses(): List[CaseDef] =
-      caseClause() :: (if (in.token == CASE) caseClauses() else Nil)
+    def caseClauses(): List[CaseDef] = {
+      val buf = new ListBuffer[CaseDef]
+      buf += caseClause()
+      while (in.token == CASE) buf += caseClause()
+      buf.toList
+    }
 
    /** CaseClause ::= case Pattern [Guard] `=>' Block
     */
@@ -1194,7 +1130,7 @@ object Parsers {
 
     /**  Pattern           ::=  Pattern1 { `|' Pattern1 }
      */
-    def pattern(): Tree = {
+    val pattern = () => {
       val pat = pattern1()
       if (isIdent(nme.raw.BAR))
         atPos(pat.pos.start) { Alternative(pat :: patternAlts()) }
@@ -1218,7 +1154,7 @@ object Parsers {
      */
     val pattern2 = () => infixPattern() match {
       case p @ Ident(name) if TreeInfo.isVarPattern(p) && in.token == AT =>
-        atPos(p.pos.start, in.skipToken()) { Bind(name, infixType()) }
+        atPos(p.pos.start, in.skipToken()) { Bind(name, infixPattern()) }
       case p =>
         p
     }
@@ -1226,7 +1162,7 @@ object Parsers {
     /**  InfixPattern ::= SimplePattern {Id [nl] SimplePattern}
      */
     def infixPattern(): Tree =
-      infixOps(simplePattern(), canStartExpressionTokens, simplePattern, noOp = nme.raw.BAR)
+      infixOps(simplePattern(), canStartExpressionTokens, simplePattern, notAnOperator = nme.raw.BAR)
 
     /** SimplePattern    ::= PatVar
      *                    |  Literal
@@ -1242,22 +1178,19 @@ object Parsers {
     val simplePattern = () => in.token match {
       case IDENTIFIER | BACKQUOTED_IDENT | THIS =>
         path(thisOK = true) match {
-          case id @ Ident(nme.raw.MINUS) if (numericLitTokens contains in.token) =>
-            atPos(id.pos.start) { literal(isNegated = true) }
-          case t =>
-            simplePatternRest(t)
+          case id @ Ident(nme.raw.MINUS) if isNumericLit => literal(id.pos.start)
+          case t => simplePatternRest(t)
         }
       case USCORE =>
-        atPos(in.skipToken()) { Ident(nme.WILDCARD) }
+        wildcardIdent()
       case LPAREN =>
-        atPos(in.offset) { inParens(ugen.mkTuple(commaSeparated(pattern))) }
+        atPos(in.offset) { ugen.mkTuple(inParens(patternsOpt())) }
       case LBRACE =>
         dotSelectors(blockExpr())
       case XMLSTART =>
         xmlLiteralPattern()
       case _ =>
-        if (literalTokens contains in.token)
-          atPos(in.offset) { literal() }
+        if (isLiteral) literal()
         else {
           syntaxErrorOrIncomplete("illegal start of simple pattern")
           errorTermTree
@@ -1267,7 +1200,7 @@ object Parsers {
     def simplePatternRest(t: Tree): Tree = {
       var p = t
       if (in.token == LBRACKET)
-        p = atPos(t.pos.start, in.offset) { TypeApply(convertToTypeId(t), typeArgs()) }
+        p = atPos(t.pos.start, in.offset) { TypeApply(p, typeArgs()) }
       if (in.token == LPAREN)
         p = atPos(t.pos.start, in.offset) { Apply(p, argumentPatterns()) }
       p
@@ -1275,8 +1208,11 @@ object Parsers {
 
     /** Patterns          ::=  Pattern [`,' Pattern]
      */
+    def patterns() = commaSeparated(pattern)
+
     def patternsOpt(): List[Tree] =
-      if (in.token == RPAREN) Nil else commaSeparated(pattern)
+      if (in.token == RPAREN) Nil else patterns()
+
 
     /** ArgumentPatterns  ::=  `(' [Patterns] `)'
      *                      |  `(' [Patterns `,'] Pattern2 `:' `_' `*' ')
@@ -1286,22 +1222,22 @@ object Parsers {
 
 /* -------- MODIFIERS and ANNOTATIONS ------------------------------------------- */
 
-    private val flagTokens: Map[Int, FlagSet] = Map(
-      ABSTRACT  -> Abstract,
-      FINAL     -> Final,
-      IMPLICIT  -> Implicit,
-      LAZY      -> Lazy,
-      OVERRIDE  -> Override,
-      PRIVATE   -> Private,
-      PROTECTED -> Protected,
-      SEALED    -> Sealed
-    )
+    private def flagOfToken(tok: Int): FlagSet = tok match {
+      case ABSTRACT  => Abstract
+      case FINAL     => Final
+      case IMPLICIT  => Implicit
+      case LAZY      => Lazy
+      case OVERRIDE  => Override
+      case PRIVATE   => Private
+      case PROTECTED => Protected
+      case SEALED    => Sealed
+    }
 
      /** Drop `private' modifier when followed by a qualifier.
      *  Contract `abstract' and `override' to ABSOVERRIDE
      */
     private def normalize(mods: Modifiers): Modifiers =
-      if ((mods is Private) && mods.privateWithin != tpnme.EMPTY)
+      if ((mods is Private) && mods.hasPrivateWithin)
         normalize(mods &~ Private)
       else if (mods is AbstractAndOverride)
         normalize(mods &~ (Abstract | Override) | AbsOverride)
@@ -1309,7 +1245,7 @@ object Parsers {
         mods
 
     private def addModifier(mods: Modifiers): Modifiers = {
-      val flag = flagTokens(in.token)
+      val flag = flagOfToken(in.token)
       if (mods is flag) syntaxError("repeated modifier")
       in.nextToken()
       mods | flag
@@ -1319,7 +1255,7 @@ object Parsers {
      */
     def accessQualifierOpt(mods: Modifiers): Modifiers =
       if (in.token == LBRACKET) {
-        if (mods.privateWithin != tpnme.EMPTY)
+        if ((mods is Local) || mods.hasPrivateWithin)
           syntaxError("duplicate private/protected qualifier")
         inBrackets {
           if (in.token == THIS) { in.nextToken(); mods | Local }
@@ -1327,7 +1263,8 @@ object Parsers {
         }
       } else mods
 
-   /** Modifiers      ::= {Modifier}
+    /** {Annotation} {Modifier}
+     *  Modifiers      ::= {Modifier}
      *  LocalModifiers ::= {LocalModifier}
      *  AccessModifier ::= (private | protected) [AccessQualifier]
      *  Modifier       ::= LocalModifier
@@ -1335,13 +1272,14 @@ object Parsers {
      *                  |  override
      *  LocalModifier  ::= abstract | final | sealed | implicit | lazy
      */
-    def modifiers(allowed: BitSet = modifierTokens): Modifiers = normalize {
-      def loop(mods: Modifiers): Modifiers =
-        if (allowed contains in.token) {
+    def modifiers(allowed: BitSet = modifierTokens, start: Modifiers = Modifiers()): Modifiers = {
+      def loop(mods: Modifiers): Modifiers = {
+        val tok = in.token
+        if (allowed contains tok) {
           val mods1 = addModifier(mods)
           loop {
             in.token match {
-              case PRIVATE | PROTECTED => in.nextToken() ; accessQualifierOpt(mods1)
+              case PRIVATE | PROTECTED => accessQualifierOpt(mods1)
               case _ => mods1
             }
           }
@@ -1351,33 +1289,30 @@ object Parsers {
         } else {
           mods
         }
-      loop(Modifiers())
+      }
+      normalize(loop(start))
     }
 
     /** Annotation        ::=  `@' SimpleType {ArgumentExprs}
-     *  ConstrAnnotation ::= `@' SimpleType ArgumentExprs
      */
-    def annot(forConstructor: Boolean = false) = {
+    def annot() = {
       accept(AT)
-      def args =
-        if (forConstructor) {
-          newLineOptWhenFollowedBy(LBRACE)
-          argumentExprs() :: Nil
-        } else argumentExprss()
-      (simpleType() /: args) (Apply(_, _))
+      argumentExprss(simpleType())
     }
 
-    def annotations(skipNewLines: Boolean, forConstructor: Boolean = false): List[Tree] = {
+    def annotations(skipNewLines: Boolean = false): List[Tree] = {
       if (skipNewLines) newLineOptWhenFollowedBy(AT)
-      if (in.token == AT) annot(forConstructor) :: annotations(skipNewLines, forConstructor)
+      if (in.token == AT) annot() :: annotations(skipNewLines)
       else Nil
     }
 
-/* -------- PARAMETERS ------------------------------------------- */
+    def annotsAsMods(skipNewLines: Boolean = false): Modifiers =
+      Modifiers() withAnnotations annotations(skipNewLines)
 
-    object ParamOwner extends Enumeration {
-      val Class, Type, TypeParam, Def = Value
-    }
+    def defAnnotsMods(allowed: BitSet): Modifiers =
+      modifiers(allowed, annotsAsMods(skipNewLines = true))
+
+ /* -------- PARAMETERS ------------------------------------------- */
 
     /** ClsTypeParamClause::=  `[' ClsTypeParam {`,' ClsTypeParam} `]'
      *  ClsTypeParam      ::=  {Annotation} [{Modifier} type] [`+' | `-']
@@ -1395,21 +1330,22 @@ object Parsers {
     def typeParamClause(ownerKind: ParamOwner.Value): List[TypeDef] = inBrackets {
       def typeParam(): TypeDef = {
         val isConcreteOwner = ownerKind == ParamOwner.Class || ownerKind == ParamOwner.Def
-        val start = in.offset
-        val annots = annotations(skipNewLines = false)
-        var mods =
-          if (ownerKind == ParamOwner.Class) {
-            val mods1 = modifiers() withAnnotations annots
-            atPos(start, in.offset) {
+        val modStart = in.offset
+        var mods = annotsAsMods()
+        if (ownerKind == ParamOwner.Class) {
+          mods = modifiers(start = mods)
+          mods =
+            atPos(modStart, in.offset) {
               if (in.token == TYPE) {
                 in.nextToken()
-                mods1 | TypeParam
+                mods | TypeParam
               } else {
-                if (mods1.flags != EmptyFlags) syntaxError("`type' expected")
-                mods1 | TypeParam | PrivateLocal
+                if (mods.hasFlags) syntaxError("`type' expected")
+                mods | TypeParam | PrivateLocal
               }
             }
-          } else atPos(start) { Modifiers(TypeParam) withAnnotations annots }
+        }
+        else mods = atPos(modStart) (mods | TypeParam)
         if (ownerKind != ParamOwner.Def) {
           if (isIdent(nme.raw.PLUS)) mods |= Covariant
           else if (isIdent(nme.raw.MINUS)) mods |= Contravariant
@@ -1443,26 +1379,27 @@ object Parsers {
     */
     def paramClauses(owner: Name): List[List[ValDef]] = {
       var implicitFlag = EmptyFlags
+      var implicitOffset = -1 // use once
       def param(): ValDef = {
-        val start = in.offset
-        val annots = annotations(skipNewLines = false)
-        val mods =
-          if (owner.isTypeName) {
-            val mods1 = modifiers() withAnnotations annots
-            if (mods1 is Lazy) syntaxError("lazy modifier not allowed here. Use call-by-name parameters instead")
-            atPos(start, in.offset) {
+        val modStart = in.offset
+        var mods = annotsAsMods()
+        if (owner.isTypeName) {
+          mods = modifiers(start = mods)
+          mods =
+            atPos(modStart, in.offset) {
               if (in.token == VAL) {
                 in.nextToken()
-                mods1 | Param
+                mods | Param
               } else if (in.token == VAR) {
                 in.nextToken()
-                mods1 | Param | Mutable
+                mods | Param | Mutable
               } else {
-                if (mods1.flags != EmptyFlags) syntaxError("`val' or `var' expected")
-                mods1 | Param | PrivateLocal
+                if (mods.hasFlags) syntaxError("`val' or `var' expected")
+                mods | Param | PrivateLocal
               }
             }
-          } else atPos(start) { Modifiers(Param) withAnnotations annots }
+        }
+        else mods = atPos(modStart) { mods | Param }
         atPos(tokenRange) {
           val name = ident()
           val tpt =
@@ -1481,6 +1418,10 @@ object Parsers {
           val default =
             if (in.token == EQUALS) { in.nextToken(); expr() }
             else EmptyTree()
+          if (implicitOffset >= 0) {
+            mods = mods.withPos(mods.pos.withStart(implicitOffset))
+            implicitOffset = -1
+          }
           ValDef(mods | implicitFlag, name, tpt, default)
         }
       }
@@ -1488,7 +1429,7 @@ object Parsers {
         if (in.token == RPAREN) Nil
         else {
           if (in.token == IMPLICIT) {
-            in.nextToken()
+            implicitOffset = in.skipToken()
             implicitFlag = Implicit
           }
           commaSeparated(param)
@@ -1512,7 +1453,6 @@ object Parsers {
 
 /* -------- DEFS ------------------------------------------- */
 
-
     /** Import  ::= import ImportExpr {`,' ImportExpr}
      */
     def importClause(): List[Tree] = {
@@ -1527,10 +1467,10 @@ object Parsers {
 
     /**  ImportExpr ::= StableId `.' (Id | `_' | ImportSelectors)
      */
-    def importExpr(): Tree = path(thisOK = false, handleImport) match {
-      case sel @ Select(qual, name) => sel.derivedImport(qual, Ident(name) :: Nil)
+    val importExpr = () => path(thisOK = false, handleImport) match {
       case imp: Import => imp
-      case _ => accept(DOT); EmptyTree()
+      case sel @ Select(qual, name) => sel.derivedImport(qual, Ident(name) :: Nil)
+      case t => accept(DOT); Import(t, Ident(nme.WILDCARD) :: Nil)
     }
 
     val handleImport = { tree: Tree =>
@@ -1546,10 +1486,11 @@ object Parsers {
       else {
         val sel = importSelector()
         sel :: {
-          if (!isWildcard(sel) && in.token == COMMA) {
+          if (!TreeInfo.isWildcardArg(sel) && in.token == COMMA) {
             in.nextToken()
             importSelectors()
-          } else Nil
+          }
+          else Nil
         }
       }
 
@@ -1582,18 +1523,13 @@ object Parsers {
       case VAR =>
         patDefOrDcl(posMods(start, mods | Mutable))
       case DEF =>
-        funDefOrDcl(posMods(start, mods))
+        defDefOrDcl(posMods(start, mods))
       case TYPE =>
         typeDefOrDcl(posMods(start, mods))
       case _ =>
         tmplDef(start, mods)
     }
 
-    def defAnnotsMods(allowed: BitSet): Modifiers = {
-      val annots = annotations(skipNewLines = true)
-      modifiers(allowed) withAnnotations annots
-    }
-
     /** PatDef ::= Pattern2 {`,' Pattern2} [`:' Type] `=' Expr
      *  VarDef ::= PatDef | Id {`,' Id} `:' Type `=' `_'
      *  ValDcl ::= Id {`,' Id} `:' Type
@@ -1624,7 +1560,7 @@ object Parsers {
      *  DefDcl ::= DefSig [`:' Type]
      *  DefSig ::= id [DefTypeParamClause] ParamClauses
      */
-    def funDefOrDcl(mods: Modifiers): Tree = atPos(tokenRange) {
+    def defDefOrDcl(mods: Modifiers): Tree = atPos(tokenRange) {
       if (in.token == THIS) {
         val vparamss = paramClauses(nme.CONSTRUCTOR)
         newLineOptWhenFollowedBy(LBRACE)
@@ -1640,8 +1576,8 @@ object Parsers {
         val name = ident()
         val tparams = typeParamClauseOpt(ParamOwner.Def)
         val vparamss = paramClauses(name)
-        newLineOptWhenFollowedBy(LBRACE)
         var restype = fromWithinReturnType(typedOpt())
+        newLineOptWhenFollowedBy(LBRACE)
         val rhs =
           if (isStatSep || in.token == RBRACE) EmptyTree()
           else if (restype.isEmpty && in.token == LBRACE) {
@@ -1666,8 +1602,7 @@ object Parsers {
     def selfInvocation(): Tree =
       atPos(accept(THIS)) {
         newLineOptWhenFollowedBy(LBRACE)
-        var t = Apply(Ident(nme.CONSTRUCTOR), argumentExprs())
-        (t /: argumentExprss())(Apply(_, _))
+        argumentExprss(Apply(Ident(nme.CONSTRUCTOR), argumentExprs()))
       }
 
     /** ConstrBlock    ::=  `{' SelfInvocation {semi BlockStat} `}'
@@ -1694,7 +1629,7 @@ object Parsers {
           case EQUALS =>
             in.nextToken()
             TypeDef(mods, name, tparams, typ())
-          case SUPERTYPE | SUBTYPE | SEMI | NEWLINE | NEWLINES | COMMA | RBRACE =>
+          case SUPERTYPE | SUBTYPE | SEMI | NEWLINE | NEWLINES | COMMA | RBRACE | EOF =>
             TypeDef(mods, name, tparams, typeBounds())
           case _ =>
             syntaxErrorOrIncomplete("`=', `>:', or `<:' expected")
@@ -1703,14 +1638,6 @@ object Parsers {
       }
     }
 
-    /** Hook for IDE, for top-level classes/objects
-    def topLevelTmplDef: Tree = {
-      val annots = annotations(true)
-      val pos    = caseAwareTokenOffset
-      val mods   = modifiers() withAnnotations annots
-      tmplDef(pos, mods)
-    }*/
-
     /**  TmplDef ::= ([`case'] `class' | `trait') ClassDef
      *            |  [`case'] `object' ObjectDef
      */
@@ -1730,24 +1657,28 @@ object Parsers {
           EmptyTree()
     }
 
-    /** ClassDef ::= Id [ClsTypeParamClause] {ConstrAnnotation}
-                     [AccessModifier] ClsParamClauses TemplateOpt
+    /** ClassDef ::= Id [ClsTypeParamClause]
+     *               [ConstrMods] ClsParamClauses TemplateOpt
      */
     def classDef(mods: Modifiers): ClassDef = atPos(tokenRange) {
       val name = ident().toTypeName
       val tparams = typeParamClauseOpt(ParamOwner.Class)
-      val constr = atPos(in.offset) {
-        val constrMods = atPos(in.offset) {
-          val constrAnnots = annotations(skipNewLines = false, forConstructor = true)
-          modifiers(accessModifierTokens) withAnnotations constrAnnots
-        }
-        val vparamss = paramClauses(name)
-        ugen.constructor(constrMods, vparamss)
-      }
+      val cmods = constrModsOpt()
+      val vparamss = paramClauses(name)
+      val constr = ugen.constructor(cmods, vparamss)
       val templ = templateOpt(constr)
       ClassDef(mods, name, tparams, templ)
     }
 
+    /** ConstrMods        ::=  AccessModifier
+     *                      |  Annotation {Annotation} (AccessModifier | `this')
+     */
+    def constrModsOpt(): Modifiers = {
+      val mods = modifiers(accessModifierTokens, annotsAsMods())
+      if (mods.hasAnnotations && !mods.hasFlags) accept(THIS)
+      mods
+    }
+
     /** ObjectDef       ::= Id TemplateOpt
      */
     def objectDef(mods: Modifiers): ModuleDef = {
@@ -1761,9 +1692,8 @@ object Parsers {
 
     /** ConstrApp         ::=  RefinedType {ArgumentExprs}
      */
-    def constrApp() =
-      (refinedType() /: argumentExprss()) (Apply(_, _))
-
+    val constrApp = () =>
+      argumentExprss(refinedType())
 
     /** Template          ::=  ConstrApps [TemplateBody] | TemplateBody
      *  ConstrApps        ::=  ConstrApp {`with' ConstrApp}
@@ -1826,22 +1756,22 @@ object Parsers {
     def topStatSeq(): List[Tree] = {
       val stats = new ListBuffer[Tree]
       while (!isStatSeqEnd) {
-        setLastDefOffset()
+        setLastStatOffset()
         if (in.token == PACKAGE) {
           val start = in.skipToken()
-          if (in.token == OBJECT) stats += objectDef(atPos(start) { Modifiers(Package) })
+          if (in.token == OBJECT) stats += objectDef(atPos(start, in.offset) { Modifiers(Package) })
           else stats += packaging(start)
         }
         else if (in.token == IMPORT)
           stats ++= importClause()
-        else if (in.token == AT || (templateIntroTokens contains in.token) || (modifierTokens contains in.token))
+        else if (in.token == AT || isTemplateIntro || isModifier)
           stats += tmplDef(in.offset, defAnnotsMods(modifierTokens))
         else if (!isStatSep) {
           syntaxErrorOrIncomplete("expected class or object definition")
-          if (mustStartStatTokens contains in.token) // do parse all definitions even if they are probably local (i.e. a "}" has been forgotten)
+          if (mustStartStat) // do parse all definitions even if they are probably local (i.e. a "}" has been forgotten)
             defOrDcl(in.offset, defAnnotsMods(modifierTokens))
         }
-        acceptStatSepOpt()
+        acceptStatSepUnlessAtEnd()
       }
       stats.toList
     }
@@ -1858,38 +1788,35 @@ object Parsers {
       var self: ValDef = EmptyValDef()
       val stats = new ListBuffer[Tree]
       if (isExprIntro) {
-        val first = expr1(Location.ElseWhere) // @S: first statement is potentially converted so cannot be stubbed.
+        val first = expr1()
         if (in.token == ARROW) {
           first match {
             case Typed(tree @ This(tpnme.EMPTY), tpt) =>
               self = ugen.selfDef(nme.WILDCARD, tpt).withPos(first.pos)
             case _ =>
-              convertToParam(first) match {
-                case tree @ ValDef(_, name, tpt, _) if (name != nme.ERROR) =>
-                  self = ugen.selfDef(name, tpt).withPos(first.pos)
-                case _ =>
-              }
+              val ValDef(_, name, tpt, _) = convertToParam(first, expected = "self type clause")
+              self = ugen.selfDef(name, tpt).withPos(first.pos)
           }
           in.nextToken()
         } else {
           stats += first
-          acceptStatSepOpt()
+          acceptStatSepUnlessAtEnd()
         }
       }
       var exitOnError = false
       while (!isStatSeqEnd && !exitOnError) {
-        setLastDefOffset()
+        setLastStatOffset()
         if (in.token == IMPORT)
           stats ++= importClause()
         else if (isExprIntro)
-          stats += expr()
+          stats += expr1()
         else if (isDefIntro(modifierTokens))
           defOrDcl(in.offset, defAnnotsMods(modifierTokens))
         else if (!isStatSep) {
-          exitOnError = mustStartStatTokens contains in.token
+          exitOnError = mustStartStat
           syntaxErrorOrIncomplete("illegal start of definition")
         }
-        acceptStatSepOpt()
+        acceptStatSepUnlessAtEnd()
       }
       (self, if (stats.isEmpty) List(EmptyTree()) else stats.toList)
     }
@@ -1902,7 +1829,7 @@ object Parsers {
     def refineStatSeq(): List[Tree] = {
       val stats = new ListBuffer[Tree]
       while (!isStatSeqEnd) {
-        if (dclIntroTokens contains in.token) {
+        if (isDclIntro) {
           stats += defOrDcl(in.offset, Modifiers())
         } else if (!isStatSep) {
           syntaxErrorOrIncomplete(
@@ -1910,7 +1837,7 @@ object Parsers {
             (if (inFunReturnType) " (possible cause: missing `=' in front of current method body)"
              else ""))
         }
-        if (in.token != RBRACE) acceptStatSep()
+        acceptStatSepUnlessAtEnd()
       }
       stats.toList
     }
@@ -1929,7 +1856,7 @@ object Parsers {
       val stats = new ListBuffer[Tree]
       var exitOnError = false
       while (!isStatSeqEnd && in.token != CASE && !exitOnError) {
-        setLastDefOffset()
+        setLastStatOffset()
         if (in.token == IMPORT) {
           stats ++= importClause()
         }
@@ -1950,11 +1877,11 @@ object Parsers {
             stats += localDef(in.offset, EmptyFlags)
           }
         else if (!isStatSep && (in.token != CASE)) {
-          exitOnError = mustStartStatTokens contains in.token
-          val addendum = if (modifierTokens contains in.token) " (no modifiers allowed here)" else ""
-          syntaxErrorOrIncomplete("illegal start of statement"+addendum)
+          exitOnError = mustStartStat
+          val addendum = if (isModifier) " (no modifiers allowed here)" else ""
+          syntaxErrorOrIncomplete("illegal start of statement" + addendum)
         }
-        acceptStatSepOpt(CASE)
+        acceptStatSepUnlessAtEnd(CASE)
       }
       stats.toList
     }
@@ -1969,7 +1896,7 @@ object Parsers {
         if (in.token == PACKAGE) {
           in.nextToken()
           if (in.token == OBJECT) {
-            ts += objectDef(atPos(start) { Modifiers(Package) })
+            ts += objectDef(atPos(start, in.offset) { Modifiers(Package) })
             if (in.token != EOF) {
               acceptStatSep()
               ts ++= topStatSeq()
@@ -1981,7 +1908,7 @@ object Parsers {
               ts += makePackaging(start, pkg, List())
             else if (in.token == LBRACE) {
               ts += inDefScopeBraces(makePackaging(start, pkg, topStatSeq()))
-              acceptStatSepOpt()
+              acceptStatSepUnlessAtEnd()
               ts ++= topStatSeq()
             }
             else {
@@ -2024,5 +1951,4 @@ object Parsers {
 
     override def templateBody() = skipBraces((EmptyValDef(), List(EmptyTree())))
   }
-
 }