From 6d7bcd5818b856d4596b57b7e9f1543b71ed7329 Mon Sep 17 00:00:00 2001 From: Paul Phillips Date: Tue, 20 Mar 2012 14:23:40 -0700 Subject: Lots of tedious warning and tree printing work. Fewer deprecation warnings, prettier trees, prettier symbols, more polished error messages. Oh the interesting people you meet handling warnings, I feel sorry for you all that I get to do it all the time. One of the characters I met invited me into the "Dead Code Society" and that's what I'm doing on Tuesdays now. No of course you haven't, it's a SECRET society. --- .../scala/reflect/internal/Definitions.scala | 18 +++- src/compiler/scala/reflect/internal/Kinds.scala | 23 +++-- src/compiler/scala/reflect/internal/Symbols.scala | 57 +++++------ src/compiler/scala/reflect/internal/Types.scala | 23 +++-- src/compiler/scala/reflect/runtime/ToolBoxes.scala | 4 +- .../scala/tools/nsc/ast/NodePrinters.scala | 90 +++++++++++++----- .../backend/icode/analysis/TypeFlowAnalysis.scala | 2 +- .../scala/tools/nsc/backend/opt/Inliners.scala | 2 +- .../tools/nsc/reporters/ConsoleReporter.scala | 4 +- .../scala/tools/nsc/symtab/clr/TypeParser.scala | 24 ++--- .../scala/tools/nsc/transform/UnCurry.scala | 2 +- .../tools/nsc/typechecker/ContextErrors.scala | 2 +- .../scala/tools/nsc/typechecker/RefChecks.scala | 2 +- .../tools/nsc/typechecker/SyntheticMethods.scala | 2 +- src/library/scala/Specializable.scala | 12 +-- .../scala/collection/GenTraversableOnce.scala | 2 +- .../collection/mutable/ConcurrentTrieMap.scala | 2 +- src/library/scala/concurrent/DelayedLazyVal.scala | 3 +- src/library/scala/reflect/api/Trees.scala | 3 +- src/library/scala/xml/Elem.scala | 8 +- src/library/scala/xml/XML.scala | 17 ++-- test/files/neg/t1364.check | 2 +- test/files/neg/t1477.check | 2 +- test/files/neg/t2070.check | 3 +- test/files/neg/t4044.check | 9 +- test/files/neg/t5152.check | 6 +- test/files/neg/t708.check | 2 +- test/files/neg/t742.check | 3 +- test/files/neg/tcpoly_override.check | 3 +- test/files/neg/tcpoly_typealias.check | 9 +- test/files/neg/tcpoly_variance_enforce.check | 34 ++++--- test/files/run/existentials-in-compiler.check | 104 ++++++++++----------- test/files/run/reify_ann1a.check | 4 +- test/files/run/reify_ann1b.check | 4 +- 34 files changed, 286 insertions(+), 201 deletions(-) diff --git a/src/compiler/scala/reflect/internal/Definitions.scala b/src/compiler/scala/reflect/internal/Definitions.scala index bd823c3128..a2dd6fc4c3 100644 --- a/src/compiler/scala/reflect/internal/Definitions.scala +++ b/src/compiler/scala/reflect/internal/Definitions.scala @@ -764,9 +764,25 @@ trait Definitions extends reflect.api.StandardDefinitions { else removeRedundantObjects(parents) } + + def typeStringNoPackage(tp: Type) = + "" + tp stripPrefix tp.typeSymbol.enclosingPackage.fullName + "." + + def briefParentsString(parents: List[Type]) = + normalizedParents(parents) map typeStringNoPackage mkString " with " + def parentsString(parents: List[Type]) = normalizedParents(parents) mkString " with " + def typeParamsString(tp: Type) = tp match { + case PolyType(tparams, _) => tparams map (_.defString) mkString ("[", ",", "]") + case _ => "" + } + def valueParamsString(tp: Type) = tp match { + case MethodType(params, _) => params map (_.defString) mkString ("(", ",", ")") + case _ => "" + } + // members of class java.lang.{ Object, String } lazy val Object_## = enterNewMethod(ObjectClass, nme.HASHHASH, Nil, inttype, FINAL) lazy val Object_== = enterNewMethod(ObjectClass, nme.EQ, anyrefparam, booltype, FINAL) @@ -970,7 +986,7 @@ trait Definitions extends reflect.api.StandardDefinitions { case (_, restpe) => NullaryMethodType(restpe) } - msym setInfoAndEnter polyType(tparams, mtpe) + msym setInfoAndEnter genPolyType(tparams, mtpe) } /** T1 means one type parameter. diff --git a/src/compiler/scala/reflect/internal/Kinds.scala b/src/compiler/scala/reflect/internal/Kinds.scala index 23bff950b8..eca63c7c15 100644 --- a/src/compiler/scala/reflect/internal/Kinds.scala +++ b/src/compiler/scala/reflect/internal/Kinds.scala @@ -49,9 +49,15 @@ trait Kinds { private def kindMessage(a: Symbol, p: Symbol)(f: (String, String) => String): String = f(a+qualify(a,p), p+qualify(p,a)) + // Normally it's nicer to print nothing rather than '>: Nothing <: Any' all over + // the place, but here we need it for the message to make sense. private def strictnessMessage(a: Symbol, p: Symbol) = - kindMessage(a, p)("%s's bounds %s are stricter than %s's declared bounds %s".format( - _, a.info, _, p.info)) + kindMessage(a, p)("%s's bounds%s are stricter than %s's declared bounds%s".format( + _, a.info, _, p.info match { + case tb @ TypeBounds(_, _) if tb.isEmptyBounds => " >: Nothing <: Any" + case tb => "" + tb + }) + ) private def varianceMessage(a: Symbol, p: Symbol) = kindMessage(a, p)("%s is %s, but %s is declared %s".format(_, varStr(a), _, varStr(p))) @@ -62,11 +68,16 @@ trait Kinds { _, countAsString(p.typeParams.length)) ) + private def buildMessage(xs: List[SymPair], f: (Symbol, Symbol) => String) = ( + if (xs.isEmpty) "" + else xs map f.tupled mkString ("\n", ", ", "") + ) + def errorMessage(targ: Type, tparam: Symbol): String = ( - (targ+"'s type parameters do not match "+tparam+"'s expected parameters: ") - + (arity map { case (a, p) => arityMessage(a, p) } mkString ", ") - + (variance map { case (a, p) => varianceMessage(a, p) } mkString ", ") - + (strictness map { case (a, p) => strictnessMessage(a, p) } mkString ", ") + (targ+"'s type parameters do not match "+tparam+"'s expected parameters:") + + buildMessage(arity, arityMessage) + + buildMessage(variance, varianceMessage) + + buildMessage(strictness, strictnessMessage) ) } val NoKindErrors = KindErrors(Nil, Nil, Nil) diff --git a/src/compiler/scala/reflect/internal/Symbols.scala b/src/compiler/scala/reflect/internal/Symbols.scala index 907f7d1237..2ba45c5972 100644 --- a/src/compiler/scala/reflect/internal/Symbols.scala +++ b/src/compiler/scala/reflect/internal/Symbols.scala @@ -2078,47 +2078,32 @@ trait Symbols extends api.Symbols { self: SymbolTable => case s => " in " + s } def fullLocationString: String = toString + locationString - def signatureString: String = if (hasRawInfo) infoString(rawInfo) else "<_>" + def signatureString: String = if (hasRawInfo) infoString(rawInfo) else "<_>" /** String representation of symbol's definition following its name */ final def infoString(tp: Type): String = { - def typeParamsString: String = tp match { - case PolyType(tparams, _) if tparams.nonEmpty => - (tparams map (_.defString)).mkString("[", ",", "]") - case _ => - "" - } - if (isClass) - typeParamsString + " extends " + tp.resultType - else if (isAliasType) - typeParamsString + " = " + tp.resultType - else if (isAbstractType) - typeParamsString + { - tp.resultType match { - case TypeBounds(lo, hi) => - (if (lo.typeSymbol == NothingClass) "" else " >: " + lo) + - (if (hi.typeSymbol == AnyClass) "" else " <: " + hi) - case rtp => - "<: " + rtp - } - } - else if (isModule) - moduleClass.infoString(tp) - else - tp match { - case PolyType(tparams, res) => - typeParamsString + infoString(res) - case NullaryMethodType(res) => - infoString(res) - case MethodType(params, res) => - params.map(_.defString).mkString("(", ",", ")") + infoString(res) - case _ => - ": " + tp + def parents = ( + if (settings.debug.value) parentsString(tp.parents) + else briefParentsString(tp.parents) + ) + if (isType) typeParamsString(tp) + ( + if (isClass) " extends " + parents + else if (isAliasType) " = " + tp.resultType + else tp.resultType match { + case rt @ TypeBounds(_, _) => "" + rt + case rt => " <: " + rt } + ) + else if (isModule) moduleClass.infoString(tp) + else tp match { + case PolyType(tparams, res) => typeParamsString(tp) + infoString(res) + case NullaryMethodType(res) => infoString(res) + case MethodType(params, res) => valueParamsString(tp) + infoString(res) + case _ => ": " + tp + } } - def infosString = infos.toString() - + def infosString = infos.toString def debugLocationString = fullLocationString + " " + debugFlagString def debugFlagString = hasFlagsToString(-1L) def hasFlagsToString(mask: Long): String = flagsToString( @@ -2684,7 +2669,7 @@ trait Symbols extends api.Symbols { self: SymbolTable => override def rawInfo: Type = NoType protected def doCookJavaRawInfo() {} override def accessBoundary(base: Symbol): Symbol = RootClass - def cloneSymbolImpl(owner: Symbol, newFlags: Long): Symbol = abort() + def cloneSymbolImpl(owner: Symbol, newFlags: Long): Symbol = abort("NoSymbol.clone()") override def originalEnclosingMethod = this override def owner: Symbol = diff --git a/src/compiler/scala/reflect/internal/Types.scala b/src/compiler/scala/reflect/internal/Types.scala index 2bb19e2b65..a20853adc8 100644 --- a/src/compiler/scala/reflect/internal/Types.scala +++ b/src/compiler/scala/reflect/internal/Types.scala @@ -1337,9 +1337,14 @@ trait Types extends api.Types { self: SymbolTable => case TypeBounds(_, _) => that <:< this case _ => lo <:< that && that <:< hi } - def isEmptyBounds = (lo.typeSymbolDirect eq NothingClass) && (hi.typeSymbolDirect eq AnyClass) + private def lowerString = if (emptyLowerBound) "" else " >: " + lo + private def upperString = if (emptyUpperBound) "" else " <: " + hi + private def emptyLowerBound = lo.typeSymbolDirect eq NothingClass + private def emptyUpperBound = hi.typeSymbolDirect eq AnyClass + def isEmptyBounds = emptyLowerBound && emptyUpperBound + // override def isNullable: Boolean = NullClass.tpe <:< lo; - override def safeToString = ">: " + lo + " <: " + hi + override def safeToString = lowerString + upperString override def kind = "TypeBoundsType" } @@ -3321,16 +3326,18 @@ trait Types extends api.Types { self: SymbolTable => * may or may not be poly? (It filched the standard "canonical creator" name.) */ object GenPolyType { - def apply(tparams: List[Symbol], tpe: Type): Type = - if (tparams nonEmpty) typeFun(tparams, tpe) - else tpe // it's okay to be forgiving here + def apply(tparams: List[Symbol], tpe: Type): Type = ( + if (tparams nonEmpty) typeFun(tparams, tpe) + else tpe // it's okay to be forgiving here + ) def unapply(tpe: Type): Option[(List[Symbol], Type)] = tpe match { - case PolyType(tparams, restpe) => Some(tparams, restpe) - case _ => Some(List(), tpe) + case PolyType(tparams, restpe) => Some((tparams, restpe)) + case _ => Some((Nil, tpe)) } } + def genPolyType(params: List[Symbol], tpe: Type): Type = GenPolyType(params, tpe) - @deprecated("use GenPolyType(...) instead") + @deprecated("use genPolyType(...) instead", "2.10.0") def polyType(params: List[Symbol], tpe: Type): Type = GenPolyType(params, tpe) /** A creator for anonymous type functions, where the symbol for the type function still needs to be created. diff --git a/src/compiler/scala/reflect/runtime/ToolBoxes.scala b/src/compiler/scala/reflect/runtime/ToolBoxes.scala index 8cc4d5f788..28f12b378f 100644 --- a/src/compiler/scala/reflect/runtime/ToolBoxes.scala +++ b/src/compiler/scala/reflect/runtime/ToolBoxes.scala @@ -1,6 +1,7 @@ package scala.reflect package runtime +import scala.tools.nsc import scala.tools.nsc.reporters.Reporter import scala.tools.nsc.reporters.StoreReporter import scala.tools.nsc.reporters.AbstractReporter @@ -21,8 +22,7 @@ trait ToolBoxes extends { self: Universe => class ToolBox(val reporter: Reporter = new StoreReporter, val options: String = "") { - class ToolBoxGlobal(settings: scala.tools.nsc.Settings, reporter: scala.tools.nsc.reporters.Reporter) - extends ReflectGlobal(settings, reporter) { + class ToolBoxGlobal(settings0: nsc.Settings, reporter0: nsc.reporters.Reporter) extends ReflectGlobal(settings0, reporter0) { import definitions._ private val trace = scala.tools.nsc.util.trace when settings.debug.value diff --git a/src/compiler/scala/tools/nsc/ast/NodePrinters.scala b/src/compiler/scala/tools/nsc/ast/NodePrinters.scala index 07e864879d..acbdcd501f 100644 --- a/src/compiler/scala/tools/nsc/ast/NodePrinters.scala +++ b/src/compiler/scala/tools/nsc/ast/NodePrinters.scala @@ -65,7 +65,7 @@ abstract class NodePrinters { def showDefTreeName(tree: DefTree) = showName(tree.name) def showFlags(tree: MemberDef) = flagsToString(tree.symbol.flags | tree.mods.flags) def showLiteral(lit: Literal) = lit.value.escapedStringValue - def showTypeTree(tt: TypeTree) = "" + showAttributes(tt) + def showTypeTree(tt: TypeTree) = "" + emptyOrComment(showType(tt)) def showName(name: Name) = name match { case nme.EMPTY | tpnme.EMPTY => "" case name => "\"" + name + "\"" @@ -74,18 +74,18 @@ abstract class NodePrinters { def showSymbol(tree: Tree): String = { val sym = tree.symbol if (sym == null || sym == NoSymbol) "" - else " sym/owner/tpe=%s %s/%s/%s".format(sym.accurateKindString, sym.name, sym.owner, sym.tpe) + else sym.defString + sym.locationString } def showType(tree: Tree): String = { val tpe = tree.tpe if (tpe == null || tpe == NoType) "" - else " tree.tpe=" + tpe + else "tree.tpe=" + tpe } def showAttributes(tree: Tree): String = { if (infolevel == InfoLevel.Quiet) "" else { - try { showSymbol(tree) + showType(tree) trim } + try { List(showSymbol(tree), showType(tree)) filterNot (_ == "") mkString ", " trim } catch { case ex: Throwable => "sym= " + ex.getMessage } } } @@ -115,13 +115,11 @@ abstract class NodePrinters { case Select(_, _) => prefix0 + "." case _ => "" }) - def attrs = showAttributes(tree) match { - case "" => "" - case s => " // " + s - } - prefix + showName(tree.name) + attrs + prefix + showName(tree.name) + emptyOrComment(showAttributes(tree)) } + def emptyOrComment(s: String) = if (s == "") "" else " // " + s + def stringify(tree: Tree): String = { buf.clear() level = 0 @@ -141,7 +139,10 @@ abstract class NodePrinters { buf append " " * level buf append value if (comment != "") { - buf append " // " + if (value != "") + buf append " " + + buf append "// " buf append comment } buf append EOL @@ -179,7 +180,7 @@ abstract class NodePrinters { def applyCommon(tree: Tree, fun: Tree, args: List[Tree]) { printMultiline(tree) { traverse(fun) - traverseList("Nil", _ + " arguments(s)")(args) + traverseList("Nil", "argument")(args) } } @@ -191,17 +192,26 @@ abstract class NodePrinters { indent(body) println(")") } + @inline private def indent[T](body: => T): T = { level += 1 try body finally level -= 1 } - def traverseList(ifEmpty: String, comment: Int => String)(trees: List[Tree]) { + def traverseList(ifEmpty: String, what: String)(trees: List[Tree]) { if (trees.isEmpty) println(ifEmpty) - else - printMultiline("List", comment(trees.length))(trees foreach traverse) + else if (trees.tail.isEmpty) + traverse(trees.head) + else { + printLine("", trees.length + " " + what + "s") + trees foreach traverse + } + } + + def printSingle(tree: Tree, name: Name) { + println(tree.printingPrefix + "(" + showName(name) + ")" + showAttributes(tree)) } def traverse(tree: Tree) { @@ -210,16 +220,44 @@ abstract class NodePrinters { case ApplyDynamic(fun, args) => applyCommon(tree, fun, args) case Apply(fun, args) => applyCommon(tree, fun, args) + case Throw(Ident(name)) => + printSingle(tree, name) + + case Function(vparams, body) => + printMultiline(tree) { + traverseList("()", "parameter")(vparams) + traverse(body) + } + case Try(block, catches, finalizer) => + printMultiline(tree) { + traverse(block) + traverseList("{}", "case")(catches) + if (finalizer ne EmptyTree) + traverse(finalizer) + } + + case Match(selector, cases) => + printMultiline(tree) { + traverse(selector) + traverseList("", "case")(cases) + } + case CaseDef(pat, guard, body) => + printMultiline(tree) { + traverse(pat) + if (guard ne EmptyTree) + traverse(guard) + traverse(body) + } case Block(stats, expr) => printMultiline(tree) { - traverseList("{}", _ + " statement(s)")(stats) + traverseList("{}", "statement")(stats) traverse(expr) } case cd @ ClassDef(mods, name, tparams, impl) => printMultiline(tree) { printModifiers(cd) println(showDefTreeName(cd)) - traverseList("[]", _ + " type parameter(s)")(tparams) + traverseList("[]", "type parameter")(tparams) traverse(impl) } case md @ ModuleDef(mods, name, impl) => @@ -232,14 +270,16 @@ abstract class NodePrinters { printMultiline(tree) { printModifiers(dd) println(showDefTreeName(dd)) - traverseList("[]", _ + " type parameter(s)")(tparams) + traverseList("[]", "type parameter")(tparams) vparamss match { case Nil => println("Nil") case Nil :: Nil => println("List(Nil)") - case xss => - printMultiline("List", xss.length + " parameter list(s)") { - xss foreach (xs => traverseList("()", _ + " parameter(s)")(xs)) - } + case ps :: Nil => + printLine("", "1 parameter list") + ps foreach traverse + case pss => + printLine("", pss.length + " parameter lists") + pss foreach (ps => traverseList("()", "parameter")(ps)) } traverse(tpt) traverse(rhs) @@ -268,14 +308,14 @@ abstract class NodePrinters { } printLine(ps0 mkString ", ", "parents") traverse(self) - traverseList("{}", _ + " statements in body")(body) + traverseList("{}", "statement")(body) } case This(qual) => - println("This(\"" + showName(qual) + "\")" + showAttributes(tree)) + printSingle(tree, qual) case TypeApply(fun, args) => printMultiline(tree) { traverse(fun) - traverseList("[]", _ + " type argument(s)")(args) + traverseList("[]", "type argument")(args) } case tt @ TypeTree() => println(showTypeTree(tt)) @@ -296,7 +336,7 @@ abstract class NodePrinters { printMultiline(tree) { printModifiers(td) println(showDefTreeName(td)) - traverseList("[]", _ + " type parameter(s)")(tparams) + traverseList("[]", "type parameter")(tparams) traverse(rhs) } diff --git a/src/compiler/scala/tools/nsc/backend/icode/analysis/TypeFlowAnalysis.scala b/src/compiler/scala/tools/nsc/backend/icode/analysis/TypeFlowAnalysis.scala index 877c51ebc1..d31eafff48 100644 --- a/src/compiler/scala/tools/nsc/backend/icode/analysis/TypeFlowAnalysis.scala +++ b/src/compiler/scala/tools/nsc/backend/icode/analysis/TypeFlowAnalysis.scala @@ -645,7 +645,7 @@ abstract class TypeFlowAnalysis { } while(!done) lastInstruction.clear() - for(b <- isOnPerimeter; val lastIns = b.toList.reverse find isOnWatchlist) { + for (b <- isOnPerimeter; lastIns = b.toList.reverse find isOnWatchlist) { lastInstruction += (b -> lastIns.get.asInstanceOf[opcodes.CALL_METHOD]) } diff --git a/src/compiler/scala/tools/nsc/backend/opt/Inliners.scala b/src/compiler/scala/tools/nsc/backend/opt/Inliners.scala index a734b2b92b..dfe9081ee5 100644 --- a/src/compiler/scala/tools/nsc/backend/opt/Inliners.scala +++ b/src/compiler/scala/tools/nsc/backend/opt/Inliners.scala @@ -262,7 +262,7 @@ abstract class Inliners extends SubComponent { def inlineWithoutTFA(inputBlocks: Traversable[BasicBlock], callsites: Function1[BasicBlock, List[opcodes.CALL_METHOD]]): Int = { var inlineCount = 0 import scala.util.control.Breaks._ - for(x <- inputBlocks; val easyCake = callsites(x); if easyCake.nonEmpty) { + for(x <- inputBlocks; easyCake = callsites(x); if easyCake.nonEmpty) { breakable { for(ocm <- easyCake) { assert(ocm.method.isEffectivelyFinal && ocm.method.owner.isEffectivelyFinal) diff --git a/src/compiler/scala/tools/nsc/reporters/ConsoleReporter.scala b/src/compiler/scala/tools/nsc/reporters/ConsoleReporter.scala index c76a04c6ba..f5335fb0f5 100644 --- a/src/compiler/scala/tools/nsc/reporters/ConsoleReporter.scala +++ b/src/compiler/scala/tools/nsc/reporters/ConsoleReporter.scala @@ -8,7 +8,7 @@ package reporters import java.io.{ BufferedReader, IOException, PrintWriter } import util._ -import scala.tools.util.StringOps.countElementsAsString +import scala.tools.util.StringOps /** * This class implements a Reporter that displays messages on a text @@ -40,7 +40,7 @@ class ConsoleReporter(val settings: Settings, reader: BufferedReader, writer: Pr * @return ... */ private def getCountString(severity: Severity): String = - countElementsAsString((severity).count, label(severity)) + StringOps.countElementsAsString((severity).count, label(severity)) /** Prints the message. */ def printMessage(msg: String) { writer.print(msg + "\n"); writer.flush() } diff --git a/src/compiler/scala/tools/nsc/symtab/clr/TypeParser.scala b/src/compiler/scala/tools/nsc/symtab/clr/TypeParser.scala index e11a5a4ad9..4b847fa94a 100644 --- a/src/compiler/scala/tools/nsc/symtab/clr/TypeParser.scala +++ b/src/compiler/scala/tools/nsc/symtab/clr/TypeParser.scala @@ -108,7 +108,7 @@ abstract class TypeParser { val method = new ConstructorInfo(declType, attrs, Array[MSILType]()) val flags = Flags.JAVA val owner = clazz - val methodSym = owner.newMethod(NoPosition, nme.CONSTRUCTOR).setFlag(flags) + val methodSym = owner.newMethod(nme.CONSTRUCTOR, NoPosition, flags) val rettype = clazz.tpe val mtype = methodType(Array[MSILType](), rettype); val mInfo = mtype(methodSym) @@ -224,14 +224,14 @@ abstract class TypeParser { if (canBeTakenAddressOf) { clazzBoxed.setInfo( if (ownTypeParams.isEmpty) classInfoAsInMetadata - else polyType(ownTypeParams, classInfoAsInMetadata) ) + else genPolyType(ownTypeParams, classInfoAsInMetadata) ) clazzBoxed.setFlag(flags) val rawValueInfoType = ClassInfoType(definitions.anyvalparam, instanceDefs, clazz) clazz.setInfo( if (ownTypeParams.isEmpty) rawValueInfoType - else polyType(ownTypeParams, rawValueInfoType) ) + else genPolyType(ownTypeParams, rawValueInfoType) ) } else { clazz.setInfo( if (ownTypeParams.isEmpty) classInfoAsInMetadata - else polyType(ownTypeParams, classInfoAsInMetadata) ) + else genPolyType(ownTypeParams, classInfoAsInMetadata) ) } // TODO I don't remember if statics.setInfo and staticModule.setInfo should also know about type params @@ -284,7 +284,7 @@ abstract class TypeParser { else getCLRType(field.FieldType) val owner = if (field.IsStatic()) statics else clazz; - val sym = owner.newValue(NoPosition, name).setFlag(flags).setInfo(fieldType); + val sym = owner.newValue(name, NoPosition, flags).setInfo(fieldType); // TODO: set private within!!! -> look at typechecker/Namers.scala (if (field.IsStatic()) staticDefs else instanceDefs).enter(sym); clrTypes.fields(sym) = field; @@ -313,7 +313,7 @@ abstract class TypeParser { val name: Name = if (gparamsLength == 0) prop.Name else nme.apply; val flags = translateAttributes(getter); val owner: Symbol = if (getter.IsStatic) statics else clazz; - val methodSym = owner.newMethod(NoPosition, name).setFlag(flags) + val methodSym = owner.newMethod(name, NoPosition, flags) val mtype: Type = if (gparamsLength == 0) NullaryMethodType(propType) // .NET properties can't be polymorphic else methodType(getter, getter.ReturnType)(methodSym) methodSym.setInfo(mtype); @@ -337,7 +337,7 @@ abstract class TypeParser { val flags = translateAttributes(setter); val mtype = methodType(setter, definitions.UnitClass.tpe); val owner: Symbol = if (setter.IsStatic) statics else clazz; - val methodSym = owner.newMethod(NoPosition, name).setFlag(flags) + val methodSym = owner.newMethod(name, NoPosition, flags) methodSym.setInfo(mtype(methodSym)) methodSym.setFlag(Flags.ACCESSOR); (if (setter.IsStatic) staticDefs else instanceDefs).enter(methodSym); @@ -424,14 +424,14 @@ abstract class TypeParser { val flags = Flags.JAVA | Flags.FINAL for (cmpName <- ENUM_CMP_NAMES) { - val enumCmp = clazz.newMethod(NoPosition, cmpName) + val enumCmp = clazz.newMethod(cmpName) val enumCmpType = JavaMethodType(enumCmp.newSyntheticValueParams(List(clazz.tpe)), definitions.BooleanClass.tpe) enumCmp.setFlag(flags).setInfo(enumCmpType) instanceDefs.enter(enumCmp) } for (bitLogName <- ENUM_BIT_LOG_NAMES) { - val enumBitLog = clazz.newMethod(NoPosition, bitLogName) + val enumBitLog = clazz.newMethod(bitLogName) val enumBitLogType = JavaMethodType(enumBitLog.newSyntheticValueParams(List(clazz.tpe)), clazz.tpe /* was classInfo, infinite typer */) enumBitLog.setFlag(flags).setInfo(enumBitLogType) instanceDefs.enter(enumBitLog) @@ -469,7 +469,7 @@ abstract class TypeParser { val flags = translateAttributes(method); val owner = if (method.IsStatic()) statics else clazz; - val methodSym = owner.newMethod(NoPosition, getName(method)).setFlag(flags) + val methodSym = owner.newMethod(getName(method), NoPosition, flags) /* START CLR generics (snippet 3) */ val newMethodTParams = populateMethodTParams(method, methodSym) /* END CLR generics (snippet 3) */ @@ -480,7 +480,7 @@ abstract class TypeParser { val mtype = methodType(method, rettype); if (mtype == null) return; /* START CLR generics (snippet 4) */ - val mInfo = if (method.IsGeneric) polyType(newMethodTParams, mtype(methodSym)) + val mInfo = if (method.IsGeneric) genPolyType(newMethodTParams, mtype(methodSym)) else mtype(methodSym) /* END CLR generics (snippet 4) */ /* START CLR non-generics (snippet 4) @@ -500,7 +500,7 @@ abstract class TypeParser { } private def createMethod(name: Name, flags: Long, mtype: Symbol => Type, method: MethodInfo, statik: Boolean): Symbol = { - val methodSym: Symbol = (if (statik) statics else clazz).newMethod(NoPosition, name) + val methodSym: Symbol = (if (statik) statics else clazz).newMethod(name) methodSym.setFlag(flags).setInfo(mtype(methodSym)) (if (statik) staticDefs else instanceDefs).enter(methodSym) if (method != null) diff --git a/src/compiler/scala/tools/nsc/transform/UnCurry.scala b/src/compiler/scala/tools/nsc/transform/UnCurry.scala index 03bef83a90..e54e0289bb 100644 --- a/src/compiler/scala/tools/nsc/transform/UnCurry.scala +++ b/src/compiler/scala/tools/nsc/transform/UnCurry.scala @@ -168,7 +168,7 @@ abstract class UnCurry extends InfoTransform private def nonLocalReturnTry(body: Tree, key: Symbol, meth: Symbol) = { localTyper typed { val extpe = nonLocalReturnExceptionType(meth.tpe.finalResultType) - val ex = meth.newValue(body.pos, nme.ex) setInfo extpe + val ex = meth.newValue(nme.ex, body.pos) setInfo extpe val pat = gen.mkBindForCase(ex, NonLocalReturnControlClass, List(meth.tpe.finalResultType)) val rhs = ( IF ((ex DOT nme.key)() OBJ_EQ Ident(key)) diff --git a/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala b/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala index ed9fee986f..e37f5784c9 100644 --- a/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala +++ b/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala @@ -684,7 +684,7 @@ trait ContextErrors { def errMsg = { val location = if (sym.isClassConstructor) owner0 else pre.widen - underlying(sym).fullLocationString + " cannot be accessed in " + + underlyingSymbol(sym).fullLocationString + " cannot be accessed in " + location + explanation } NormalTypeError(tree, errMsg, ErrorKinds.Access) diff --git a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala index ec42d251ff..fa19f380fd 100644 --- a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala +++ b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala @@ -266,7 +266,7 @@ abstract class RefChecks extends InfoTransform with reflect.internal.transform.R (if (showLocation) sym1.locationString + (if (sym1.isAliasType) ", which equals "+self.memberInfo(sym1) - else if (sym1.isAbstractType) " with bounds "+self.memberInfo(sym1) + else if (sym1.isAbstractType) " with bounds"+self.memberInfo(sym1) else if (sym1.isTerm) " of type "+self.memberInfo(sym1) else "") else "") diff --git a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala index 2f4eff30d2..da87d38ab0 100644 --- a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala +++ b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala @@ -136,7 +136,7 @@ trait SyntheticMethods extends ast.TreeDSL { * where that is the given methods first parameter. */ def thatTest(eqmeth: Symbol): Tree = - gen.mkIsInstanceOf(Ident(eqmeth.firstParam), typeCaseType(clazz), true, false) + gen.mkIsInstanceOf(Ident(eqmeth.firstParam), classExistentialType(clazz), true, false) /** (that.asInstanceOf[this.C]) * where that is the given methods first parameter. diff --git a/src/library/scala/Specializable.scala b/src/library/scala/Specializable.scala index 67126b3069..d5e22195d2 100644 --- a/src/library/scala/Specializable.scala +++ b/src/library/scala/Specializable.scala @@ -20,10 +20,10 @@ object Specializable { // Smuggle a list of types by way of a tuple upon which Group is parameterized. class Group[T >: Null](value: T) extends SpecializedGroup { } - final val Primitives = new Group(Byte, Short, Int, Long, Char, Float, Double, Boolean, Unit) - final val Everything = new Group(Byte, Short, Int, Long, Char, Float, Double, Boolean, Unit, AnyRef) - final val Bits32AndUp = new Group(Int, Long, Float, Double) - final val Integral = new Group(Byte, Short, Int, Long, Char) - final val AllNumeric = new Group(Byte, Short, Int, Long, Char, Float, Double) - final val BestOfBreed = new Group(Int, Double, Boolean, Unit, AnyRef) + final val Primitives = new Group((Byte, Short, Int, Long, Char, Float, Double, Boolean, Unit)) + final val Everything = new Group((Byte, Short, Int, Long, Char, Float, Double, Boolean, Unit, AnyRef)) + final val Bits32AndUp = new Group((Int, Long, Float, Double)) + final val Integral = new Group((Byte, Short, Int, Long, Char)) + final val AllNumeric = new Group((Byte, Short, Int, Long, Char, Float, Double)) + final val BestOfBreed = new Group((Int, Double, Boolean, Unit, AnyRef)) } diff --git a/src/library/scala/collection/GenTraversableOnce.scala b/src/library/scala/collection/GenTraversableOnce.scala index f18e2ab6bb..019d3d0785 100644 --- a/src/library/scala/collection/GenTraversableOnce.scala +++ b/src/library/scala/collection/GenTraversableOnce.scala @@ -124,7 +124,7 @@ trait GenTraversableOnce[+A] extends Any { * scala> val b = (a /:\ 5)(_+_) * b: Int = 15 * }}}*/ - @deprecated("use fold instead") + @deprecated("use fold instead", "2.10.0") def /:\[A1 >: A](z: A1)(op: (A1, A1) => A1): A1 = fold(z)(op) /** Applies a binary operator to a start value and all elements of this $coll, diff --git a/src/library/scala/collection/mutable/ConcurrentTrieMap.scala b/src/library/scala/collection/mutable/ConcurrentTrieMap.scala index 1a44c8e423..cfe1b1950d 100644 --- a/src/library/scala/collection/mutable/ConcurrentTrieMap.scala +++ b/src/library/scala/collection/mutable/ConcurrentTrieMap.scala @@ -1027,7 +1027,7 @@ private[collection] class ConcurrentTrieMapIterator[K, V](var level: Int, privat Seq(this) } - def printDebug { + def printDebug() { println("ctrie iterator") println(stackpos.mkString(",")) println("depth: " + depth) diff --git a/src/library/scala/concurrent/DelayedLazyVal.scala b/src/library/scala/concurrent/DelayedLazyVal.scala index a17153bad5..96a66d83b6 100644 --- a/src/library/scala/concurrent/DelayedLazyVal.scala +++ b/src/library/scala/concurrent/DelayedLazyVal.scala @@ -40,9 +40,8 @@ class DelayedLazyVal[T](f: () => T, body: => Unit) { def apply(): T = if (isDone) complete else f() // TODO replace with scala.concurrent.future { ... } - ops.future { + future { body _isDone = true } - } diff --git a/src/library/scala/reflect/api/Trees.scala b/src/library/scala/reflect/api/Trees.scala index a8276dc853..466c380cef 100644 --- a/src/library/scala/reflect/api/Trees.scala +++ b/src/library/scala/reflect/api/Trees.scala @@ -165,11 +165,12 @@ trait Trees { self: Universe => def foreach(f: Tree => Unit) { new ForeachTreeTraverser(f).traverse(this) } /** Find all subtrees matching predicate `p` */ - def filter(f: Tree => Boolean): List[Tree] = { + def withFilter(f: Tree => Boolean): List[Tree] = { val ft = new FilterTreeTraverser(f) ft.traverse(this) ft.hits.toList } + def filter(f: Tree => Boolean): List[Tree] = withFilter(f) /** Returns optionally first tree (in a preorder traversal) which satisfies predicate `p`, * or None if none exists. diff --git a/src/library/scala/xml/Elem.scala b/src/library/scala/xml/Elem.scala index cc244a5b88..5b6b9f2bb9 100755 --- a/src/library/scala/xml/Elem.scala +++ b/src/library/scala/xml/Elem.scala @@ -23,12 +23,12 @@ object Elem { * @deprecated This factory method is retained for backward compatibility; please use the other one, with which you * can specify your own preference for minimizeEmpty. */ - @deprecated - def apply(prefix: String,label: String, attributes: MetaData, scope: NamespaceBinding, child: Node*): Elem = + @deprecated("Use the other apply method in this object", "2.10.0") + def apply(prefix: String, label: String, attributes: MetaData, scope: NamespaceBinding, child: Node*): Elem = apply(prefix, label, attributes, scope, child.isEmpty, child: _*) - def apply(prefix: String,label: String, attributes: MetaData, scope: NamespaceBinding, minimizeEmpty: Boolean, child: Node*): Elem = - new Elem(prefix,label,attributes,scope, minimizeEmpty, child:_*) + def apply(prefix: String, label: String, attributes: MetaData, scope: NamespaceBinding, minimizeEmpty: Boolean, child: Node*): Elem = + new Elem(prefix, label, attributes, scope, minimizeEmpty, child: _*) def unapplySeq(n: Node) = n match { case _: SpecialNode | _: Group => None diff --git a/src/library/scala/xml/XML.scala b/src/library/scala/xml/XML.scala index 4beba91899..f6955c6612 100755 --- a/src/library/scala/xml/XML.scala +++ b/src/library/scala/xml/XML.scala @@ -15,8 +15,7 @@ import java.io.{ InputStream, Reader, StringReader, Writer } import java.nio.channels.Channels import scala.util.control.Exception.ultimately -object Source -{ +object Source { def fromFile(file: File) = new InputSource(new FileInputStream(file)) def fromFile(fd: FileDescriptor) = new InputSource(new FileInputStream(fd)) def fromFile(name: String) = new InputSource(new FileInputStream(name)) @@ -31,13 +30,18 @@ object Source * Governs how empty elements (i.e. those without child elements) should be serialized. */ object MinimizeMode extends Enumeration { - /** Minimize empty tags if they were originally empty when parsed, or if they were constructed with [[scala.xml.Elem]]`#minimizeEmpty` == true */ + /** Minimize empty tags if they were originally empty when parsed, or if they were constructed + * with [[scala.xml.Elem]]`#minimizeEmpty` == true + */ val Default = Value - /** Always minimize empty tags. Note that this may be problematic for XHTML, in which case [[scala.xml.Xhtml]]`#toXhtml` should be used instead. */ + /** Always minimize empty tags. Note that this may be problematic for XHTML, in which + * case [[scala.xml.Xhtml]]`#toXhtml` should be used instead. + */ val Always = Value - /** Never minimize empty tags. */ + /** Never minimize empty tags. + */ val Never = Value } @@ -50,8 +54,7 @@ import Source._ * @author Burak Emir * @version 1.0, 25/04/2005 */ -object XML extends XMLLoader[Elem] -{ +object XML extends XMLLoader[Elem] { val xml = "xml" val xmlns = "xmlns" val namespace = "http://www.w3.org/XML/1998/namespace" diff --git a/test/files/neg/t1364.check b/test/files/neg/t1364.check index 78375333c2..cb8803abdc 100644 --- a/test/files/neg/t1364.check +++ b/test/files/neg/t1364.check @@ -1,4 +1,4 @@ -t1364.scala:9: error: overriding type T in trait A with bounds >: Nothing <: AnyRef{type S[-U]}; +t1364.scala:9: error: overriding type T in trait A with bounds <: AnyRef{type S[-U]}; type T has incompatible type type T = { type S[U] = U } ^ diff --git a/test/files/neg/t1477.check b/test/files/neg/t1477.check index e497637857..72bffa3270 100644 --- a/test/files/neg/t1477.check +++ b/test/files/neg/t1477.check @@ -1,4 +1,4 @@ -t1477.scala:13: error: overriding type V in trait C with bounds >: Nothing <: Middle.this.D; +t1477.scala:13: error: overriding type V in trait C with bounds <: Middle.this.D; type V is a volatile type; cannot override a type with non-volatile upper bound type V <: (D with U) ^ diff --git a/test/files/neg/t2070.check b/test/files/neg/t2070.check index bd049409a8..ef1d08f7b7 100644 --- a/test/files/neg/t2070.check +++ b/test/files/neg/t2070.check @@ -1,5 +1,6 @@ t2070.scala:8: error: The kind of trait T does not conform to the expected kind of type T[X] in trait A. -t2070.B.T's type parameters do not match type T's expected parameters: type X (in object B) has one type parameter, but type X (in trait A) has none +t2070.B.T's type parameters do not match type T's expected parameters: +type X (in object B) has one type parameter, but type X (in trait A) has none trait T[X[_]] ^ one error found diff --git a/test/files/neg/t4044.check b/test/files/neg/t4044.check index 75dcf63bfe..41a04f69b9 100644 --- a/test/files/neg/t4044.check +++ b/test/files/neg/t4044.check @@ -2,15 +2,18 @@ t4044.scala:9: error: AnyRef takes no type parameters, expected: one M[AnyRef] // error, (AnyRef :: *) not kind-conformant to (N :: * -> * -> *) ^ t4044.scala:9: error: kinds of the type arguments () do not conform to the expected kinds of the type parameters (type N). -'s type parameters do not match type N's expected parameters: has no type parameters, but type N has one +'s type parameters do not match type N's expected parameters: + has no type parameters, but type N has one M[AnyRef] // error, (AnyRef :: *) not kind-conformant to (N :: * -> * -> *) ^ t4044.scala:11: error: kinds of the type arguments (Test.A) do not conform to the expected kinds of the type parameters (type N). -Test.A's type parameters do not match type N's expected parameters: type _ has no type parameters, but type O has one +Test.A's type parameters do not match type N's expected parameters: +type _ has no type parameters, but type O has one M[A] // error, (A :: (* -> *) not kind-conformant to (N :: * -> * -> *) ^ t4044.scala:15: error: kinds of the type arguments (Test.C) do not conform to the expected kinds of the type parameters (type N). -Test.C's type parameters do not match type N's expected parameters: type _ has one type parameter, but type _ has none +Test.C's type parameters do not match type N's expected parameters: +type _ has one type parameter, but type _ has none M[C] // error, (C :: (* -> * -> * -> *) not kind-conformant to (N :: * -> * -> *) ^ four errors found diff --git a/test/files/neg/t5152.check b/test/files/neg/t5152.check index 80e0141b64..fd510dbae0 100644 --- a/test/files/neg/t5152.check +++ b/test/files/neg/t5152.check @@ -1,9 +1,11 @@ t5152.scala:7: error: kinds of the type arguments (Test.B) do not conform to the expected kinds of the type parameters (type E) in class A. -Test.B's type parameters do not match type E's expected parameters: type E has one type parameter, but type _ has none +Test.B's type parameters do not match type E's expected parameters: +type E has one type parameter, but type _ has none class B[E[_]] extends A[B] { } // B is depth 2 but A requires 1 ^ t5152.scala:11: error: kinds of the type arguments (Test.B1) do not conform to the expected kinds of the type parameters (type E) in class A1. -Test.B1's type parameters do not match type E's expected parameters: type _ has no type parameters, but type G has one +Test.B1's type parameters do not match type E's expected parameters: +type _ has no type parameters, but type G has one class B1[E[_]] extends A1[B1] // B1 is depth 2 but A1 requires 3 ^ two errors found diff --git a/test/files/neg/t708.check b/test/files/neg/t708.check index 15a9c9ed93..4983aab613 100644 --- a/test/files/neg/t708.check +++ b/test/files/neg/t708.check @@ -1,4 +1,4 @@ -t708.scala:8: error: overriding type S in trait X with bounds >: Nothing <: A.this.T; +t708.scala:8: error: overriding type S in trait X with bounds <: A.this.T; type S has incompatible type override private[A] type S = Any; ^ diff --git a/test/files/neg/t742.check b/test/files/neg/t742.check index f587948ef1..d355715442 100644 --- a/test/files/neg/t742.check +++ b/test/files/neg/t742.check @@ -1,5 +1,6 @@ t742.scala:5: error: kinds of the type arguments (Crash._1,Crash._2,Any) do not conform to the expected kinds of the type parameters (type m,type n,type z). -Crash._1's type parameters do not match type m's expected parameters: type s1 has one type parameter, but type n has two +Crash._1's type parameters do not match type m's expected parameters: +type s1 has one type parameter, but type n has two type p = mul[_1, _2, Any] // mul[_1, _1, Any] needs -Yrecursion ^ one error found diff --git a/test/files/neg/tcpoly_override.check b/test/files/neg/tcpoly_override.check index 95529329e8..dbc3ff9461 100644 --- a/test/files/neg/tcpoly_override.check +++ b/test/files/neg/tcpoly_override.check @@ -1,5 +1,6 @@ tcpoly_override.scala:9: error: The kind of type T does not conform to the expected kind of type T[_] in trait A. -C.this.T's type parameters do not match type T's expected parameters: type T (in class C) has no type parameters, but type T (in trait A) has one +C.this.T's type parameters do not match type T's expected parameters: +type T (in class C) has no type parameters, but type T (in trait A) has one type T = B // This compiles well (@M: ... but it shouldn't) ^ one error found diff --git a/test/files/neg/tcpoly_typealias.check b/test/files/neg/tcpoly_typealias.check index 670add2c04..4beac0e440 100644 --- a/test/files/neg/tcpoly_typealias.check +++ b/test/files/neg/tcpoly_typealias.check @@ -1,13 +1,16 @@ tcpoly_typealias.scala:37: error: The kind of type m does not conform to the expected kind of type m[+x] in trait A. -BInv.this.m's type parameters do not match type m's expected parameters: type x (in trait BInv) is invariant, but type x (in trait A) is declared covariant +BInv.this.m's type parameters do not match type m's expected parameters: +type x (in trait BInv) is invariant, but type x (in trait A) is declared covariant type m[x] = FooCov[x] // error: invariant x in alias def ^ tcpoly_typealias.scala:41: error: The kind of type m does not conform to the expected kind of type m[+x] in trait A. -BCon.this.m's type parameters do not match type m's expected parameters: type x (in trait BCon) is contravariant, but type x (in trait A) is declared covariant +BCon.this.m's type parameters do not match type m's expected parameters: +type x (in trait BCon) is contravariant, but type x (in trait A) is declared covariant type m[-x] = FooCon[x] // error: contravariant x ^ tcpoly_typealias.scala:45: error: The kind of type m does not conform to the expected kind of type m[+x] in trait A. -BBound.this.m's type parameters do not match type m's expected parameters: type x (in trait BBound)'s bounds >: Nothing <: String are stricter than type x (in trait A)'s declared bounds >: Nothing <: Any +BBound.this.m's type parameters do not match type m's expected parameters: +type x (in trait BBound)'s bounds <: String are stricter than type x (in trait A)'s declared bounds >: Nothing <: Any type m[+x <: String] = FooBound[x] // error: x with stricter bound ^ three errors found diff --git a/test/files/neg/tcpoly_variance_enforce.check b/test/files/neg/tcpoly_variance_enforce.check index 44b5b2c15c..3299cc3435 100644 --- a/test/files/neg/tcpoly_variance_enforce.check +++ b/test/files/neg/tcpoly_variance_enforce.check @@ -1,45 +1,57 @@ tcpoly_variance_enforce.scala:15: error: kinds of the type arguments (FooInvar) do not conform to the expected kinds of the type parameters (type m) in trait coll. -FooInvar's type parameters do not match type m's expected parameters: type x (in class FooInvar) is invariant, but type x is declared covariant +FooInvar's type parameters do not match type m's expected parameters: +type x (in class FooInvar) is invariant, but type x is declared covariant object fcollinv extends coll[FooInvar] // error ^ tcpoly_variance_enforce.scala:16: error: kinds of the type arguments (FooContra) do not conform to the expected kinds of the type parameters (type m) in trait coll. -FooContra's type parameters do not match type m's expected parameters: type x (in class FooContra) is contravariant, but type x is declared covariant +FooContra's type parameters do not match type m's expected parameters: +type x (in class FooContra) is contravariant, but type x is declared covariant object fcollcon extends coll[FooContra] // error ^ tcpoly_variance_enforce.scala:17: error: kinds of the type arguments (FooString) do not conform to the expected kinds of the type parameters (type m) in trait coll. -FooString's type parameters do not match type m's expected parameters: type x (in class FooString)'s bounds >: Nothing <: String are stricter than type x's declared bounds >: Nothing <: Any +FooString's type parameters do not match type m's expected parameters: +type x (in class FooString)'s bounds <: String are stricter than type x's declared bounds >: Nothing <: Any object fcollwb extends coll[FooString] // error ^ tcpoly_variance_enforce.scala:19: error: kinds of the type arguments (FooCov) do not conform to the expected kinds of the type parameters (type m) in trait coll2. -FooCov's type parameters do not match type m's expected parameters: type x (in class FooCov) is covariant, but type x is declared contravariant +FooCov's type parameters do not match type m's expected parameters: +type x (in class FooCov) is covariant, but type x is declared contravariant object fcoll2ok extends coll2[FooCov] // error ^ tcpoly_variance_enforce.scala:20: error: kinds of the type arguments (FooInvar) do not conform to the expected kinds of the type parameters (type m) in trait coll2. -FooInvar's type parameters do not match type m's expected parameters: type x (in class FooInvar) is invariant, but type x is declared contravariant +FooInvar's type parameters do not match type m's expected parameters: +type x (in class FooInvar) is invariant, but type x is declared contravariant object fcoll2inv extends coll2[FooInvar] // error ^ tcpoly_variance_enforce.scala:22: error: kinds of the type arguments (FooString) do not conform to the expected kinds of the type parameters (type m) in trait coll2. -FooString's type parameters do not match type m's expected parameters: type x (in class FooString) is covariant, but type x is declared contravarianttype x (in class FooString)'s bounds >: Nothing <: String are stricter than type x's declared bounds >: Nothing <: Any +FooString's type parameters do not match type m's expected parameters: +type x (in class FooString) is covariant, but type x is declared contravariant +type x (in class FooString)'s bounds <: String are stricter than type x's declared bounds >: Nothing <: Any object fcoll2wb extends coll2[FooString] // error ^ tcpoly_variance_enforce.scala:27: error: kinds of the type arguments (FooString) do not conform to the expected kinds of the type parameters (type m) in trait coll3. -FooString's type parameters do not match type m's expected parameters: type x (in class FooString)'s bounds >: Nothing <: String are stricter than type x's declared bounds >: Nothing <: Any +FooString's type parameters do not match type m's expected parameters: +type x (in class FooString)'s bounds <: String are stricter than type x's declared bounds >: Nothing <: Any object fcoll3wb extends coll3[FooString] // error ^ tcpoly_variance_enforce.scala:30: error: kinds of the type arguments (FooString,Int) do not conform to the expected kinds of the type parameters (type m,type y) in trait coll4. -FooString's type parameters do not match type m's expected parameters: type x (in class FooString)'s bounds >: Nothing <: String are stricter than type x's declared bounds >: Nothing <: y +FooString's type parameters do not match type m's expected parameters: +type x (in class FooString)'s bounds <: String are stricter than type x's declared bounds <: y object fcoll4_1 extends coll4[FooString, Int] // error ^ tcpoly_variance_enforce.scala:31: error: kinds of the type arguments (FooString,Any) do not conform to the expected kinds of the type parameters (type m,type y) in trait coll4. -FooString's type parameters do not match type m's expected parameters: type x (in class FooString)'s bounds >: Nothing <: String are stricter than type x's declared bounds >: Nothing <: y +FooString's type parameters do not match type m's expected parameters: +type x (in class FooString)'s bounds <: String are stricter than type x's declared bounds <: y object fcoll4_2 extends coll4[FooString, Any] // error ^ tcpoly_variance_enforce.scala:37: error: kinds of the type arguments (FooInvar) do not conform to the expected kinds of the type parameters (type m) in trait coll. -FooInvar's type parameters do not match type m's expected parameters: type x (in class FooInvar) is invariant, but type x is declared covariant +FooInvar's type parameters do not match type m's expected parameters: +type x (in class FooInvar) is invariant, but type x is declared covariant def x: coll[FooInvar] = sys.error("foo") // error ^ tcpoly_variance_enforce.scala:38: error: kinds of the type arguments (FooContra) do not conform to the expected kinds of the type parameters (type m) in trait coll. -FooContra's type parameters do not match type m's expected parameters: type x (in class FooContra) is contravariant, but type x is declared covariant +FooContra's type parameters do not match type m's expected parameters: +type x (in class FooContra) is contravariant, but type x is declared covariant def y: coll[FooContra] = sys.error("foo") // error ^ 11 errors found diff --git a/test/files/run/existentials-in-compiler.check b/test/files/run/existentials-in-compiler.check index c8040a4cb1..83e3cdf435 100644 --- a/test/files/run/existentials-in-compiler.check +++ b/test/files/run/existentials-in-compiler.check @@ -1,156 +1,156 @@ -abstract trait Bippy[A <: AnyRef,B] extends Object +abstract trait Bippy[A <: AnyRef, B] extends Object extest.Bippy[_ <: AnyRef, _] -abstract trait BippyBud[A <: AnyRef,B,C <: List[A]] extends Object +abstract trait BippyBud[A <: AnyRef, B, C <: List[A]] extends Object extest.BippyBud[A,B,C] forSome { A <: AnyRef; B; C <: List[A] } -abstract trait BippyLike[A <: AnyRef,B <: List[A],This <: extest.BippyLike[A,B,This] with extest.Bippy[A,B]] extends Object +abstract trait BippyLike[A <: AnyRef, B <: List[A], This <: extest.BippyLike[A,B,This] with extest.Bippy[A,B]] extends Object extest.BippyLike[A,B,This] forSome { A <: AnyRef; B <: List[A]; This <: extest.BippyLike[A,B,This] with extest.Bippy[A,B] } -abstract trait Contra[-A >: AnyRef,-B] extends Object +abstract trait Contra[-A >: AnyRef, -B] extends Object extest.Contra[_ >: AnyRef, _] -abstract trait ContraLike[-A >: AnyRef,-B >: List[A]] extends Object +abstract trait ContraLike[-A >: AnyRef, -B >: List[A]] extends Object extest.ContraLike[A,B] forSome { -A >: AnyRef; -B >: List[A] } -abstract trait Cov01[+A <: AnyRef,+B] extends Object +abstract trait Cov01[+A <: AnyRef, +B] extends Object extest.Cov01[_ <: AnyRef, _] -abstract trait Cov02[+A <: AnyRef,B] extends Object +abstract trait Cov02[+A <: AnyRef, B] extends Object extest.Cov02[_ <: AnyRef, _] -abstract trait Cov03[+A <: AnyRef,-B] extends Object +abstract trait Cov03[+A <: AnyRef, -B] extends Object extest.Cov03[_ <: AnyRef, _] -abstract trait Cov04[A <: AnyRef,+B] extends Object +abstract trait Cov04[A <: AnyRef, +B] extends Object extest.Cov04[_ <: AnyRef, _] -abstract trait Cov05[A <: AnyRef,B] extends Object +abstract trait Cov05[A <: AnyRef, B] extends Object extest.Cov05[_ <: AnyRef, _] -abstract trait Cov06[A <: AnyRef,-B] extends Object +abstract trait Cov06[A <: AnyRef, -B] extends Object extest.Cov06[_ <: AnyRef, _] -abstract trait Cov07[-A <: AnyRef,+B] extends Object +abstract trait Cov07[-A <: AnyRef, +B] extends Object extest.Cov07[_ <: AnyRef, _] -abstract trait Cov08[-A <: AnyRef,B] extends Object +abstract trait Cov08[-A <: AnyRef, B] extends Object extest.Cov08[_ <: AnyRef, _] -abstract trait Cov09[-A <: AnyRef,-B] extends Object +abstract trait Cov09[-A <: AnyRef, -B] extends Object extest.Cov09[_ <: AnyRef, _] -abstract trait Cov11[+A <: AnyRef,+B <: List[_]] extends Object +abstract trait Cov11[+A <: AnyRef, +B <: List[_]] extends Object extest.Cov11[_ <: AnyRef, _ <: List[_]] -abstract trait Cov12[+A <: AnyRef,B <: List[_]] extends Object +abstract trait Cov12[+A <: AnyRef, B <: List[_]] extends Object extest.Cov12[_ <: AnyRef, _ <: List[_]] -abstract trait Cov13[+A <: AnyRef,-B <: List[_]] extends Object +abstract trait Cov13[+A <: AnyRef, -B <: List[_]] extends Object extest.Cov13[_ <: AnyRef, _ <: List[_]] -abstract trait Cov14[A <: AnyRef,+B <: List[_]] extends Object +abstract trait Cov14[A <: AnyRef, +B <: List[_]] extends Object extest.Cov14[_ <: AnyRef, _ <: List[_]] -abstract trait Cov15[A <: AnyRef,B <: List[_]] extends Object +abstract trait Cov15[A <: AnyRef, B <: List[_]] extends Object extest.Cov15[_ <: AnyRef, _ <: List[_]] -abstract trait Cov16[A <: AnyRef,-B <: List[_]] extends Object +abstract trait Cov16[A <: AnyRef, -B <: List[_]] extends Object extest.Cov16[_ <: AnyRef, _ <: List[_]] -abstract trait Cov17[-A <: AnyRef,+B <: List[_]] extends Object +abstract trait Cov17[-A <: AnyRef, +B <: List[_]] extends Object extest.Cov17[_ <: AnyRef, _ <: List[_]] -abstract trait Cov18[-A <: AnyRef,B <: List[_]] extends Object +abstract trait Cov18[-A <: AnyRef, B <: List[_]] extends Object extest.Cov18[_ <: AnyRef, _ <: List[_]] -abstract trait Cov19[-A <: AnyRef,-B <: List[_]] extends Object +abstract trait Cov19[-A <: AnyRef, -B <: List[_]] extends Object extest.Cov19[_ <: AnyRef, _ <: List[_]] -abstract trait Cov21[+A,+B] extends Object +abstract trait Cov21[+A, +B] extends Object extest.Cov21[_, _] -abstract trait Cov22[+A,B] extends Object +abstract trait Cov22[+A, B] extends Object extest.Cov22[_, _] -abstract trait Cov23[+A,-B] extends Object +abstract trait Cov23[+A, -B] extends Object extest.Cov23[_, _] -abstract trait Cov24[A,+B] extends Object +abstract trait Cov24[A, +B] extends Object extest.Cov24[_, _] -abstract trait Cov25[A,B] extends Object +abstract trait Cov25[A, B] extends Object extest.Cov25[_, _] -abstract trait Cov26[A,-B] extends Object +abstract trait Cov26[A, -B] extends Object extest.Cov26[_, _] -abstract trait Cov27[-A,+B] extends Object +abstract trait Cov27[-A, +B] extends Object extest.Cov27[_, _] -abstract trait Cov28[-A,B] extends Object +abstract trait Cov28[-A, B] extends Object extest.Cov28[_, _] -abstract trait Cov29[-A,-B] extends Object +abstract trait Cov29[-A, -B] extends Object extest.Cov29[_, _] -abstract trait Cov31[+A,+B,C <: (A, B)] extends Object +abstract trait Cov31[+A, +B, C <: (A, B)] extends Object extest.Cov31[A,B,C] forSome { +A; +B; C <: (A, B) } -abstract trait Cov32[+A,B,C <: (A, B)] extends Object +abstract trait Cov32[+A, B, C <: (A, B)] extends Object extest.Cov32[A,B,C] forSome { +A; B; C <: (A, B) } -abstract trait Cov33[+A,-B,C <: (A, _$10) forSome { type _$10 }] extends Object +abstract trait Cov33[+A, -B, C <: (A, _$10) forSome { type _$10 }] extends Object extest.Cov33[A,B,C] forSome { +A; -B; C <: (A, _$10) forSome { type _$10 } } -abstract trait Cov34[A,+B,C <: (A, B)] extends Object +abstract trait Cov34[A, +B, C <: (A, B)] extends Object extest.Cov34[A,B,C] forSome { A; +B; C <: (A, B) } -abstract trait Cov35[A,B,C <: (A, B)] extends Object +abstract trait Cov35[A, B, C <: (A, B)] extends Object extest.Cov35[A,B,C] forSome { A; B; C <: (A, B) } -abstract trait Cov36[A,-B,C <: (A, _$11) forSome { type _$11 }] extends Object +abstract trait Cov36[A, -B, C <: (A, _$11) forSome { type _$11 }] extends Object extest.Cov36[A,B,C] forSome { A; -B; C <: (A, _$11) forSome { type _$11 } } -abstract trait Cov37[-A,+B,C <: (_$12, B) forSome { type _$12 }] extends Object +abstract trait Cov37[-A, +B, C <: (_$12, B) forSome { type _$12 }] extends Object extest.Cov37[A,B,C] forSome { -A; +B; C <: (_$12, B) forSome { type _$12 } } -abstract trait Cov38[-A,B,C <: (_$13, B) forSome { type _$13 }] extends Object +abstract trait Cov38[-A, B, C <: (_$13, B) forSome { type _$13 }] extends Object extest.Cov38[A,B,C] forSome { -A; B; C <: (_$13, B) forSome { type _$13 } } -abstract trait Cov39[-A,-B,C <: Tuple2[_, _]] extends Object +abstract trait Cov39[-A, -B, C <: Tuple2[_, _]] extends Object extest.Cov39[_, _, _ <: Tuple2[_, _]] -abstract trait Cov41[+A >: Null,+B] extends Object +abstract trait Cov41[+A >: Null, +B] extends Object extest.Cov41[_ >: Null, _] -abstract trait Cov42[+A >: Null,B] extends Object +abstract trait Cov42[+A >: Null, B] extends Object extest.Cov42[_ >: Null, _] -abstract trait Cov43[+A >: Null,-B] extends Object +abstract trait Cov43[+A >: Null, -B] extends Object extest.Cov43[_ >: Null, _] -abstract trait Cov44[A >: Null,+B] extends Object +abstract trait Cov44[A >: Null, +B] extends Object extest.Cov44[_ >: Null, _] -abstract trait Cov45[A >: Null,B] extends Object +abstract trait Cov45[A >: Null, B] extends Object extest.Cov45[_ >: Null, _] -abstract trait Cov46[A >: Null,-B] extends Object +abstract trait Cov46[A >: Null, -B] extends Object extest.Cov46[_ >: Null, _] -abstract trait Cov47[-A >: Null,+B] extends Object +abstract trait Cov47[-A >: Null, +B] extends Object extest.Cov47[_ >: Null, _] -abstract trait Cov48[-A >: Null,B] extends Object +abstract trait Cov48[-A >: Null, B] extends Object extest.Cov48[_ >: Null, _] -abstract trait Cov49[-A >: Null,-B] extends Object +abstract trait Cov49[-A >: Null, -B] extends Object extest.Cov49[_ >: Null, _] -abstract trait Covariant[+A <: AnyRef,+B] extends Object +abstract trait Covariant[+A <: AnyRef, +B] extends Object extest.Covariant[_ <: AnyRef, _] -abstract trait CovariantLike[+A <: AnyRef,+B <: List[A],+This <: extest.CovariantLike[A,B,This] with extest.Covariant[A,B]] extends Object +abstract trait CovariantLike[+A <: AnyRef, +B <: List[A], +This <: extest.CovariantLike[A,B,This] with extest.Covariant[A,B]] extends Object extest.CovariantLike[A,B,This] forSome { +A <: AnyRef; +B <: List[A]; +This <: extest.CovariantLike[A,B,This] with extest.Covariant[A,B] } diff --git a/test/files/run/reify_ann1a.check b/test/files/run/reify_ann1a.check index 97d4848a49..66dce778a8 100644 --- a/test/files/run/reify_ann1a.check +++ b/test/files/run/reify_ann1a.check @@ -1,5 +1,5 @@ { - @new ann(immutable.this.List.apply[String]("1a")) @new ann(immutable.this.List.apply[String]("1b")) class C[@new ann(immutable.this.List.apply[String]("2a")) @new ann(immutable.this.List.apply[String]("2b")) T>: Nothing <: Any] extends scala.AnyRef { + @new ann(immutable.this.List.apply[String]("1a")) @new ann(immutable.this.List.apply[String]("1b")) class C[@new ann(immutable.this.List.apply[String]("2a")) @new ann(immutable.this.List.apply[String]("2b")) T] extends scala.AnyRef { @new ann(immutable.this.List.apply[String]("3a")) @new ann(immutable.this.List.apply[String]("3b")) private[this] val x: T @ann(immutable.this.List.apply[String]("4a")) @ann(immutable.this.List.apply[String]("4b")) = _; def (@new ann(immutable.this.List.apply[String]("3a")) @new ann(immutable.this.List.apply[String]("3b")) x: T @ann(immutable.this.List.apply[String]("4a")) @ann(immutable.this.List.apply[String]("4b"))) = { super.(); @@ -14,7 +14,7 @@ () } { - @ann(immutable.this.List.apply[String]("1a")) @ann(immutable.this.List.apply[String]("1b")) class C[@ann(immutable.this.List.apply[String]("2a")) @ann(immutable.this.List.apply[String]("2b")) T>: Nothing <: Any] extends scala.AnyRef { + @ann(immutable.this.List.apply[String]("1a")) @ann(immutable.this.List.apply[String]("1b")) class C[@ann(immutable.this.List.apply[String]("2a")) @ann(immutable.this.List.apply[String]("2b")) T] extends scala.AnyRef { @ann(immutable.this.List.apply[String]("3a")) @ann(immutable.this.List.apply[String]("3b")) private[this] val x: T @ann(immutable.this.List.apply[String]("4b")) @ann(immutable.this.List.apply[String]("4a")) = _; def (@ann(immutable.this.List.apply[String]("3a")) @ann(immutable.this.List.apply[String]("3b")) x: T @ann(immutable.this.List.apply[String]("4b")) @ann(immutable.this.List.apply[String]("4a"))): C[T] = { C.super.(); diff --git a/test/files/run/reify_ann1b.check b/test/files/run/reify_ann1b.check index ceebc0e2ed..9bc65a422e 100644 --- a/test/files/run/reify_ann1b.check +++ b/test/files/run/reify_ann1b.check @@ -1,5 +1,5 @@ { - @new ann(bar = "1a") @new ann(bar = "1b") class C[@new ann(bar = "2a") @new ann(bar = "2b") T>: Nothing <: Any] extends scala.AnyRef { + @new ann(bar = "1a") @new ann(bar = "1b") class C[@new ann(bar = "2a") @new ann(bar = "2b") T] extends scala.AnyRef { @new ann(bar = "3a") @new ann(bar = "3b") private[this] val x: T @ann(bar = "4a") @ann(bar = "4b") = _; def (@new ann(bar = "3a") @new ann(bar = "3b") x: T @ann(bar = "4a") @ann(bar = "4b")) = { super.(); @@ -14,7 +14,7 @@ () } { - @ann(bar = "1a") @ann(bar = "1b") class C[@ann(bar = "2a") @ann(bar = "2b") T>: Nothing <: Any] extends scala.AnyRef { + @ann(bar = "1a") @ann(bar = "1b") class C[@ann(bar = "2a") @ann(bar = "2b") T] extends scala.AnyRef { @ann(bar = "3a") @ann(bar = "3b") private[this] val x: T @ann(bar = "4b") @ann(bar = "4a") = _; def (@ann(bar = "3a") @ann(bar = "3b") x: T @ann(bar = "4b") @ann(bar = "4a")): C[T] = { C.super.(); -- cgit v1.2.3