diff options
59 files changed, 426 insertions, 530 deletions
diff --git a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala index 50aad8e043..a894e38ab4 100644 --- a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala @@ -303,15 +303,6 @@ self => def o2p(offset: Int): Position def r2p(start: Int, mid: Int, end: Int): Position - /** Creates a range position from the given start offset to - * the value of in.lastOffset. - */ - def rangeSince(start: Int): Position = r2p(start, start, in.lastOffset) - - /** Like in.skipToken, but returns a range position surrounding the skipped token. - */ - def skipTokenRange(): Position = rangeSince(in.skipToken()) - /** whether a non-continuable syntax error has been seen */ private var lastErrorOffset : Int = -1 @@ -577,9 +568,8 @@ self => and } - def expectedMsgTemplate(expected: String, found: String): String = s"$expected expected but $found found." - def expectedMsg(expected: Int, found: Int): String = expectedMsgTemplate(token2string(expected), token2string(found)) - def expectedMsg(token: Int): String = expectedMsg(token, in.token) + def expectedMsgTemplate(exp: String, fnd: String) = s"$exp expected but $fnd found." + def expectedMsg(token: Int): String = expectedMsgTemplate(token2string(token), token2string(in.token)) /** Consume one token of the specified type, or signal an error if it is not there. */ def accept(token: Int): Int = { @@ -597,10 +587,6 @@ self => if (in.token == token) in.nextToken() offset } - /** If the given token is available for consumption, consume it and return true. - * Otherwise, do nothing and return false. - */ - def acceptIfPresent(token: Int) = (in.token == token) && { accept(token) ; true } /** {{{ * semi = nl {nl} | `;` @@ -717,24 +703,14 @@ self => /* ---------- TREE CONSTRUCTION ------------------------------------------- */ - def atPos[T <: Tree](start: Int)(t: T): T = atPos[T](start, start)(t) - def atPos[T <: Tree](start: Int, point: Int)(t: T): T = atPos[T](start, point, in.lastOffset max start)(t) + def atPos[T <: Tree](offset: Int)(t: T): T = atPos(r2p(offset, offset, in.lastOffset max offset))(t) + def atPos[T <: Tree](start: Int, point: Int)(t: T): T = atPos(r2p(start, point, in.lastOffset max start))(t) def atPos[T <: Tree](start: Int, point: Int, end: Int)(t: T): T = atPos(r2p(start, point, end))(t) def atPos[T <: Tree](pos: Position)(t: T): T = global.atPos(pos)(t) def atInPos[T <: Tree](t: T): T = atPos(o2p(in.offset))(t) def setInPos[T <: Tree](t: T): T = t setPos o2p(in.offset) - /** Use with caution. */ - def peekahead(): Unit = { - in.prev copyFrom in - in.nextToken() - } - def pushback(): Unit = { - in.next copyFrom in - in copyFrom in.prev - } - /** Convert tree to formal parameter list. */ def convertToParams(tree: Tree): List[ValDef] = tree match { case Parens(ts) => ts map convertToParam @@ -773,9 +749,10 @@ self => if (!sepFirst) ts += part - while (acceptIfPresent(separator)) + while (in.token == separator) { + in.nextToken() ts += part - + } ts.toList } @inline final def commaSeparated[T](part: => T): List[T] = tokenSeparated(COMMA, sepFirst = false, part) @@ -852,8 +829,10 @@ self => private def tupleInfixType(start: Int) = { in.nextToken() - if (acceptIfPresent(RPAREN)) + if (in.token == RPAREN) { + in.nextToken() atPos(start, accept(ARROW)) { makeFunctionTypeTree(Nil, typ()) } + } else { val ts = functionTypes() accept(RPAREN) @@ -957,8 +936,13 @@ self => ) def compoundTypeRest(t: Tree): Tree = { - val types = t :: tokenSeparated(WITH, sepFirst = true, annotType()) + val ts = new ListBuffer[Tree] += t + while (in.token == WITH) { + in.nextToken() + ts += annotType() + } newLineOptWhenFollowedBy(LBRACE) + val types = ts.toList val braceOffset = in.offset val hasRefinement = in.token == LBRACE val refinements = if (hasRefinement) refinement() else Nil @@ -972,7 +956,7 @@ self => } // The second case includes an empty refinement - refinements is empty, but // it still gets a CompoundTypeTree. - types match { + ts.toList match { case tp :: Nil if !hasRefinement => tp // single type, no refinement, already positioned case tps => atPos(t.pos.startOrPoint)(CompoundTypeTree(Template(tps, emptyValDef, refinements))) } @@ -1040,19 +1024,19 @@ self => def path(thisOK: Boolean, typeOK: Boolean): Tree = { val start = in.offset var t: Tree = null - if (acceptIfPresent(THIS)) { + if (in.token == THIS) { + in.nextToken() t = atPos(start) { This(tpnme.EMPTY) } if (!thisOK || in.token == DOT) { t = selectors(t, typeOK, accept(DOT)) } - } - else if (acceptIfPresent(SUPER)) { + } else if (in.token == SUPER) { + in.nextToken() t = atPos(start) { Super(This(tpnme.EMPTY), mixinQualifierOpt()) } accept(DOT) t = selector(t) if (in.token == DOT) t = selectors(t, typeOK, in.skipToken()) - } - else { + } else { val tok = in.token val name = ident() t = atPos(start) { @@ -1061,18 +1045,18 @@ self => } if (in.token == DOT) { val dotOffset = in.skipToken() - if (acceptIfPresent(THIS)) { + if (in.token == THIS) { + in.nextToken() t = atPos(start) { This(name.toTypeName) } if (!thisOK || in.token == DOT) t = selectors(t, typeOK, accept(DOT)) - } - else if (acceptIfPresent(SUPER)) { + } else if (in.token == SUPER) { + in.nextToken() t = atPos(start) { Super(This(name.toTypeName), mixinQualifierOpt()) } accept(DOT) t = selector(t) if (in.token == DOT) t = selectors(t, typeOK, in.skipToken()) - } - else { + } else { t = selectors(t, typeOK, dotOffset) } } @@ -1081,8 +1065,10 @@ self => } def selectors(t: Tree, typeOK: Boolean, dotOffset: Int): Tree = - if (typeOK && acceptIfPresent(TYPE)) + if (typeOK && in.token == TYPE) { + in.nextToken() atPos(t.pos.startOrPoint, dotOffset) { SingletonTypeTree(t) } + } else { val t1 = selector(t) if (in.token == DOT) { selectors(t1, typeOK, in.skipToken()) } @@ -1179,10 +1165,10 @@ self => private def freshPlaceholder(): Tree = { val start = in.offset val pname = freshName("x$") - accept(USCORE) + in.nextToken() val id = atPos(start)(Ident(pname)) val param = atPos(id.pos.focus)(gen.mkSyntheticParam(pname.toTermName)) - placeholderParams ::= param + placeholderParams = param :: placeholderParams id } @@ -1225,7 +1211,7 @@ self => /* ------------- NEW LINES ------------------------------------------------- */ def newLineOpt() { - acceptIfPresent(NEWLINE) + if (in.token == NEWLINE) in.nextToken() } def newLinesOpt() { @@ -1249,7 +1235,9 @@ self => * TypedOpt ::= [`:' Type] * }}} */ - def typedOpt(): Tree = if (acceptIfPresent(COLON)) typ() else TypeTree() + def typedOpt(): Tree = + if (in.token == COLON) { in.nextToken(); typ() } + else TypeTree() def typeOrInfixType(location: Int): Tree = if (location == Local) typ() @@ -1273,9 +1261,16 @@ self => /* ----------- EXPRESSIONS ------------------------------------------------ */ - def condExpr(): Tree = in.token match { - case LPAREN => inParens(expr()) - case _ => syntaxErrorOrIncompleteAnd("parenthesized conditional expression expected", skipIt = false)(newLiteral(true)) + def condExpr(): Tree = { + if (in.token == LPAREN) { + in.nextToken() + val r = expr() + accept(RPAREN) + r + } else { + accept(LPAREN) + newLiteral(true) + } } /* hook for IDE, unlike expression can be stubbed @@ -1316,7 +1311,8 @@ self => val cond = condExpr() newLinesOpt() val thenp = expr() - val elsep = if (acceptIfPresent(ELSE)) expr() else literalUnit + val elsep = if (in.token == ELSE) { in.nextToken(); expr() } + else literalUnit If(cond, thenp, elsep) } parseIf @@ -1325,19 +1321,23 @@ self => val body = in.token match { case LBRACE => inBracesOrUnit(block()) case LPAREN => inParensOrUnit(expr()) - case _ => expr() + case _ => expr() } def catchFromExpr() = List(makeCatchFromExpr(expr())) - val catches: List[CaseDef] = ( - if (!acceptIfPresent(CATCH)) Nil else { + val catches: List[CaseDef] = + if (in.token != CATCH) Nil + else { + in.nextToken() if (in.token != LBRACE) catchFromExpr() else inBracesOrNil { if (isCaseDefStart) caseClauses() else catchFromExpr() } } - ) - val finalizer = if (acceptIfPresent(FINALLY)) expr() else EmptyTree + val finalizer = in.token match { + case FINALLY => in.nextToken(); expr() + case _ => EmptyTree + } Try(body, catches, finalizer) } parseTry @@ -1348,7 +1348,7 @@ self => val cond = condExpr() newLinesOpt() val body = expr() - makeWhile(cond, body) + makeWhile(start, cond, body) } } parseWhile @@ -1367,15 +1367,16 @@ self => case FOR => val start = in.skipToken() def parseFor = atPos(start) { - val enums = ( + val enums = if (in.token == LBRACE) inBracesOrNil(enumerators()) else inParensOrNil(enumerators()) - ) newLinesOpt() - if (acceptIfPresent(YIELD)) + if (in.token == YIELD) { + in.nextToken() makeForYield(enums, expr()) - else + } else { makeFor(enums, expr()) + } } def adjustStart(tree: Tree) = if (tree.pos.isRange && start < tree.pos.start) @@ -1466,8 +1467,9 @@ self => val param0 = convertToParam { atPos(in.offset) { Ident(ident()) match { - case expr if acceptIfPresent(COLON) => Typed(expr, typeOrInfixType(location)) - case expr => expr + case expr if in.token == COLON => + in.nextToken() ; Typed(expr, typeOrInfixType(location)) + case expr => expr } } } @@ -1543,28 +1545,32 @@ self => * }}} */ def simpleExpr(): Tree = { - val canApply = in.token match { - case LBRACE | NEW => false - case _ => true - } - def mkNew(): Tree = { - val npos = skipTokenRange() - val tstart = in.offset - val (parents, self, stats) = template() - val cpos = rangeSince(tstart) - - gen.mkNew(parents, self, stats, npos, cpos) - } - val t = in.token match { - case _ if isLiteral => literal() - case XMLSTART => xmlLiteral() - case IDENTIFIER | BACKQUOTED_IDENT | THIS | SUPER => path(thisOK = true, typeOK = false) - case USCORE => freshPlaceholder() - case LPAREN => atPos(in.offset)(makeParens(commaSeparated(expr()))) - case LBRACE => blockExpr() - case NEW => mkNew() - case _ => syntaxErrorOrIncompleteAnd("illegal start of simple expression", skipIt = true)(errorTermTree) - } + var canApply = true + val t = + if (isLiteral) literal() + else in.token match { + case XMLSTART => + xmlLiteral() + case IDENTIFIER | BACKQUOTED_IDENT | THIS | SUPER => + path(thisOK = true, typeOK = false) + case USCORE => + freshPlaceholder() + case LPAREN => + atPos(in.offset)(makeParens(commaSeparated(expr()))) + case LBRACE => + canApply = false + blockExpr() + case NEW => + canApply = false + val nstart = in.skipToken() + val npos = r2p(nstart, nstart, in.lastOffset) + val tstart = in.offset + val (parents, self, stats) = template() + val cpos = r2p(tstart, tstart, in.lastOffset max tstart) + gen.mkNew(parents, self, stats, npos, cpos) + case _ => + syntaxErrorOrIncompleteAnd("illegal start of simple expression", skipIt = true)(errorTermTree) + } simpleExprRest(t, canApply = canApply) } @@ -1671,9 +1677,9 @@ self => * Guard ::= if PostfixExpr * }}} */ - def guard(): Tree = if (acceptIfPresent(IF)) guardExpr() else EmptyTree - - def guardExpr(): Tree = stripParens(postfixExpr()) + def guard(): Tree = + if (in.token == IF) { in.nextToken(); stripParens(postfixExpr()) } + else EmptyTree /** {{{ * Enumerators ::= Generator {semi Enumerator} @@ -1698,26 +1704,27 @@ self => * }}} */ def generator(enums: ListBuffer[Enumerator], eqOK: Boolean) { - val start = in.offset - val hasVal = acceptIfPresent(VAL) - val pat = noSeq.pattern1() - val point = in.offset - val equalsBody = equalsExprOpt() - val hasEq = !equalsBody.isEmpty - - if (hasVal && !hasEq) - syntaxError(in.offset, "val in for comprehension must be followed by assignment") - else if (hasEq && !eqOK) - syntaxError(point, "for comprehension must start with generator: " + expectedMsg(expected = LARROW, found = EQUALS)) - else if (hasVal) - deprecationWarning(start, "val keyword in for comprehension is deprecated") - - val rhs = equalsBody orElse { accept(LARROW) ; expr() } + val start = in.offset + val hasVal = in.token == VAL + if (hasVal) + in.nextToken() + val pat = noSeq.pattern1() + val point = in.offset + val hasEq = in.token == EQUALS + + if (hasVal) { + if (hasEq) deprecationWarning(in.offset, "val keyword in for comprehension is deprecated") + else syntaxError(in.offset, "val in for comprehension must be followed by assignment") + } + + if (hasEq && eqOK) in.nextToken() + else accept(LARROW) + val rhs = expr() enums += makeGenerator(r2p(start, point, in.lastOffset max start), pat, hasEq, rhs) // why max above? IDE stress tests have shown that lastOffset could be less than start, // I guess this happens if instead if a for-expression we sit on a closing paren. - enums ++= tokenSeparated(IF, sepFirst = true, makeFilter(in.offset, guardExpr())) + while (in.token == IF) enums += makeFilter(in.offset, guard()) } def makeFilter(start: Int, tree: Tree) = Filter(r2p(start, tree.pos.point, tree.pos.endOrPoint), tree) @@ -1825,6 +1832,14 @@ self => var top = simplePattern(badPattern3) // after peekahead def acceptWildStar() = atPos(top.pos.startOrPoint, in.prev.offset)(Star(stripParens(top))) + def peekahead() = { + in.prev copyFrom in + in.nextToken() + } + def pushback() = { + in.next copyFrom in + in copyFrom in.prev + } // See SI-3189, SI-4832 for motivation. Cf SI-3480 for counter-motivation. // TODO: dredge out the remnants of regexp patterns. // /{/ peek for _*) or _*} (for xml escape) @@ -1998,15 +2013,16 @@ self => * }}} */ def accessQualifierOpt(mods: Modifiers): Modifiers = { - def newModifiers(): Modifiers = ( - if (acceptIfPresent(THIS)) mods | Flags.LOCAL // private/protected[this] - else Modifiers(mods.flags, identForType()) // private/protected[foo] - ) - in.token match { - case LBRACKET if mods.hasAccessBoundary => syntaxError("duplicate private/protected qualifier", skipIt = false) ; mods - case LBRACKET => inBrackets(newModifiers()) - case _ => mods + var result = mods + if (in.token == LBRACKET) { + in.nextToken() + if (mods.hasAccessBoundary) + syntaxError("duplicate private/protected qualifier", skipIt = false) + result = if (in.token == THIS) { in.nextToken(); mods | Flags.LOCAL } + else Modifiers(mods.flags, identForType()) + accept(RBRACKET) } + result } private val flagTokens: Map[Int, Long] = Map( @@ -2144,24 +2160,25 @@ self => } paramType() } - val default = ( - if (acceptIfPresent(EQUALS)) { + val default = + if (in.token == EQUALS) { + in.nextToken() mods |= Flags.DEFAULTPARAM expr() - } - else EmptyTree - ) + } else EmptyTree atPos(start, if (name == nme.ERROR) start else nameOffset) { ValDef((mods | implicitmod.toLong | bynamemod) withAnnotations annots, name.toTermName, tpt, default) } } - def paramClause(): List[ValDef] = in.token match { - case RPAREN => Nil - case _ => - if (acceptIfPresent(IMPLICIT)) - implicitmod = Flags.IMPLICIT + def paramClause(): List[ValDef] = { + if (in.token == RPAREN) + return Nil - commaSeparated(param()) + if (in.token == IMPLICIT) { + in.nextToken() + implicitmod = Flags.IMPLICIT + } + commaSeparated(param()) } val vds = new ListBuffer[List[ValDef]] val start = in.offset @@ -2169,7 +2186,8 @@ self => if (ofCaseClass && in.token != LPAREN) syntaxError(in.lastOffset, "case classes without a parameter list are not allowed;\n"+ "use either case objects or case classes with an explicit `()' as a parameter list.") - while (implicitmod == 0 && acceptIfPresent(LPAREN)) { + while (implicitmod == 0 && in.token == LPAREN) { + in.nextToken() vds += paramClause() accept(RPAREN) caseParam = false @@ -2193,16 +2211,18 @@ self => def paramType(): Tree = paramType(useStartAsPosition = false) def paramType(useStartAsPosition: Boolean): Tree = { val start = in.offset - if (acceptIfPresent(ARROW)) - atPos(start)(byNameApplication(typ())) - else { - val t = typ() - if (isRawStar) { + in.token match { + case ARROW => in.nextToken() - if (useStartAsPosition) atPos(start)(repeatedApplication(t)) - else atPos(t.pos.startOrPoint, t.pos.point)(repeatedApplication(t)) - } - else t + atPos(start)(byNameApplication(typ())) + case _ => + val t = typ() + if (isRawStar) { + in.nextToken() + if (useStartAsPosition) atPos(start)(repeatedApplication(t)) + else atPos(t.pos.startOrPoint, t.pos.point)(repeatedApplication(t)) + } + else t } } @@ -2237,13 +2257,14 @@ self => } if (contextBoundBuf ne null) { while (in.token == VIEWBOUND) { - contextBoundBuf += atPos(in.skipToken())(makeFunctionTypeTree(List(Ident(pname)), typ())) + contextBoundBuf += atPos(in.skipToken()) { + makeFunctionTypeTree(List(Ident(pname)), typ()) + } } while (in.token == COLON) { - val start = in.skipToken() - val tycon = typ() - val applied = atPos(tycon.pos withStart start)(AppliedTypeTree(tycon, Ident(pname) :: Nil)) - contextBoundBuf += applied + contextBoundBuf += atPos(in.skipToken()) { + AppliedTypeTree(typ(), List(Ident(pname))) + } } } param @@ -2269,7 +2290,7 @@ self => t setPos o2p(in.offset) } - def bound(tok: Int): Tree = if (acceptIfPresent(tok)) typ() else EmptyTree + def bound(tok: Int): Tree = if (in.token == tok) { in.nextToken(); typ() } else EmptyTree /* -------- DEFS ------------------------------------------- */ @@ -2281,10 +2302,11 @@ self => def importClause(): List[Tree] = { val offset = accept(IMPORT) commaSeparated(importExpr()) match { - case Nil => Nil + case Nil => Nil case t :: rest => // The first import should start at the position of the keyword. - (t setPos (t.pos withStart offset)) :: rest + t.setPos(t.pos.withStart(offset)) + t :: rest } } @@ -2313,9 +2335,12 @@ self => case _ => val nameOffset = in.offset val name = ident() - if (acceptIfPresent(DOT)) + if (in.token == DOT) { // import foo.bar.ident.<unknown> and so create a select node and recurse. - return loop(atPos(start, if (name == nme.ERROR) in.offset else nameOffset)(Select(expr, name))) + val t = atPos(start, if (name == nme.ERROR) in.offset else nameOffset)(Select(expr, name)) + in.nextToken() + return loop(t) + } // import foo.bar.Baz; else List(makeImportSelector(name, nameOffset)) } @@ -2346,27 +2371,30 @@ self => selectors } - def wildcardOrIdent() = if (acceptIfPresent(USCORE)) nme.WILDCARD else ident() + def wildcardOrIdent() = { + if (in.token == USCORE) { in.nextToken() ; nme.WILDCARD } + else ident() + } /** {{{ * ImportSelector ::= Id [`=>' Id | `=>' `_'] * }}} */ def importSelector(): ImportSelector = { - val start = in.offset - val name = wildcardOrIdent() - - // The first case is overly cleverly using named arguments to reverse the - // positions of the last two parameters, because reading the rename will - // move the value of in.offset. Hey, I didn't invent side effects, I too am - // a victim here. I can't find a single place where the rename position - // is used anyway. - if (acceptIfPresent(ARROW)) - ImportSelector(name, start, renamePos = in.offset, rename = wildcardOrIdent()) - else if (name == nme.WILDCARD) - ImportSelector(name, start, null, -1) - else - ImportSelector(name, start, name, start) + val start = in.offset + val name = wildcardOrIdent() + var renameOffset = -1 + val rename = in.token match { + case ARROW => + in.nextToken() + renameOffset = in.offset + wildcardOrIdent() + case _ if name == nme.WILDCARD => null + case _ => + renameOffset = start + name + } + ImportSelector(name, start, rename, renameOffset) } /** {{{ @@ -2405,8 +2433,6 @@ self => defOrDcl(caseAwareTokenOffset, modifiers() withAnnotations annots) } - def equalsExprOpt(): Tree = if (acceptIfPresent(EQUALS)) expr() else EmptyTree - /** {{{ * PatDef ::= Pattern2 {`,' Pattern2} [`:' Type] `=' Expr * ValDcl ::= Id {`,' Id} `:' Type @@ -2414,55 +2440,45 @@ self => * }}} */ def patDefOrDcl(pos : Int, mods: Modifiers): List[Tree] = { + var newmods = mods in.nextToken() - - val lhses = commaSeparated(stripParens(noSeq.pattern2())) - val lhs = lhses.last - val tpt = typedOpt() - val ascriptedLhs = if (tpt.isEmpty) lhs else atPos(lhs.pos union tpt.pos)(Typed(lhs, tpt)) - val hasEq = acceptIfPresent(EQUALS) - // SI-7854 an underscore following the equals doesn't necessarily mean default initialization. - val isDefaultInit = hasEq && in.token == USCORE && { - peekahead() - isStatSep || isStatSeqEnd || { pushback() ; false } - } - val rhs = if (hasEq && !isDefaultInit) expr() else EmptyTree - def allIdents = lhses forall (_.isInstanceOf[Ident]) - - def defaultInitFlag(): Long = { - if (!allIdents) - syntaxError(lhs.pos, "pattern definition is ineligible for default initialization", skipIt = false) - else if (!mods.isMutable) - syntaxError(lhs.pos, "only vars are eligible for default initialization", skipIt = false) - else if (tpt.isEmpty) - syntaxError(lhs.pos, "an explicit type is required for default initialization", skipIt = false) - - Flags.DEFAULTINIT - } - def deferredFlag(): Long = { - if (mods.isLazy) // e.g. lazy val foo: Int - syntaxError(lhs.pos, "lazy values may not be abstract", skipIt = false) - else if (!allIdents) // e.g. val Some(x) - syntaxError(lhs.pos, "pattern definition may not be abstract", skipIt = false) - - Flags.DEFERRED - } - val newmods = mods | ( - if (isDefaultInit) defaultInitFlag() - else if (rhs.isEmpty) deferredFlag() - else 0L - ) - - def makeValDefs(decl: Tree): List[Tree] = { - val newTpt = if (tpt.isEmpty) decl else Typed(decl, tpt.duplicate setPos tpt.pos.focus) setPos decl.pos.focus - makePatDef(newmods, newTpt, rhs.duplicate setPos rhs.pos.focus) match { - case tree :: Nil => (tree setPos decl.pos) :: Nil - case trees => trees map (_ setPos decl.pos.focus) + val lhs = commaSeparated(stripParens(noSeq.pattern2())) + val tp = typedOpt() + val rhs = + if (tp.isEmpty || in.token == EQUALS) { + accept(EQUALS) + if (!tp.isEmpty && newmods.isMutable && + (lhs.toList forall (_.isInstanceOf[Ident])) && in.token == USCORE) { + in.nextToken() + newmods = newmods | Flags.DEFAULTINIT + EmptyTree + } else { + expr() + } + } else { + newmods = newmods | Flags.DEFERRED + EmptyTree } + def mkDefs(p: Tree, tp: Tree, rhs: Tree): List[Tree] = { + //Console.println("DEBUG: p = "+p.toString()); // DEBUG + val trees = + makePatDef(newmods, + if (tp.isEmpty) p + else Typed(p, tp) setPos (p.pos union tp.pos), + rhs) + if (newmods.isDeferred) { + trees match { + case List(ValDef(_, _, _, EmptyTree)) => + if (mods.isLazy) syntaxError(p.pos, "lazy values may not be abstract", skipIt = false) + case _ => syntaxError(p.pos, "pattern definition may not be abstract", skipIt = false) + } + } + trees } - - val trees = (lhses.init flatMap makeValDefs) ::: makePatDef(newmods, ascriptedLhs, rhs) - ensureNonOverlapping(trees.last, trees.init) + val trees = (lhs.toList.init flatMap (mkDefs(_, tp.duplicate, rhs.duplicate))) ::: mkDefs(lhs.last, tp, rhs) + val hd = trees.head + hd setPos hd.pos.withStart(pos) + ensureNonOverlapping(hd, trees.tail) trees } @@ -2507,8 +2523,7 @@ self => in.nextToken() if (in.token == THIS) { atPos(start, in.skipToken()) { - val cbounds = classContextBounds map (_.duplicate) - val vparamss = paramClauses(nme.CONSTRUCTOR, cbounds, ofCaseClass = false) + val vparamss = paramClauses(nme.CONSTRUCTOR, classContextBounds map (_.duplicate), ofCaseClass = false) newLineOptWhenFollowedBy(LBRACE) val rhs = in.token match { case LBRACE => atPos(in.offset) { constrBlock(vparamss) } @@ -2532,8 +2547,7 @@ self => // i.e. (B[T] or T => B) val contextBoundBuf = new ListBuffer[Tree] val tparams = typeParamClauseOpt(name, contextBoundBuf) - val cbounds = contextBoundBuf.toList - val vparamss = paramClauses(name, cbounds, ofCaseClass = false) + val vparamss = paramClauses(name, contextBoundBuf.toList, ofCaseClass = false) newLineOptWhenFollowedBy(LBRACE) var restype = fromWithinReturnType(typedOpt()) val rhs = @@ -2693,9 +2707,8 @@ self => val result = gen.mkClassDef(mods1, name, tparams, template) // Context bounds generate implicit parameters (part of the template) with types // from tparams: we need to ensure these don't overlap - if (classContextBounds.nonEmpty) + if (!classContextBounds.isEmpty) ensureNonOverlapping(template, tparams) - result } } @@ -2757,15 +2770,18 @@ self => * }}} */ def templateParents(): List[Tree] = { - def readAppliedParent(): Tree = { + val parents = new ListBuffer[Tree] + def readAppliedParent() = { val start = in.offset val parent = startAnnotType() - in.token match { + parents += (in.token match { case LPAREN => atPos(start)((parent /: multipleArgumentExprs())(Apply.apply)) case _ => parent - } + }) } - tokenSeparated(WITH, sepFirst = false, readAppliedParent()) + readAppliedParent() + while (in.token == WITH) { in.nextToken(); readAppliedParent() } + parents.toList } /** {{{ @@ -2799,9 +2815,9 @@ self => def ensureEarlyDef(tree: Tree): Tree = tree match { case vdef @ ValDef(mods, _, _, _) if !mods.isDeferred => copyValDef(vdef)(mods = mods | Flags.PRESUPER) - case tdef @ TypeDef(mods, _, _, _) => + case tdef @ TypeDef(mods, name, tparams, rhs) => deprecationWarning(tdef.pos.point, "early type members are deprecated. Move them to the regular body: the semantics are the same.") - copyTypeDef(tdef)(mods = mods | Flags.PRESUPER) + treeCopy.TypeDef(tdef, mods | Flags.PRESUPER, name, tparams, rhs) case docdef @ DocDef(comm, rhs) => treeCopy.DocDef(docdef, comm, rhs) case stat if !stat.isEmpty => @@ -2836,6 +2852,7 @@ self => ) val parentPos = o2p(in.offset) val tstart1 = if (body.isEmpty && in.lastOffset < tstart) in.lastOffset else tstart + atPos(tstart1) { // Exclude only the 9 primitives plus AnyVal. if (inScalaRootPackage && ScalaValueClassNames.contains(name)) @@ -3086,9 +3103,10 @@ self => def compilationUnit(): PackageDef = checkNoEscapingPlaceholders { def topstats(): List[Tree] = { val ts = new ListBuffer[Tree] - while (acceptIfPresent(SEMI)) () + while (in.token == SEMI) in.nextToken() val start = in.offset - if (acceptIfPresent(PACKAGE)) { + if (in.token == PACKAGE) { + in.nextToken() if (in.token == OBJECT) { // TODO - this next line is supposed to be // ts += packageObjectDef(start) diff --git a/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala b/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala index 5ef40923b4..6957f85689 100644 --- a/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala @@ -52,15 +52,6 @@ trait Scanners extends ScannersCommon { type Offset = Int trait TokenData extends CommonTokenData { - override def toString = s""" - |TokenData( - | token $token ${token2string(token)} - | offset $offset - | last $lastOffset - | name $name - | strVal $strVal - | base $base - |)""".stripMargin.trim /** the next token */ var token: Int = EMPTY diff --git a/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala b/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala index fba74330a6..0d93a1b427 100644 --- a/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala @@ -198,21 +198,22 @@ abstract class TreeBuilder { } /** Create tree representing a while loop */ - def makeWhile(cond: Tree, body: Tree): Tree = { - val lname = freshTermName(nme.WHILE_PREFIX) - val continu = atPos(cond.pos.focus)(Apply(Ident(lname), Nil)) - val rhs = atPos(cond.pos union body.pos)(If(cond, atPos(body.pos)(Block(body :: Nil, continu)), Literal(Constant(())))) - - atPos(rhs.pos)(LabelDef(lname, Nil, rhs)) + def makeWhile(startPos: Int, cond: Tree, body: Tree): Tree = { + val lname = freshTermName(nme.WHILE_PREFIX) + def default = wrappingPos(List(cond, body)) match { + case p if p.isDefined => p.endOrPoint + case _ => startPos + } + val continu = atPos(o2p(body.pos pointOrElse default)) { Apply(Ident(lname), Nil) } + val rhs = If(cond, Block(List(body), continu), Literal(Constant(()))) + LabelDef(lname, Nil, rhs) } /** Create tree representing a do-while loop */ def makeDoWhile(lname: TermName, body: Tree, cond: Tree): Tree = { - val continu = atPos(cond.pos.focus)(Apply(Ident(lname), Nil)) - val condition = atPos(cond.pos)(If(cond, continu, Literal(Constant(())))) - val rhs = atPos(cond.pos union body.pos)(Block(body :: Nil, condition)) - - atPos(rhs.pos)(LabelDef(lname, Nil, rhs)) + val continu = Apply(Ident(lname), Nil) + val rhs = Block(List(body), If(cond, continu, Literal(Constant(())))) + LabelDef(lname, Nil, rhs) } /** Create block of statements `stats` */ @@ -304,13 +305,19 @@ abstract class TreeBuilder { * The closure is assigned a transparent position with the point at pos.point and * the limits given by pat and body. */ - def makeClosure(pos: Position, pat: Tree, body: Tree): Tree = - atPos((pos union pat.pos union body.pos).makeTransparent) { - matchVarPattern(pat) match { - case Some((name, tpt)) => Function(atPos(pat.pos)(ValDef(Modifiers(PARAM), name.toTermName, tpt, EmptyTree)) :: Nil, body) - case None => makeVisitor(CaseDef(pat, body) :: Nil, checkExhaustive = false) - } + def makeClosure(pos: Position, pat: Tree, body: Tree): Tree = { + def splitpos = wrappingPos(List(pat, body)).withPoint(pos.point).makeTransparent + matchVarPattern(pat) match { + case Some((name, tpt)) => + Function( + List(atPos(pat.pos) { ValDef(Modifiers(PARAM), name.toTermName, tpt, EmptyTree) }), + body) setPos splitpos + case None => + atPos(splitpos) { + makeVisitor(List(CaseDef(pat, EmptyTree, body)), checkExhaustive = false) + } } + } /* Make an application qual.meth(pat => body) positioned at `pos`. */ @@ -488,7 +495,7 @@ abstract class TreeBuilder { tmp, TypeTree(), matchExpr) } var cnt = 0 - val restDefs = for ((vname, tpt, pos) <- vars) yield atPos(pos.focus) { + val restDefs = for ((vname, tpt, pos) <- vars) yield atPos(pos) { cnt += 1 ValDef(mods, vname.toTermName, tpt, Select(Ident(tmp), newTermName("_" + cnt))) } diff --git a/src/reflect/scala/reflect/internal/TreeGen.scala b/src/reflect/scala/reflect/internal/TreeGen.scala index a9f2807e9f..c8ae4df13d 100644 --- a/src/reflect/scala/reflect/internal/TreeGen.scala +++ b/src/reflect/scala/reflect/internal/TreeGen.scala @@ -280,7 +280,7 @@ abstract class TreeGen extends macros.TreeBuilder { /** Builds a tuple */ def mkTuple(elems: List[Tree]): Tree = - if (elems.isEmpty) mkUnit() + if (elems.isEmpty) Literal(Constant(())) else Apply( Select(mkAttributedRef(TupleClass(elems.length).caseModule), nme.apply), elems) @@ -326,7 +326,8 @@ abstract class TreeGen extends macros.TreeBuilder { * body * } */ - def mkTemplate(parents: List[Tree], self: ValDef, constrMods: Modifiers, vparamss: List[List[ValDef]], body: List[Tree], superPos: Position = NoPosition): Template = { + def mkTemplate(parents: List[Tree], self: ValDef, constrMods: Modifiers, + vparamss: List[List[ValDef]], body: List[Tree], superPos: Position = NoPosition): Template = { /* Add constructor to template */ // create parameters for <init> as synthetic trees. @@ -397,42 +398,52 @@ abstract class TreeGen extends macros.TreeBuilder { * @param npos the position of the new * @param cpos the position of the anonymous class starting with parents */ - def mkNew(parents: List[Tree], self: ValDef, stats: List[Tree], npos: Position, cpos: Position): Tree = { - def enclosingPos = wrappingPos(cpos, parents ::: List(self) ::: stats) - def upos = cpos union npos - def anonTemplate = atPos(cpos)(mkTemplate(parents, self, NoMods, ListOfNil, stats, cpos)) - def anonClass = atPos(anonTemplate.pos.makeTransparent)(ClassDef(Modifiers(FINAL), tpnme.ANON_CLASS_NAME, Nil, anonTemplate)) - def anonNew = atPos(npos)(New(Ident(tpnme.ANON_CLASS_NAME) setPos cpos.focus, Nil)) - - // `Parsers.template` no longer differentiates tpts and their argss - // e.g. `C()` will be represented as a single tree Apply(Ident(C), Nil) - // instead of parents = Ident(C), argss = Nil as before - // this change works great for things that are actually templates - // but in this degenerate case we need to perform postprocessing - parents match { - case Nil => mkNew(List(scalaAnyRefConstr), self, stats, npos, cpos) - case treeInfo.AppliedArgs(callee, argss) :: Nil if stats.isEmpty => atPos(upos)(New(callee, argss)) - case _ => atPos(upos)(mkBlock(anonClass :: anonNew :: Nil)) + def mkNew(parents: List[Tree], self: ValDef, stats: List[Tree], + npos: Position, cpos: Position): Tree = + if (parents.isEmpty) + mkNew(List(scalaAnyRefConstr), self, stats, npos, cpos) + else if (parents.tail.isEmpty && stats.isEmpty) { + // `Parsers.template` no longer differentiates tpts and their argss + // e.g. `C()` will be represented as a single tree Apply(Ident(C), Nil) + // instead of parents = Ident(C), argss = Nil as before + // this change works great for things that are actually templates + // but in this degenerate case we need to perform postprocessing + val app = treeInfo.dissectApplied(parents.head) + atPos(npos union cpos) { New(app.callee, app.argss) } + } else { + val x = tpnme.ANON_CLASS_NAME + atPos(npos union cpos) { + Block( + List( + atPos(cpos) { + ClassDef( + Modifiers(FINAL), x, Nil, + mkTemplate(parents, self, NoMods, ListOfNil, stats, cpos.focus)) + }), + atPos(npos) { + New( + Ident(x) setPos npos.focus, + Nil) + } + ) + } } - } /** Create a tree representing the function type (argtpes) => restpe */ def mkFunctionTypeTree(argtpes: List[Tree], restpe: Tree): Tree = AppliedTypeTree(rootScalaDot(newTypeName("Function" + argtpes.length)), argtpes ::: List(restpe)) - def mkUnit() = Literal(Constant(())) - /** Create block of statements `stats` */ - def mkBlock(stats: List[Tree]): Tree = stats match { - case stats if stats.isEmpty || !stats.last.isTerm => mkBlock(stats :+ mkUnit()) - case stat :: Nil => stat - case stats => Block(stats.init, stats.last) - } + def mkBlock(stats: List[Tree]): Tree = + if (stats.isEmpty) Literal(Constant(())) + else if (!stats.last.isTerm) Block(stats, Literal(Constant(()))) + else if (stats.length == 1) stats.head + else Block(stats.init, stats.last) def mkTreeOrBlock(stats: List[Tree]) = stats match { - case Nil => EmptyTree + case Nil => EmptyTree case head :: Nil => head - case _ => gen.mkBlock(stats) + case _ => gen.mkBlock(stats) } /** Create a tree representing an assignment <lhs = rhs> */ diff --git a/src/reflect/scala/reflect/internal/TreeInfo.scala b/src/reflect/scala/reflect/internal/TreeInfo.scala index 1b763b8632..34fe0afb1a 100644 --- a/src/reflect/scala/reflect/internal/TreeInfo.scala +++ b/src/reflect/scala/reflect/internal/TreeInfo.scala @@ -773,13 +773,6 @@ abstract class TreeInfo { unapply(dissectApplied(tree)) } - object AppliedArgs { - def unapply(tree: Tree): Some[(Tree, List[List[Tree]])] = tree match { - case Apply(AppliedArgs(fn, argss), args) => Some((fn, argss :+ args)) - case _ => Some((tree, Nil)) - } - } - /** Locates the synthetic Apply node corresponding to an extractor's call to * unapply (unwrapping nested Applies) and returns the fun part of that Apply. */ diff --git a/src/reflect/scala/reflect/internal/util/Position.scala b/src/reflect/scala/reflect/internal/util/Position.scala index d62ab40a9d..8e7df28167 100644 --- a/src/reflect/scala/reflect/internal/util/Position.scala +++ b/src/reflect/scala/reflect/internal/util/Position.scala @@ -197,11 +197,10 @@ private[util] trait InternalPositionImpl { } def showDebug: String = toString def show = ( - if (isOpaqueRange && start != point) s"[$point/$start:$end]" - else if (isOpaqueRange) s"[$start:$end]" + if (isOpaqueRange) s"[$start:$end]" else if (isTransparent) s"<$start:$end>" else if (isDefined) s"[$point]" - else "[X]" + else "[NoPosition]" ) private def asOffset(point: Int): Position = Position.offset(source, point) diff --git a/test/files/continuations-run/t5472.check b/test/files/continuations-run/t5472.check index 1af7767f6d..3192c746eb 100644 --- a/test/files/continuations-run/t5472.check +++ b/test/files/continuations-run/t5472.check @@ -5,7 +5,7 @@ t5472.scala:12: warning: expression case4(){ case5() } is cps-transformed unexpectedly (location, accessors) <- new ContinuationizedParallelIterable(map) - ^ + ^ t5472.scala:12: warning: expression matchEnd3(x: Int){ x } is cps-transformed unexpectedly diff --git a/test/files/neg/classmanifests_new_deprecations.check b/test/files/neg/classmanifests_new_deprecations.check index 39b6bf216c..fd1e2728c3 100644 --- a/test/files/neg/classmanifests_new_deprecations.check +++ b/test/files/neg/classmanifests_new_deprecations.check @@ -1,6 +1,6 @@ classmanifests_new_deprecations.scala:2: warning: type ClassManifest in object Predef is deprecated: Use `scala.reflect.ClassTag` instead def cm1[T: ClassManifest] = ??? - ^ + ^ classmanifests_new_deprecations.scala:3: warning: type ClassManifest in object Predef is deprecated: Use `scala.reflect.ClassTag` instead def cm2[T](implicit evidence$1: ClassManifest[T]) = ??? ^ @@ -9,7 +9,7 @@ classmanifests_new_deprecations.scala:4: warning: type ClassManifest in object P ^ classmanifests_new_deprecations.scala:6: warning: type ClassManifest in package reflect is deprecated: Use scala.reflect.ClassTag instead def rcm1[T: scala.reflect.ClassManifest] = ??? - ^ + ^ classmanifests_new_deprecations.scala:7: warning: type ClassManifest in package reflect is deprecated: Use scala.reflect.ClassTag instead def rcm2[T](implicit evidence$1: scala.reflect.ClassManifest[T]) = ??? ^ diff --git a/test/files/neg/divergent-implicit.check b/test/files/neg/divergent-implicit.check index b5c607cf59..5f20df1b91 100644 --- a/test/files/neg/divergent-implicit.check +++ b/test/files/neg/divergent-implicit.check @@ -10,9 +10,9 @@ starting with method cast in object Test1 divergent-implicit.scala:14: error: diverging implicit expansion for type Test2.Baz => Test2.Bar starting with method baz2bar in object Test2 val x: Bar = new Foo - ^ + ^ divergent-implicit.scala:15: error: diverging implicit expansion for type Test2.Foo => Test2.Bar starting with method foo2bar in object Test2 val y: Bar = new Baz - ^ + ^ four errors found diff --git a/test/files/neg/for-comprehension-old.check b/test/files/neg/for-comprehension-old.check index fc04beca53..1ecaf12af4 100644 --- a/test/files/neg/for-comprehension-old.check +++ b/test/files/neg/for-comprehension-old.check @@ -1,15 +1,15 @@ for-comprehension-old.scala:3: warning: val keyword in for comprehension is deprecated for (x <- 1 to 5 ; val y = x) yield x+y // fail - ^ + ^ for-comprehension-old.scala:5: warning: val keyword in for comprehension is deprecated for (val x <- 1 to 5 ; val y = x) yield x+y // fail - ^ + ^ for-comprehension-old.scala:8: warning: val keyword in for comprehension is deprecated for (z <- 1 to 2 ; x <- 1 to 5 ; val y = x) yield x+y // fail - ^ + ^ for-comprehension-old.scala:10: warning: val keyword in for comprehension is deprecated for (z <- 1 to 2 ; val x <- 1 to 5 ; val y = x) yield x+y // fail - ^ + ^ for-comprehension-old.scala:4: error: val in for comprehension must be followed by assignment for (val x <- 1 to 5 ; y = x) yield x+y // fail ^ diff --git a/test/files/neg/found-req-variance.check b/test/files/neg/found-req-variance.check index 55a01012a9..cc26458ac5 100644 --- a/test/files/neg/found-req-variance.check +++ b/test/files/neg/found-req-variance.check @@ -4,56 +4,56 @@ found-req-variance.scala:22: error: type mismatch; Note: B <: A, but class Inv is invariant in type T. You may wish to define T as +T instead. (SLS 4.5) def f2 = Set[Inv[A]]() + new Inv[B] - ^ + ^ found-req-variance.scala:23: error: type mismatch; found : Inv[C] required: Inv[A] Note: C <: A, but class Inv is invariant in type T. You may wish to define T as +T instead. (SLS 4.5) def f3 = Set[Inv[A]]() + new Inv[C] - ^ + ^ found-req-variance.scala:24: error: type mismatch; found : Inv[A] required: Inv[B] Note: A >: B, but class Inv is invariant in type T. You may wish to define T as -T instead. (SLS 4.5) def f4 = Set[Inv[B]]() + new Inv[A] - ^ + ^ found-req-variance.scala:26: error: type mismatch; found : Inv[C] required: Inv[B] Note: C <: B, but class Inv is invariant in type T. You may wish to define T as +T instead. (SLS 4.5) def f6 = Set[Inv[B]]() + new Inv[C] - ^ + ^ found-req-variance.scala:27: error: type mismatch; found : Inv[A] required: Inv[C] Note: A >: C, but class Inv is invariant in type T. You may wish to define T as -T instead. (SLS 4.5) def f7 = Set[Inv[C]]() + new Inv[A] - ^ + ^ found-req-variance.scala:28: error: type mismatch; found : Inv[B] required: Inv[C] Note: B >: C, but class Inv is invariant in type T. You may wish to define T as -T instead. (SLS 4.5) def f8 = Set[Inv[C]]() + new Inv[B] - ^ + ^ found-req-variance.scala:34: error: type mismatch; found : MultiInv[A] required: Multi[A,B,C] Note: A >: B (and MultiInv[A] <: Multi[A,A,C]), but class Multi is invariant in type Inv. You may wish to define Inv as -Inv instead. (SLS 4.5) def g4 = Set[Multi[A, B, C]]() + new MultiInv[A] - ^ + ^ found-req-variance.scala:36: error: type mismatch; found : MultiInv[C] required: Multi[A,B,C] Note: C <: B (and MultiInv[C] <: Multi[A,C,C]), but class Multi is invariant in type Inv. You may wish to define Inv as +Inv instead. (SLS 4.5) def g6 = Set[Multi[A, B, C]]() + new MultiInv[C] - ^ + ^ found-req-variance.scala:47: error: type mismatch; found : FF1[A,A] required: FF1[B,B] @@ -160,7 +160,7 @@ found-req-variance.scala:94: error: type mismatch; Note: Int <: AnyVal (and Misc.MyData <: Misc.Data[Int]), but class Data is invariant in type A. You may wish to define A as +A instead. (SLS 4.5) def f1 = Set[Data[AnyVal]]() + new MyData - ^ + ^ found-req-variance.scala:100: error: type mismatch; found : Set[String] required: Set[CharSequence] @@ -174,7 +174,7 @@ found-req-variance.scala:104: error: type mismatch; Note: String <: Object, but class Trippy is invariant in type T2. You may wish to define T2 as +T2 instead. (SLS 4.5) def g1 = Set[Trippy[AnyRef, AnyRef, AnyRef]]() + new Trippy[String, String, String] - ^ + ^ found-req-variance.scala:105: error: type mismatch; found : scala.collection.immutable.Map[AnyRef,String] required: Map[String,String] diff --git a/test/files/neg/lazyvals.check b/test/files/neg/lazyvals.check index 1ae8b13d92..c4daf9d842 100644 --- a/test/files/neg/lazyvals.check +++ b/test/files/neg/lazyvals.check @@ -7,9 +7,9 @@ lazyvals.scala:9: error: lazy not allowed here. Only vals can be lazy lazyvals.scala:12: error: lazy not allowed here. Only vals can be lazy lazy def q: Double = 0.0 ^ -lazyvals.scala:15: error: lazy values may not be abstract +lazyvals.scala:15: error: '=' expected but ';' found. lazy val t; - ^ + ^ lazyvals.scala:20: error: lazy not allowed here. Only vals can be lazy lazy trait T {} ^ diff --git a/test/files/neg/multi-array.check b/test/files/neg/multi-array.check index 6bdeb34c9e..511caa126f 100644 --- a/test/files/neg/multi-array.check +++ b/test/files/neg/multi-array.check @@ -1,4 +1,4 @@ multi-array.scala:7: error: too many arguments for constructor Array: (_length: Int)Array[T] val a: Array[Int] = new Array(10, 10) - ^ + ^ one error found diff --git a/test/files/neg/names-defaults-neg.check b/test/files/neg/names-defaults-neg.check index 4966779cc3..cdc12c2490 100644 --- a/test/files/neg/names-defaults-neg.check +++ b/test/files/neg/names-defaults-neg.check @@ -97,7 +97,7 @@ names-defaults-neg.scala:82: error: type mismatch; required: String Error occurred in an application involving default arguments. new A2[String]() - ^ + ^ names-defaults-neg.scala:86: error: module extending its companion class cannot use default constructor arguments object C extends C() ^ diff --git a/test/files/neg/nested-annotation.check b/test/files/neg/nested-annotation.check index c077d35a29..ca263943fe 100644 --- a/test/files/neg/nested-annotation.check +++ b/test/files/neg/nested-annotation.check @@ -5,6 +5,6 @@ class ComplexAnnotation(val value: Annotation) extends ClassfileAnnotation ^ nested-annotation.scala:8: error: nested classfile annotations must be defined in java; found: inline @ComplexAnnotation(new inline) def bippy(): Int = 1 - ^ + ^ one warning found one error found diff --git a/test/files/neg/no-implicit-to-anyref.check b/test/files/neg/no-implicit-to-anyref.check index 5ab5fd12a1..fe417ad8b0 100644 --- a/test/files/neg/no-implicit-to-anyref.check +++ b/test/files/neg/no-implicit-to-anyref.check @@ -18,5 +18,5 @@ Note that AV extends Any, not AnyRef. Such types can participate in value classes, but instances cannot appear in singleton types or in reference comparisons. new AV(0): AnyRef - ^ + ^ four errors found diff --git a/test/files/neg/no-predef.check b/test/files/neg/no-predef.check index fc538892ef..a63d8c5ba5 100644 --- a/test/files/neg/no-predef.check +++ b/test/files/neg/no-predef.check @@ -7,7 +7,7 @@ no-predef.scala:3: error: type mismatch; found : java.lang.Long required: scala.Long def f2 = new java.lang.Long(5) : Long - ^ + ^ no-predef.scala:4: error: value map is not a member of String def f3 = "abc" map (_ + 1) ^ diff --git a/test/files/neg/parser-errors.check b/test/files/neg/parser-errors.check deleted file mode 100644 index 0ab3331c0c..0000000000 --- a/test/files/neg/parser-errors.check +++ /dev/null @@ -1,16 +0,0 @@ -parser-errors.scala:1: error: lazy values may not be abstract -abstract class A1 { lazy val foo: Int } - ^ -parser-errors.scala:2: error: pattern definition may not be abstract -abstract class A2 { val Some(x) } - ^ -parser-errors.scala:3: error: an explicit type is required for default initialization -abstract class A3 { var x = _ } - ^ -parser-errors.scala:4: error: only vars are eligible for default initialization -abstract class A4 { val x: Int = _ } - ^ -parser-errors.scala:5: error: pattern definition is ineligible for default initialization -abstract class A5 { var Some(x) = _ } - ^ -5 errors found diff --git a/test/files/neg/parser-errors.scala b/test/files/neg/parser-errors.scala deleted file mode 100644 index 7b1a290629..0000000000 --- a/test/files/neg/parser-errors.scala +++ /dev/null @@ -1,5 +0,0 @@ -abstract class A1 { lazy val foo: Int } -abstract class A2 { val Some(x) } -abstract class A3 { var x = _ } -abstract class A4 { val x: Int = _ } -abstract class A5 { var Some(x) = _ } diff --git a/test/files/neg/parser-import-errors.check b/test/files/neg/parser-import-errors.check deleted file mode 100644 index e211c275a6..0000000000 --- a/test/files/neg/parser-import-errors.check +++ /dev/null @@ -1,28 +0,0 @@ -parser-import-errors.scala:12: error: not found: type B1 - new B1 - ^ -parser-import-errors.scala:13: error: not found: type C1 - new C1 - ^ -parser-import-errors.scala:19: error: object X1 is not a member of package p1 - import p1.{ A1 => X1, X1 => A1 } - ^ -parser-import-errors.scala:21: error: not found: type A1 - new A1 - ^ -parser-import-errors.scala:22: error: not found: type B1 - new B1 - ^ -parser-import-errors.scala:23: error: not found: type C1 - new C1 - ^ -parser-import-errors.scala:33: error: not found: type C1 - new C1 - ^ -parser-import-errors.scala:38: error: A1 appears twice as a target of a renaming - import p1.{ A1, B1 => A1 } - ^ -parser-import-errors.scala:45: error: object Z1 is not a member of package p1 - import p1.{ Z1, B1 => Z1 } - ^ -9 errors found diff --git a/test/files/neg/parser-import-errors.scala b/test/files/neg/parser-import-errors.scala deleted file mode 100644 index 010bb95a1e..0000000000 --- a/test/files/neg/parser-import-errors.scala +++ /dev/null @@ -1,49 +0,0 @@ -package p1 { - class A1 - class B1 - class C1 -} - -package p2 { - import p1.{ A1, B1 => Q1, C1 => _ } - - class X { - new A1 - new B1 - new C1 - new Q1 - } -} - -package p3 { - import p1.{ A1 => X1, X1 => A1 } - class X { - new A1 - new B1 - new C1 - new X1 - } -} - -package p4 { - import p1.{ A1 => B1, B1 => A1 } - class X { - new A1 - new B1 - new C1 - } -} - -package p5 { - import p1.{ A1, B1 => A1 } - class X { - new A1 - } -} - -package p6 { - import p1.{ Z1, B1 => Z1 } - class X { - new Z1 - } -} diff --git a/test/files/neg/primitive-sigs-1.check b/test/files/neg/primitive-sigs-1.check index d0619fa1d3..77dc457a49 100644 --- a/test/files/neg/primitive-sigs-1.check +++ b/test/files/neg/primitive-sigs-1.check @@ -2,5 +2,5 @@ B.scala:3: error: type mismatch; found : Bippy required: AC[Integer] J.f(new Bippy()) - ^ + ^ one error found diff --git a/test/files/neg/protected-constructors.check b/test/files/neg/protected-constructors.check index b636d076e4..f44d7db9b9 100644 --- a/test/files/neg/protected-constructors.check +++ b/test/files/neg/protected-constructors.check @@ -1,12 +1,12 @@ protected-constructors.scala:17: error: too many arguments for constructor Foo1: ()dingus.Foo1 val foo1 = new Foo1("abc") - ^ + ^ protected-constructors.scala:18: error: constructor Foo2 in class Foo2 cannot be accessed in object P Access to protected constructor Foo2 not permitted because enclosing object P in package hungus is not a subclass of class Foo2 in package dingus where target is defined val foo2 = new Foo2("abc") - ^ + ^ protected-constructors.scala:19: error: class Foo3 in object Ding cannot be accessed in object dingus.Ding Access to protected class Foo3 not permitted because enclosing object P in package hungus is not a subclass of diff --git a/test/files/neg/saito.check b/test/files/neg/saito.check index f78b300b4c..061a45b76e 100644 --- a/test/files/neg/saito.check +++ b/test/files/neg/saito.check @@ -1,4 +1,4 @@ saito.scala:10: error: class A cannot be instantiated because it does not conform to its self-type A with B val a: A = new A; // should not be allowed - ^ + ^ one error found diff --git a/test/files/neg/sensitive.check b/test/files/neg/sensitive.check index 9270e639c3..32d988ec97 100644 --- a/test/files/neg/sensitive.check +++ b/test/files/neg/sensitive.check @@ -1,4 +1,4 @@ sensitive.scala:17: error: constructor Sensitive in class Sensitive cannot be accessed in object Attacker val y = new Sensitive() - ^ + ^ one error found diff --git a/test/files/neg/stringinterpolation_macro-neg.check b/test/files/neg/stringinterpolation_macro-neg.check index fa4f2c9472..457f497f2f 100644 --- a/test/files/neg/stringinterpolation_macro-neg.check +++ b/test/files/neg/stringinterpolation_macro-neg.check @@ -1,6 +1,6 @@ stringinterpolation_macro-neg.scala:8: error: too few parts new StringContext().f() - ^ + ^ stringinterpolation_macro-neg.scala:9: error: too few arguments for interpolated string new StringContext("", " is ", "%2d years old").f(s) ^ diff --git a/test/files/neg/t0209.check b/test/files/neg/t0209.check index 4ba5fef4e9..1904e58e7a 100644 --- a/test/files/neg/t0209.check +++ b/test/files/neg/t0209.check @@ -2,5 +2,5 @@ t0209.scala:15: error: type mismatch; found : C required: _1.type where val _1: A (new B: A).f(new C) - ^ + ^ one error found diff --git a/test/files/neg/t1038.check b/test/files/neg/t1038.check index c74d8b338f..b191b89ad1 100644 --- a/test/files/neg/t1038.check +++ b/test/files/neg/t1038.check @@ -1,5 +1,5 @@ t1038.scala:4: error: not enough arguments for constructor X: (x: Int)X. Unspecified value parameter x. val a = new X - ^ + ^ one error found diff --git a/test/files/neg/t1623.check b/test/files/neg/t1623.check index e30db5cddd..251039ad30 100644 --- a/test/files/neg/t1623.check +++ b/test/files/neg/t1623.check @@ -1,4 +1,4 @@ t1623.scala:11: error: class BImpl cannot be instantiated because it does not conform to its self-type test.BImpl with test.A val b = new BImpl - ^ + ^ one error found diff --git a/test/files/neg/t1705.check b/test/files/neg/t1705.check index 12f5c27de6..7f75bd0fb5 100644 --- a/test/files/neg/t1705.check +++ b/test/files/neg/t1705.check @@ -1,6 +1,6 @@ t1705.scala:9: error: can't existentially abstract over parameterized type this.T[Z] val c = new C{ - ^ + ^ t1705.scala:14: error: can't existentially abstract over parameterized type C[String] val x1 = { ^ diff --git a/test/files/neg/t2775.check b/test/files/neg/t2775.check index 2c901665d6..934a970f2e 100644 --- a/test/files/neg/t2775.check +++ b/test/files/neg/t2775.check @@ -1,4 +1,4 @@ t2775.scala:1: error: cannot find class tag for element type B.this.T trait B[S] { type T = S; val c = new Array[T](1) } - ^ + ^ one error found diff --git a/test/files/neg/t3453.check b/test/files/neg/t3453.check index 2472e8b212..52c948128c 100644 --- a/test/files/neg/t3453.check +++ b/test/files/neg/t3453.check @@ -2,20 +2,20 @@ t3453.scala:18: error: type mismatch; found : A required: B new A - ^ + ^ t3453.scala:36: error: type mismatch; found : A required: B new A - ^ + ^ t3453.scala:50: error: type mismatch; found : A required: B new A - ^ + ^ t3453.scala:64: error: type mismatch; found : A required: B new A - ^ + ^ four errors found diff --git a/test/files/neg/t3692-new.check b/test/files/neg/t3692-new.check index 358eaed41e..9b96449930 100644 --- a/test/files/neg/t3692-new.check +++ b/test/files/neg/t3692-new.check @@ -9,7 +9,7 @@ t3692-new.scala:16: warning: non-variable type argument Int in type pattern Map[ ^ t3692-new.scala:15: warning: unreachable code case m1: Map[Int, V] => new java.util.HashMap[Integer, V] - ^ + ^ t3692-new.scala:4: warning: Tester has a main method with parameter type Array[String], but Tester will not be a runnable program. Reason: main method must have exact signature (Array[String])Unit object Tester { diff --git a/test/files/neg/t3977.check b/test/files/neg/t3977.check index 4242059463..72335a0926 100644 --- a/test/files/neg/t3977.check +++ b/test/files/neg/t3977.check @@ -1,4 +1,4 @@ t3977.scala:12: error: could not find implicit value for parameter w: False#If[E] new NoNull - ^ + ^ one error found diff --git a/test/files/neg/t4163.check b/test/files/neg/t4163.check index a09a522e3a..47bc78d31c 100644 --- a/test/files/neg/t4163.check +++ b/test/files/neg/t4163.check @@ -1,4 +1,7 @@ -t4163.scala:4: error: for comprehension must start with generator: '<-' expected but '=' found. +t4163.scala:4: error: '<-' expected but '=' found. x = 3 ^ -one error found +t4163.scala:5: error: illegal start of simple expression + y <- 0 to 100 +^ +two errors found diff --git a/test/files/neg/t4417.check b/test/files/neg/t4417.check index dfc9feca24..dbd0f1df46 100644 --- a/test/files/neg/t4417.check +++ b/test/files/neg/t4417.check @@ -3,5 +3,5 @@ t4417.scala:11: error: constructor Pixel$mcD$sp in class Pixel$mcD$sp cannot be enclosing object Pixel is not a subclass of class Pixel$mcD$sp where target is defined def apply(v: Double): Pixel1d = new Pixel1d(v) - ^ + ^ one error found diff --git a/test/files/neg/t4727.check b/test/files/neg/t4727.check index 55d4d01b97..a17cdde044 100644 --- a/test/files/neg/t4727.check +++ b/test/files/neg/t4727.check @@ -1,5 +1,5 @@ t4727.scala:5: error: an expression of type Null is ineligible for implicit conversion Error occurred in an application involving default arguments. new C[Int] - ^ + ^ one error found diff --git a/test/files/neg/t4851.check b/test/files/neg/t4851.check index 6d0f424e82..4f2919807e 100644 --- a/test/files/neg/t4851.check +++ b/test/files/neg/t4851.check @@ -3,19 +3,19 @@ S.scala:2: warning: Adapting argument list by inserting (): leaky (Object-receiv given arguments: <none> after adaptation: new J((): Unit) val x1 = new J - ^ + ^ S.scala:3: warning: Adapting argument list by inserting (): leaky (Object-receiving) target makes this especially dangerous. signature: J(x: Any): J given arguments: <none> after adaptation: new J((): Unit) val x2 = new J() - ^ + ^ S.scala:4: warning: Adapting argument list by creating a 5-tuple: this may not be what you want. signature: J(x: Any): J given arguments: 1, 2, 3, 4, 5 after adaptation: new J((1, 2, 3, 4, 5): (Int, Int, Int, Int, Int)) val x3 = new J(1, 2, 3, 4, 5) - ^ + ^ S.scala:6: warning: Adapting argument list by creating a 3-tuple: this may not be what you want. signature: Some.apply[A](x: A): Some[A] given arguments: 1, 2, 3 @@ -27,19 +27,19 @@ S.scala:7: warning: Adapting argument list by creating a 3-tuple: this may not b given arguments: 1, 2, 3 after adaptation: new Some((1, 2, 3): (Int, Int, Int)) val y2 = new Some(1, 2, 3) - ^ + ^ S.scala:9: warning: Adapting argument list by inserting (): this is unlikely to be what you want. signature: J2[T](x: T): J2[T] given arguments: <none> after adaptation: new J2((): Unit) val z1 = new J2 - ^ + ^ S.scala:10: warning: Adapting argument list by inserting (): this is unlikely to be what you want. signature: J2[T](x: T): J2[T] given arguments: <none> after adaptation: new J2((): Unit) val z2 = new J2() - ^ + ^ S.scala:14: warning: Adapting argument list by creating a 3-tuple: this may not be what you want. signature: Test.anyId(a: Any): Any given arguments: 1, 2, 3 diff --git a/test/files/neg/t4987.check b/test/files/neg/t4987.check index ee058f0ac1..8d7344d27b 100644 --- a/test/files/neg/t4987.check +++ b/test/files/neg/t4987.check @@ -1,4 +1,4 @@ t4987.scala:2: error: constructor Foo2 in class Foo2 cannot be accessed in object Bar2 object Bar2 { new Foo2(0, 0) } - ^ + ^ one error found diff --git a/test/files/neg/t5120.check b/test/files/neg/t5120.check index fc65ca16a5..34d4ebde31 100644 --- a/test/files/neg/t5120.check +++ b/test/files/neg/t5120.check @@ -2,11 +2,11 @@ t5120.scala:11: error: type mismatch; found : Object required: _1 List(str, other) foreach (_.x1 = new AnyRef) - ^ + ^ t5120.scala:25: error: type mismatch; found : Thread required: h.T (which expands to) _2 List(str, num).foreach(h => h.f1 = new Thread()) - ^ + ^ two errors found diff --git a/test/files/neg/t5666.check b/test/files/neg/t5666.check index da6b9d73e7..1c714796ba 100644 --- a/test/files/neg/t5666.check +++ b/test/files/neg/t5666.check @@ -1,37 +1,37 @@ t5666.scala:2: error: class Any is abstract; cannot be instantiated new Any - ^ + ^ t5666.scala:3: error: class AnyVal is abstract; cannot be instantiated new AnyVal - ^ + ^ t5666.scala:4: error: class Double is abstract; cannot be instantiated new Double - ^ + ^ t5666.scala:5: error: class Float is abstract; cannot be instantiated new Float - ^ + ^ t5666.scala:6: error: class Long is abstract; cannot be instantiated new Long - ^ + ^ t5666.scala:7: error: class Int is abstract; cannot be instantiated new Int - ^ + ^ t5666.scala:8: error: class Char is abstract; cannot be instantiated new Char - ^ + ^ t5666.scala:9: error: class Short is abstract; cannot be instantiated new Short - ^ + ^ t5666.scala:10: error: class Byte is abstract; cannot be instantiated new Byte - ^ + ^ t5666.scala:11: error: class Boolean is abstract; cannot be instantiated new Boolean - ^ + ^ t5666.scala:12: error: class Unit is abstract; cannot be instantiated new Unit - ^ + ^ t5666.scala:13: error: class Nothing is abstract; cannot be instantiated new Nothing - ^ + ^ 12 errors found diff --git a/test/files/neg/t5761.check b/test/files/neg/t5761.check index 8086af2fcf..89d766fe34 100644 --- a/test/files/neg/t5761.check +++ b/test/files/neg/t5761.check @@ -5,7 +5,7 @@ Unspecified value parameter x. t5761.scala:8: error: not enough arguments for constructor D: (x: Int)D[Int]. Unspecified value parameter x. println(new D[Int]()) // no crash - ^ + ^ t5761.scala:9: error: not enough arguments for constructor D: (x: Int)D[Int]. Unspecified value parameter x. println(new D[Int]{}) // crash diff --git a/test/files/neg/t5803.check b/test/files/neg/t5803.check index c4f901e511..6a2de2e1df 100644 --- a/test/files/neg/t5803.check +++ b/test/files/neg/t5803.check @@ -1,4 +1,4 @@ t5803.scala:3: error: could not find implicit value for parameter ev: Nothing new Foo(): String - ^ + ^ one error found diff --git a/test/files/neg/t6074.check b/test/files/neg/t6074.check index 6abf5e2906..38670e5b3d 100644 --- a/test/files/neg/t6074.check +++ b/test/files/neg/t6074.check @@ -1,4 +1,4 @@ t6074.scala:5: error: constructor A in class A cannot be accessed in object T def t = new A() - ^ + ^ one error found diff --git a/test/files/neg/t6601.check b/test/files/neg/t6601.check index b05c67ad9a..1410e1b11a 100644 --- a/test/files/neg/t6601.check +++ b/test/files/neg/t6601.check @@ -1,4 +1,4 @@ AccessPrivateConstructor_2.scala:2: error: constructor PrivateConstructor in class PrivateConstructor cannot be accessed in class AccessPrivateConstructor new PrivateConstructor("") // Scalac should forbid accessing to the private constructor! - ^ + ^ one error found diff --git a/test/files/neg/t6667b.check b/test/files/neg/t6667b.check index a8705fa1c2..99cea9a47c 100644 --- a/test/files/neg/t6667b.check +++ b/test/files/neg/t6667b.check @@ -3,11 +3,11 @@ t6667b.scala:16: error: ambiguous implicit values: and value b of type Test.Box match expected type Test.Box new Test() - ^ + ^ t6667b.scala:19: error: ambiguous implicit values: both value a in object Test of type => Test.Box and value b of type Test.Box match expected type Test.Box new Test() - ^ + ^ two errors found diff --git a/test/files/neg/t7385.check b/test/files/neg/t7385.check index c196ec0b4f..70d3c3fb61 100644 --- a/test/files/neg/t7385.check +++ b/test/files/neg/t7385.check @@ -1,7 +1,10 @@ -t7385.scala:2: error: parenthesized conditional expression expected +t7385.scala:2: error: '(' expected but identifier found. do { println("bippy") } while i<10 ^ -t7385.scala:6: error: parenthesized conditional expression expected +t7385.scala:6: error: '(' expected but identifier found. while i<10 { () } ^ -two errors found +t7385.scala:7: error: illegal start of simple expression +} +^ +three errors found diff --git a/test/files/neg/t7473.check b/test/files/neg/t7473.check index c686466a44..bc8c29d463 100644 --- a/test/files/neg/t7473.check +++ b/test/files/neg/t7473.check @@ -1,7 +1,7 @@ -t7473.scala:5: error: for comprehension must start with generator: '<-' expected but '=' found. - for (x = Option(i); if x == j) yield 42 //t7473.scala:4: error: '<-' expected but '=' found. - ^ -t7473.scala:8: error: for comprehension must start with generator: '<-' expected but '=' found. +t7473.scala:6: error: '<-' expected but '=' found. (for (x = Option(i); if x == j) yield 42) toList ^ +t7473.scala:6: error: illegal start of simple expression + (for (x = Option(i); if x == j) yield 42) toList + ^ two errors found diff --git a/test/files/neg/t7473.scala b/test/files/neg/t7473.scala index 1eb9e6cb7a..593231d5f2 100644 --- a/test/files/neg/t7473.scala +++ b/test/files/neg/t7473.scala @@ -1,9 +1,7 @@ object Foo { val i,j = 3 - - for (x = Option(i); if x == j) yield 42 //t7473.scala:4: error: '<-' expected but '=' found. - + //for (x = Option(i); if x == j) yield 42 //t7473.scala:4: error: '<-' expected but '=' found. // evil postfix! (for (x = Option(i); if x == j) yield 42) toList } diff --git a/test/files/neg/t771.check b/test/files/neg/t771.check index 51b0c97f8c..c0d1e002f8 100644 --- a/test/files/neg/t771.check +++ b/test/files/neg/t771.check @@ -1,4 +1,4 @@ t771.scala:4: error: trait Iterator is abstract; cannot be instantiated def c[A](it:java.util.Iterator[A]) = new scala.Iterator[A] - ^ + ^ one error found diff --git a/test/files/pos/t7854.scala b/test/files/pos/t7854.scala deleted file mode 100644 index d4de7dfe38..0000000000 --- a/test/files/pos/t7854.scala +++ /dev/null @@ -1,5 +0,0 @@ -class A { - var f: Int => Unit = _ => () - - f = null -} diff --git a/test/files/run/existential-rangepos.check b/test/files/run/existential-rangepos.check index f426c6471f..1212b60bae 100644 --- a/test/files/run/existential-rangepos.check +++ b/test/files/run/existential-rangepos.check @@ -1,13 +1,13 @@ [[syntax trees at end of patmat]] // newSource1.scala [0:76]package [0:0]<empty> { - [15/0:76]abstract class A[[17:18]T[17:18]] extends [20:76][76]scala.AnyRef { + [0:76]abstract class A[[17:18]T[17:18]] extends [20:76][76]scala.AnyRef { [76]def <init>(): [20]A[T] = [76]{ [76][76][76]A.super.<init>(); [20]() }; - [28:51]private[this] val foo: [28]Set[_ <: T] = [47:51]null; + [24:51]private[this] val foo: [28]Set[_ <: T] = [47:51]null; [28]<stable> <accessor> def foo: [28]Set[_ <: T] = [28][28]A.this.foo; - [58:74]<stable> <accessor> def bar: [58]Set[_ <: T] + [54:74]<stable> <accessor> def bar: [58]Set[_ <: T] } } diff --git a/test/files/run/t5064.check b/test/files/run/t5064.check index 7b92e40c35..61ccfd16e7 100644 --- a/test/files/run/t5064.check +++ b/test/files/run/t5064.check @@ -1,19 +1,19 @@ [53] T5064.super.<init>() [53] T5064.super.<init> [53] this -[20/16:23] immutable.this.List.apply(scala.this.Predef.wrapIntArray(Array[Int]{1})) +[16:23] immutable.this.List.apply(scala.this.Predef.wrapIntArray(Array[Int]{1})) [16:20] immutable.this.List.apply <16:20> immutable.this.List <16:20> immutable.this -[20/16:23] scala.this.Predef.wrapIntArray(Array[Int]{1}) +[16:23] scala.this.Predef.wrapIntArray(Array[Int]{1}) [20] scala.this.Predef.wrapIntArray [20] scala.this.Predef [20] scala.this -[29/26:32] collection.this.Seq.apply(scala.this.Predef.wrapIntArray(Array[Int]{1})) +[26:32] collection.this.Seq.apply(scala.this.Predef.wrapIntArray(Array[Int]{1})) [26:29] collection.this.Seq.apply <26:29> collection.this.Seq <26:29> collection.this -[29/26:32] scala.this.Predef.wrapIntArray(Array[Int]{1}) +[26:32] scala.this.Predef.wrapIntArray(Array[Int]{1}) [29] scala.this.Predef.wrapIntArray [29] scala.this.Predef [29] scala.this diff --git a/test/files/run/t5385.check b/test/files/run/t5385.check index f56464facd..1df74fcfb5 100644 --- a/test/files/run/t5385.check +++ b/test/files/run/t5385.check @@ -1,8 +1,8 @@ -[6/0:9] class Azz -[6/0:9] class Bzz -[6/0:9] class Czz -[6/0:9] class Dzz -[6/0:11] class Ezz -[6/0:11] class Fzz -[6/0:13] class Gzz -[6/0:13] class Hzz +[0:9] class Azz +[0:9] class Bzz +[0:9] class Czz +[0:9] class Dzz +[0:11] class Ezz +[0:11] class Fzz +[0:13] class Gzz +[0:13] class Hzz diff --git a/test/files/run/t5603.check b/test/files/run/t5603.check index 46fcdd4470..188f39ff82 100644 --- a/test/files/run/t5603.check +++ b/test/files/run/t5603.check @@ -1,29 +1,29 @@ [[syntax trees at end of parser]] // newSource1.scala [0:241]package [0:0]<empty> { - [6/0:82]abstract trait Greeting extends [15:82][83]scala.AnyRef { + [0:82]abstract trait Greeting extends [15:82][83]scala.AnyRef { [15]def $init$() = [15]{ [15]() }; - [27:39]val name: [33:39]String; - [50:76]val msg = [71/56:76][71/56:72][56:71]"How are you, ".$plus([72:76]name) + [23:39]val name: [33:39]String; + [46:76]val msg = [56:76][56:72][56:71]"How are you, ".$plus([72:76]name) }; - [93/87:209]class C extends [94:209][151:159]Greeting { - [123:139]val nameElse = _; + [87:209]class C extends [94:209][151:159]Greeting { + [119:139]val nameElse = _; [95:101]<paramaccessor> private[this] val i: [98:101]Int = _; - <123:139>def <init>([95]i: [98]Int) = <123:139>{ - <123:139>val nameElse = <134:139>"Bob"; - [X][X][X]super.<init>(); + <119:139>def <init>([95]i: [98]Int) = <119:139>{ + <119:139>val nameElse = <134:139>"Bob"; + [NoPosition][NoPosition][NoPosition]super.<init>(); [94]() }; - [172:184]val name = [179:184]"avc"; - [198/191:203][191:198]println([199:202]msg) + [168:184]val name = [179:184]"avc"; + [191:203][191:198]println([199:202]msg) }; - [222/215:241]object Test extends [227:241][235:238]App { + [215:241]object Test extends [227:241][235:238]App { [227]def <init>() = [227]{ - [X][X][X]super.<init>(); + [NoPosition][NoPosition][NoPosition]super.<init>(); [227]() }; - [X]<empty> + [NoPosition]<empty> } } diff --git a/test/files/run/t6288.check b/test/files/run/t6288.check index 0da03c0439..a032a10de6 100644 --- a/test/files/run/t6288.check +++ b/test/files/run/t6288.check @@ -18,7 +18,7 @@ [64]case6(){ [64][64]matchEnd4([64]throw [64][64][64]new [64]MatchError([64]x1)) }; - [64]matchEnd4(x: [X]Unit){ + [64]matchEnd4(x: [NoPosition]Unit){ [64]x } } @@ -44,7 +44,7 @@ [175]case6(){ [175][175]matchEnd4([175]throw [175][175][175]new [175]MatchError([175]x1)) }; - [175]matchEnd4(x: [X]Unit){ + [175]matchEnd4(x: [NoPosition]Unit){ [175]x } } @@ -70,7 +70,7 @@ [273]case6(){ [273][273]matchEnd4([273]throw [273][273][273]new [273]MatchError([273]x1)) }; - [273]matchEnd4(x: [X]Unit){ + [273]matchEnd4(x: [NoPosition]Unit){ [273]x } } diff --git a/test/files/run/t6768.check b/test/files/run/t6768.check deleted file mode 100644 index 64df4568ec..0000000000 --- a/test/files/run/t6768.check +++ /dev/null @@ -1,12 +0,0 @@ -[[syntax trees at end of typer]] // newSource1.scala -[1:58]package [1:1]<empty> { - [7/1:58]class A extends [9:58][58]scala.AnyRef { - [58]def <init>(): [9]A = [58]{ - [58][58][58]A.super.<init>(); - [9]() - }; - [17/13:31]def f1: [17]Some[String] = [26/22:31][22:26][22:26]scala.Some.apply[[22]String]([27:30]"a"); - [38/34:56]def f2: [38]Some[String] = [47/43:56][47:51][47:51]new [47:51]<type: [47:51]scala.Some>([52:55]"b") - } -} - diff --git a/test/files/run/t6768.scala b/test/files/run/t6768.scala deleted file mode 100644 index 11470a0ef8..0000000000 --- a/test/files/run/t6768.scala +++ /dev/null @@ -1,12 +0,0 @@ -import scala.tools.partest._ - -object Test extends DirectTest { - override def extraSettings: String = "-usejavacp -Xprint:typer -Yrangepos -Xprint-pos -d " + testOutput.path - override def show() = Console.withErr(System.out)(compile()) - - override def code = """ -class A { - def f1 = Some("a") - def f2 = new Some("b") -}""" -} diff --git a/test/files/run/t7271.check b/test/files/run/t7271.check index 86b5230fd7..f7a23018ca 100644 --- a/test/files/run/t7271.check +++ b/test/files/run/t7271.check @@ -2,7 +2,7 @@ [6]package [6]<empty> { [6]class C extends [8][91]scala.AnyRef { [8]def <init>() = [8]{ - [X][X][X]super.<init>(); + [NoPosition][NoPosition][NoPosition]super.<init>(); [8]() }; [20]def quote = [28][28][28][28]StringContext([30]"foo", [40]"baz").s([35]this); |