diff options
163 files changed, 1163 insertions, 784 deletions
diff --git a/lib/jline.jar.desired.sha1 b/lib/jline.jar.desired.sha1 index a0f97c4d7a..74b0d9d91e 100644 --- a/lib/jline.jar.desired.sha1 +++ b/lib/jline.jar.desired.sha1 @@ -1 +1 @@ -115e0f58e2ffa089c083c466b0161216dd4c916e ?jline.jar +5eade2bafa228aab1f5abc63e6062ce8052e4f6d ?jline.jar diff --git a/lib/scala-compiler.jar.desired.sha1 b/lib/scala-compiler.jar.desired.sha1 index d2eb0e93e3..41809695eb 100644 --- a/lib/scala-compiler.jar.desired.sha1 +++ b/lib/scala-compiler.jar.desired.sha1 @@ -1 +1 @@ -e0382dfa2712e567b49f5826ac50eae59cf03cb3 ?scala-compiler.jar +5f31fab985a3efc21229297810c625b0a2593757 ?scala-compiler.jar diff --git a/lib/scala-library-src.jar.desired.sha1 b/lib/scala-library-src.jar.desired.sha1 index 1b5b949434..3370299a4a 100644 --- a/lib/scala-library-src.jar.desired.sha1 +++ b/lib/scala-library-src.jar.desired.sha1 @@ -1 +1 @@ -5ad90238f4fc57e8147fb69496c68d02ca073ca0 ?scala-library-src.jar +364c3b992bdebeac9fafb187e1acbece45644de7 ?scala-library-src.jar diff --git a/lib/scala-library.jar.desired.sha1 b/lib/scala-library.jar.desired.sha1 index b0aa256cb4..4993fe9421 100644 --- a/lib/scala-library.jar.desired.sha1 +++ b/lib/scala-library.jar.desired.sha1 @@ -1 +1 @@ -678ada3690dd149c2bd302407e315a74de0bfd42 ?scala-library.jar +c52dbed261e4870a504cef24518484b335a38067 ?scala-library.jar diff --git a/src/actors/scala/actors/Scheduler.scala b/src/actors/scala/actors/Scheduler.scala index 3bf1b33abf..7fe492cae2 100644 --- a/src/actors/scala/actors/Scheduler.scala +++ b/src/actors/scala/actors/Scheduler.scala @@ -50,7 +50,7 @@ object Scheduler extends DelegatingScheduler { /* Only <code>ForkJoinScheduler</code> implements this method. */ - @deprecated("restart will be removed") + @deprecated("restart will be removed", "2.8.0") def restart() { if (sched.isInstanceOf[ForkJoinScheduler]) { sched.asInstanceOf[ForkJoinScheduler].restart() diff --git a/src/compiler/scala/tools/nsc/GenericRunnerSettings.scala b/src/compiler/scala/tools/nsc/GenericRunnerSettings.scala index 45f8d1af5f..b9e9a14adf 100644 --- a/src/compiler/scala/tools/nsc/GenericRunnerSettings.scala +++ b/src/compiler/scala/tools/nsc/GenericRunnerSettings.scala @@ -40,6 +40,6 @@ class GenericRunnerSettings(error: String => Unit) extends Settings(error) { "-nc", "do not use the fsc compilation daemon") withAbbreviation "-nocompdaemon" - @deprecated("Use `nc` instead") def nocompdaemon = nc - @deprecated("Use `save` instead") def savecompiled = save + @deprecated("Use `nc` instead", "2.9.0") def nocompdaemon = nc + @deprecated("Use `save` instead", "2.9.0") def savecompiled = save } diff --git a/src/compiler/scala/tools/nsc/Interpreter.scala b/src/compiler/scala/tools/nsc/Interpreter.scala index ad39ee2b26..434f19f21b 100644 --- a/src/compiler/scala/tools/nsc/Interpreter.scala +++ b/src/compiler/scala/tools/nsc/Interpreter.scala @@ -5,7 +5,7 @@ import java.io._ /** A compatibility stub. */ -@deprecated("Use a class in the scala.tools.nsc.interpreter package.") +@deprecated("Use a class in the scala.tools.nsc.interpreter package.", "2.9.0") class Interpreter(settings: Settings, out: PrintWriter) extends IMain(settings, out) { def this(settings: Settings) = this(settings, new NewLinePrintWriter(new ConsoleWriter, true)) def this() = this(new Settings()) diff --git a/src/compiler/scala/tools/nsc/InterpreterCommand.scala b/src/compiler/scala/tools/nsc/InterpreterCommand.scala index ae2530ce40..e25a83e08b 100644 --- a/src/compiler/scala/tools/nsc/InterpreterCommand.scala +++ b/src/compiler/scala/tools/nsc/InterpreterCommand.scala @@ -4,5 +4,5 @@ import interpreter._ /** A compatibility stub. */ -@deprecated("Use a class in the scala.tools.nsc.interpreter package.") +@deprecated("Use a class in the scala.tools.nsc.interpreter package.", "2.9.0") class InterpreterCommand(arguments: List[String], error: String => Unit) extends CommandLine(arguments, error) { }
\ No newline at end of file diff --git a/src/compiler/scala/tools/nsc/InterpreterLoop.scala b/src/compiler/scala/tools/nsc/InterpreterLoop.scala index 8eb381f18a..a0be3f4fdb 100644 --- a/src/compiler/scala/tools/nsc/InterpreterLoop.scala +++ b/src/compiler/scala/tools/nsc/InterpreterLoop.scala @@ -5,7 +5,7 @@ import java.io._ /** A compatibility stub. */ -@deprecated("Use a class in the scala.tools.nsc.interpreter package.") +@deprecated("Use a class in the scala.tools.nsc.interpreter package.", "2.9.0") class InterpreterLoop(in0: Option[BufferedReader], out: PrintWriter) extends ILoop(in0, out) { def this(in0: BufferedReader, out: PrintWriter) = this(Some(in0), out) def this() = this(None, new PrintWriter(scala.Console.out)) diff --git a/src/compiler/scala/tools/nsc/MainInterpreter.scala b/src/compiler/scala/tools/nsc/MainInterpreter.scala index 9055466dd7..5d190bbe14 100644 --- a/src/compiler/scala/tools/nsc/MainInterpreter.scala +++ b/src/compiler/scala/tools/nsc/MainInterpreter.scala @@ -7,7 +7,7 @@ package scala.tools.nsc import interpreter._ -@deprecated("Use a class in the scala.tools.nsc.interpreter package.") +@deprecated("Use a class in the scala.tools.nsc.interpreter package.", "2.9.0") object MainInterpreter { def main(args: Array[String]): Unit = new ILoop main args } diff --git a/src/compiler/scala/tools/nsc/ast/DocComments.scala b/src/compiler/scala/tools/nsc/ast/DocComments.scala index 9df0069ada..5d276e2004 100755 --- a/src/compiler/scala/tools/nsc/ast/DocComments.scala +++ b/src/compiler/scala/tools/nsc/ast/DocComments.scala @@ -301,7 +301,7 @@ trait DocComments { self: SymbolTable => val defines = sections filter { startsWithTag(raw, _, "@define") } val usecases = sections filter { startsWithTag(raw, _, "@usecase") } - val end = startTag(raw, (defines ::: usecases).sort(_._1 < _._1)) + val end = startTag(raw, (defines ::: usecases).sortBy(_._1)) (if (end == raw.length - 2) raw else raw.substring(0, end) + "*/", defines map { case (start, end) => raw.substring(start, end) }, diff --git a/src/compiler/scala/tools/nsc/doc/html/page/Template.scala b/src/compiler/scala/tools/nsc/doc/html/page/Template.scala index f3e197d0be..e87f297094 100644 --- a/src/compiler/scala/tools/nsc/doc/html/page/Template.scala +++ b/src/compiler/scala/tools/nsc/doc/html/page/Template.scala @@ -322,11 +322,10 @@ class Template(tpl: DocTemplateEntity) extends HtmlPage { val annotations: Seq[scala.xml.Node] = { // A list of annotations which don't show their arguments, e. g. because they are shown separately. - val annotationsWithHiddenArguments = List("deprecated", "Deprecated") + val annotationsWithHiddenArguments = List("deprecated", "Deprecated", "migration") - def showArguments(annotation: Annotation) = { + def showArguments(annotation: Annotation) = if (annotationsWithHiddenArguments.contains(annotation.qualifiedName)) false else true - } if (!mbr.annotations.isEmpty) { <dt>Annotations</dt> @@ -358,11 +357,21 @@ class Template(tpl: DocTemplateEntity) extends HtmlPage { <dd class="cmt">{ bodyToHtml(mbr.deprecation.get) }</dd> } + val migration: Seq[scala.xml.Node] = { + mbr.annotations.find(_.qualifiedName == "migration") match { + case None => NodeSeq.Empty + case Some(mig) => { + <dt>Migration</dt> + <dd class="cmt"><p>{mig.arguments.view.map(_.value).drop(2).mkString(" ")}</p></dd> + } + } + } + val mainComment: Seq[scala.xml.Node] = mbr.comment match { case Some(comment) => val example = if(!comment.example.isEmpty && !isReduced) - <div class="block">Example{ if (comment.example.length > 1) "s" else ""} : + <div class="block">Example{ if (comment.example.length > 1) "s" else ""}: <ol>{ val exampleXml: List[scala.xml.NodeSeq] = for(example <- comment.example ) yield @@ -399,7 +408,7 @@ class Template(tpl: DocTemplateEntity) extends HtmlPage { } // end attributes block vals --- - val attributesInfo = attributes ++ definitionClasses ++ selfType ++ annotations ++ sourceLink ++ deprecation ++ mainComment + val attributesInfo = attributes ++ definitionClasses ++ selfType ++ annotations ++ deprecation ++ migration ++ sourceLink ++ mainComment val attributesBlock = if (attributesInfo.isEmpty) NodeSeq.Empty diff --git a/src/compiler/scala/tools/nsc/doc/model/Entity.scala b/src/compiler/scala/tools/nsc/doc/model/Entity.scala index 4fb0341684..86de011e68 100644 --- a/src/compiler/scala/tools/nsc/doc/model/Entity.scala +++ b/src/compiler/scala/tools/nsc/doc/model/Entity.scala @@ -127,7 +127,7 @@ trait MemberEntity extends Entity { /** Some deprecation message if this member is deprecated, or none otherwise. */ def deprecation: Option[Body] - @deprecated("Use `inDefinitionTemplates` instead") + @deprecated("Use `inDefinitionTemplates` instead", "2.9.0") def inheritedFrom: List[TemplateEntity] /** For members representing values: the type of the value returned by this member; for members @@ -204,7 +204,7 @@ trait DocTemplateEntity extends TemplateEntity with MemberEntity { /** The direct super-type of this template. */ def parentType: Option[TypeEntity] - @deprecated("Use `linearizationTemplates` and `linearizationTypes` instead") + @deprecated("Use `linearizationTemplates` and `linearizationTypes` instead", "2.9.0") def linearization: List[(TemplateEntity, TypeEntity)] /** All class, trait and object templates which are part of this template's linearization, in lineratization order. diff --git a/src/compiler/scala/tools/nsc/interactive/CompilerControl.scala b/src/compiler/scala/tools/nsc/interactive/CompilerControl.scala index 0c5d85d2a8..ba15ea8aed 100644 --- a/src/compiler/scala/tools/nsc/interactive/CompilerControl.scala +++ b/src/compiler/scala/tools/nsc/interactive/CompilerControl.scala @@ -66,11 +66,11 @@ trait CompilerControl { self: Global => * if it does not yet exist create a new one atomically * Note: We want to get roid of this operation as it messes compiler invariants. */ - @deprecated("use getUnitOf(s) or onUnitOf(s) instead") + @deprecated("use getUnitOf(s) or onUnitOf(s) instead", "2.9.0") def unitOf(s: SourceFile): RichCompilationUnit = getOrCreateUnitOf(s) /** The compilation unit corresponding to a position */ - @deprecated("use getUnitOf(pos.source) or onUnitOf(pos.source) instead") + @deprecated("use getUnitOf(pos.source) or onUnitOf(pos.source) instead", "2.9.0") def unitOf(pos: Position): RichCompilationUnit = getOrCreateUnitOf(pos.source) /** Removes the CompilationUnit corresponding to the given SourceFile @@ -107,7 +107,7 @@ trait CompilerControl { self: Global => if (item.onCompilerThread) item() else scheduler.postWorkItem(item) /** Makes sure a set of compilation units is loaded and parsed. - * Returns () to syncvar `response` on completions. + * Returns () to syncvar `response` on completion. * Afterwards a new background compiler run is started with * the given sources at the head of the list of to-be-compiled sources. */ @@ -120,6 +120,13 @@ trait CompilerControl { self: Global => postWorkItem(new ReloadItem(sources, response)) } + /** Removes source files and toplevel symbols, and issues a new typer run. + * Returns () to syncvar `response` on completion. + */ + def askFilesDeleted(sources: List[SourceFile], response: Response[Unit]) = { + postWorkItem(new FilesDeletedItem(sources, response)) + } + /** Sets sync var `response` to the smallest fully attributed tree that encloses position `pos`. * Note: Unlike for most other ask... operations, the source file belonging to `pos` needs not be be loaded. */ @@ -204,7 +211,7 @@ trait CompilerControl { self: Global => /** Tells the compile server to shutdown, and not to restart again */ def askShutdown() = scheduler raise ShutdownReq - @deprecated("use parseTree(source) instead") + @deprecated("use parseTree(source) instead", "2.9.0") def askParse(source: SourceFile, response: Response[Tree]) = respond(response) { parseTree(source) } @@ -261,6 +268,11 @@ trait CompilerControl { self: Global => override def toString = "reload "+sources } + case class FilesDeletedItem(sources: List[SourceFile], response: Response[Unit]) extends WorkItem { + def apply() = filesDeleted(sources, response) + override def toString = "files deleted "+sources + } + class AskTypeAtItem(val pos: Position, response: Response[Tree]) extends WorkItem { def apply() = self.getTypedTreeAt(pos, response) override def toString = "typeat "+pos.source+" "+pos.show diff --git a/src/compiler/scala/tools/nsc/interactive/Global.scala b/src/compiler/scala/tools/nsc/interactive/Global.scala index 2b920c8c03..d8f43fd209 100644 --- a/src/compiler/scala/tools/nsc/interactive/Global.scala +++ b/src/compiler/scala/tools/nsc/interactive/Global.scala @@ -578,6 +578,22 @@ class Global(settings: Settings, reporter: Reporter, projectName: String = "") demandNewCompilerRun() } + private[interactive] def filesDeleted(sources: List[SourceFile], response: Response[Unit]) { + informIDE("files deleted: " + sources) + val deletedFiles = sources.map(_.file).toSet + val deletedSyms = currentTopLevelSyms filter {sym => deletedFiles contains sym.sourceFile} + for (d <- deletedSyms) { + d.owner.info.decls unlink d + deletedTopLevelSyms += d + currentTopLevelSyms -= d + } + sources foreach (removeUnitOf(_)) + minRunId = currentRunId + respond(response) () + demandNewCompilerRun() + } + + /** A fully attributed tree located at position `pos` */ private def typedTreeAt(pos: Position): Tree = getUnit(pos.source) match { case None => diff --git a/src/compiler/scala/tools/nsc/interpreter/ILoop.scala b/src/compiler/scala/tools/nsc/interpreter/ILoop.scala index d6e447ca0a..fbb3457f4d 100644 --- a/src/compiler/scala/tools/nsc/interpreter/ILoop.scala +++ b/src/compiler/scala/tools/nsc/interpreter/ILoop.scala @@ -51,10 +51,10 @@ class ILoop(in0: Option[BufferedReader], protected val out: PrintWriter) // TODO // object opt extends AestheticSettings // - @deprecated("Use `intp` instead.") + @deprecated("Use `intp` instead.", "2.9.0") def interpreter = intp - @deprecated("Use `intp` instead.") + @deprecated("Use `intp` instead.", "2.9.0") def interpreter_= (i: Interpreter): Unit = intp = i def history = in.history @@ -835,14 +835,14 @@ class ILoop(in0: Option[BufferedReader], protected val out: PrintWriter) } } - @deprecated("Use `process` instead") + @deprecated("Use `process` instead", "2.9.0") def main(args: Array[String]): Unit = { if (isReplDebug) System.out.println(new java.util.Date) process(args) } - @deprecated("Use `process` instead") + @deprecated("Use `process` instead", "2.9.0") def main(settings: Settings): Unit = process(settings) } diff --git a/src/compiler/scala/tools/nsc/interpreter/IMain.scala b/src/compiler/scala/tools/nsc/interpreter/IMain.scala index 62e781958f..2eeefbefce 100644 --- a/src/compiler/scala/tools/nsc/interpreter/IMain.scala +++ b/src/compiler/scala/tools/nsc/interpreter/IMain.scala @@ -162,7 +162,7 @@ class IMain(val settings: Settings, protected val out: PrintWriter) extends Impo if (_isInitialized()) _compiler else null } - @deprecated("Use `global` for access to the compiler instance.") + @deprecated("Use `global` for access to the compiler instance.", "2.9.0") lazy val compiler: global.type = global import global._ diff --git a/src/compiler/scala/tools/nsc/interpreter/InteractiveReader.scala b/src/compiler/scala/tools/nsc/interpreter/InteractiveReader.scala index edade4da1b..55706f4fd2 100644 --- a/src/compiler/scala/tools/nsc/interpreter/InteractiveReader.scala +++ b/src/compiler/scala/tools/nsc/interpreter/InteractiveReader.scala @@ -52,7 +52,7 @@ object InteractiveReader { } def apply(): InteractiveReader = SimpleReader() - @deprecated("Use `apply` instead.") + @deprecated("Use `apply` instead.", "2.9.0") def createDefault(): InteractiveReader = apply() } diff --git a/src/compiler/scala/tools/nsc/matching/Matrix.scala b/src/compiler/scala/tools/nsc/matching/Matrix.scala index 5648f97f84..8dc960894c 100644 --- a/src/compiler/scala/tools/nsc/matching/Matrix.scala +++ b/src/compiler/scala/tools/nsc/matching/Matrix.scala @@ -88,6 +88,7 @@ trait Matrix extends MatrixAdditions { context: MatrixContext): Tree = { import context._ + TRACE("handlePattern", "(%s: %s) match { %s cases }", selector, selector.tpe, cases.size) val matrixInit: MatrixInit = { val v = copyVar(selector, isChecked, selector.tpe, "temp") diff --git a/src/compiler/scala/tools/nsc/matching/ParallelMatching.scala b/src/compiler/scala/tools/nsc/matching/ParallelMatching.scala index 1b0265ce5d..f41c37080a 100644 --- a/src/compiler/scala/tools/nsc/matching/ParallelMatching.scala +++ b/src/compiler/scala/tools/nsc/matching/ParallelMatching.scala @@ -39,15 +39,16 @@ trait ParallelMatching extends ast.TreeDSL def data: MatrixContext#MatrixInit - lazy val MatrixInit(roots, cases, failTree) = data - lazy val ExpandedMatrix(rows, targets) = expand(roots, cases) - lazy val expansion: Rep = make(roots, rows) + lazy val MatrixInit(roots, cases, failTree) = data + lazy val (rows, targets) = expand(roots, cases).unzip + lazy val expansion: Rep = make(roots, rows) - val shortCuts = new ListBuffer[Symbol]() + private val shortCuts = mutable.HashMap[Int, Symbol]() - final def shortCut(theLabel: Symbol): Int = { - shortCuts += theLabel - -shortCuts.length + final def createShortCut(theLabel: Symbol): Int = { + val key = shortCuts.size + 1 + shortCuts(key) = theLabel + -key } /** first time bx is requested, a LabelDef is returned. next time, a jump. @@ -55,18 +56,25 @@ trait ParallelMatching extends ast.TreeDSL */ final def requestBody(bx: Int, subst: Bindings): Tree = { // shortcut - if (bx < 0) Apply(ID(shortCuts(-bx-1)), Nil) + if (bx < 0) Apply(ID(shortCuts(-bx)), Nil) else targets(bx) labelBody subst } - /** the injection here handles alternatives and unapply type tests */ - final def make(tvars: PatternVarGroup, row1: List[Row]): Rep = { - // TRACE("make(%s%s)", pp(tvars.pvs, 1, true), pp(row1, 1, true)) - def classifyPat(opat: Pattern, j: Int): Pattern = opat simplify tvars(j) + /** This is the recursively focal point for translating the current + * list of pattern variables and a list of pattern match rows into + * a tree suitable for entering erasure. + * + * The first time it is called, the variables are (copies of) the + * original pattern matcher roots, and the rows correspond to the + * original casedefs. + */ + final def make(roots1: PatternVarGroup, rows1: List[Row]): Rep = { + traceCategory("New Match", "%sx%s (%s)", roots1.size, rows1.size, roots1.syms.mkString(", ")) + def classifyPat(opat: Pattern, j: Int): Pattern = opat simplify roots1(j) - val rows = row1 flatMap (_ expandAlternatives classifyPat) - if (rows.length != row1.length) make(tvars, rows) // recursive call if any change - else Rep(tvars, rows).checkExhaustive + val newRows = rows1 flatMap (_ expandAlternatives classifyPat) + if (rows1.length != newRows.length) make(roots1, newRows) // recursive call if any change + else Rep(roots1, newRows).checkExhaustive } override def toString() = "MatchMatrix(%s) { %s }".format(matchResultType, indentAll(targets)) @@ -182,17 +190,11 @@ trait ParallelMatching extends ast.TreeDSL } } - object TypedUnapply { - def unapply(x: Tree): Option[Boolean] = condOpt(x) { - case Typed(UnapplyParamType(tpe), tpt) => !(tpt.tpe <:< tpe) - } - } - def mkRule(rest: Rep): RuleApplication = { tracing("Rule")(head match { case x if isEquals(x.tree.tpe) => new MixEquals(this, rest) case x: SequencePattern => new MixSequence(this, rest, x) - case AnyUnapply(false) => new MixUnapply(this, rest, false) + case AnyUnapply(false) => new MixUnapply(this, rest) case _ => isPatternSwitch(scrut, ps) match { case Some(x) => new MixLiteralInts(x, rest) @@ -327,7 +329,7 @@ trait ParallelMatching extends ast.TreeDSL /** mixture rule for unapply pattern */ - class MixUnapply(val pmatch: PatternMatch, val rest: Rep, typeTest: Boolean) extends RuleApplication { + class MixUnapply(val pmatch: PatternMatch, val rest: Rep) extends RuleApplication { val uapattern = head match { case x: UnapplyPattern => x ; case _ => abort("XXX") } val ua @ UnApply(app, args) = head.tree @@ -494,7 +496,9 @@ trait ParallelMatching extends ast.TreeDSL val compareFn: Tree => Tree = (t: Tree) => compareOp((t DOT methodOp)(LIT(pivotLen)), ZERO) // wrapping in a null check on the scrutinee + // XXX this needs to use the logic in "def condition" nullSafe(compareFn, FALSE)(scrut.id) + // condition(head.tpe, scrut.id, head.boundVariables.nonEmpty) } lazy val success = squeezedBlock(pvs map (_.valDef), remake(successRows, pvs, hasStar).toTree) lazy val failure = remake(failRows).toTree @@ -521,7 +525,7 @@ trait ParallelMatching extends ast.TreeDSL lazy val success = remake(List( rest.rows.head.insert2(List(NoPattern), head.boundVariables, scrut.sym), - Row(emptyPatterns(1 + rest.tvars.size), NoBinding, EmptyTree, shortCut(label)) + Row(emptyPatterns(1 + rest.tvars.size), NoBinding, EmptyTree, createShortCut(label)) )).toTree lazy val failure = LabelDef(label, Nil, labelBody) @@ -615,8 +619,6 @@ trait ParallelMatching extends ast.TreeDSL case class Row(pats: List[Pattern], subst: Bindings, guard: Tree, bx: Int) { private def nobindings = subst.get().isEmpty private def bindstr = if (nobindings) "" else pp(subst) - // if (pats exists (p => !p.isDefault)) - // traceCategory("Row", "%s%s", pats, bindstr) /** Extracts the 'i'th pattern. */ def extractColumn(i: Int) = { @@ -655,29 +657,6 @@ trait ParallelMatching extends ast.TreeDSL } } - object ExpandedMatrix { - def unapply(x: ExpandedMatrix) = Some((x.rows, x.targets)) - def apply(rowz: List[(Row, FinalState)]) = - new ExpandedMatrix(rowz map (_._1), rowz map (_._2) toIndexedSeq) - } - - class ExpandedMatrix(val rows: List[Row], val targets: IndexedSeq[FinalState]) { - require(rows.size == targets.size) - - override def toString() = { - def vprint(vs: List[Any]) = if (vs.isEmpty) "" else ": %s".format(pp(vs)) - def rprint(r: Row) = pp(r) - def tprint(t: FinalState) = - if (t.params.isEmpty) " ==> %s".format(pp(t.body)) - else " ==>\n %s".format(pp(t.params -> t.body)) - - val xs = rows zip targets map { case (r,t) => rprint(r) + tprint(t) } - val ppstr = pp(xs, newlines = true) - - "ExpandedMatrix(%d rows)".format(rows.size) + ppstr - } - } - case class FinalState(bx: Int, body: Tree, params: List[Symbol]) { private var referenceCount = 0 // typer is not able to digest a body of type Nothing being assigned result type Unit @@ -762,21 +741,19 @@ trait ParallelMatching extends ast.TreeDSL } /** Expands the patterns recursively. */ - final def expand(roots: List[PatternVar], cases: List[CaseDef]) = - tracing("Expanded")(ExpandedMatrix( - for ((CaseDef(pat, guard, body), index) <- cases.zipWithIndex) yield { - def mkRow(ps: List[Tree]) = Row(toPats(ps), NoBinding, guard, index) - - val pattern = Pattern(pat) - val row = mkRow(pat match { - case x if roots.length <= 1 => List(x) - case Apply(_, args) => args - case WILD() => emptyTrees(roots.length) - }) - - row -> FinalState(index, body, pattern.deepBoundVariables) - }) - ) + final def expand(roots: List[PatternVar], cases: List[CaseDef]) = tracing("expand") { + for ((CaseDef(pat, guard, body), index) <- cases.zipWithIndex) yield { + val subtrees = pat match { + case x if roots.length <= 1 => List(x) + case Apply(_, args) => args + case WILD() => emptyTrees(roots.length) + } + val row = Row(toPats(subtrees), NoBinding, guard, index) + val state = FinalState(index, body, Pattern(pat).deepBoundVariables) + + row -> state + } + } /** returns the condition in "if (cond) k1 else k2" */ diff --git a/src/compiler/scala/tools/nsc/matching/PatternBindings.scala b/src/compiler/scala/tools/nsc/matching/PatternBindings.scala index bb062b3c0a..88983a792f 100644 --- a/src/compiler/scala/tools/nsc/matching/PatternBindings.scala +++ b/src/compiler/scala/tools/nsc/matching/PatternBindings.scala @@ -89,8 +89,8 @@ trait PatternBindings extends ast.TreeDSL } // Wrap this pattern's bindings around (_: Type) - def rebindToType(tpe: Type, annotatedType: Type = null): Pattern = { - val aType = if (annotatedType == null) tpe else annotatedType + def rebindToType(tpe: Type, ascription: Type = null): Pattern = { + val aType = if (ascription == null) tpe else ascription rebindTo(Typed(WILD(tpe), TypeTree(aType)) setType tpe) } @@ -104,10 +104,8 @@ trait PatternBindings extends ast.TreeDSL // Like rebindToEqualsCheck, but subtly different. Not trying to be // mysterious -- I haven't sorted it all out yet. - def rebindToObjectCheck(): Pattern = { - val sType = sufficientType - rebindToType(mkEqualsRef(sType), sType) - } + def rebindToObjectCheck(): Pattern = + rebindToType(mkEqualsRef(sufficientType), sufficientType) /** Helpers **/ private def wrapBindings(vs: List[Symbol], pat: Tree): Tree = vs match { diff --git a/src/compiler/scala/tools/nsc/matching/Patterns.scala b/src/compiler/scala/tools/nsc/matching/Patterns.scala index 742ab32736..e1f8204960 100644 --- a/src/compiler/scala/tools/nsc/matching/Patterns.scala +++ b/src/compiler/scala/tools/nsc/matching/Patterns.scala @@ -27,6 +27,16 @@ trait Patterns extends ast.TreeDSL { type PatternMatch = MatchMatrix#PatternMatch private type PatternVar = MatrixContext#PatternVar + // private def unapplyArgs(x: Any) = x match { + // case UnApply(Apply(TypeApply(_, targs), args), _) => (targs map (_.symbol), args map (_.symbol)) + // case _ => (Nil, Nil) + // } + // + // private def unapplyCall(x: Any) = x match { + // case UnApply(t, _) => treeInfo.methPart(t).symbol + // case _ => NoSymbol + // } + // Fresh patterns def emptyPatterns(i: Int): List[Pattern] = List.fill(i)(NoPattern) def emptyTrees(i: Int): List[Tree] = List.fill(i)(EmptyTree) @@ -45,14 +55,12 @@ trait Patterns extends ast.TreeDSL { val Ident(name) = tree require(isVarPattern(tree) && name != nme.WILDCARD) - override def irrefutableFor(tpe: Type) = true override def description = "%s".format(name) } // 8.1.1 (b) case class WildcardPattern() extends Pattern { val tree = EmptyTree - override def irrefutableFor(tpe: Type) = true override def isDefault = true override def description = "_" } @@ -62,11 +70,9 @@ trait Patterns extends ast.TreeDSL { private val Typed(expr, tpt) = tree override def subpatternsForVars: List[Pattern] = List(Pattern(expr)) - - override def irrefutableFor(tpe: Type) = tpe <:< tree.tpe override def simplify(pv: PatternVar) = Pattern(expr) match { - case ExtractorPattern(ua) if pv.sym.tpe <:< tpt.tpe => this rebindTo expr - case _ => this + case ExtractorPattern(ua) if pv.sym.tpe <:< tpt.tpe => this rebindTo expr + case _ => this } override def description = "Typ(%s: %s)".format(Pattern(expr), tpt) } @@ -159,77 +165,67 @@ trait Patterns extends ast.TreeDSL { if (isColonColon) "%s :: %s".format(Pattern(args(0)), Pattern(args(1))) else "%s(%s)".format(name, toPats(args).mkString(", ")) } - - // XXX todo - // override def irrefutableFor(tpe: Type) = false } // 8.1.6 case class TuplePattern(tree: Apply) extends ApplyPattern { - // XXX todo - // override def irrefutableFor(tpe: Type) = false override def description = "((%s))".format(args.size, toPats(args).mkString(", ")) } - // 8.1.7 + // 8.1.7 / 8.1.8 (unapply and unapplySeq calls) case class ExtractorPattern(tree: UnApply) extends UnapplyPattern { - private val Apply(fn, _) = unfn - private val MethodType(List(arg, _*), _) = fn.tpe - private def uaTyped = Typed(tree, TypeTree(arg.tpe)) setType arg.tpe - - override def necessaryType = arg.tpe - override def simplify(pv: PatternVar) = - if (pv.sym.tpe <:< arg.tpe) this + if (pv.tpe <:< arg.tpe) this else this rebindTo uaTyped - override def description = "UnApp(%s => %s)".format(necessaryType, resTypesString) + override def description = "Unapply(%s => %s)".format(necessaryType, resTypesString) } - // 8.1.8 (unapplySeq calls) - case class SequenceExtractorPattern(tree: UnApply) extends UnapplyPattern with SequenceLikePattern { + case class SequenceExtractorPattern(tree: UnApply, elems: List[Tree]) extends UnapplyPattern with SequenceLikePattern { + override def simplify(pv: PatternVar) = { + pv.sym setFlag NO_EXHAUSTIVE - lazy val UnApply( - Apply(TypeApply(Select(_, nme.unapplySeq), List(tptArg)), _), - List(ArrayValue(_, elems)) - ) = tree + if (pv.tpe <:< arg.tpe) this + else this rebindTo uaTyped + } - /** For folding a list into a well-typed x :: y :: etc :: tree. */ - private def listFolder = { - val tpe = tptArg.tpe - val MethodType(_, TypeRef(pre, sym, _)) = ConsClass.primaryConstructor.tpe - val consRef = typeRef(pre, sym, List(tpe)) - val listRef = typeRef(pre, ListClass, List(tpe)) + override def description = "UnapplySeq(%s => %s)".format(necessaryType, resTypesString) + } - def fold(x: Tree, xs: Tree) = unbind(x) match { - case _: Star => Pattern(x) rebindTo WILD(x.tpe) boundTree // this is using boundVariables instead of deepBoundVariables - case _ => - val dummyMethod = new TermSymbol(NoSymbol, NoPosition, "matching$dummy") - val consType = MethodType(dummyMethod newSyntheticValueParams List(tpe, listRef), consRef) + // Special List handling. It was like that when I got here. + case class ListExtractorPattern(tree: UnApply, tpt: Tree, elems: List[Tree]) extends UnapplyPattern with SequenceLikePattern { + private val cons = ConsClass.primaryConstructor.tpe.resultType + private val consRef = typeRef(cons.prefix, ConsClass, List(tpt.tpe)) + private val listRef = typeRef(cons.prefix, ListClass, List(tpt.tpe)) - Apply(TypeTree(consType), List(x, xs)) setType consRef - } + // Fold a list into a well-typed x :: y :: etc :: tree. + private def listFolder(x: Tree, xs: Tree) = unbind(x) match { + case _: Star => Pattern(x) rebindTo WILD(x.tpe) boundTree + case _ => + val dummyMethod = new TermSymbol(NoSymbol, NoPosition, "matching$dummy") + val consType = MethodType(dummyMethod newSyntheticValueParams List(tpt.tpe, listRef), consRef) - fold _ + Apply(TypeTree(consType), List(x, xs)) setType consRef } - - // @pre: is not right-ignoring (no star pattern) ; no exhaustivity check + override def necessaryType = if (nonStarPatterns.nonEmpty) consRef else listRef override def simplify(pv: PatternVar) = { pv.sym setFlag NO_EXHAUSTIVE - this rebindTo elems.foldRight(gen.mkNil)(listFolder) + + if (pv.tpe <:< necessaryType) + this rebindTo elems.foldRight(gen.mkNil)(listFolder) + else + this rebindTo (Typed(tree, TypeTree(necessaryType)) setType necessaryType) } - override def description = "UnSeq(%s => %s)".format(tptArg, resTypesString) + override def description = "List(%s => %s)".format(tpt.tpe, resTypesString) } trait SequenceLikePattern extends Pattern { def elems: List[Tree] - def elemPatterns = toPats(elems) - - def nonStarPatterns: List[Pattern] = if (hasStar) elemPatterns.init else elemPatterns - def nonStarLength = nonStarPatterns.length - def isAllDefaults = nonStarPatterns forall (_.isDefault) + override def hasStar = elems.nonEmpty && isStar(elems.last) - def isShorter(other: SequenceLikePattern) = nonStarLength < other.nonStarLength - def isSameLength(other: SequenceLikePattern) = nonStarLength == other.nonStarLength + def elemPatterns = toPats(elems) + def nonStarElems = if (hasStar) elems.init else elems + def nonStarPatterns = toPats(nonStarElems) + def nonStarLength = nonStarElems.length } // 8.1.8 (b) (literal ArrayValues) @@ -273,16 +269,6 @@ trait Patterns extends ast.TreeDSL { private val cache = new collection.mutable.HashMap[Tree, Pattern] def clear() = cache.clear() - def unadorn(x: Tree): Tree = x match { - case Typed(expr, _) => unadorn(expr) - case Bind(_, x) => unadorn(x) - case _ => x - } - - def isRightIgnoring(t: Tree) = cond(unadorn(t)) { - case ArrayValue(_, xs) if !xs.isEmpty => isStar(unadorn(xs.last)) - } - def apply(tree: Tree): Pattern = { if (cache contains tree) return cache(tree) @@ -321,21 +307,22 @@ trait Patterns extends ast.TreeDSL { object UnapplyPattern { private object UnapplySeq { - private object TypeApp { - def unapply(x: Any) = condOpt(x) { - case TypeApply(sel @ Select(stor, nme.unapplySeq), List(tpe)) if stor.symbol eq ListModule => tpe - } - } - def unapply(x: UnApply) = condOpt(x) { - case UnApply(Apply(TypeApp(tptArg), _), List(ArrayValue(_, xs))) => (tptArg, xs) - } + def unapply(x: UnApply) = x match { + case UnApply( + Apply(TypeApply(Select(qual, nme.unapplySeq), List(tpt)), _), + List(ArrayValue(_, elems))) => + Some(qual.symbol, tpt, elems) + case _ => + None + } } - def apply(x: UnApply): Pattern = { - x match { - case UnapplySeq(_, _) => SequenceExtractorPattern(x) - case _ => ExtractorPattern(x) - } + def apply(x: UnApply): Pattern = x match { + case UnapplySeq(container, tpt, elems) => + if (container == ListModule) ListExtractorPattern(x, tpt, elems) + else SequenceExtractorPattern(x, elems) + case _ => + ExtractorPattern(x) } } @@ -401,7 +388,15 @@ trait Patterns extends ast.TreeDSL { sealed trait UnapplyPattern extends Pattern { lazy val UnApply(unfn, args) = tree - override def subpatternsForVars: List[Pattern] = toPats(args) + lazy val Apply(fn, _) = unfn + lazy val MethodType(List(arg, _*), _) = fn.tpe + protected def uaTyped = Typed(tree, TypeTree(arg.tpe)) setType arg.tpe + + override def necessaryType = arg.tpe + override def subpatternsForVars = args match { + case List(ArrayValue(elemtpe, elems)) => toPats(elems) + case _ => toPats(args) + } def resTypes = analyzer.unapplyTypeList(unfn.symbol, unfn.tpe) def resTypesString = resTypes match { @@ -433,23 +428,10 @@ trait Patterns extends ast.TreeDSL { // returns either a simplification of this pattern or identity. def simplify(pv: PatternVar): Pattern = this - def simplify(): Pattern = this simplify null // the right number of dummies for this pattern def dummies: List[Pattern] = Nil - // 8.1.13 - // A pattern p is irrefutable for type T if any of the following applies: - // 1) p is a variable pattern - // 2) p is a typed pattern x: T', and T <: T' - // 3) p is a constructor pattern C(p1,...,pn), the type T is an instance of class C, - // the primary constructor of type T has argument types T1,...,Tn and and each - // pi is irrefutable for Ti. - def irrefutableFor(tpe: Type) = false - - // does this pattern completely cover that pattern (i.e. latter cannot be matched) - def completelyCovers(second: Pattern) = false - // Is this a default pattern (untyped "_" or an EmptyTree inserted by the matcher) def isDefault = false @@ -460,34 +442,18 @@ trait Patterns extends ast.TreeDSL { // (nullness and guards will still be checked.) def sufficientType = tpe - // XXX have to determine if this can be made useful beyond an extractor barrier. - // Default sufficient type might be NothingClass.tpe, tpe.narrow, ... - // the subpatterns for this pattern (at the moment, that means constructor arguments) def subpatterns(pm: MatchMatrix#PatternMatch): List[Pattern] = pm.dummies def sym = tree.symbol def tpe = tree.tpe - def prefix = tpe.prefix def isEmpty = tree.isEmpty - def isSymValid = (sym != null) && (sym != NoSymbol) - def isModule = sym.isModule || tpe.termSymbol.isModule + def isModule = sym.isModule || tpe.termSymbol.isModule def isCaseClass = tpe.typeSymbol.isCase - def isObject = isSymValid && prefix.isStable // XXX not entire logic + def isObject = (sym != null) && (sym != NoSymbol) && tpe.prefix.isStable // XXX not entire logic - def unadorn(t: Tree): Tree = Pattern unadorn t - - private def isStar(x: Tree) = cond(unadorn(x)) { case Star(_) => true } - private def endsStar(xs: List[Tree]) = xs.nonEmpty && isStar(xs.last) - - def isStarSequence = isSequence && hasStar - def isSequence = cond(unadorn(tree)) { - case ArrayValue(_, _) => true - } - def hasStar = cond(unadorn(tree)) { - case ArrayValue(_, xs) if endsStar(xs) => true - } + def hasStar = false def setType(tpe: Type): this.type = { tree setType tpe diff --git a/src/compiler/scala/tools/nsc/package.scala b/src/compiler/scala/tools/nsc/package.scala index 79ced4f05a..9b9cfe7280 100644 --- a/src/compiler/scala/tools/nsc/package.scala +++ b/src/compiler/scala/tools/nsc/package.scala @@ -6,8 +6,8 @@ package scala.tools package object nsc { - @deprecated("Use a class in the scala.tools.nsc.interpreter package.") + @deprecated("Use a class in the scala.tools.nsc.interpreter package.", "2.9.0") type InterpreterSettings = interpreter.ISettings - @deprecated("Use a class in the scala.tools.nsc.interpreter package.") + @deprecated("Use a class in the scala.tools.nsc.interpreter package.", "2.9.0") val InterpreterResults = interpreter.Results }
\ No newline at end of file diff --git a/src/compiler/scala/tools/nsc/symtab/Definitions.scala b/src/compiler/scala/tools/nsc/symtab/Definitions.scala index 1134f0e15f..9f666e008f 100644 --- a/src/compiler/scala/tools/nsc/symtab/Definitions.scala +++ b/src/compiler/scala/tools/nsc/symtab/Definitions.scala @@ -217,6 +217,7 @@ trait Definitions extends reflect.generic.StandardDefinitions { lazy val ScalaInlineClass = getClass("scala.inline") lazy val ScalaNoInlineClass = getClass("scala.noinline") lazy val SpecializedClass = getClass("scala.specialized") + lazy val BridgeClass = getClass("scala.annotation.bridge") // fundamental reference classes lazy val ScalaObjectClass = getClass("scala.ScalaObject") @@ -607,6 +608,13 @@ trait Definitions extends reflect.generic.StandardDefinitions { result } + def getClassIfDefined(fullname: Name): Symbol = + try { + getClass(fullname) + } catch { + case ex: MissingRequirementError => NoSymbol + } + def getMember(owner: Symbol, name: Name): Symbol = { if (owner == NoSymbol) NoSymbol else owner.info.nonPrivateMember(name) match { diff --git a/src/compiler/scala/tools/nsc/symtab/Names.scala b/src/compiler/scala/tools/nsc/symtab/Names.scala index a046058faf..7eccb9a49f 100644 --- a/src/compiler/scala/tools/nsc/symtab/Names.scala +++ b/src/compiler/scala/tools/nsc/symtab/Names.scala @@ -120,7 +120,7 @@ trait Names extends reflect.generic.Names { def isTypeName(name: Name): Boolean = name.isTypeName def nameChars: Array[Char] = chrs - @deprecated("") def view(s: String): TermName = newTermName(s) + @deprecated("", "2.9.0") def view(s: String): TermName = newTermName(s) // Classes ---------------------------------------------------------------------- diff --git a/src/compiler/scala/tools/nsc/symtab/Symbols.scala b/src/compiler/scala/tools/nsc/symtab/Symbols.scala index bbdbb09a9d..c29edaa75d 100644 --- a/src/compiler/scala/tools/nsc/symtab/Symbols.scala +++ b/src/compiler/scala/tools/nsc/symtab/Symbols.scala @@ -1579,10 +1579,6 @@ trait Symbols extends reflect.generic.Symbols { self: SymbolTable => */ def nameString: String = decodedName + idString - /** The name of the symbol before decoding, e.g. `$eq$eq` instead of `==`. - */ - def encodedName: String = name.toString - /** If settings.uniqid is set, the symbol's id, else "" */ final def idString: String = if (settings.uniqid.value) "#"+id // +" in "+owner.name+"#"+owner.id // DEBUG diff --git a/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala b/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala index 7c891667b4..7e523d292c 100644 --- a/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala +++ b/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala @@ -58,8 +58,12 @@ abstract class AddInterfaces extends InfoTransform { private def isInterfaceMember(sym: Symbol): Boolean = { sym.isType || { sym.info; // to set lateMETHOD flag if necessary - sym.isMethod && !sym.isLabel && !(sym hasFlag (PRIVATE | BRIDGE)) && - !sym.isConstructor && !sym.isImplOnly + sym.isMethod && + !sym.isLabel && + !(sym hasFlag PRIVATE) && + (!(sym hasFlag BRIDGE) || (sym hasAnnotation BridgeClass)) && // count @_$bridge$_ annotated classes as interface members + !sym.isConstructor && + !sym.isImplOnly } } diff --git a/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala b/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala index f7fa9f57ee..5f9c2b544a 100644 --- a/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala +++ b/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala @@ -68,6 +68,13 @@ abstract class ExplicitOuter extends InfoTransform result } + class RemoveBindingsTransformer(toRemove: Set[Symbol]) extends Transformer { + override def transform(tree: Tree) = tree match { + case Bind(_, body) if toRemove(tree.symbol) => super.transform(body) + case _ => super.transform(tree) + } + } + /** Issue a migration warning for instance checks which might be on an Array and * for which the type parameter conforms to Seq, because these answers changed in 2.8. */ @@ -374,18 +381,23 @@ abstract class ExplicitOuter extends InfoTransform val nguard = new ListBuffer[Tree] val ncases = - for (CaseDef(p, guard, b) <- cases) yield { + for (CaseDef(pat, guard, body) <- cases) yield { + // Strip out any unused pattern bindings up front + val patternIdents = for (b @ Bind(_, _) <- pat) yield b.symbol + val references: Set[Symbol] = Set(guard, body) flatMap { t => for (id @ Ident(name) <- t) yield id.symbol } + val (used, unused) = patternIdents partition references + val strippedPat = if (unused.isEmpty) pat else new RemoveBindingsTransformer(unused.toSet) transform pat + val gdcall = if (guard == EmptyTree) EmptyTree else { - val vs = Pattern(p).deepBoundVariables - val guardDef = makeGuardDef(vs, guard) - nguard += transform(guardDef) // building up list of guards + val guardDef = makeGuardDef(used, guard) + nguard += transform(guardDef) // building up list of guards - localTyper typed (Ident(guardDef.symbol) APPLY (vs map Ident)) + localTyper typed (Ident(guardDef.symbol) APPLY (used map Ident)) } - (CASE(transform(p)) IF gdcall) ==> transform(b) + (CASE(transform(strippedPat)) IF gdcall) ==> transform(body) } def isUncheckedAnnotation(tpe: Type) = tpe hasAnnotation UncheckedClass diff --git a/src/compiler/scala/tools/nsc/typechecker/Infer.scala b/src/compiler/scala/tools/nsc/typechecker/Infer.scala index d198303d66..fd27f178ef 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Infer.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Infer.scala @@ -232,7 +232,7 @@ trait Infer { } def explainTypes(tp1: Type, tp2: Type) = - withDisambiguation(tp1, tp2)(global.explainTypes(tp1, tp2)) + withDisambiguation(List(), tp1, tp2)(global.explainTypes(tp1, tp2)) /* -- Tests & Checks---------------------------------------------------- */ @@ -1506,7 +1506,7 @@ trait Infer { secondTry = true } def improves(sym1: Symbol, sym2: Symbol): Boolean = - sym2 == NoSymbol || + sym2 == NoSymbol || sym2.hasAnnotation(BridgeClass) || { val tp1 = pre.memberType(sym1) val tp2 = pre.memberType(sym2) (tp2 == ErrorType || @@ -1596,7 +1596,7 @@ trait Infer { def improves(sym1: Symbol, sym2: Symbol) = // util.trace("improve "+sym1+sym1.locationString+" on "+sym2+sym2.locationString)( - sym2 == NoSymbol || sym2.isError || + sym2 == NoSymbol || sym2.isError || sym2.hasAnnotation(BridgeClass) || isStrictlyMoreSpecific(followApply(pre.memberType(sym1)), followApply(pre.memberType(sym2)), sym1, sym2) diff --git a/src/compiler/scala/tools/nsc/typechecker/Namers.scala b/src/compiler/scala/tools/nsc/typechecker/Namers.scala index 3b3eb74745..f1f8257fff 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Namers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Namers.scala @@ -454,6 +454,8 @@ trait Namers { self: Analyzer => finishWith(tparams) case DefDef(mods, name, tparams, _, _, _) => tree.symbol = enterNewMethod(tree, name, mods.flags, mods, tree.pos) + if (mods.annotations.exists(ann => isAnn(ann, "bridge"))) + tree.symbol setFlag BRIDGE finishWith(tparams) case TypeDef(mods, name, tparams, _) => var flags: Long = mods.flags @@ -496,14 +498,15 @@ trait Namers { self: Analyzer => def enterAccessorMethod(tree: Tree, name: Name, flags: Long, mods: Modifiers): TermSymbol = enterNewMethod(tree, name, flags, mods, tree.pos.focus) + def isAnn(ann: Tree, demand: String) = ann match { + case Apply(Select(New(Ident(name)), _), _) => + name.toString == demand + case Apply(Select(New(Select(pre, name)), _), _) => + name.toString == demand + case _ => false + } + private def addBeanGetterSetter(vd: ValDef, getter: Symbol) { - def isAnn(ann: Tree, demand: String) = ann match { - case Apply(Select(New(Ident(name)), _), _) => - name.toString == demand - case Apply(Select(New(Select(pre, name)), _), _) => - name.toString == demand - case _ => false - } val ValDef(mods, name, tpt, _) = vd val hasBP = mods.annotations.exists(isAnn(_, "BeanProperty")) val hasBoolBP = mods.annotations.exists(isAnn(_, "BooleanBeanProperty")) @@ -1122,13 +1125,9 @@ trait Namers { self: Analyzer => * @param namer is the namer of the module class (the comp. obj) */ def addApplyUnapply(cdef: ClassDef, namer: Namer) { - if (!(cdef.symbol hasFlag ABSTRACT)) { - val applyMethod = caseModuleApplyMeth(cdef) - if (applyMethod.vparamss.size > 2) - context.error(cdef.symbol.pos, "case classes limited by implementation: maximum of 2 constructor parameter lists.") + if (!cdef.symbol.hasAbstractFlag) + namer.enterSyntheticSym(caseModuleApplyMeth(cdef)) - namer.enterSyntheticSym(applyMethod) - } namer.enterSyntheticSym(caseModuleUnapplyMeth(cdef)) } diff --git a/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala b/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala index 240f0c5f12..7bdca6dbab 100644 --- a/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala +++ b/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala @@ -184,7 +184,7 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT curTree = tree val body1 = atOwner(currentOwner) { transformTrees(body) } accDefs = accDefs.tail; - treeCopy.Template(tree, parents, self, ownAccDefs.toList ::: body1); + treeCopy.Template(tree, parents, self, ownAccDefs.toList ::: body1) case TypeApply(sel @ Select(This(_), name), args) => mayNeedProtectedAccessor(sel, args, false) diff --git a/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala b/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala index b0547cb2e2..2abecfa572 100644 --- a/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala +++ b/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala @@ -195,8 +195,9 @@ trait TypeDiagnostics { def resType = if (pt isWildcard) "" else " with expected result type " + pt def allTypes = (alternatives(tree) flatMap (_.paramTypes)) ++ argtpes :+ pt + def locals = alternatives(tree) flatMap (_.typeParams) - withDisambiguation(allTypes: _*) { + withDisambiguation(locals, allTypes: _*) { treeSymTypeMsg(tree) + msg + asParams(argtpes) + resType } } @@ -292,7 +293,7 @@ trait TypeDiagnostics { } def foundReqMsg(found: Type, req: Type): String = { - (withDisambiguation(found, req) { + (withDisambiguation(List(), found, req) { ";\n found : " + found.toLongString + existentialContext(found) + "\n required: " + req + existentialContext(req) }) + explainVariance(found, req) @@ -344,17 +345,16 @@ trait TypeDiagnostics { ) } } - private def typeDiags(types: Type*): List[TypeDiag] = { + private def typeDiags(locals: List[Symbol], types: Type*): List[TypeDiag] = { object SymExtractor { def unapply(x: Any) = x match { case t @ ConstantType(_) => Some(t -> t.underlying.typeSymbol) - case t @ TypeRef(_, sym, _) => Some(t -> sym) + case t @ TypeRef(_, sym, _) => if (locals contains sym) None else Some(t -> sym) case _ => None } } - for (tp <- types.toList ; SymExtractor(t, sym) <- tp) yield - TypeDiag(t, sym) + for (tp <- types.toList; SymExtractor(t, sym) <- tp) yield TypeDiag(t, sym) } /** The distinct pairs from an ordered list. */ @@ -367,8 +367,8 @@ trait TypeDiagnostics { * until they can be distinguished from one another: then executes the given * code. The names are restored and the result is returned. */ - def withDisambiguation[T](types: Type*)(op: => T): T = { - val typeRefs = typeDiags(types: _*) + def withDisambiguation[T](locals: List[Symbol], types: Type*)(op: => T): T = { + val typeRefs = typeDiags(locals, types: _*) val toCheck = pairs(typeRefs) filterNot { case (td1, td2) => td1 sym_== td2 } ultimately(typeRefs foreach (_.restoreName())) { diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala index fb71c8caae..add3bca6f2 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala @@ -1908,6 +1908,12 @@ trait Typers extends Modes { error(x.pos, "_* may only come last") val pat1: Tree = typedPattern(cdef.pat, pattpe) + // When case classes have more than two parameter lists, the pattern ends + // up typed as a method. We only pattern match on the first parameter + // list, so substitute the final result type of the method, i.e. the type + // of the case class. + if (pat1.tpe.paramSectionCount > 0) + pat1 setType pat1.tpe.finalResultType if (forInteractive) { for (bind @ Bind(name, _) <- cdef.pat) @@ -2096,7 +2102,8 @@ trait Typers extends Modes { (e.sym.isType || inBlock || (e.sym.tpe matches e1.sym.tpe))) // default getters are defined twice when multiple overloads have defaults. an // error for this is issued in RefChecks.checkDefaultsInOverloaded - if (!e.sym.isErroneous && !e1.sym.isErroneous && !e.sym.hasDefaultFlag) { + if (!e.sym.isErroneous && !e1.sym.isErroneous && !e.sym.hasDefaultFlag && + !e.sym.hasAnnotation(BridgeClass) && !e1.sym.hasAnnotation(BridgeClass)) { error(e.sym.pos, e1.sym+" is defined twice"+ {if(!settings.debug.value) "" else " in "+unit.toString}) scope.unlink(e1) // need to unlink to avoid later problems with lub; see #2779 @@ -2466,35 +2473,33 @@ trait Typers extends Modes { /* --- begin unapply --- */ case otpe if inPatternMode(mode) && unapplyMember(otpe).exists => - val unapp = unapplyMember(otpe) - assert(unapp.exists, tree) - val unappType = otpe.memberType(unapp) - val argDummyType = pt // was unappArg - // @S: do we need to memoize this? - val argDummy = context.owner.newValue(fun.pos, nme.SELECTOR_DUMMY) - .setFlag(SYNTHETIC) - .setInfo(argDummyType) if (args.length > MaxTupleArity) error(fun.pos, "too many arguments for unapply pattern, maximum = "+MaxTupleArity) - val arg = Ident(argDummy) setType argDummyType - val oldArgType = arg.tpe - if (!isApplicableSafe(List(), unappType, List(arg.tpe), WildcardType)) { + + def freshArgType(tp: Type): (Type, List[Symbol]) = (tp: @unchecked) match { + case MethodType(param :: _, _) => + (param.tpe, Nil) + case PolyType(tparams, restype) => + val tparams1 = cloneSymbols(tparams) + (freshArgType(restype)._1.substSym(tparams, tparams1), tparams1) + case OverloadedType(_, _) => + error(fun.pos, "cannot resolve overloaded unapply") + (ErrorType, Nil) + } + + val unapp = unapplyMember(otpe) + val unappType = otpe.memberType(unapp) + val argDummy = context.owner.newValue(fun.pos, nme.SELECTOR_DUMMY) setFlag SYNTHETIC setInfo pt + val arg = Ident(argDummy) setType pt + + if (!isApplicableSafe(Nil, unappType, List(pt), WildcardType)) { //Console.println("UNAPP: need to typetest, arg.tpe = "+arg.tpe+", unappType = "+unappType) - def freshArgType(tp: Type): (Type, List[Symbol]) = tp match { - case MethodType(params, _) => - (params(0).tpe, Nil) - case PolyType(tparams, restype) => - val tparams1 = cloneSymbols(tparams) - (freshArgType(restype)._1.substSym(tparams, tparams1), tparams1) - case OverloadedType(_, _) => - error(fun.pos, "cannot resolve overloaded unapply") - (ErrorType, Nil) - } val (unappFormal, freeVars) = freshArgType(unappType.skolemizeExistential(context.owner, tree)) val context1 = context.makeNewScope(context.tree, context.owner) freeVars foreach context1.scope.enter + val typer1 = newTyper(context1) - val pattp = typer1.infer.inferTypedPattern(tree.pos, unappFormal, arg.tpe) + val pattp = typer1.infer.inferTypedPattern(tree.pos, unappFormal, arg.tpe) // turn any unresolved type variables in freevars into existential skolems val skolems = freeVars map { fv => @@ -2504,8 +2509,7 @@ trait Typers extends Modes { skolem } arg.tpe = pattp.substSym(freeVars, skolems) - //todo: replace arg with arg.asInstanceOf[inferTypedPattern(unappFormal, arg.tpe)] instead. - argDummy.setInfo(arg.tpe) // bq: this line fixed #1281. w.r.t. comment ^^^, maybe good enough? + argDummy setInfo arg.tpe } // setType null is necessary so that ref will be stabilized; see bug 881 @@ -2517,12 +2521,13 @@ trait Typers extends Modes { val formals1 = formalTypes(formals0, args.length) if (sameLength(formals1, args)) { val args1 = typedArgs(args, mode, formals0, formals1) - if (!isFullyDefined(pt)) assert(false, tree+" ==> "+UnApply(fun1, args1)+", pt = "+pt) - val itype = glb(List(pt, arg.tpe)) - // restore old type (arg is a dummy tree, just needs to pass typechecking) - arg.tpe = oldArgType + assert(isFullyDefined(pt), tree+" ==> "+UnApply(fun1, args1)+", pt = "+pt) + + val itype = glb(List(pt, arg.tpe)) + arg.tpe = pt // restore type (arg is a dummy tree, just needs to pass typechecking) UnApply(fun1, args1) setPos tree.pos setType itype - } else { + } + else { errorTree(tree, "wrong number of arguments for "+treeSymTypeMsg(fun)) } } @@ -3136,14 +3141,20 @@ trait Typers extends Modes { ) { errorTree(tree, "return outside method definition") } else { - val DefDef(_, _, _, _, restpt, _) = enclMethod.tree - var restpt0 = restpt - if (restpt0.tpe eq null) { - errorTree(tree, "" + enclMethod.owner + - " has return statement; needs result type") - } else { + val DefDef(_, name, _, _, restpt, _) = enclMethod.tree + if (restpt.tpe eq null) + errorTree(tree, enclMethod.owner + " has return statement; needs result type") + else { context.enclMethod.returnsSeen = true - val expr1: Tree = typed(expr, EXPRmode | BYVALmode, restpt0.tpe) + val expr1: Tree = typed(expr, EXPRmode | BYVALmode, restpt.tpe) + // Warn about returning a value if no value can be returned. + if (restpt.tpe.typeSymbol == UnitClass) { + // The typing in expr1 says expr is Unit (it has already been coerced if + // it is non-Unit) so we have to retype it. Fortunately it won't come up much + // unless the warning is legitimate. + if (typed(expr).tpe.typeSymbol != UnitClass) + unit.warning(tree.pos, "enclosing method " + name + " has result type Unit: return value discarded") + } treeCopy.Return(tree, checkDead(expr1)) setSymbol enclMethod.owner setType NothingClass.tpe } } @@ -3890,7 +3901,7 @@ trait Typers extends Modes { case UnApply(fun, args) => val fun1 = typed(fun) val tpes = formalTypes(unapplyTypeList(fun.symbol, fun1.tpe), args.length) - val args1 = (args, tpes).zipped map (typedPattern(_, _)) + val args1 = (args, tpes).zipped map typedPattern treeCopy.UnApply(tree, fun1, args1) setType pt case ArrayValue(elemtpt, elems) => diff --git a/src/compiler/scala/tools/nsc/util/FreshNameCreator.scala b/src/compiler/scala/tools/nsc/util/FreshNameCreator.scala index 086de23e90..998e1694cc 100644 --- a/src/compiler/scala/tools/nsc/util/FreshNameCreator.scala +++ b/src/compiler/scala/tools/nsc/util/FreshNameCreator.scala @@ -15,9 +15,9 @@ trait FreshNameCreator { def newName(): String def newName(prefix: String): String - @deprecated("use newName(prefix)") + @deprecated("use newName(prefix)", "2.9.0") def newName(pos: util.Position, prefix: String): String = newName(prefix) - @deprecated("use newName()") + @deprecated("use newName()", "2.9.0") def newName(pos: util.Position): String = newName() } diff --git a/src/compiler/scala/tools/nsc/util/Position.scala b/src/compiler/scala/tools/nsc/util/Position.scala index d296f45aed..49e9c12eb4 100644 --- a/src/compiler/scala/tools/nsc/util/Position.scala +++ b/src/compiler/scala/tools/nsc/util/Position.scala @@ -96,7 +96,7 @@ trait Position { /** The end of the position's range, or point if not a range position */ def endOrPoint: Int = point - @deprecated("use point instead") + @deprecated("use point instead", "2.9.0") def offset: Option[Int] = if (isDefined) Some(point) else None /** The same position with a different start value (if a range) */ diff --git a/src/compiler/scala/tools/nsc/util/Set.scala b/src/compiler/scala/tools/nsc/util/Set.scala index 108956321c..2bc2526b16 100644 --- a/src/compiler/scala/tools/nsc/util/Set.scala +++ b/src/compiler/scala/tools/nsc/util/Set.scala @@ -20,7 +20,7 @@ abstract class Set[T <: AnyRef] { def apply(x: T): Boolean = contains(x) - @deprecated("use `iterator' instead") def elements = iterator + @deprecated("use `iterator' instead", "2.9.0") def elements = iterator def contains(x: T): Boolean = findEntry(x) ne null diff --git a/src/dbc/scala/dbc/DataType.scala b/src/dbc/scala/dbc/DataType.scala index 3a485d317e..677621e0c0 100644 --- a/src/dbc/scala/dbc/DataType.scala +++ b/src/dbc/scala/dbc/DataType.scala @@ -14,7 +14,7 @@ package scala.dbc; /** An ISO-9075:2003 (SQL) data type. Mappings between SQL types and * database specific types should be provided by the database driver. */ -@deprecated(DbcIsDeprecated) abstract class DataType { +@deprecated(DbcIsDeprecated, "2.9.0") abstract class DataType { /** Tests whether this datatype is equivalent to another. Usually, two * types are defined as equivalent if they are equal. Two types can be @@ -50,7 +50,7 @@ package scala.dbc; } -@deprecated(DbcIsDeprecated) object DataType { +@deprecated(DbcIsDeprecated, "2.9.0") object DataType { type Id = Int; diff --git a/src/dbc/scala/dbc/Database.scala b/src/dbc/scala/dbc/Database.scala index 86774292ea..2895f2cb29 100644 --- a/src/dbc/scala/dbc/Database.scala +++ b/src/dbc/scala/dbc/Database.scala @@ -18,7 +18,7 @@ import java.sql._ * * @author Gilles Dubochet */ -@deprecated(DbcIsDeprecated) case class Database(dbms: Vendor) { +@deprecated(DbcIsDeprecated, "2.9.0") case class Database(dbms: Vendor) { class Closed extends Exception {} diff --git a/src/dbc/scala/dbc/Syntax.scala b/src/dbc/scala/dbc/Syntax.scala index f8eb810ece..85cd1c1a1d 100644 --- a/src/dbc/scala/dbc/Syntax.scala +++ b/src/dbc/scala/dbc/Syntax.scala @@ -17,7 +17,7 @@ import java.math.{BigDecimal, BigInteger}; /** This class .. * */ -@deprecated(DbcIsDeprecated) object Syntax { +@deprecated(DbcIsDeprecated, "2.9.0") object Syntax { import syntax.DataTypeUtil; diff --git a/src/dbc/scala/dbc/Utilities.scala b/src/dbc/scala/dbc/Utilities.scala index d0f1300cb0..c37b1bb98d 100644 --- a/src/dbc/scala/dbc/Utilities.scala +++ b/src/dbc/scala/dbc/Utilities.scala @@ -15,7 +15,7 @@ package scala.dbc; * This object's members must be visible in an expression to use value * auto-conversion. */ -@deprecated(DbcIsDeprecated) object Utilities { +@deprecated(DbcIsDeprecated, "2.9.0") object Utilities { implicit def constantToValue (obj: statement.expression.Constant): Value = obj.constantValue; diff --git a/src/dbc/scala/dbc/Value.scala b/src/dbc/scala/dbc/Value.scala index 1dabec0377..a502f51cb5 100644 --- a/src/dbc/scala/dbc/Value.scala +++ b/src/dbc/scala/dbc/Value.scala @@ -12,7 +12,7 @@ package scala.dbc; /** A SQL-99 value of any type. */ -@deprecated(DbcIsDeprecated) abstract class Value { +@deprecated(DbcIsDeprecated, "2.9.0") abstract class Value { /** The SQL-99 type of the value. */ val dataType: DataType; diff --git a/src/dbc/scala/dbc/Vendor.scala b/src/dbc/scala/dbc/Vendor.scala index 2099430646..68f6102526 100644 --- a/src/dbc/scala/dbc/Vendor.scala +++ b/src/dbc/scala/dbc/Vendor.scala @@ -16,7 +16,7 @@ import java.sql.{Connection, Driver}; /** This class .. */ -@deprecated(DbcIsDeprecated) abstract class Vendor { +@deprecated(DbcIsDeprecated, "2.9.0") abstract class Vendor { def nativeDriverClass: Class[_]; def uri: java.net.URI; diff --git a/src/dbc/scala/dbc/datatype/ApproximateNumeric.scala b/src/dbc/scala/dbc/datatype/ApproximateNumeric.scala index 1be836039f..31752e18c7 100644 --- a/src/dbc/scala/dbc/datatype/ApproximateNumeric.scala +++ b/src/dbc/scala/dbc/datatype/ApproximateNumeric.scala @@ -15,7 +15,7 @@ package datatype; /** A type category for all SQL types that store varying-precision * numbers. */ -@deprecated(DbcIsDeprecated) abstract class ApproximateNumeric[Type] ( +@deprecated(DbcIsDeprecated, "2.9.0") abstract class ApproximateNumeric[Type] ( override val nativeTypeId: DataType.Id ) extends datatype.Numeric[Type](nativeTypeId) { diff --git a/src/dbc/scala/dbc/datatype/Boolean.scala b/src/dbc/scala/dbc/datatype/Boolean.scala index 89498f3d9e..4a32ce98f1 100644 --- a/src/dbc/scala/dbc/datatype/Boolean.scala +++ b/src/dbc/scala/dbc/datatype/Boolean.scala @@ -13,7 +13,7 @@ package datatype; /** The SQL type for a truth value. */ -@deprecated(DbcIsDeprecated) class Boolean extends DataType { +@deprecated(DbcIsDeprecated, "2.9.0") class Boolean extends DataType { def isEquivalent (datatype:DataType) = datatype match { case dt:Boolean => true diff --git a/src/dbc/scala/dbc/datatype/Character.scala b/src/dbc/scala/dbc/datatype/Character.scala index e3b57a230b..02dec06281 100644 --- a/src/dbc/scala/dbc/datatype/Character.scala +++ b/src/dbc/scala/dbc/datatype/Character.scala @@ -15,7 +15,7 @@ package datatype; /** A SQL type for a string of characters of arbitrary length with * arbitrary character set. */ -@deprecated(DbcIsDeprecated) abstract class Character extends CharacterString { +@deprecated(DbcIsDeprecated, "2.9.0") abstract class Character extends CharacterString { def isEquivalent(datatype: DataType) = datatype match { case dt: Character => diff --git a/src/dbc/scala/dbc/datatype/CharacterLargeObject.scala b/src/dbc/scala/dbc/datatype/CharacterLargeObject.scala index ba25acb87c..2c7ef64d66 100644 --- a/src/dbc/scala/dbc/datatype/CharacterLargeObject.scala +++ b/src/dbc/scala/dbc/datatype/CharacterLargeObject.scala @@ -14,7 +14,7 @@ package datatype; /** A SQL type for an unbounded length string of characters with arbitrary * character set. */ -@deprecated(DbcIsDeprecated) class CharacterLargeObject extends CharacterString { +@deprecated(DbcIsDeprecated, "2.9.0") class CharacterLargeObject extends CharacterString { def isEquivalent (datatype:DataType) = datatype match { case dt:CharacterLargeObject => { diff --git a/src/dbc/scala/dbc/datatype/CharacterString.scala b/src/dbc/scala/dbc/datatype/CharacterString.scala index 11ad6ed5e5..54d6e0111f 100644 --- a/src/dbc/scala/dbc/datatype/CharacterString.scala +++ b/src/dbc/scala/dbc/datatype/CharacterString.scala @@ -13,7 +13,7 @@ package datatype; /** A type category for all SQL types that store strings of characters. */ -@deprecated(DbcIsDeprecated) abstract class CharacterString extends String { +@deprecated(DbcIsDeprecated, "2.9.0") abstract class CharacterString extends String { type NativeType = java.lang.String; val nativeTypeId = DataType.STRING; diff --git a/src/dbc/scala/dbc/datatype/CharacterVarying.scala b/src/dbc/scala/dbc/datatype/CharacterVarying.scala index 5951aa07d4..9df487579f 100644 --- a/src/dbc/scala/dbc/datatype/CharacterVarying.scala +++ b/src/dbc/scala/dbc/datatype/CharacterVarying.scala @@ -15,7 +15,7 @@ package datatype; /** A SQL type for a varying length string of characters with arbitrary * maximal length and arbitrary character set. */ -@deprecated(DbcIsDeprecated) abstract class CharacterVarying extends CharacterString { +@deprecated(DbcIsDeprecated, "2.9.0") abstract class CharacterVarying extends CharacterString { def isEquivalent(datatype: DataType) = datatype match { case dt: CharacterVarying => diff --git a/src/dbc/scala/dbc/datatype/ExactNumeric.scala b/src/dbc/scala/dbc/datatype/ExactNumeric.scala index b41486c2bc..a578846977 100644 --- a/src/dbc/scala/dbc/datatype/ExactNumeric.scala +++ b/src/dbc/scala/dbc/datatype/ExactNumeric.scala @@ -15,7 +15,7 @@ package datatype; /** A type category for all SQL types that store constant-precision * numbers. */ -@deprecated(DbcIsDeprecated) abstract class ExactNumeric[Type]( +@deprecated(DbcIsDeprecated, "2.9.0") abstract class ExactNumeric[Type]( override val nativeTypeId: DataType.Id ) extends datatype.Numeric[Type](nativeTypeId) { diff --git a/src/dbc/scala/dbc/datatype/Factory.scala b/src/dbc/scala/dbc/datatype/Factory.scala index eef5f1d0d3..bb9b3f5b61 100644 --- a/src/dbc/scala/dbc/datatype/Factory.scala +++ b/src/dbc/scala/dbc/datatype/Factory.scala @@ -16,7 +16,7 @@ import java.sql.Types._; import java.math.BigInteger; import java.math.BigDecimal; -@deprecated(DbcIsDeprecated) object Factory { +@deprecated(DbcIsDeprecated, "2.9.0") object Factory { final val java_lang_Integer_SIZE = 32; final val java_lang_Long_SIZE = 64; diff --git a/src/dbc/scala/dbc/datatype/Numeric.scala b/src/dbc/scala/dbc/datatype/Numeric.scala index c5a3482a7d..c13f454dde 100644 --- a/src/dbc/scala/dbc/datatype/Numeric.scala +++ b/src/dbc/scala/dbc/datatype/Numeric.scala @@ -13,7 +13,7 @@ package datatype; /** A type category for all SQL types that store numbers. */ -@deprecated(DbcIsDeprecated) abstract class Numeric[Type](_nativeTypeId: DataType.Id) extends DataType { +@deprecated(DbcIsDeprecated, "2.9.0") abstract class Numeric[Type](_nativeTypeId: DataType.Id) extends DataType { type NativeType = Type; val nativeTypeId = _nativeTypeId; diff --git a/src/dbc/scala/dbc/datatype/String.scala b/src/dbc/scala/dbc/datatype/String.scala index 85db4e471d..291504f777 100644 --- a/src/dbc/scala/dbc/datatype/String.scala +++ b/src/dbc/scala/dbc/datatype/String.scala @@ -14,7 +14,7 @@ package datatype; /** A type category for all SQL types that store strings of elements. */ -@deprecated(DbcIsDeprecated) abstract class String extends DataType { +@deprecated(DbcIsDeprecated, "2.9.0") abstract class String extends DataType { /** The maximal possible length of the string defined in characters. * This is an implementation-specific value. diff --git a/src/dbc/scala/dbc/datatype/Unknown.scala b/src/dbc/scala/dbc/datatype/Unknown.scala index ee7a6a15fc..14a33c6be9 100644 --- a/src/dbc/scala/dbc/datatype/Unknown.scala +++ b/src/dbc/scala/dbc/datatype/Unknown.scala @@ -13,7 +13,7 @@ package datatype; /** The SQL type for a truth value. */ -@deprecated(DbcIsDeprecated) class Unknown extends DataType { +@deprecated(DbcIsDeprecated, "2.9.0") class Unknown extends DataType { def isEquivalent(datatype: DataType) = datatype match { case dt: Unknown => diff --git a/src/dbc/scala/dbc/exception/IncompatibleSchema.scala b/src/dbc/scala/dbc/exception/IncompatibleSchema.scala index 4e21daba07..c8d53bbf1a 100644 --- a/src/dbc/scala/dbc/exception/IncompatibleSchema.scala +++ b/src/dbc/scala/dbc/exception/IncompatibleSchema.scala @@ -13,7 +13,7 @@ package exception /** A type category for all SQL types that store constant-precision numbers. */ -@deprecated(DbcIsDeprecated) case class IncompatibleSchema ( +@deprecated(DbcIsDeprecated, "2.9.0") case class IncompatibleSchema ( expectedSchema: List[DataType], foundSchema: List[DataType] ) extends Exception; diff --git a/src/dbc/scala/dbc/exception/UnsupportedFeature.scala b/src/dbc/scala/dbc/exception/UnsupportedFeature.scala index 1f286c5bbd..dd6f904077 100644 --- a/src/dbc/scala/dbc/exception/UnsupportedFeature.scala +++ b/src/dbc/scala/dbc/exception/UnsupportedFeature.scala @@ -13,4 +13,4 @@ package exception /** A type category for all SQL types that store constant-precision numbers. */ -@deprecated(DbcIsDeprecated) case class UnsupportedFeature (msg: String) extends Exception; +@deprecated(DbcIsDeprecated, "2.9.0") case class UnsupportedFeature (msg: String) extends Exception; diff --git a/src/dbc/scala/dbc/result/Field.scala b/src/dbc/scala/dbc/result/Field.scala index 08acbf010c..cd3309bb14 100644 --- a/src/dbc/scala/dbc/result/Field.scala +++ b/src/dbc/scala/dbc/result/Field.scala @@ -16,7 +16,7 @@ import scala.dbc.datatype._ import scala.dbc.value._ /** An ISO-9075:2003 (SQL) table field. */ -@deprecated(DbcIsDeprecated) abstract class Field { +@deprecated(DbcIsDeprecated, "2.9.0") abstract class Field { /** The content (value) of the field. The type of this value is undefined, * transformation into a useful type will be done by an automatic view @@ -56,7 +56,7 @@ import scala.dbc.value._ } -@deprecated(DbcIsDeprecated) object Field { +@deprecated(DbcIsDeprecated, "2.9.0") object Field { implicit def fieldToValue (field: Field): Value = field.content diff --git a/src/dbc/scala/dbc/result/FieldMetadata.scala b/src/dbc/scala/dbc/result/FieldMetadata.scala index f0ec7cf9eb..3c2de297d0 100644 --- a/src/dbc/scala/dbc/result/FieldMetadata.scala +++ b/src/dbc/scala/dbc/result/FieldMetadata.scala @@ -15,7 +15,7 @@ package result /** The class <code>FieldMetadata</cocde> provides informations attached to * a field about its content and its relationship to the originating database. */ -@deprecated(DbcIsDeprecated) abstract class FieldMetadata { +@deprecated(DbcIsDeprecated, "2.9.0") abstract class FieldMetadata { /** The name of the field. */ def name: String diff --git a/src/dbc/scala/dbc/result/Relation.scala b/src/dbc/scala/dbc/result/Relation.scala index ef4c3e4ad1..4897cd1030 100644 --- a/src/dbc/scala/dbc/result/Relation.scala +++ b/src/dbc/scala/dbc/result/Relation.scala @@ -14,7 +14,7 @@ package result /** An ISO-9075:2003 (SQL) table. This is equivalent to a relation in the * relational model. */ -@deprecated(DbcIsDeprecated) abstract class Relation extends AnyRef with Iterable[Tuple] { +@deprecated(DbcIsDeprecated, "2.9.0") abstract class Relation extends AnyRef with Iterable[Tuple] { /** The statement that generated this relation. */ def statement: scala.dbc.statement.Relation diff --git a/src/dbc/scala/dbc/result/Status.scala b/src/dbc/scala/dbc/result/Status.scala index 91ca9131b7..d3152a58ab 100644 --- a/src/dbc/scala/dbc/result/Status.scala +++ b/src/dbc/scala/dbc/result/Status.scala @@ -15,7 +15,7 @@ package result; import scala.dbc.datatype._; /** An object containing the status of a query */ -@deprecated(DbcIsDeprecated) abstract class Status[ResultType] { +@deprecated(DbcIsDeprecated, "2.9.0") abstract class Status[ResultType] { /** The statement that generated this status result. */ def statement: scala.dbc.statement.Statement; diff --git a/src/dbc/scala/dbc/result/Tuple.scala b/src/dbc/scala/dbc/result/Tuple.scala index 90149c4905..80ab5c22aa 100644 --- a/src/dbc/scala/dbc/result/Tuple.scala +++ b/src/dbc/scala/dbc/result/Tuple.scala @@ -13,7 +13,7 @@ package result; /** An ISO-9075:2003 (SQL) table row. This is equivalent to a tuple in the relational model. */ -@deprecated(DbcIsDeprecated) abstract class Tuple { +@deprecated(DbcIsDeprecated, "2.9.0") abstract class Tuple { /** All the fields contained in the tuple. */ def fields: List[Field]; diff --git a/src/dbc/scala/dbc/statement/AccessMode.scala b/src/dbc/scala/dbc/statement/AccessMode.scala index 35c76981e1..885e0012f2 100644 --- a/src/dbc/scala/dbc/statement/AccessMode.scala +++ b/src/dbc/scala/dbc/statement/AccessMode.scala @@ -12,11 +12,11 @@ package scala.dbc package statement -@deprecated(DbcIsDeprecated) abstract class AccessMode { +@deprecated(DbcIsDeprecated, "2.9.0") abstract class AccessMode { def sqlString: String } -@deprecated(DbcIsDeprecated) object AccessMode { +@deprecated(DbcIsDeprecated, "2.9.0") object AccessMode { case object ReadOnly extends AccessMode { def sqlString = "READ ONLY" } diff --git a/src/dbc/scala/dbc/statement/DerivedColumn.scala b/src/dbc/scala/dbc/statement/DerivedColumn.scala index 61ba5a0224..ae05df986a 100644 --- a/src/dbc/scala/dbc/statement/DerivedColumn.scala +++ b/src/dbc/scala/dbc/statement/DerivedColumn.scala @@ -12,7 +12,7 @@ package scala.dbc package statement -@deprecated(DbcIsDeprecated) abstract class DerivedColumn { +@deprecated(DbcIsDeprecated, "2.9.0") abstract class DerivedColumn { /** The value for the column. This value can be of any type but must be * calculated from fields that appear in a relation that takes part diff --git a/src/dbc/scala/dbc/statement/Expression.scala b/src/dbc/scala/dbc/statement/Expression.scala index 9cd04dfb98..c2da91e9ef 100644 --- a/src/dbc/scala/dbc/statement/Expression.scala +++ b/src/dbc/scala/dbc/statement/Expression.scala @@ -13,7 +13,7 @@ package statement /** An expression that calculates some value from fields. */ -@deprecated(DbcIsDeprecated) abstract class Expression extends Relation { +@deprecated(DbcIsDeprecated, "2.9.0") abstract class Expression extends Relation { def fieldTypes: List[DataType] = Nil diff --git a/src/dbc/scala/dbc/statement/Insert.scala b/src/dbc/scala/dbc/statement/Insert.scala index f2f06e27ee..189ccec54f 100644 --- a/src/dbc/scala/dbc/statement/Insert.scala +++ b/src/dbc/scala/dbc/statement/Insert.scala @@ -15,7 +15,7 @@ package statement import scala.dbc.statement.expression._ /** An insertion of values into a table. */ -@deprecated(DbcIsDeprecated) case class Insert(insertionTarget: String, insertionData: InsertionData) +@deprecated(DbcIsDeprecated, "2.9.0") case class Insert(insertionTarget: String, insertionData: InsertionData) extends Status { /** A SQL-99 compliant string representation of the select statement. */ diff --git a/src/dbc/scala/dbc/statement/InsertionData.scala b/src/dbc/scala/dbc/statement/InsertionData.scala index 9ba729b645..e91ad7efe6 100644 --- a/src/dbc/scala/dbc/statement/InsertionData.scala +++ b/src/dbc/scala/dbc/statement/InsertionData.scala @@ -15,17 +15,17 @@ package statement import scala.dbc.statement.expression._ /** Data to be inserted into a table in an <code>Insert</code>. */ -@deprecated(DbcIsDeprecated) abstract class InsertionData { +@deprecated(DbcIsDeprecated, "2.9.0") abstract class InsertionData { def sqlString: String } -@deprecated(DbcIsDeprecated) object InsertionData { +@deprecated(DbcIsDeprecated, "2.9.0") object InsertionData { /** Insertion of data resulting from a query on the database. */ - @deprecated(DbcIsDeprecated) case class Subquery(query: Relation) extends InsertionData { + @deprecated(DbcIsDeprecated, "2.9.0") case class Subquery(query: Relation) extends InsertionData { def sqlString = query.sqlString } /** Insertion of data as explicitly defined values. */ - @deprecated(DbcIsDeprecated) case class Constructor( + @deprecated(DbcIsDeprecated, "2.9.0") case class Constructor( columnNames: Option[List[String]], columnValues: List[Expression] ) extends InsertionData { diff --git a/src/dbc/scala/dbc/statement/IsolationLevel.scala b/src/dbc/scala/dbc/statement/IsolationLevel.scala index 2185393316..b31614c3dd 100644 --- a/src/dbc/scala/dbc/statement/IsolationLevel.scala +++ b/src/dbc/scala/dbc/statement/IsolationLevel.scala @@ -12,11 +12,11 @@ package scala.dbc package statement -@deprecated(DbcIsDeprecated) abstract class IsolationLevel { +@deprecated(DbcIsDeprecated, "2.9.0") abstract class IsolationLevel { def sqlString: String } -@deprecated(DbcIsDeprecated) object IsolationLevel { +@deprecated(DbcIsDeprecated, "2.9.0") object IsolationLevel { case object ReadUncommitted extends IsolationLevel { def sqlString = "ISOLATION LEVEL READ UNCOMMITTED" } diff --git a/src/dbc/scala/dbc/statement/JoinType.scala b/src/dbc/scala/dbc/statement/JoinType.scala index 68e6168867..698612b10d 100644 --- a/src/dbc/scala/dbc/statement/JoinType.scala +++ b/src/dbc/scala/dbc/statement/JoinType.scala @@ -13,12 +13,12 @@ package statement /** A join behaviour in a <code>Jointure</code>. */ -@deprecated(DbcIsDeprecated) abstract class JoinType { +@deprecated(DbcIsDeprecated, "2.9.0") abstract class JoinType { /** A SQL-99 string representation of the join behaviour. */ def sqlString: String } -@deprecated(DbcIsDeprecated) object JoinType { +@deprecated(DbcIsDeprecated, "2.9.0") object JoinType { /** A join behaviour where a joined tuple is created only when a * corresponding tuple exists in both original relations. diff --git a/src/dbc/scala/dbc/statement/Jointure.scala b/src/dbc/scala/dbc/statement/Jointure.scala index 40d9f1e24a..74c871cc3e 100644 --- a/src/dbc/scala/dbc/statement/Jointure.scala +++ b/src/dbc/scala/dbc/statement/Jointure.scala @@ -13,7 +13,7 @@ package statement /** A jointure between two relations. */ -@deprecated(DbcIsDeprecated) abstract class Jointure extends Relation { +@deprecated(DbcIsDeprecated, "2.9.0") abstract class Jointure extends Relation { /** The relation on the left part of the join. */ def leftRelation: Relation diff --git a/src/dbc/scala/dbc/statement/Relation.scala b/src/dbc/scala/dbc/statement/Relation.scala index ce617f0f75..787707ee82 100644 --- a/src/dbc/scala/dbc/statement/Relation.scala +++ b/src/dbc/scala/dbc/statement/Relation.scala @@ -13,7 +13,7 @@ package statement; /** A statement that returns a relation. */ -@deprecated(DbcIsDeprecated) abstract class Relation extends Statement { +@deprecated(DbcIsDeprecated, "2.9.0") abstract class Relation extends Statement { def isCompatibleType: (DataType,DataType)=>Boolean = ((dt,wdt)=>dt.isSubtypeOf(wdt)); diff --git a/src/dbc/scala/dbc/statement/Select.scala b/src/dbc/scala/dbc/statement/Select.scala index f75cd22082..a9ca0212ed 100644 --- a/src/dbc/scala/dbc/statement/Select.scala +++ b/src/dbc/scala/dbc/statement/Select.scala @@ -15,7 +15,7 @@ package statement /** A statement that when executed on a database will return a relation. * The returned relation will be a subset of a table in the database or * a jointure between such subsets. */ -@deprecated(DbcIsDeprecated) abstract class Select extends Relation { +@deprecated(DbcIsDeprecated, "2.9.0") abstract class Select extends Relation { /** Defines if duplicated tuples should be removed from the returned * relation. <h3>Compatibility notice</h3> Some DBMS (PostgreSQL) allow diff --git a/src/dbc/scala/dbc/statement/SetClause.scala b/src/dbc/scala/dbc/statement/SetClause.scala index 4818fdda2a..3af509c026 100644 --- a/src/dbc/scala/dbc/statement/SetClause.scala +++ b/src/dbc/scala/dbc/statement/SetClause.scala @@ -15,7 +15,7 @@ package statement import scala.dbc.statement.expression._ /** Data to be inserted into a table in an <code>Insert</code>. */ -@deprecated(DbcIsDeprecated) case class SetClause(name: String, expr: Expression) { +@deprecated(DbcIsDeprecated, "2.9.0") case class SetClause(name: String, expr: Expression) { val value: Pair[String,Expression] = (name, expr) def sqlString: String = value._1 + " = " + value._2.sqlInnerString } diff --git a/src/dbc/scala/dbc/statement/SetQuantifier.scala b/src/dbc/scala/dbc/statement/SetQuantifier.scala index 62245d74fd..77a4b79b8d 100644 --- a/src/dbc/scala/dbc/statement/SetQuantifier.scala +++ b/src/dbc/scala/dbc/statement/SetQuantifier.scala @@ -13,12 +13,12 @@ package statement /** A set quantifier that defines the collection type of a relation. */ -@deprecated(DbcIsDeprecated) abstract class SetQuantifier { +@deprecated(DbcIsDeprecated, "2.9.0") abstract class SetQuantifier { /** A SQL-99 compliant string representation of the set quantifier. */ def sqlString: String } -@deprecated(DbcIsDeprecated) object SetQuantifier { +@deprecated(DbcIsDeprecated, "2.9.0") object SetQuantifier { /** A set quantifier that defines a relation as being a bag. That means * that duplicates are allowed. diff --git a/src/dbc/scala/dbc/statement/Statement.scala b/src/dbc/scala/dbc/statement/Statement.scala index ad69f5b11f..fc5374262d 100644 --- a/src/dbc/scala/dbc/statement/Statement.scala +++ b/src/dbc/scala/dbc/statement/Statement.scala @@ -13,4 +13,4 @@ package statement /** An ISO-9075:2003 (SQL) statement. */ -@deprecated(DbcIsDeprecated) abstract class Statement +@deprecated(DbcIsDeprecated, "2.9.0") abstract class Statement diff --git a/src/dbc/scala/dbc/statement/Status.scala b/src/dbc/scala/dbc/statement/Status.scala index e1f358077d..0ce64b978d 100644 --- a/src/dbc/scala/dbc/statement/Status.scala +++ b/src/dbc/scala/dbc/statement/Status.scala @@ -15,7 +15,7 @@ import scala.dbc.Database import scala.dbc.result /** A statement that changes the status of the database. */ -@deprecated(DbcIsDeprecated) abstract class Status extends Statement { +@deprecated(DbcIsDeprecated, "2.9.0") abstract class Status extends Statement { /** A SQL-99 compliant string representation of the statement. */ def sqlString: String diff --git a/src/dbc/scala/dbc/statement/Table.scala b/src/dbc/scala/dbc/statement/Table.scala index b88f4c1af8..e729f801a3 100644 --- a/src/dbc/scala/dbc/statement/Table.scala +++ b/src/dbc/scala/dbc/statement/Table.scala @@ -15,7 +15,7 @@ package statement /** A reference to a table in the database. * @author Gilles Dubochet * @version 1.0 */ -@deprecated(DbcIsDeprecated) abstract class Table extends Relation { +@deprecated(DbcIsDeprecated, "2.9.0") abstract class Table extends Relation { /** The name of the table in the database. */ def tableName: String diff --git a/src/dbc/scala/dbc/statement/Transaction.scala b/src/dbc/scala/dbc/statement/Transaction.scala index a94b509885..1740dae3f9 100644 --- a/src/dbc/scala/dbc/statement/Transaction.scala +++ b/src/dbc/scala/dbc/statement/Transaction.scala @@ -13,7 +13,7 @@ package statement; /** A statement that changes the status of the database. */ -@deprecated(DbcIsDeprecated) case class Transaction [ResultType] ( +@deprecated(DbcIsDeprecated, "2.9.0") case class Transaction [ResultType] ( transactionBody: (scala.dbc.Database=>ResultType), accessMode: Option[AccessMode], isolationLevel: Option[IsolationLevel] diff --git a/src/dbc/scala/dbc/statement/Update.scala b/src/dbc/scala/dbc/statement/Update.scala index 918bfae3cd..836549a4be 100644 --- a/src/dbc/scala/dbc/statement/Update.scala +++ b/src/dbc/scala/dbc/statement/Update.scala @@ -15,7 +15,7 @@ package statement; import scala.dbc.statement.expression._; /** An update of the state of a table. */ -@deprecated(DbcIsDeprecated) case class Update ( +@deprecated(DbcIsDeprecated, "2.9.0") case class Update ( updateTarget: String, setClauses: List[SetClause], whereClause: Option[Expression] diff --git a/src/dbc/scala/dbc/statement/expression/Aggregate.scala b/src/dbc/scala/dbc/statement/expression/Aggregate.scala index 02225b5cfa..c42bffe20e 100644 --- a/src/dbc/scala/dbc/statement/expression/Aggregate.scala +++ b/src/dbc/scala/dbc/statement/expression/Aggregate.scala @@ -13,7 +13,7 @@ package statement package expression -@deprecated(DbcIsDeprecated) abstract class Aggregate extends Expression { +@deprecated(DbcIsDeprecated, "2.9.0") abstract class Aggregate extends Expression { def aggregateName: String; diff --git a/src/dbc/scala/dbc/statement/expression/BinaryOperator.scala b/src/dbc/scala/dbc/statement/expression/BinaryOperator.scala index 7a52e10537..32f016dbf6 100644 --- a/src/dbc/scala/dbc/statement/expression/BinaryOperator.scala +++ b/src/dbc/scala/dbc/statement/expression/BinaryOperator.scala @@ -13,7 +13,7 @@ package statement package expression; -@deprecated(DbcIsDeprecated) abstract class BinaryOperator extends Expression { +@deprecated(DbcIsDeprecated, "2.9.0") abstract class BinaryOperator extends Expression { /** The name of the operator. */ def operator: String; diff --git a/src/dbc/scala/dbc/statement/expression/Constant.scala b/src/dbc/scala/dbc/statement/expression/Constant.scala index ae12917f65..70ec7819dc 100644 --- a/src/dbc/scala/dbc/statement/expression/Constant.scala +++ b/src/dbc/scala/dbc/statement/expression/Constant.scala @@ -13,7 +13,7 @@ package statement package expression; -@deprecated(DbcIsDeprecated) abstract class Constant extends Expression { +@deprecated(DbcIsDeprecated, "2.9.0") abstract class Constant extends Expression { /** A SQL-99 compliant string representation of the relation sub- * statement. This only has a meaning inside another statement. */ def sqlInnerString: String = constantValue.sqlString; diff --git a/src/dbc/scala/dbc/statement/expression/Field.scala b/src/dbc/scala/dbc/statement/expression/Field.scala index 57177d9ab9..9a90903a99 100644 --- a/src/dbc/scala/dbc/statement/expression/Field.scala +++ b/src/dbc/scala/dbc/statement/expression/Field.scala @@ -13,7 +13,7 @@ package statement package expression; -@deprecated(DbcIsDeprecated) abstract class Field extends Expression { +@deprecated(DbcIsDeprecated, "2.9.0") abstract class Field extends Expression { /** The name of the schema in the database where the field is located. */ def schemaName: Option[String] = None; diff --git a/src/dbc/scala/dbc/statement/expression/FunctionCall.scala b/src/dbc/scala/dbc/statement/expression/FunctionCall.scala index 9c2f412413..962cf209b9 100644 --- a/src/dbc/scala/dbc/statement/expression/FunctionCall.scala +++ b/src/dbc/scala/dbc/statement/expression/FunctionCall.scala @@ -13,7 +13,7 @@ package statement package expression; -@deprecated(DbcIsDeprecated) case class FunctionCall ( +@deprecated(DbcIsDeprecated, "2.9.0") case class FunctionCall ( functionName: String, arguments: List[Expression] ) extends Expression { diff --git a/src/dbc/scala/dbc/statement/expression/Select.scala b/src/dbc/scala/dbc/statement/expression/Select.scala index 24b46f2d3d..7a6a4a21c4 100644 --- a/src/dbc/scala/dbc/statement/expression/Select.scala +++ b/src/dbc/scala/dbc/statement/expression/Select.scala @@ -13,7 +13,7 @@ package statement package expression; -@deprecated(DbcIsDeprecated) abstract class Select extends Expression { +@deprecated(DbcIsDeprecated, "2.9.0") abstract class Select extends Expression { /** The actual select statement */ def selectStatement: statement.Select; diff --git a/src/dbc/scala/dbc/statement/expression/SetFunction.scala b/src/dbc/scala/dbc/statement/expression/SetFunction.scala index 07bd94ada7..060b2236f2 100644 --- a/src/dbc/scala/dbc/statement/expression/SetFunction.scala +++ b/src/dbc/scala/dbc/statement/expression/SetFunction.scala @@ -13,12 +13,12 @@ package statement package expression; -@deprecated(DbcIsDeprecated) abstract class SetFunction { +@deprecated(DbcIsDeprecated, "2.9.0") abstract class SetFunction { /** A SQL-99 compliant string representation of the set quantifier. */ def sqlString: String; } -@deprecated(DbcIsDeprecated) object SetFunction { +@deprecated(DbcIsDeprecated, "2.9.0") object SetFunction { abstract class Asterisk extends SetFunction { def sqlString = "(*)"; } diff --git a/src/dbc/scala/dbc/statement/expression/TypeCast.scala b/src/dbc/scala/dbc/statement/expression/TypeCast.scala index 54ef99ebc0..dbb8dc1b4d 100644 --- a/src/dbc/scala/dbc/statement/expression/TypeCast.scala +++ b/src/dbc/scala/dbc/statement/expression/TypeCast.scala @@ -13,7 +13,7 @@ package statement package expression; -@deprecated(DbcIsDeprecated) case class TypeCast ( +@deprecated(DbcIsDeprecated, "2.9.0") case class TypeCast ( expression: Expression, castType: DataType ) extends Expression { diff --git a/src/dbc/scala/dbc/statement/expression/UnaryOperator.scala b/src/dbc/scala/dbc/statement/expression/UnaryOperator.scala index 29f01f702b..4172c451fb 100644 --- a/src/dbc/scala/dbc/statement/expression/UnaryOperator.scala +++ b/src/dbc/scala/dbc/statement/expression/UnaryOperator.scala @@ -13,7 +13,7 @@ package statement package expression; -@deprecated(DbcIsDeprecated) abstract class UnaryOperator extends Expression { +@deprecated(DbcIsDeprecated, "2.9.0") abstract class UnaryOperator extends Expression { /** The name of the operator */ def operator: String; diff --git a/src/dbc/scala/dbc/syntax/DataTypeUtil.scala b/src/dbc/scala/dbc/syntax/DataTypeUtil.scala index 573337d01c..a0ebd1713e 100644 --- a/src/dbc/scala/dbc/syntax/DataTypeUtil.scala +++ b/src/dbc/scala/dbc/syntax/DataTypeUtil.scala @@ -15,7 +15,7 @@ package syntax; import java.math.BigDecimal; import java.math.BigInteger; -@deprecated(DbcIsDeprecated) object DataTypeUtil { +@deprecated(DbcIsDeprecated, "2.9.0") object DataTypeUtil { final val java_lang_Integer_SIZE = 32; final val java_lang_Long_SIZE = 64; diff --git a/src/dbc/scala/dbc/syntax/Database.scala b/src/dbc/scala/dbc/syntax/Database.scala index 1fbaaf8210..4357fb7d4c 100644 --- a/src/dbc/scala/dbc/syntax/Database.scala +++ b/src/dbc/scala/dbc/syntax/Database.scala @@ -14,7 +14,7 @@ package syntax; import java.net.URI; -@deprecated(DbcIsDeprecated) object Database { +@deprecated(DbcIsDeprecated, "2.9.0") object Database { def database (server:String, username:String, password:String): dbc.Database = { val uri = new URI(server); diff --git a/src/dbc/scala/dbc/syntax/Statement.scala b/src/dbc/scala/dbc/syntax/Statement.scala index 21294a2f87..baccbfaa64 100644 --- a/src/dbc/scala/dbc/syntax/Statement.scala +++ b/src/dbc/scala/dbc/syntax/Statement.scala @@ -31,7 +31,7 @@ FIXED: */ -@deprecated(DbcIsDeprecated) object Statement { +@deprecated(DbcIsDeprecated, "2.9.0") object Statement { // SELECT ZYGOTE ... diff --git a/src/dbc/scala/dbc/syntax/StatementExpression.scala b/src/dbc/scala/dbc/syntax/StatementExpression.scala index 60211df3aa..65bb0947f7 100644 --- a/src/dbc/scala/dbc/syntax/StatementExpression.scala +++ b/src/dbc/scala/dbc/syntax/StatementExpression.scala @@ -15,7 +15,7 @@ package syntax; import java.math.BigDecimal; import java.math.BigInteger; -@deprecated(DbcIsDeprecated) abstract class StatementExpression { +@deprecated(DbcIsDeprecated, "2.9.0") abstract class StatementExpression { def toStatement: statement.Expression; @@ -171,7 +171,7 @@ import java.math.BigInteger; } -@deprecated(DbcIsDeprecated) object StatementExpression { +@deprecated(DbcIsDeprecated, "2.9.0") object StatementExpression { def not (se:StatementExpression): StatementExpression = new StatementExpression { val toStatement = new statement.expression.UnaryOperator { diff --git a/src/dbc/scala/dbc/value/ApproximateNumeric.scala b/src/dbc/scala/dbc/value/ApproximateNumeric.scala index 435da796c5..fa47d8815b 100644 --- a/src/dbc/scala/dbc/value/ApproximateNumeric.scala +++ b/src/dbc/scala/dbc/value/ApproximateNumeric.scala @@ -12,7 +12,7 @@ package scala.dbc package value; -@deprecated(DbcIsDeprecated) abstract class ApproximateNumeric [Type] extends Value { +@deprecated(DbcIsDeprecated, "2.9.0") abstract class ApproximateNumeric [Type] extends Value { val dataType: datatype.ApproximateNumeric[Type]; @@ -20,7 +20,7 @@ package value; } -@deprecated(DbcIsDeprecated) object ApproximateNumeric { +@deprecated(DbcIsDeprecated, "2.9.0") object ApproximateNumeric { implicit def approximateNumericToFloar (obj:value.ApproximateNumeric[Float]): Float = obj.nativeValue; implicit def approximateNumericToDouble (obj:value.ApproximateNumeric[Double]): Double = obj.nativeValue; diff --git a/src/dbc/scala/dbc/value/Boolean.scala b/src/dbc/scala/dbc/value/Boolean.scala index 399c3a3450..5221ce2328 100644 --- a/src/dbc/scala/dbc/value/Boolean.scala +++ b/src/dbc/scala/dbc/value/Boolean.scala @@ -12,7 +12,7 @@ package scala.dbc package value; -@deprecated(DbcIsDeprecated) abstract class Boolean extends Value { +@deprecated(DbcIsDeprecated, "2.9.0") abstract class Boolean extends Value { val dataType: datatype.Boolean; @@ -20,7 +20,7 @@ package value; } -@deprecated(DbcIsDeprecated) object Boolean { +@deprecated(DbcIsDeprecated, "2.9.0") object Boolean { implicit def booleanToBoolean (obj:value.Boolean): scala.Boolean = obj.nativeValue; diff --git a/src/dbc/scala/dbc/value/Character.scala b/src/dbc/scala/dbc/value/Character.scala index e328bb2edc..4ff983c591 100644 --- a/src/dbc/scala/dbc/value/Character.scala +++ b/src/dbc/scala/dbc/value/Character.scala @@ -13,7 +13,7 @@ package value; /** A SQL-99 value of type character string. */ -@deprecated(DbcIsDeprecated) abstract class Character extends Value { +@deprecated(DbcIsDeprecated, "2.9.0") abstract class Character extends Value { override val dataType: datatype.Character; @@ -27,7 +27,7 @@ package value; /** An object offering transformation methods (views) on the value. * This object must be visible in an expression to use value auto- * conversion. */ -@deprecated(DbcIsDeprecated) object Character { +@deprecated(DbcIsDeprecated, "2.9.0") object Character { /** A character string value as a native string. */ implicit def characterToString (obj:value.Character): String = obj.nativeValue; diff --git a/src/dbc/scala/dbc/value/CharacterLargeObject.scala b/src/dbc/scala/dbc/value/CharacterLargeObject.scala index 19ceaeee59..b9e81eb3af 100644 --- a/src/dbc/scala/dbc/value/CharacterLargeObject.scala +++ b/src/dbc/scala/dbc/value/CharacterLargeObject.scala @@ -13,7 +13,7 @@ package value; /** A SQL-99 value of type character large object. */ -@deprecated(DbcIsDeprecated) abstract class CharacterLargeObject extends Value { +@deprecated(DbcIsDeprecated, "2.9.0") abstract class CharacterLargeObject extends Value { override val dataType: datatype.CharacterLargeObject; @@ -27,7 +27,7 @@ package value; /** An object offering transformation methods (views) on the value. * This object must be visible in an expression to use value auto- * conversion. */ -@deprecated(DbcIsDeprecated) object CharacterLargeObject { +@deprecated(DbcIsDeprecated, "2.9.0") object CharacterLargeObject { /** A character large object value as a native string. */ implicit def characterLargeObjectToString (obj:value.CharacterLargeObject): String = obj.nativeValue; diff --git a/src/dbc/scala/dbc/value/CharacterVarying.scala b/src/dbc/scala/dbc/value/CharacterVarying.scala index d114a28b07..72e7d06362 100644 --- a/src/dbc/scala/dbc/value/CharacterVarying.scala +++ b/src/dbc/scala/dbc/value/CharacterVarying.scala @@ -13,7 +13,7 @@ package value; /** A SQL-99 value of type character varying string. */ -@deprecated(DbcIsDeprecated) abstract class CharacterVarying extends Value { +@deprecated(DbcIsDeprecated, "2.9.0") abstract class CharacterVarying extends Value { override val dataType: datatype.CharacterVarying; @@ -27,7 +27,7 @@ package value; /** An object offering transformation methods (views) on the value. * This object must be visible in an expression to use value auto- * conversion. */ -@deprecated(DbcIsDeprecated) object CharacterVarying { +@deprecated(DbcIsDeprecated, "2.9.0") object CharacterVarying { /** A character varying string value as a native string. */ implicit def characterVaryingToString (obj:value.CharacterVarying): String = obj.nativeValue; diff --git a/src/dbc/scala/dbc/value/Conversion.scala b/src/dbc/scala/dbc/value/Conversion.scala index 5b3d3ef7af..c9297e37db 100644 --- a/src/dbc/scala/dbc/value/Conversion.scala +++ b/src/dbc/scala/dbc/value/Conversion.scala @@ -13,7 +13,7 @@ package value; import java.math._; -@deprecated(DbcIsDeprecated) object Conversion { +@deprecated(DbcIsDeprecated, "2.9.0") object Conversion { class Illegal (msg:String) extends Exception(msg); diff --git a/src/dbc/scala/dbc/value/ExactNumeric.scala b/src/dbc/scala/dbc/value/ExactNumeric.scala index 5176d15028..7cd8b89a8c 100644 --- a/src/dbc/scala/dbc/value/ExactNumeric.scala +++ b/src/dbc/scala/dbc/value/ExactNumeric.scala @@ -15,7 +15,7 @@ package value; import java.math.BigInteger; import java.math.BigDecimal; -@deprecated(DbcIsDeprecated) abstract class ExactNumeric [Type] extends Value { +@deprecated(DbcIsDeprecated, "2.9.0") abstract class ExactNumeric [Type] extends Value { val dataType: datatype.ExactNumeric[Type]; @@ -23,7 +23,7 @@ import java.math.BigDecimal; } -@deprecated(DbcIsDeprecated) object ExactNumeric { +@deprecated(DbcIsDeprecated, "2.9.0") object ExactNumeric { implicit def exactNumericToByte (obj:value.ExactNumeric[Byte]): Byte = obj.nativeValue; implicit def exactNumericToShort (obj:value.ExactNumeric[Short]): Short = obj.nativeValue; diff --git a/src/dbc/scala/dbc/value/Factory.scala b/src/dbc/scala/dbc/value/Factory.scala index cc7406a945..2d6101f6de 100644 --- a/src/dbc/scala/dbc/value/Factory.scala +++ b/src/dbc/scala/dbc/value/Factory.scala @@ -15,7 +15,7 @@ package value; import java.math.BigInteger; import java.math.BigDecimal; -@deprecated(DbcIsDeprecated) object Factory { +@deprecated(DbcIsDeprecated, "2.9.0") object Factory { def create (result: java.sql.ResultSet, index: Int, expectedDataType: DataType): Value = { expectedDataType.nativeTypeId match { diff --git a/src/dbc/scala/dbc/value/Unknown.scala b/src/dbc/scala/dbc/value/Unknown.scala index 90bf565a58..89764a5831 100644 --- a/src/dbc/scala/dbc/value/Unknown.scala +++ b/src/dbc/scala/dbc/value/Unknown.scala @@ -12,7 +12,7 @@ package scala.dbc package value; -@deprecated(DbcIsDeprecated) abstract class Unknown extends Value { +@deprecated(DbcIsDeprecated, "2.9.0") abstract class Unknown extends Value { val dataType: datatype.Unknown; @@ -20,7 +20,7 @@ package value; } -@deprecated(DbcIsDeprecated) object UnknownType { +@deprecated(DbcIsDeprecated, "2.9.0") object UnknownType { def view (obj:value.Unknown): AnyRef = obj.nativeValue; diff --git a/src/dbc/scala/dbc/vendor/PostgreSQL.scala b/src/dbc/scala/dbc/vendor/PostgreSQL.scala index 4bd10c6629..ac528d5f82 100644 --- a/src/dbc/scala/dbc/vendor/PostgreSQL.scala +++ b/src/dbc/scala/dbc/vendor/PostgreSQL.scala @@ -14,7 +14,7 @@ package vendor; import compat.Platform -@deprecated(DbcIsDeprecated) abstract class PostgreSQL extends Vendor { +@deprecated(DbcIsDeprecated, "2.9.0") abstract class PostgreSQL extends Vendor { def uri:java.net.URI; def user:String; diff --git a/src/jline/project/plugins/project/build.properties b/src/jline/project/plugins/project/build.properties index 24481fef8e..218ed2577f 100644 --- a/src/jline/project/plugins/project/build.properties +++ b/src/jline/project/plugins/project/build.properties @@ -1,3 +1,3 @@ #Project properties -#Tue Apr 05 12:32:56 PDT 2011 +#Wed Mar 23 21:05:33 PDT 2011 plugin.uptodate=true diff --git a/src/jline/src/main/java/scala/tools/jline/TerminalSupport.java b/src/jline/src/main/java/scala/tools/jline/TerminalSupport.java index 03004fea68..1ca12cb73f 100644 --- a/src/jline/src/main/java/scala/tools/jline/TerminalSupport.java +++ b/src/jline/src/main/java/scala/tools/jline/TerminalSupport.java @@ -24,10 +24,6 @@ public abstract class TerminalSupport implements Terminal { public static String DEFAULT_KEYBINDINGS_PROPERTIES = "keybindings.properties"; - public static String DEFAULT_KEYBINDINGS_PROPERTIES_MAC = "macbindings.properties"; - public static boolean isMac() { - return System.getProperty("os.name").toLowerCase().startsWith("mac"); - } public static final String JLINE_SHUTDOWNHOOK = "jline.shutdownhook"; @@ -161,11 +157,7 @@ public abstract class TerminalSupport } public InputStream getDefaultBindings() { - // Mac bindings are slightly different from Unix/Linux. - // For instance, the Delete key behavior is different between them. - return TerminalSupport.class.getResourceAsStream( - isMac() ? DEFAULT_KEYBINDINGS_PROPERTIES_MAC : DEFAULT_KEYBINDINGS_PROPERTIES - ); + return TerminalSupport.class.getResourceAsStream(DEFAULT_KEYBINDINGS_PROPERTIES); } // diff --git a/src/jline/src/main/java/scala/tools/jline/console/ConsoleReader.java b/src/jline/src/main/java/scala/tools/jline/console/ConsoleReader.java index 5e6f5c166a..f493619bcd 100644 --- a/src/jline/src/main/java/scala/tools/jline/console/ConsoleReader.java +++ b/src/jline/src/main/java/scala/tools/jline/console/ConsoleReader.java @@ -1283,7 +1283,7 @@ public class ConsoleReader if (buf.buffer.length() == 0) { return null; } else { - success = deleteCurrentCharacter(); + deleteCurrentCharacter(); } break; diff --git a/src/jline/src/main/resources/scala/tools/jline/macbindings.properties b/src/jline/src/main/resources/scala/tools/jline/macbindings.properties deleted file mode 100644 index 8e810a8364..0000000000 --- a/src/jline/src/main/resources/scala/tools/jline/macbindings.properties +++ /dev/null @@ -1,62 +0,0 @@ -# Keybinding mapping for JLine. The format is: -# [key code]: [logical operation] - -# CTRL-B: move to the previous character -2: PREV_CHAR - -# CTRL-G: move to the previous word -7: PREV_WORD - -# CTRL-F: move to the next character -6: NEXT_CHAR - -# CTRL-A: move to the beginning of the line -1: MOVE_TO_BEG - -# CTRL-D: close out the input stream -4: EXIT - -# CTRL-E: move the cursor to the end of the line -5: MOVE_TO_END - -# BACKSPACE, CTRL-H: delete the previous character -# 8 is the ASCII code for backspace and therefor -# deleting the previous character -8: DELETE_PREV_CHAR - -# TAB, CTRL-I: signal that console completion should be attempted -9: COMPLETE - -# CTRL-J, CTRL-M: newline -10: NEWLINE - -# CTRL-K: erase the current line -11: KILL_LINE - -# ENTER: newline -13: NEWLINE - -# CTRL-L: clear screen -12: CLEAR_SCREEN - -# CTRL-N: scroll to the next element in the history buffer -14: NEXT_HISTORY - -# CTRL-P: scroll to the previous element in the history buffer -16: PREV_HISTORY - -# CTRL-R: redraw the current line -18: REDISPLAY - -# CTRL-U: delete all the characters before the cursor position -21: KILL_LINE_PREV - -# CTRL-V: paste the contents of the clipboard (useful for Windows terminal) -22: PASTE - -# CTRL-W: delete the word directly before the cursor -23: DELETE_PREV_WORD - -# DELETE, CTRL-?: delete the previous character -# 127 is the ASCII code for delete -127: DELETE_NEXT_CHAR diff --git a/src/library/scala/annotation/bridge.scala b/src/library/scala/annotation/bridge.scala new file mode 100644 index 0000000000..690370854e --- /dev/null +++ b/src/library/scala/annotation/bridge.scala @@ -0,0 +1,13 @@ +/* __ *\ +** ________ ___ / / ___ Scala API ** +** / __/ __// _ | / / / _ | (c) 2002-2011, LAMP/EPFL ** +** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** +** /____/\___/_/ |_/____/_/ | | ** +** |/ ** +\* */ + +package scala.annotation + +/** If this annotation is present on a method, it will be treated as a bridge method. + */ +private[scala] class bridge extends annotation.StaticAnnotation diff --git a/src/library/scala/collection/GenIterable.scala b/src/library/scala/collection/GenIterable.scala index 8d735dd86d..9d25f21c38 100644 --- a/src/library/scala/collection/GenIterable.scala +++ b/src/library/scala/collection/GenIterable.scala @@ -29,7 +29,7 @@ extends GenIterableLike[A, GenIterable[A]] } -object GenIterable extends TraversableFactory[GenIterable] { +object GenIterable extends GenTraversableFactory[GenIterable] { implicit def canBuildFrom[A] = new GenericCanBuildFrom[A] def newBuilder[A] = Iterable.newBuilder } diff --git a/src/library/scala/collection/GenMap.scala b/src/library/scala/collection/GenMap.scala index 7e7b6c7fb0..0556069371 100644 --- a/src/library/scala/collection/GenMap.scala +++ b/src/library/scala/collection/GenMap.scala @@ -26,7 +26,7 @@ extends GenMapLike[A, B, GenMap[A, B]] } -object GenMap extends MapFactory[GenMap] { +object GenMap extends GenMapFactory[GenMap] { def empty[A, B]: immutable.Map[A, B] = immutable.Map.empty /** $mapCanBuildFromInfo */ diff --git a/src/library/scala/collection/GenSeq.scala b/src/library/scala/collection/GenSeq.scala index ac5f953e88..9a7ee9890e 100644 --- a/src/library/scala/collection/GenSeq.scala +++ b/src/library/scala/collection/GenSeq.scala @@ -30,7 +30,7 @@ extends GenSeqLike[A, GenSeq[A]] } -object GenSeq extends TraversableFactory[GenSeq] { +object GenSeq extends GenTraversableFactory[GenSeq] { implicit def canBuildFrom[A] = new GenericCanBuildFrom[A] def newBuilder[A] = Seq.newBuilder } diff --git a/src/library/scala/collection/GenSeqLike.scala b/src/library/scala/collection/GenSeqLike.scala index 1502853d8e..f5e8113d28 100644 --- a/src/library/scala/collection/GenSeqLike.scala +++ b/src/library/scala/collection/GenSeqLike.scala @@ -9,6 +9,7 @@ package scala.collection import generic._ +import annotation.bridge /** A template trait for all sequences which may be traversed * in parallel. @@ -209,6 +210,9 @@ private[collection] trait GenSeqLike[+A, +Repr] extends GenIterableLike[A, Repr] */ def startsWith[B](that: GenSeq[B]): Boolean = startsWith(that, 0) + @bridge + def startsWith[B](that: Seq[B]): Boolean = startsWith(that: GenSeq[B]) + /** Tests whether this $coll contains the given sequence at a given index. * * If the both the receiver object, <code>this</code> and @@ -338,6 +342,10 @@ private[collection] trait GenSeqLike[+A, +Repr] extends GenIterableLike[A, Repr] */ def union[B >: A, That](that: GenSeq[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = this ++ that + @bridge + def union[B >: A, That](that: Seq[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = + union(that: GenSeq[B])(bf) + /** Computes the multiset difference between this $coll and another sequence. * $willNotTerminateInf * diff --git a/src/library/scala/collection/GenSet.scala b/src/library/scala/collection/GenSet.scala index ec066844b4..fdf6d1edb2 100644 --- a/src/library/scala/collection/GenSet.scala +++ b/src/library/scala/collection/GenSet.scala @@ -30,7 +30,7 @@ extends GenSetLike[A, GenSet[A]] } -object GenSet extends TraversableFactory[GenSet] { +object GenSet extends GenTraversableFactory[GenSet] { implicit def canBuildFrom[A] = new GenericCanBuildFrom[A] def newBuilder[A] = Set.newBuilder } diff --git a/src/library/scala/collection/GenSetLike.scala b/src/library/scala/collection/GenSetLike.scala index d45810d2e7..1c998351b4 100644 --- a/src/library/scala/collection/GenSetLike.scala +++ b/src/library/scala/collection/GenSetLike.scala @@ -8,6 +8,8 @@ package scala.collection +import annotation.bridge + /** A template trait for sets which may possibly * have their operations implemented in parallel. * @@ -49,6 +51,9 @@ private[collection] trait GenSetLike[A, +Repr] */ def intersect(that: GenSet[A]): Repr = this filter that + @bridge + def intersect(that: Set[A]): Repr = intersect(that: GenSet[A]) + /** Computes the intersection between this set and another set. * * '''Note:''' Same as `intersect`. @@ -58,6 +63,9 @@ private[collection] trait GenSetLike[A, +Repr] */ def &(that: GenSet[A]): Repr = this intersect that + @bridge + def &(that: Set[A]): Repr = &(that: GenSet[A]) + /** Computes the union between of set and another set. * * @param that the set to form the union with. @@ -75,6 +83,9 @@ private[collection] trait GenSetLike[A, +Repr] */ def | (that: GenSet[A]): Repr = this union that + @bridge + def | (that: Set[A]): Repr = | (that: GenSet[A]) + /** Computes the difference of this set and another set. * * @param that the set of elements to exclude. @@ -92,6 +103,9 @@ private[collection] trait GenSetLike[A, +Repr] */ def &~(that: GenSet[A]): Repr = this diff that + @bridge + def &~(that: Set[A]): Repr = &~(that: GenSet[A]) + /** Tests whether this set is a subset of another set. * * @param that the set to test. @@ -100,6 +114,9 @@ private[collection] trait GenSetLike[A, +Repr] */ def subsetOf(that: GenSet[A]): Boolean = this forall that + @bridge + def subsetOf(that: Set[A]): Boolean = subsetOf(that: GenSet[A]) + /** Compares this set with another object for equality. * * '''Note:''' This operation contains an unchecked cast: if `that` diff --git a/src/library/scala/collection/GenTraversable.scala b/src/library/scala/collection/GenTraversable.scala index fc1f84d2e5..8e6ab50f1a 100644 --- a/src/library/scala/collection/GenTraversable.scala +++ b/src/library/scala/collection/GenTraversable.scala @@ -31,7 +31,7 @@ extends GenTraversableLike[A, GenTraversable[A]] } -object GenTraversable extends TraversableFactory[GenTraversable] { +object GenTraversable extends GenTraversableFactory[GenTraversable] { implicit def canBuildFrom[A] = new GenericCanBuildFrom[A] def newBuilder[A] = Traversable.newBuilder } diff --git a/src/library/scala/collection/IterableLike.scala b/src/library/scala/collection/IterableLike.scala index b6713b65e4..55c12b8e8c 100644 --- a/src/library/scala/collection/IterableLike.scala +++ b/src/library/scala/collection/IterableLike.scala @@ -12,7 +12,7 @@ package scala.collection import generic._ import immutable.{ List, Stream } import annotation.unchecked.uncheckedVariance - +import annotation.bridge /** A template trait for iterable collections of type `Iterable[A]`. * $iterableInfo @@ -237,6 +237,10 @@ self => b.result } + @bridge + def zip[A1 >: A, B, That](that: Iterable[B])(implicit bf: CanBuildFrom[Repr, (A1, B), That]): That = + zip(that: GenIterable[B])(bf) + def zipAll[B, A1 >: A, That](that: GenIterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[Repr, (A1, B), That]): That = { val b = bf(repr) val these = this.iterator @@ -250,6 +254,10 @@ self => b.result } + @bridge + def zipAll[B, A1 >: A, That](that: Iterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[Repr, (A1, B), That]): That = + zipAll(that: GenIterable[B], thisElem, thatElem)(bf) + def zipWithIndex[A1 >: A, That](implicit bf: CanBuildFrom[Repr, (A1, Int), That]): That = { val b = bf(repr) var i = 0 @@ -270,6 +278,9 @@ self => !these.hasNext && !those.hasNext } + @bridge + def sameElements[B >: A](that: Iterable[B]): Boolean = sameElements(that: GenIterable[B]) + override /*TraversableLike*/ def toStream: Stream[A] = iterator.toStream /** Method called from equality methods, so that user-defined subclasses can diff --git a/src/library/scala/collection/LinearSeqOptimized.scala b/src/library/scala/collection/LinearSeqOptimized.scala index 236a5bdaa3..5e0bd010a6 100755 --- a/src/library/scala/collection/LinearSeqOptimized.scala +++ b/src/library/scala/collection/LinearSeqOptimized.scala @@ -48,7 +48,7 @@ trait LinearSeqOptimized[+A, +Repr <: LinearSeqOptimized[A, Repr]] extends Linea */ def apply(n: Int): A = { val rest = drop(n) - if (n < 0 || rest.isEmpty) throw new IndexOutOfBoundsException + if (n < 0 || rest.isEmpty) throw new IndexOutOfBoundsException("" + n) rest.head } diff --git a/src/library/scala/collection/MapLike.scala b/src/library/scala/collection/MapLike.scala index a832f9089d..92be57aa89 100644 --- a/src/library/scala/collection/MapLike.scala +++ b/src/library/scala/collection/MapLike.scala @@ -11,7 +11,7 @@ package scala.collection import generic._ import mutable.{ Builder, MapBuilder } -import annotation.migration +import annotation.{migration, bridge} import parallel.ParMap /** A template trait for maps, which associate keys with values. @@ -290,6 +290,9 @@ self => def ++[B1 >: B](xs: GenTraversableOnce[(A, B1)]): Map[A, B1] = ((repr: Map[A, B1]) /: xs.seq) (_ + _) + @bridge + def ++[B1 >: B](xs: TraversableOnce[(A, B1)]): Map[A, B1] = ++(xs: GenTraversableOnce[(A, B1)]) + /** Returns a new map with all key/value pairs for which the predicate * `p` returns `true`. * diff --git a/src/library/scala/collection/SeqLike.scala b/src/library/scala/collection/SeqLike.scala index 87649e8b03..0411a2987e 100644 --- a/src/library/scala/collection/SeqLike.scala +++ b/src/library/scala/collection/SeqLike.scala @@ -14,6 +14,7 @@ import mutable.{ListBuffer, HashMap, ArraySeq} import immutable.{List, Range} import generic._ import parallel.ParSeq +import annotation.bridge /** A template trait for sequences of type `Seq[A]` * $seqInfo @@ -303,6 +304,9 @@ trait SeqLike[+A, +Repr] extends IterableLike[A, Repr] with GenSeqLike[A, Repr] !j.hasNext } + @bridge + def startsWith[B](that: Seq[B], offset: Int): Boolean = startsWith(that: GenSeq[B], offset) + def endsWith[B](that: GenSeq[B]): Boolean = { val i = this.iterator.drop(length - that.length) val j = that.iterator @@ -313,6 +317,10 @@ trait SeqLike[+A, +Repr] extends IterableLike[A, Repr] with GenSeqLike[A, Repr] !j.hasNext } + @bridge + def endsWith[B](that: Seq[B]): Boolean = endsWith(that: GenSeq[B]) + + /** Finds first index where this $coll contains a given sequence as a slice. * $mayNotTerminateInf * @param that the sequence to test @@ -321,6 +329,9 @@ trait SeqLike[+A, +Repr] extends IterableLike[A, Repr] with GenSeqLike[A, Repr] */ def indexOfSlice[B >: A](that: GenSeq[B]): Int = indexOfSlice(that, 0) + @bridge + def indexOfSlice[B >: A](that: Seq[B]): Int = indexOfSlice(that: GenSeq[B]) + /** Finds first index after or at a start index where this $coll contains a given sequence as a slice. * $mayNotTerminateInf * @param that the sequence to test @@ -344,6 +355,9 @@ trait SeqLike[+A, +Repr] extends IterableLike[A, Repr] with GenSeqLike[A, Repr] -1 } + @bridge + def indexOfSlice[B >: A](that: Seq[B], from: Int): Int = indexOfSlice(that: GenSeq[B], from) + /** Finds last index where this $coll contains a given sequence as a slice. * $willNotTerminateInf * @param that the sequence to test @@ -352,6 +366,9 @@ trait SeqLike[+A, +Repr] extends IterableLike[A, Repr] with GenSeqLike[A, Repr] */ def lastIndexOfSlice[B >: A](that: GenSeq[B]): Int = lastIndexOfSlice(that, length) + @bridge + def lastIndexOfSlice[B >: A](that: Seq[B]): Int = lastIndexOfSlice(that: GenSeq[B]) + /** Finds last index before or at a given end index where this $coll contains a given sequence as a slice. * @param that the sequence to test * @param end the end index @@ -361,6 +378,9 @@ trait SeqLike[+A, +Repr] extends IterableLike[A, Repr] with GenSeqLike[A, Repr] def lastIndexOfSlice[B >: A](that: GenSeq[B], end: Int): Int = SeqLike.lastIndexOf(thisCollection, 0, length, that.seq, 0, that.length, end) + @bridge + def lastIndexOfSlice[B >: A](that: Seq[B], end: Int): Int = lastIndexOfSlice(that: GenSeq[B], end) + /** Tests whether this $coll contains a given sequence as a slice. * $mayNotTerminateInf * @param that the sequence to test @@ -369,6 +389,9 @@ trait SeqLike[+A, +Repr] extends IterableLike[A, Repr] with GenSeqLike[A, Repr] */ def containsSlice[B](that: GenSeq[B]): Boolean = indexOfSlice(that) != -1 + @bridge + def containsSlice[B](that: Seq[B]): Boolean = containsSlice(that: GenSeq[B]) + /** Tests whether this $coll contains a given value as an element. * $mayNotTerminateInf * @@ -429,6 +452,9 @@ trait SeqLike[+A, +Repr] extends IterableLike[A, Repr] with GenSeqLike[A, Repr] b.result } + @bridge + def diff[B >: A](that: Seq[B]): Repr = diff(that: GenSeq[B]) + /** Computes the multiset intersection between this $coll and another sequence. * $mayNotTerminateInf * @@ -459,6 +485,9 @@ trait SeqLike[+A, +Repr] extends IterableLike[A, Repr] with GenSeqLike[A, Repr] b.result } + @bridge + def intersect[B >: A](that: Seq[B]): Repr = intersect(that: GenSeq[B]) + private def occCounts[B](sq: Seq[B]): mutable.Map[B, Int] = { val occ = new mutable.HashMap[B, Int] { override def default(k: B) = 0 } for (y <- sq.seq) occ(y) += 1 @@ -491,6 +520,10 @@ trait SeqLike[+A, +Repr] extends IterableLike[A, Repr] with GenSeqLike[A, Repr] b.result } + @bridge + def patch[B >: A, That](from: Int, patch: Seq[B], replaced: Int)(implicit bf: CanBuildFrom[Repr, B, That]): That = + this.patch(from, patch: GenSeq[B], replaced)(bf) + def updated[B >: A, That](index: Int, elem: B)(implicit bf: CanBuildFrom[Repr, B, That]): That = { val b = bf(repr) val (prefix, rest) = this.splitAt(index) @@ -536,6 +569,10 @@ trait SeqLike[+A, +Repr] extends IterableLike[A, Repr] with GenSeqLike[A, Repr] !i.hasNext && !j.hasNext } + @bridge + def corresponds[B](that: Seq[B])(p: (A,B) => Boolean): Boolean = + corresponds(that: GenSeq[B])(p) + /** Sorts this $coll according to a comparison function. * $willNotTerminateInf * diff --git a/src/library/scala/collection/SetLike.scala b/src/library/scala/collection/SetLike.scala index c5b97c135d..2a208e0e3f 100644 --- a/src/library/scala/collection/SetLike.scala +++ b/src/library/scala/collection/SetLike.scala @@ -11,7 +11,7 @@ package scala.collection import generic._ import mutable.{ Builder, SetBuilder } -import scala.annotation.migration +import annotation.{migration, bridge} import parallel.ParSet /** A template trait for sets. @@ -127,6 +127,9 @@ self => */ def ++ (elems: GenTraversableOnce[A]): This = newBuilder ++= seq ++= elems.seq result + @bridge + def ++ (elems: TraversableOnce[A]): This = ++ (elems: GenTraversableOnce[A]) + /** Creates a new set with a given element removed from this set. * * @param elem the element to be removed @@ -148,7 +151,7 @@ self => * @param that the set to intersect with */ @deprecated("use & instead", "2.8.0") - def ** (that: GenSet[A]): This = &(that) + def ** (that: Set[A]): This = &(that) /** Computes the union between of set and another set. * @@ -158,6 +161,9 @@ self => */ def union(that: GenSet[A]): This = this ++ that + @bridge + def union(that: Set[A]): This = union(that: GenSet[A]) + /** Computes the difference of this set and another set. * * @param that the set of elements to exclude. @@ -166,6 +172,9 @@ self => */ def diff(that: GenSet[A]): This = this -- that + @bridge + def diff(that: Set[A]): This = diff(that: GenSet[A]) + /** An iterator over all subsets of this set of the given size. * If the requested size is impossible, an empty iterator is returned. * diff --git a/src/library/scala/collection/Traversable.scala b/src/library/scala/collection/Traversable.scala index 500c340368..71c5839d43 100644 --- a/src/library/scala/collection/Traversable.scala +++ b/src/library/scala/collection/Traversable.scala @@ -13,6 +13,7 @@ package scala.collection import generic._ import mutable.{Builder, Buffer, ArrayBuffer, ListBuffer} import scala.util.control.Breaks +import annotation.bridge /** A trait for traversable collections. * All operations are guaranteed to be performed in a single-threaded manner. @@ -27,6 +28,12 @@ trait Traversable[+A] extends TraversableLike[A, Traversable[A]] override def seq: Traversable[A] = this + @bridge + def flatten[B](implicit asTraversable: A => /*<:<!!!*/ TraversableOnce[B]): Traversable[B] = super.flatten(asTraversable) + + @bridge + def transpose[B](implicit asTraversable: A => /*<:<!!!*/ TraversableOnce[B]): Traversable[Traversable[B]] = super.transpose(asTraversable) + /* The following methods are inherited from TraversableLike * override def isEmpty: Boolean diff --git a/src/library/scala/collection/TraversableLike.scala b/src/library/scala/collection/TraversableLike.scala index fe1d5d7d77..c8b8dfda5f 100644 --- a/src/library/scala/collection/TraversableLike.scala +++ b/src/library/scala/collection/TraversableLike.scala @@ -10,8 +10,7 @@ package scala.collection import generic._ import mutable.{ Builder, ListBuffer } -import annotation.tailrec -import annotation.migration +import annotation.{tailrec, migration, bridge} import annotation.unchecked.{ uncheckedVariance => uV } import parallel.ParIterable @@ -153,6 +152,10 @@ trait TraversableLike[+A, +Repr] extends HasNewBuilder[A, Repr] b.result } + @bridge + def ++[B >: A, That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = + ++(that: GenTraversableOnce[B])(bf) + /** Concatenates this $coll with the elements of a traversable collection. * It differs from ++ in that the right operand determines the type of the * resulting collection rather than the left one. diff --git a/src/library/scala/collection/generic/Addable.scala b/src/library/scala/collection/generic/Addable.scala index 8f33a62f10..e2a34c1ed2 100644 --- a/src/library/scala/collection/generic/Addable.scala +++ b/src/library/scala/collection/generic/Addable.scala @@ -10,6 +10,8 @@ package scala.collection package generic +import annotation.bridge + /** This trait represents collection-like objects that can be added to * using a '+' operator. It defines variants of `+` and `++` * as convenience methods in terms of single-element addition `+`. @@ -53,4 +55,7 @@ trait Addable[A, +Repr <: Addable[A, Repr]] { self => * @return a new $coll with the given elements added. */ def ++ (xs: GenTraversableOnce[A]): Repr = (repr /: xs.seq) (_ + _) + + @bridge + def ++ (xs: TraversableOnce[A]): Repr = ++ (xs: GenTraversableOnce[A]) } diff --git a/src/library/scala/collection/generic/GenMapFactory.scala b/src/library/scala/collection/generic/GenMapFactory.scala new file mode 100644 index 0000000000..f3537e8c6b --- /dev/null +++ b/src/library/scala/collection/generic/GenMapFactory.scala @@ -0,0 +1,62 @@ +/* __ *\ +** ________ ___ / / ___ Scala API ** +** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** +** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** +** /____/\___/_/ |_/____/_/ | | ** +** |/ ** +\* */ + +package scala.collection +package generic + + +import mutable.{Builder, MapBuilder} + + +/** A template for companion objects of `Map` and subclasses thereof. + * + * @define coll map + * @define Coll Map + * @define factoryInfo + * This object provides a set of operations needed to create `$Coll` values. + * @author Martin Odersky + * @version 2.8 + * @since 2.8 + * @define canBuildFromInfo + * The standard `CanBuildFrom` instance for `$Coll` objects. + * @see CanBuildFrom + * @define mapCanBuildFromInfo + * The standard `CanBuildFrom` instance for `$Coll` objects. + * The created value is an instance of class `MapCanBuildFrom`. + * @see CanBuildFrom + * @see GenericCanBuildFrom + */ +abstract class GenMapFactory[CC[A, B] <: GenMap[A, B] with GenMapLike[A, B, CC[A, B]]] { + + /** The type constructor of the collection that can be built by this factory */ + type Coll = CC[_, _] + + /** An empty $Coll */ + def empty[A, B]: CC[A, B] + + /** A collection of type $Coll that contains given key/value bindings. + * @param elems the key/value pairs that make up the $coll + * @tparam A the type of the keys + * @tparam B the type of the associated values + * @return a new $coll consisting key/value pairs given by `elems`. + */ + def apply[A, B](elems: (A, B)*): CC[A, B] = (newBuilder[A, B] ++= elems).result + + /** The default builder for $Coll objects. + * @tparam A the type of the keys + * @tparam B the type of the associated values + */ + def newBuilder[A, B]: Builder[(A, B), CC[A, B]] = new MapBuilder[A, B, CC[A, B]](empty[A, B]) + + /** The standard `CanBuildFrom` class for maps. + */ + class MapCanBuildFrom[A, B] extends CanBuildFrom[Coll, (A, B), CC[A, B]] { + def apply(from: Coll) = newBuilder[A, B] + def apply() = newBuilder + } +} diff --git a/src/library/scala/collection/generic/GenSeqFactory.scala b/src/library/scala/collection/generic/GenSeqFactory.scala new file mode 100644 index 0000000000..6fcecc422b --- /dev/null +++ b/src/library/scala/collection/generic/GenSeqFactory.scala @@ -0,0 +1,26 @@ +/* __ *\ +** ________ ___ / / ___ Scala API ** +** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** +** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** +** /____/\___/_/ |_/____/_/ | | ** +** |/ ** +\* */ + + + +package scala.collection +package generic + +/** A template for companion objects of Seq and subclasses thereof. + * + * @since 2.8 + */ +abstract class GenSeqFactory[CC[X] <: GenSeq[X] with GenericTraversableTemplate[X, CC]] extends GenTraversableFactory[CC] { + + /** This method is called in a pattern match { case Seq(...) => }. + * + * @param x the selector value + * @return sequence wrapped in an option, if this is a Seq, otherwise none + */ + def unapplySeq[A](x: CC[A]): Some[CC[A]] = Some(x) +} diff --git a/src/library/scala/collection/generic/GenSetFactory.scala b/src/library/scala/collection/generic/GenSetFactory.scala new file mode 100644 index 0000000000..d83f248aff --- /dev/null +++ b/src/library/scala/collection/generic/GenSetFactory.scala @@ -0,0 +1,44 @@ +/* __ *\ +** ________ ___ / / ___ Scala API ** +** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** +** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** +** /____/\___/_/ |_/____/_/ | | ** +** |/ ** +\* */ + + + +package scala.collection +package generic + +import mutable.Builder + +/** A template for companion objects of `Set` and subclasses thereof. + * + * @define coll set + * @define Coll Set + * @define factoryInfo + * This object provides a set of operations needed to create `$Coll` values. + * @author Martin Odersky + * @version 2.8 + * @since 2.8 + * @define canBuildFromInfo + * The standard `CanBuildFrom` instance for `$Coll` objects. + * @see CanBuildFrom + * @define setCanBuildFromInfo + * The standard `CanBuildFrom` instance for `$Coll` objects. + * @see CanBuildFrom + * @see GenericCanBuildFrom + */ +abstract class GenSetFactory[CC[X] <: GenSet[X] with GenSetLike[X, CC[X]]] + extends GenericCompanion[CC] { + + def newBuilder[A]: Builder[A, CC[A]] + + /** $setCanBuildFromInfo + */ + def setCanBuildFrom[A] = new CanBuildFrom[CC[_], A, CC[A]] { + def apply(from: CC[_]) = newBuilder[A] + def apply() = newBuilder[A] + } +} diff --git a/src/library/scala/collection/generic/GenTraversableFactory.scala b/src/library/scala/collection/generic/GenTraversableFactory.scala new file mode 100644 index 0000000000..c2718e5ee2 --- /dev/null +++ b/src/library/scala/collection/generic/GenTraversableFactory.scala @@ -0,0 +1,245 @@ +/* __ *\ +** ________ ___ / / ___ Scala API ** +** / __/ __// _ | / / / _ | (c) 2006-2011, LAMP/EPFL ** +** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** +** /____/\___/_/ |_/____/_/ | | ** +** |/ ** +\* */ + + +package scala.collection +package generic + +/** A template for companion objects of `Traversable` and subclasses thereof. + * This class provides a set of operations to create `$Coll` objects. + * It is typically inherited by companion objects of subclasses of `Traversable`. + * + * @since 2.8 + * + * @define coll collection + * @define Coll Traversable + * @define factoryInfo + * This object provides a set of operations to create `$Coll` values. + * @author Martin Odersky + * @version 2.8 + * @define canBuildFromInfo + * The standard `CanBuildFrom` instance for $Coll objects. + * @see CanBuildFrom + * @define genericCanBuildFromInfo + * The standard `CanBuildFrom` instance for $Coll objects. + * The created value is an instance of class `GenericCanBuildFrom`, + * which forwards calls to create a new builder to the + * `genericBuilder` method of the requesting collection. + * @see CanBuildFrom + * @see GenericCanBuildFrom + */ +abstract class GenTraversableFactory[CC[X] <: GenTraversable[X] with GenericTraversableTemplate[X, CC]] + extends GenericCompanion[CC] { + + /** A generic implementation of the `CanBuildFrom` trait, which forwards + * all calls to `apply(from)` to the `genericBuilder` method of + * $coll `from`, and which forwards all calls of `apply()` to the + * `newBuilder` method of this factory. + */ + class GenericCanBuildFrom[A] extends CanBuildFrom[CC[_], A, CC[A]] { + /** Creates a new builder on request of a collection. + * @param from the collection requesting the builder to be created. + * @return the result of invoking the `genericBuilder` method on `from`. + */ + def apply(from: Coll) = from.genericBuilder[A] + + /** Creates a new builder from scratch + * @return the result of invoking the `newBuilder` method of this factory. + */ + def apply() = newBuilder[A] + } + + /** Concatenates all argument collections into a single $coll. + * + * @param xss the collections that are to be concatenated. + * @return the concatenation of all the collections. + */ + def concat[A](xss: Traversable[A]*): CC[A] = { + val b = newBuilder[A] + // At present we're using IndexedSeq as a proxy for "has a cheap size method". + if (xss forall (_.isInstanceOf[IndexedSeq[_]])) + b.sizeHint(xss map (_.size) sum) + + for (xs <- xss.seq) b ++= xs + b.result + } + + /** Produces a $coll containing the results of some element computation a number of times. + * @param n the number of elements contained in the $coll. + * @param elem the element computation + * @return A $coll that contains the results of `n` evaluations of `elem`. + */ + def fill[A](n: Int)(elem: => A): CC[A] = { + val b = newBuilder[A] + b.sizeHint(n) + var i = 0 + while (i < n) { + b += elem + i += 1 + } + b.result + } + + /** Produces a two-dimensional $coll containing the results of some element computation a number of times. + * @param n1 the number of elements in the 1st dimension + * @param n2 the number of elements in the 2nd dimension + * @param elem the element computation + * @return A $coll that contains the results of `n1 x n2` evaluations of `elem`. + */ + def fill[A](n1: Int, n2: Int)(elem: => A): CC[CC[A]] = + tabulate(n1)(_ => fill(n2)(elem)) + + /** Produces a three-dimensional $coll containing the results of some element computation a number of times. + * @param n1 the number of elements in the 1st dimension + * @param n2 the number of elements in the 2nd dimension + * @param n3 the number of elements in the 3nd dimension + * @param elem the element computation + * @return A $coll that contains the results of `n1 x n2 x n3` evaluations of `elem`. + */ + def fill[A](n1: Int, n2: Int, n3: Int)(elem: => A): CC[CC[CC[A]]] = + tabulate(n1)(_ => fill(n2, n3)(elem)) + + /** Produces a four-dimensional $coll containing the results of some element computation a number of times. + * @param n1 the number of elements in the 1st dimension + * @param n2 the number of elements in the 2nd dimension + * @param n3 the number of elements in the 3nd dimension + * @param n4 the number of elements in the 4th dimension + * @param elem the element computation + * @return A $coll that contains the results of `n1 x n2 x n3 x n4` evaluations of `elem`. + */ + def fill[A](n1: Int, n2: Int, n3: Int, n4: Int)(elem: => A): CC[CC[CC[CC[A]]]] = + tabulate(n1)(_ => fill(n2, n3, n4)(elem)) + + /** Produces a five-dimensional $coll containing the results of some element computation a number of times. + * @param n1 the number of elements in the 1st dimension + * @param n2 the number of elements in the 2nd dimension + * @param n3 the number of elements in the 3nd dimension + * @param n4 the number of elements in the 4th dimension + * @param n5 the number of elements in the 5th dimension + * @param elem the element computation + * @return A $coll that contains the results of `n1 x n2 x n3 x n4 x n5` evaluations of `elem`. + */ + def fill[A](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(elem: => A): CC[CC[CC[CC[CC[A]]]]] = + tabulate(n1)(_ => fill(n2, n3, n4, n5)(elem)) + + /** Produces a $coll containing values of a given function over a range of integer values starting from 0. + * @param n The number of elements in the $coll + * @param f The function computing element values + * @return A $coll consisting of elements `f(0), ..., f(n -1)` + */ + def tabulate[A](n: Int)(f: Int => A): CC[A] = { + val b = newBuilder[A] + b.sizeHint(n) + var i = 0 + while (i < n) { + b += f(i) + i += 1 + } + b.result + } + + /** Produces a two-dimensional $coll containing values of a given function over ranges of integer values starting from 0. + * @param n1 the number of elements in the 1st dimension + * @param n2 the number of elements in the 2nd dimension + * @param f The function computing element values + * @return A $coll consisting of elements `f(i1, i2)` + * for `0 <= i1 < n1` and `0 <= i2 < n2`. + */ + def tabulate[A](n1: Int, n2: Int)(f: (Int, Int) => A): CC[CC[A]] = + tabulate(n1)(i1 => tabulate(n2)(f(i1, _))) + + /** Produces a three-dimensional $coll containing values of a given function over ranges of integer values starting from 0. + * @param n1 the number of elements in the 1st dimension + * @param n2 the number of elements in the 2nd dimension + * @param n3 the number of elements in the 3nd dimension + * @param f The function computing element values + * @return A $coll consisting of elements `f(i1, i2, i3)` + * for `0 <= i1 < n1`, `0 <= i2 < n2`, and `0 <= i3 < n3`. + */ + def tabulate[A](n1: Int, n2: Int, n3: Int)(f: (Int, Int, Int) => A): CC[CC[CC[A]]] = + tabulate(n1)(i1 => tabulate(n2, n3)(f(i1, _, _))) + + /** Produces a four-dimensional $coll containing values of a given function over ranges of integer values starting from 0. + * @param n1 the number of elements in the 1st dimension + * @param n2 the number of elements in the 2nd dimension + * @param n3 the number of elements in the 3nd dimension + * @param n4 the number of elements in the 4th dimension + * @param f The function computing element values + * @return A $coll consisting of elements `f(i1, i2, i3, i4)` + * for `0 <= i1 < n1`, `0 <= i2 < n2`, `0 <= i3 < n3`, and `0 <= i4 < n4`. + */ + def tabulate[A](n1: Int, n2: Int, n3: Int, n4: Int)(f: (Int, Int, Int, Int) => A): CC[CC[CC[CC[A]]]] = + tabulate(n1)(i1 => tabulate(n2, n3, n4)(f(i1, _, _, _))) + + /** Produces a five-dimensional $coll containing values of a given function over ranges of integer values starting from 0. + * @param n1 the number of elements in the 1st dimension + * @param n2 the number of elements in the 2nd dimension + * @param n3 the number of elements in the 3nd dimension + * @param n4 the number of elements in the 4th dimension + * @param n5 the number of elements in the 5th dimension + * @param f The function computing element values + * @return A $coll consisting of elements `f(i1, i2, i3, i4, i5)` + * for `0 <= i1 < n1`, `0 <= i2 < n2`, `0 <= i3 < n3`, `0 <= i4 < n4`, and `0 <= i5 < n5`. + */ + def tabulate[A](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(f: (Int, Int, Int, Int, Int) => A): CC[CC[CC[CC[CC[A]]]]] = + tabulate(n1)(i1 => tabulate(n2, n3, n4, n5)(f(i1, _, _, _, _))) + + /** Produces a $coll containing a sequence of increasing of integers. + * + * @param from the first element of the $coll + * @param end the end value of the $coll (the first value NOT contained) + * @return a $coll with values `start, start + 1, ..., end - 1` + */ + def range[T: Integral](start: T, end: T): CC[T] = range(start, end, implicitly[Integral[T]].one) + + /** Produces a $coll containing equally spaced values in some integer interval. + * @param start the start value of the $coll + * @param end the end value of the $coll (the first value NOT contained) + * @param step the difference between successive elements of the $coll (must be positive or negative) + * @return a $coll with values `start, start + step, ...` up to, but excluding `end` + */ + def range[T: Integral](start: T, end: T, step: T): CC[T] = { + val num = implicitly[Integral[T]] + import num._ + + if (step == zero) throw new IllegalArgumentException("zero step") + val b = newBuilder[T] + b sizeHint immutable.NumericRange.count(start, end, step, false) + var i = start + while (if (step < zero) end < i else i < end) { + b += i + i += step + } + b.result + } + + /** Produces a $coll containing repeated applications of a function to a start value. + * + * @param start the start value of the $coll + * @param len the number of elements contained inthe $coll + * @param f the function that's repeatedly applied + * @return a $coll with `len` values in the sequence `start, f(start), f(f(start)), ...` + */ + def iterate[A](start: A, len: Int)(f: A => A): CC[A] = { + val b = newBuilder[A] + if (len > 0) { + b.sizeHint(len) + var acc = start + var i = 1 + b += acc + + while (i < len) { + acc = f(acc) + i += 1 + b += acc + } + } + b.result + } +} + diff --git a/src/library/scala/collection/generic/GenericSeqCompanion.scala b/src/library/scala/collection/generic/GenericSeqCompanion.scala new file mode 100644 index 0000000000..41e8d6dd39 --- /dev/null +++ b/src/library/scala/collection/generic/GenericSeqCompanion.scala @@ -0,0 +1,24 @@ +/* __ *\ +** ________ ___ / / ___ Scala API ** +** / __/ __// _ | / / / _ | (c) 2006-2011, LAMP/EPFL ** +** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** +** /____/\___/_/ |_/____/_/ | | ** +** |/ ** +\* */ + + +package scala.collection +package generic + +import annotation.bridge + +trait GenericSeqCompanion[CC[X] <: Traversable[X]] + extends GenericCompanion[CC] { + + @bridge + override def empty[A]: CC[A] = super.empty[A] + + @bridge + override def apply[A](elems: A*): CC[A] = super.apply(elems: _*) + +} diff --git a/src/library/scala/collection/generic/MapFactory.scala b/src/library/scala/collection/generic/MapFactory.scala index 122d1c9313..a60e3032c1 100644 --- a/src/library/scala/collection/generic/MapFactory.scala +++ b/src/library/scala/collection/generic/MapFactory.scala @@ -11,7 +11,7 @@ package generic import mutable.{Builder, MapBuilder} - +import annotation.bridge /** A template for companion objects of `Map` and subclasses thereof. * @@ -31,32 +31,10 @@ import mutable.{Builder, MapBuilder} * @see CanBuildFrom * @see GenericCanBuildFrom */ -abstract class MapFactory[CC[A, B] <: GenMap[A, B] with GenMapLike[A, B, CC[A, B]]] { - - /** The type constructor of the collection that can be built by this factory */ - type Coll = CC[_, _] +abstract class MapFactory[CC[A, B] <: Map[A, B] with MapLike[A, B, CC[A, B]]] extends GenMapFactory[CC] { - /** An empty $Coll */ def empty[A, B]: CC[A, B] - /** A collection of type $Coll that contains given key/value bindings. - * @param elems the key/value pairs that make up the $coll - * @tparam A the type of the keys - * @tparam B the type of the associated values - * @return a new $coll consisting key/value pairs given by `elems`. - */ - def apply[A, B](elems: (A, B)*): CC[A, B] = (newBuilder[A, B] ++= elems).result - - /** The default builder for $Coll objects. - * @tparam A the type of the keys - * @tparam B the type of the associated values - */ - def newBuilder[A, B]: Builder[(A, B), CC[A, B]] = new MapBuilder[A, B, CC[A, B]](empty[A, B]) - - /** The standard `CanBuildFrom` class for maps. - */ - class MapCanBuildFrom[A, B] extends CanBuildFrom[Coll, (A, B), CC[A, B]] { - def apply(from: Coll) = newBuilder[A, B] - def apply() = newBuilder - } + @bridge + override def apply[A, B](elems: (A, B)*): CC[A, B] = super.apply(elems: _*) } diff --git a/src/library/scala/collection/generic/ParFactory.scala b/src/library/scala/collection/generic/ParFactory.scala index e8c2b239c3..637a1dca6a 100644 --- a/src/library/scala/collection/generic/ParFactory.scala +++ b/src/library/scala/collection/generic/ParFactory.scala @@ -21,7 +21,7 @@ import scala.collection.parallel.Combiner * @define Coll ParIterable */ abstract class ParFactory[CC[X] <: ParIterable[X] with GenericParTemplate[X, CC]] -extends TraversableFactory[CC] +extends GenTraversableFactory[CC] with GenericParCompanion[CC] { //type EPC[T, C] = collection.parallel.EnvironmentPassingCombiner[T, C] diff --git a/src/library/scala/collection/generic/ParMapFactory.scala b/src/library/scala/collection/generic/ParMapFactory.scala index 1a9efdf7a7..06105c9756 100644 --- a/src/library/scala/collection/generic/ParMapFactory.scala +++ b/src/library/scala/collection/generic/ParMapFactory.scala @@ -20,7 +20,7 @@ import scala.collection.mutable.Builder * @define Coll ParMap */ abstract class ParMapFactory[CC[X, Y] <: ParMap[X, Y] with ParMapLike[X, Y, CC[X, Y], _]] -extends MapFactory[CC] +extends GenMapFactory[CC] with GenericParMapCompanion[CC] { type MapColl = CC[_, _] diff --git a/src/library/scala/collection/generic/ParSetFactory.scala b/src/library/scala/collection/generic/ParSetFactory.scala index 4cf39f9041..221e893593 100644 --- a/src/library/scala/collection/generic/ParSetFactory.scala +++ b/src/library/scala/collection/generic/ParSetFactory.scala @@ -23,7 +23,7 @@ import collection.parallel.ParSetLike abstract class ParSetFactory[CC[X] <: ParSet[X] with ParSetLike[X, CC[X], _] with GenericParTemplate[X, CC]] - extends SetFactory[CC] + extends GenSetFactory[CC] with GenericParCompanion[CC] { def newBuilder[A]: Combiner[A, CC[A]] = newCombiner[A] diff --git a/src/library/scala/collection/generic/SeqFactory.scala b/src/library/scala/collection/generic/SeqFactory.scala index 5e733d8444..544d8f4d6f 100644 --- a/src/library/scala/collection/generic/SeqFactory.scala +++ b/src/library/scala/collection/generic/SeqFactory.scala @@ -11,16 +11,12 @@ package scala.collection package generic +import annotation.bridge + /** A template for companion objects of Seq and subclasses thereof. * * @since 2.8 */ -abstract class SeqFactory[CC[X] <: GenSeq[X] with GenericTraversableTemplate[X, CC]] extends TraversableFactory[CC] { +abstract class SeqFactory[CC[X] <: Seq[X] with GenericTraversableTemplate[X, CC]] + extends GenSeqFactory[CC] with TraversableFactory[CC] - /** This method is called in a pattern match { case Seq(...) => }. - * - * @param x the selector value - * @return sequence wrapped in an option, if this is a Seq, otherwise none - */ - def unapplySeq[A](x: CC[A]): Some[CC[A]] = Some(x) -} diff --git a/src/library/scala/collection/generic/SetFactory.scala b/src/library/scala/collection/generic/SetFactory.scala index 3b8b5d3d47..348743a120 100644 --- a/src/library/scala/collection/generic/SetFactory.scala +++ b/src/library/scala/collection/generic/SetFactory.scala @@ -12,33 +12,14 @@ package scala.collection package generic import mutable.Builder +import annotation.bridge -/** A template for companion objects of `Set` and subclasses thereof. - * - * @define coll set - * @define Coll Set - * @define factoryInfo - * This object provides a set of operations needed to create `$Coll` values. - * @author Martin Odersky - * @version 2.8 - * @since 2.8 - * @define canBuildFromInfo - * The standard `CanBuildFrom` instance for `$Coll` objects. - * @see CanBuildFrom - * @define setCanBuildFromInfo - * The standard `CanBuildFrom` instance for `$Coll` objects. - * @see CanBuildFrom - * @see GenericCanBuildFrom - */ -abstract class SetFactory[CC[X] <: GenSet[X] with GenSetLike[X, CC[X]]] - extends GenericCompanion[CC] { +abstract class SetFactory[CC[X] <: Set[X] with SetLike[X, CC[X]]] + extends GenSetFactory[CC] with GenericSeqCompanion[CC] { - def newBuilder[A]: Builder[A, CC[A]] + @bridge + override def empty[A]: CC[A] = super.empty[A] - /** $setCanBuildFromInfo - */ - def setCanBuildFrom[A] = new CanBuildFrom[CC[_], A, CC[A]] { - def apply(from: CC[_]) = newBuilder[A] - def apply() = newBuilder[A] - } + @bridge + override def apply[A](elems: A*): CC[A] = super.apply(elems: _*) } diff --git a/src/library/scala/collection/generic/Subtractable.scala b/src/library/scala/collection/generic/Subtractable.scala index 1e151f9212..1ca9d706f0 100644 --- a/src/library/scala/collection/generic/Subtractable.scala +++ b/src/library/scala/collection/generic/Subtractable.scala @@ -10,6 +10,8 @@ package scala.collection package generic +import annotation.bridge + /** This trait represents collection-like objects that can be reduced * using a '+' operator. It defines variants of `-` and `--` * as convenience methods in terms of single-element removal `-`. @@ -56,4 +58,7 @@ trait Subtractable[A, +Repr <: Subtractable[A, Repr]] { self => * except one less occurrence of each of the elements of `elems`. */ def --(xs: GenTraversableOnce[A]): Repr = (repr /: xs.seq) (_ - _) + + @bridge + def --(xs: TraversableOnce[A]): Repr = --(xs: GenTraversableOnce[A]) } diff --git a/src/library/scala/collection/generic/TraversableFactory.scala b/src/library/scala/collection/generic/TraversableFactory.scala index 66e5d2db77..e71de1252c 100644 --- a/src/library/scala/collection/generic/TraversableFactory.scala +++ b/src/library/scala/collection/generic/TraversableFactory.scala @@ -10,6 +10,8 @@ package scala.collection package generic +import annotation.bridge + /** A template for companion objects of `Traversable` and subclasses thereof. * This class provides a set of operations to create `$Coll` objects. * It is typically inherited by companion objects of subclasses of `Traversable`. @@ -33,213 +35,49 @@ package generic * @see CanBuildFrom * @see GenericCanBuildFrom */ -abstract class TraversableFactory[CC[X] <: GenTraversable[X] with GenericTraversableTemplate[X, CC]] - extends GenericCompanion[CC] { - - /** A generic implementation of the `CanBuildFrom` trait, which forwards - * all calls to `apply(from)` to the `genericBuilder` method of - * $coll `from`, and which forwards all calls of `apply()` to the - * `newBuilder` method of this factory. - */ - class GenericCanBuildFrom[A] extends CanBuildFrom[CC[_], A, CC[A]] { - /** Creates a new builder on request of a collection. - * @param from the collection requesting the builder to be created. - * @return the result of invoking the `genericBuilder` method on `from`. - */ - def apply(from: Coll) = from.genericBuilder[A] - - /** Creates a new builder from scratch - * @return the result of invoking the `newBuilder` method of this factory. - */ - def apply() = newBuilder[A] - } - - /** Concatenates all argument collections into a single $coll. - * - * @param xss the collections that are to be concatenated. - * @return the concatenation of all the collections. - */ - def concat[A](xss: Traversable[A]*): CC[A] = { - val b = newBuilder[A] - // At present we're using IndexedSeq as a proxy for "has a cheap size method". - if (xss forall (_.isInstanceOf[IndexedSeq[_]])) - b.sizeHint(xss map (_.size) sum) - - for (xs <- xss.seq) b ++= xs - b.result - } - - /** Produces a $coll containing the results of some element computation a number of times. - * @param n the number of elements contained in the $coll. - * @param elem the element computation - * @return A $coll that contains the results of `n` evaluations of `elem`. - */ - def fill[A](n: Int)(elem: => A): CC[A] = { - val b = newBuilder[A] - b.sizeHint(n) - var i = 0 - while (i < n) { - b += elem - i += 1 - } - b.result - } - - /** Produces a two-dimensional $coll containing the results of some element computation a number of times. - * @param n1 the number of elements in the 1st dimension - * @param n2 the number of elements in the 2nd dimension - * @param elem the element computation - * @return A $coll that contains the results of `n1 x n2` evaluations of `elem`. - */ - def fill[A](n1: Int, n2: Int)(elem: => A): CC[CC[A]] = - tabulate(n1)(_ => fill(n2)(elem)) - - /** Produces a three-dimensional $coll containing the results of some element computation a number of times. - * @param n1 the number of elements in the 1st dimension - * @param n2 the number of elements in the 2nd dimension - * @param n3 the number of elements in the 3nd dimension - * @param elem the element computation - * @return A $coll that contains the results of `n1 x n2 x n3` evaluations of `elem`. - */ - def fill[A](n1: Int, n2: Int, n3: Int)(elem: => A): CC[CC[CC[A]]] = - tabulate(n1)(_ => fill(n2, n3)(elem)) - - /** Produces a four-dimensional $coll containing the results of some element computation a number of times. - * @param n1 the number of elements in the 1st dimension - * @param n2 the number of elements in the 2nd dimension - * @param n3 the number of elements in the 3nd dimension - * @param n4 the number of elements in the 4th dimension - * @param elem the element computation - * @return A $coll that contains the results of `n1 x n2 x n3 x n4` evaluations of `elem`. - */ - def fill[A](n1: Int, n2: Int, n3: Int, n4: Int)(elem: => A): CC[CC[CC[CC[A]]]] = - tabulate(n1)(_ => fill(n2, n3, n4)(elem)) - - /** Produces a five-dimensional $coll containing the results of some element computation a number of times. - * @param n1 the number of elements in the 1st dimension - * @param n2 the number of elements in the 2nd dimension - * @param n3 the number of elements in the 3nd dimension - * @param n4 the number of elements in the 4th dimension - * @param n5 the number of elements in the 5th dimension - * @param elem the element computation - * @return A $coll that contains the results of `n1 x n2 x n3 x n4 x n5` evaluations of `elem`. - */ - def fill[A](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(elem: => A): CC[CC[CC[CC[CC[A]]]]] = - tabulate(n1)(_ => fill(n2, n3, n4, n5)(elem)) - - /** Produces a $coll containing values of a given function over a range of integer values starting from 0. - * @param n The number of elements in the $coll - * @param f The function computing element values - * @return A $coll consisting of elements `f(0), ..., f(n -1)` - */ - def tabulate[A](n: Int)(f: Int => A): CC[A] = { - val b = newBuilder[A] - b.sizeHint(n) - var i = 0 - while (i < n) { - b += f(i) - i += 1 - } - b.result - } - - /** Produces a two-dimensional $coll containing values of a given function over ranges of integer values starting from 0. - * @param n1 the number of elements in the 1st dimension - * @param n2 the number of elements in the 2nd dimension - * @param f The function computing element values - * @return A $coll consisting of elements `f(i1, i2)` - * for `0 <= i1 < n1` and `0 <= i2 < n2`. - */ - def tabulate[A](n1: Int, n2: Int)(f: (Int, Int) => A): CC[CC[A]] = - tabulate(n1)(i1 => tabulate(n2)(f(i1, _))) - - /** Produces a three-dimensional $coll containing values of a given function over ranges of integer values starting from 0. - * @param n1 the number of elements in the 1st dimension - * @param n2 the number of elements in the 2nd dimension - * @param n3 the number of elements in the 3nd dimension - * @param f The function computing element values - * @return A $coll consisting of elements `f(i1, i2, i3)` - * for `0 <= i1 < n1`, `0 <= i2 < n2`, and `0 <= i3 < n3`. - */ - def tabulate[A](n1: Int, n2: Int, n3: Int)(f: (Int, Int, Int) => A): CC[CC[CC[A]]] = - tabulate(n1)(i1 => tabulate(n2, n3)(f(i1, _, _))) - - /** Produces a four-dimensional $coll containing values of a given function over ranges of integer values starting from 0. - * @param n1 the number of elements in the 1st dimension - * @param n2 the number of elements in the 2nd dimension - * @param n3 the number of elements in the 3nd dimension - * @param n4 the number of elements in the 4th dimension - * @param f The function computing element values - * @return A $coll consisting of elements `f(i1, i2, i3, i4)` - * for `0 <= i1 < n1`, `0 <= i2 < n2`, `0 <= i3 < n3`, and `0 <= i4 < n4`. - */ - def tabulate[A](n1: Int, n2: Int, n3: Int, n4: Int)(f: (Int, Int, Int, Int) => A): CC[CC[CC[CC[A]]]] = - tabulate(n1)(i1 => tabulate(n2, n3, n4)(f(i1, _, _, _))) - - /** Produces a five-dimensional $coll containing values of a given function over ranges of integer values starting from 0. - * @param n1 the number of elements in the 1st dimension - * @param n2 the number of elements in the 2nd dimension - * @param n3 the number of elements in the 3nd dimension - * @param n4 the number of elements in the 4th dimension - * @param n5 the number of elements in the 5th dimension - * @param f The function computing element values - * @return A $coll consisting of elements `f(i1, i2, i3, i4, i5)` - * for `0 <= i1 < n1`, `0 <= i2 < n2`, `0 <= i3 < n3`, `0 <= i4 < n4`, and `0 <= i5 < n5`. - */ - def tabulate[A](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(f: (Int, Int, Int, Int, Int) => A): CC[CC[CC[CC[CC[A]]]]] = - tabulate(n1)(i1 => tabulate(n2, n3, n4, n5)(f(i1, _, _, _, _))) - - /** Produces a $coll containing a sequence of increasing of integers. - * - * @param from the first element of the $coll - * @param end the end value of the $coll (the first value NOT contained) - * @return a $coll with values `start, start + 1, ..., end - 1` - */ - def range[T: Integral](start: T, end: T): CC[T] = range(start, end, implicitly[Integral[T]].one) - - /** Produces a $coll containing equally spaced values in some integer interval. - * @param start the start value of the $coll - * @param end the end value of the $coll (the first value NOT contained) - * @param step the difference between successive elements of the $coll (must be positive or negative) - * @return a $coll with values `start, start + step, ...` up to, but excluding `end` - */ - def range[T: Integral](start: T, end: T, step: T): CC[T] = { - val num = implicitly[Integral[T]] - import num._ - - if (step == zero) throw new IllegalArgumentException("zero step") - val b = newBuilder[T] - b sizeHint immutable.NumericRange.count(start, end, step, false) - var i = start - while (if (step < zero) end < i else i < end) { - b += i - i += step - } - b.result - } - - /** Produces a $coll containing repeated applications of a function to a start value. - * - * @param start the start value of the $coll - * @param len the number of elements contained inthe $coll - * @param f the function that's repeatedly applied - * @return a $coll with `len` values in the sequence `start, f(start), f(f(start)), ...` - */ - def iterate[A](start: A, len: Int)(f: A => A): CC[A] = { - val b = newBuilder[A] - if (len > 0) { - b.sizeHint(len) - var acc = start - var i = 1 - b += acc - - while (i < len) { - acc = f(acc) - i += 1 - b += acc - } - } - b.result - } +trait TraversableFactory[CC[X] <: Traversable[X] with GenericTraversableTemplate[X, CC]] + extends GenTraversableFactory[CC] with GenericSeqCompanion[CC] { + + @bridge + override def concat[A](xss: Traversable[A]*): CC[A] = super.concat(xss: _*) + + @bridge + override def fill[A](n: Int)(elem: => A): CC[A] = super.fill(n)(elem) + + @bridge + override def fill[A](n1: Int, n2: Int)(elem: => A): CC[CC[A]] = super.fill(n1, n2)(elem) + + @bridge + override def fill[A](n1: Int, n2: Int, n3: Int)(elem: => A): CC[CC[CC[A]]] = super.fill(n1, n2, n3)(elem) + + @bridge + override def fill[A](n1: Int, n2: Int, n3: Int, n4: Int)(elem: => A): CC[CC[CC[CC[A]]]] = super.fill(n1, n2, n3, n4)(elem) + + @bridge + override def fill[A](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(elem: => A): CC[CC[CC[CC[CC[A]]]]] = super.fill(n1, n2, n3, n4, n5)(elem) + + @bridge + override def tabulate[A](n: Int)(f: Int => A): CC[A] = super.tabulate(n)(f) + + @bridge + override def tabulate[A](n1: Int, n2: Int)(f: (Int, Int) => A): CC[CC[A]] = super.tabulate(n1, n2)(f) + + @bridge + override def tabulate[A](n1: Int, n2: Int, n3: Int)(f: (Int, Int, Int) => A): CC[CC[CC[A]]] = super.tabulate(n1, n2, n3)(f) + + @bridge + override def tabulate[A](n1: Int, n2: Int, n3: Int, n4: Int)(f: (Int, Int, Int, Int) => A): CC[CC[CC[CC[A]]]] = super.tabulate(n1, n2, n3, n4)(f) + + @bridge + override def tabulate[A](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(f: (Int, Int, Int, Int, Int) => A): CC[CC[CC[CC[CC[A]]]]] = super.tabulate(n1, n2, n3, n4, n5)(f) + + @bridge + override def range[T: Integral](start: T, end: T): CC[T] = super.range(start, end) + + @bridge + override def range[T: Integral](start: T, end: T, step: T): CC[T] = super.range(start, end, step) + + @bridge + override def iterate[A](start: A, len: Int)(f: A => A): CC[A] = super.iterate(start, len)(f) } diff --git a/src/library/scala/collection/immutable/Range.scala b/src/library/scala/collection/immutable/Range.scala index 2a5ba9839f..2b1e4bff13 100644 --- a/src/library/scala/collection/immutable/Range.scala +++ b/src/library/scala/collection/immutable/Range.scala @@ -10,6 +10,7 @@ package scala.collection.immutable import scala.collection.parallel.immutable.ParRange +import annotation.bridge /** The `Range` class represents integer values in range * ''[start;end)'' with non-zero step value `step`. @@ -326,4 +327,10 @@ object Range { def apply(start: Int, end: Int, step: Int) = NumericRange(start, end, step) def inclusive(start: Int, end: Int, step: Int) = NumericRange.inclusive(start, end, step) } + + @deprecated("use Range instead") + trait ByOne extends Range { + @bridge override def foreach[@specialized(Unit) U](f: Int => U) = + super.foreach(f) + } } diff --git a/src/library/scala/collection/mutable/BufferLike.scala b/src/library/scala/collection/mutable/BufferLike.scala index 3c9e336e6f..c48dd5d621 100644 --- a/src/library/scala/collection/mutable/BufferLike.scala +++ b/src/library/scala/collection/mutable/BufferLike.scala @@ -13,7 +13,7 @@ package mutable import generic._ import script._ -import annotation.migration +import annotation.{migration, bridge} /** A template trait for buffers of type `Buffer[A]`. * @@ -271,6 +271,9 @@ trait BufferLike[A, +This <: BufferLike[A, This] with Buffer[A]] ) def ++(xs: GenTraversableOnce[A]): This = clone() ++= xs.seq + @bridge + def ++(xs: TraversableOnce[A]): This = ++(xs: GenTraversableOnce[A]) + /** Creates a new collection with all the elements of this collection except `elem`. * * @param elem the element to remove. diff --git a/src/library/scala/collection/mutable/PriorityQueue.scala b/src/library/scala/collection/mutable/PriorityQueue.scala index 59648f160c..2c03f329a7 100644 --- a/src/library/scala/collection/mutable/PriorityQueue.scala +++ b/src/library/scala/collection/mutable/PriorityQueue.scala @@ -12,7 +12,7 @@ package scala.collection package mutable import generic._ -import annotation.migration +import annotation.{migration, bridge} /** This class implements priority queues using a heap. * To prioritize elements of type A there must be an implicit @@ -127,7 +127,10 @@ class PriorityQueue[A](implicit val ord: Ordering[A]) * @param xs a traversable object. * @return a new priority queue containing elements of both `xs` and `this`. */ - def ++(xs: GenTraversableOnce[A]) = { this.clone() ++= xs.seq } + def ++(xs: GenTraversableOnce[A]): PriorityQueue[A] = { this.clone() ++= xs.seq } + + @bridge + def ++(xs: TraversableOnce[A]): PriorityQueue[A] = ++ (xs: GenTraversableOnce[A]) /** Adds all elements to the queue. * diff --git a/src/library/scala/collection/parallel/immutable/package.scala b/src/library/scala/collection/parallel/immutable/package.scala index c62459deeb..19f8665667 100644 --- a/src/library/scala/collection/parallel/immutable/package.scala +++ b/src/library/scala/collection/parallel/immutable/package.scala @@ -6,19 +6,8 @@ ** |/ ** \* */ - package scala.collection.parallel - - - - - - - - - - package object immutable { /* package level methods */ @@ -36,7 +25,7 @@ package object immutable { */ private[parallel] class Repetition[T](elem: T, val length: Int) extends ParSeq[T] { self => - def apply(idx: Int) = if (0 <= idx && idx < length) elem else throw new IndexOutOfBoundsException + def apply(idx: Int) = if (0 <= idx && idx < length) elem else throw new IndexOutOfBoundsException("" + idx) override def seq = throw new UnsupportedOperationException def update(idx: Int, elem: T) = throw new UnsupportedOperationException @@ -58,15 +47,4 @@ package object immutable { def splitter = new ParIterator with SCPI } - } - - - - - - - - - - diff --git a/src/library/scala/reflect/generic/Scopes.scala b/src/library/scala/reflect/generic/Scopes.scala index 9f8a8ecd19..9aff63d958 100755 --- a/src/library/scala/reflect/generic/Scopes.scala +++ b/src/library/scala/reflect/generic/Scopes.scala @@ -4,7 +4,7 @@ package generic trait Scopes { self: Universe => abstract class AbsScope extends Iterable[Symbol] { - def enter(sym: Symbol): Symbol + private[reflect] def enter(sym: Symbol): Symbol } type Scope <: AbsScope diff --git a/src/library/scala/reflect/generic/Symbols.scala b/src/library/scala/reflect/generic/Symbols.scala index 49cf7df1ef..3614bfdeb4 100755 --- a/src/library/scala/reflect/generic/Symbols.scala +++ b/src/library/scala/reflect/generic/Symbols.scala @@ -27,7 +27,7 @@ trait Symbols { self: Universe => /** The name of the symbol before decoding, e.g. `\$eq\$eq` instead of `==`. */ - def encodedName: String + def encodedName: String = name.toString /** The decoded name of the symbol, e.g. `==` instead of `\$eq\$eq`. */ diff --git a/src/library/scala/reflect/generic/Types.scala b/src/library/scala/reflect/generic/Types.scala index 6dcd90e66c..c0eded6ab7 100755 --- a/src/library/scala/reflect/generic/Types.scala +++ b/src/library/scala/reflect/generic/Types.scala @@ -36,20 +36,21 @@ trait Types { self: Universe => } type Type >: Null <: AbsType + type SingletonType >: Null <: Type val NoType: Type val NoPrefix: Type - type ThisType <: Type + type ThisType <: SingletonType val ThisType: ThisTypeExtractor type TypeRef <: Type val TypeRef: TypeRefExtractor - type SingleType <: Type + type SingleType <: SingletonType val SingleType: SingleTypeExtractor - type SuperType <: Type + type SuperType <: SingletonType val SuperType: SuperTypeExtractor type TypeBounds <: Type diff --git a/src/library/scala/runtime/RichInt.scala b/src/library/scala/runtime/RichInt.scala index 771d430c92..cb02b6d3a8 100644 --- a/src/library/scala/runtime/RichInt.scala +++ b/src/library/scala/runtime/RichInt.scala @@ -10,6 +10,7 @@ package scala.runtime import scala.collection.immutable.Range +import annotation.bridge // Note that this does not implement IntegralProxy[Int] so that it can return // the Int-specific Range class from until/to. @@ -20,10 +21,16 @@ final class RichInt(val self: Int) extends ScalaNumberProxy[Int] with RangedProx def until(end: Int): Range = Range(self, end) def until(end: Int, step: Int): Range = Range(self, end, step) + @bridge + def until(end: Int): Range with Range.ByOne = new Range(self, end, 1) with Range.ByOne + /** like `until`, but includes the last index */ def to(end: Int): Range.Inclusive = Range.inclusive(self, end) def to(end: Int, step: Int): Range.Inclusive = Range.inclusive(self, end, step) + @bridge + def to(end: Int): Range with Range.ByOne = new Range.Inclusive(self, end, 1) with Range.ByOne + override def min(that: Int): Int = if (self < that) self else that override def max(that: Int): Int = if (self > that) self else that override def abs: Int = if (self < 0) -self else self diff --git a/src/library/scala/util/automata/BaseBerrySethi.scala b/src/library/scala/util/automata/BaseBerrySethi.scala index c6a3d40c4f..4b1003ba33 100644 --- a/src/library/scala/util/automata/BaseBerrySethi.scala +++ b/src/library/scala/util/automata/BaseBerrySethi.scala @@ -85,14 +85,12 @@ abstract class BaseBerrySethi { case x: Meta => compFollow1(fol1, x.r) case x: Star => compFollow1(fol1 ++ compFirst(x.r), x.r) case x: Sequ => - var first = emptySet x.rs.foldRight(fol1) { (p, fol) => val first = compFollow1(fol, p) if (p.isNullable) fol ++ first else first } - first case _ => throw new IllegalArgumentException("unexpected pattern: " + r.getClass()) } diff --git a/src/swing/scala/swing/Component.scala b/src/swing/scala/swing/Component.scala index b7a93ef448..fc4936cfde 100644 --- a/src/swing/scala/swing/Component.scala +++ b/src/swing/scala/swing/Component.scala @@ -122,7 +122,7 @@ abstract class Component extends UIElement { - @deprecated("Use mouse instead") lazy val Mouse = mouse + @deprecated("Use mouse instead", "2.8.0") lazy val Mouse = mouse /** * Contains publishers for various mouse events. They are separated for diff --git a/src/swing/scala/swing/GUIApplication.scala b/src/swing/scala/swing/GUIApplication.scala index 23844bb063..8c63115707 100644 --- a/src/swing/scala/swing/GUIApplication.scala +++ b/src/swing/scala/swing/GUIApplication.scala @@ -16,7 +16,7 @@ import javax.swing._ /** * Convenience class with utility methods for GUI applications. */ -@deprecated("Use SwingApplication instead") class GUIApplication { +@deprecated("Use SwingApplication instead", "2.8.0") class GUIApplication { /** * Called before the GUI is created. Override to customize. diff --git a/src/swing/scala/swing/ListView.scala b/src/swing/scala/swing/ListView.scala index 0c019f773c..c5a50752ea 100644 --- a/src/swing/scala/swing/ListView.scala +++ b/src/swing/scala/swing/ListView.scala @@ -195,13 +195,13 @@ class ListView[A] extends Component { object indices extends Indices(peer.getSelectedIndices) { def -=(n: Int): this.type = { peer.removeSelectionInterval(n,n); this } def +=(n: Int): this.type = { peer.addSelectionInterval(n,n); this } - @deprecated("Use ListView.selection.leadIndex") + @deprecated("Use ListView.selection.leadIndex", "2.8.0") def leadIndex: Int = peer.getSelectionModel.getLeadSelectionIndex - @deprecated("Use ListView.selection.anchorIndex") + @deprecated("Use ListView.selection.anchorIndex", "2.8.0") def anchorIndex: Int = peer.getSelectionModel.getAnchorSelectionIndex } - @deprecated("Use ListView.selectIndices") + @deprecated("Use ListView.selectIndices", "2.8.0") def selectIndices(ind: Int*) = peer.setSelectedIndices(ind.toArray) /** @@ -209,9 +209,9 @@ class ListView[A] extends Component { */ object items extends scala.collection.SeqProxy[A] { def self = peer.getSelectedValues.map(_.asInstanceOf[A]) - @deprecated("Use ListView.selection.leadIndex") + @deprecated("Use ListView.selection.leadIndex", "2.8.0") def leadIndex: Int = peer.getSelectionModel.getLeadSelectionIndex - @deprecated("Use ListView.selection.anchorIndex") + @deprecated("Use ListView.selection.anchorIndex", "2.8.0") def anchorIndex: Int = peer.getSelectionModel.getAnchorSelectionIndex } diff --git a/src/swing/scala/swing/SimpleGUIApplication.scala b/src/swing/scala/swing/SimpleGUIApplication.scala index 5f32a63afe..74d5d5ee04 100644 --- a/src/swing/scala/swing/SimpleGUIApplication.scala +++ b/src/swing/scala/swing/SimpleGUIApplication.scala @@ -21,7 +21,7 @@ import javax.swing._ * the EDT (see Swing.onEDT and Swing.onEDTWait). Lazy values are okay for the same reason * if they are initialized on the EDT always. */ -@deprecated("Use SimpleSwingApplication instead") abstract class SimpleGUIApplication extends GUIApplication { +@deprecated("Use SimpleSwingApplication instead", "2.8.0") abstract class SimpleGUIApplication extends GUIApplication { /** * A GUI application's version of the main method. Called by the default diff --git a/src/swing/scala/swing/UIElement.scala b/src/swing/scala/swing/UIElement.scala index 5f1d39bb64..8e34b0c38c 100644 --- a/src/swing/scala/swing/UIElement.scala +++ b/src/swing/scala/swing/UIElement.scala @@ -100,7 +100,7 @@ trait UIElement extends Proxy with LazyPublisher { def bounds = peer.getBounds def size = peer.getSize @deprecated("Explicit size assignement for UIElements is not supported anymore. " + - "Use a layout manager or subclass Window.") + "Use a layout manager or subclass Window.", "2.8.0") def size_=(dim: Dimension) = peer.setSize(dim) def locale = peer.getLocale diff --git a/src/swing/scala/swing/event/ComponentEvent.scala b/src/swing/scala/swing/event/ComponentEvent.scala index f312cb33d8..d8cff46168 100644 --- a/src/swing/scala/swing/event/ComponentEvent.scala +++ b/src/swing/scala/swing/event/ComponentEvent.scala @@ -15,11 +15,11 @@ trait ComponentEvent extends UIEvent { val source: Component } -@deprecated("Use UIElementMoved instead.") +@deprecated("Use UIElementMoved instead.", "2.8.0") case class ComponentMoved(source: Component) extends ComponentEvent -@deprecated("Use UIElementResized instead.") +@deprecated("Use UIElementResized instead.", "2.8.0") case class ComponentResized(source: Component) extends ComponentEvent -@deprecated("Use UIElementShown instead.") +@deprecated("Use UIElementShown instead.", "2.8.0") case class ComponentShown(source: Component) extends ComponentEvent -@deprecated("Use UIElementHidden instead.") +@deprecated("Use UIElementHidden instead.", "2.8.0") case class ComponentHidden(source: Component) extends ComponentEvent diff --git a/test/files/neg/bug1333.check b/test/files/neg/bug1333.check deleted file mode 100644 index 11ba633194..0000000000 --- a/test/files/neg/bug1333.check +++ /dev/null @@ -1,4 +0,0 @@ -bug1333.scala:1: error: case classes limited by implementation: maximum of 2 constructor parameter lists. -case class A(a: Int)(b: Int)(c: Int) - ^ -one error found diff --git a/test/files/neg/bug1333.scala b/test/files/neg/bug1333.scala deleted file mode 100644 index e16b38cefc..0000000000 --- a/test/files/neg/bug1333.scala +++ /dev/null @@ -1 +0,0 @@ -case class A(a: Int)(b: Int)(c: Int) diff --git a/test/files/neg/unit-returns-value.check b/test/files/neg/unit-returns-value.check new file mode 100644 index 0000000000..18368f45ab --- /dev/null +++ b/test/files/neg/unit-returns-value.check @@ -0,0 +1,4 @@ +unit-returns-value.scala:4: error: enclosing method f has result type Unit: return value discarded + if (b) return 5 + ^ +one error found diff --git a/test/files/neg/unit-returns-value.flags b/test/files/neg/unit-returns-value.flags new file mode 100644 index 0000000000..e8fb65d50c --- /dev/null +++ b/test/files/neg/unit-returns-value.flags @@ -0,0 +1 @@ +-Xfatal-warnings
\ No newline at end of file diff --git a/test/files/neg/unit-returns-value.scala b/test/files/neg/unit-returns-value.scala new file mode 100644 index 0000000000..27a1111c5b --- /dev/null +++ b/test/files/neg/unit-returns-value.scala @@ -0,0 +1,11 @@ +object Test { + def f { + var b = false + if (b) return 5 + } + + // no warning + def g { + return println("hello") + } +} diff --git a/test/files/pos/bug3972.scala b/test/files/pos/bug3972.scala new file mode 100644 index 0000000000..5dfc10fcef --- /dev/null +++ b/test/files/pos/bug3972.scala @@ -0,0 +1,11 @@ +object CompilerCrash { + def main(args: Array[String]) { + args match { + case Array("a", a @ _*) => { } // The code compiles fine if this line is commented out or "@ _*" is deleted or this line is swapped for the next line + case Array("b") => { } // The code compiles fine if this line is commented out + case Array("c", c) => { + 0 // The code compiles fine if this line is commented out + } + } + } +} diff --git a/test/files/pos/bug4269.scala b/test/files/pos/bug4269.scala new file mode 100644 index 0000000000..99a30785b4 --- /dev/null +++ b/test/files/pos/bug4269.scala @@ -0,0 +1,5 @@ +class A { + PartialFunction.condOpt(Nil) { + case items@List(_*) if true => + } +} diff --git a/test/files/run/bug1333.check b/test/files/run/bug1333.check new file mode 100644 index 0000000000..6303af7f1c --- /dev/null +++ b/test/files/run/bug1333.check @@ -0,0 +1,3 @@ +10 +-10 +-1 diff --git a/test/files/run/bug1333.scala b/test/files/run/bug1333.scala new file mode 100644 index 0000000000..1696629cbb --- /dev/null +++ b/test/files/run/bug1333.scala @@ -0,0 +1,14 @@ +object Test { + case class A(x: Int)(y: Int)(z: String) + + def f(x: Any) = x match { + case A(x) => x + case _ => -1 + } + + def main(args: Array[String]): Unit = { + println(f(A(10)(20)("abc"))) + println(f(A(-10)(20)("abc"))) + println(f(List(1))) + } +} diff --git a/test/files/run/bug2800.check b/test/files/run/bug2800.check new file mode 100644 index 0000000000..546ee52413 --- /dev/null +++ b/test/files/run/bug2800.check @@ -0,0 +1,14 @@ +false +false +List() +false +false +false +false +Vector(1) +false +false +true +false +false +false diff --git a/test/files/run/bug2800.scala b/test/files/run/bug2800.scala new file mode 100644 index 0000000000..84d1de0507 --- /dev/null +++ b/test/files/run/bug2800.scala @@ -0,0 +1,36 @@ +object Test { + def f1 = ("": Any) match { case List(x @ _*) => x ; case _ => false } + def f2 = (5: Any) match { case List(x @ _*) => x ; case _ => false } + def f3 = (Nil: Any) match { case List(x @ _*) => x ; case _ => false } + def f4 = (Array(1): Any) match { case List(x @ _*) => x ; case _ => false } + + def f5 = ("": Any) match { case Array(x @ _*) => x ; case _ => false } + def f6 = (5: Any) match { case Array(x @ _*) => x ; case _ => false } + def f7 = (Nil: Any) match { case Array(x @ _*) => x ; case _ => false } + def f8 = (Array(1): Any) match { case Array(x @ _*) => x ; case _ => false } + + def f9 = ("": Any) match { case x @ List(_*) => x ; case _ => false } + def f10 = ("": Any) match { case List(_*) => true ; case _ => false } + def f11 = (Nil: Any) match { case List(_*) => true ; case _ => false } + def f12 = ("": Any) match { case x @ Array(_*) => x ; case _ => false } + def f13 = ("": Any) match { case Array(_*) => true ; case _ => false } + def f14 = (Nil: Any) match { case Array(_*) => true ; case _ => false } + + + def main(args: Array[String]): Unit = { + println(f1) + println(f2) + println(f3) + println(f4) + println(f5) + println(f6) + println(f7) + println(f8) + println(f9) + println(f10) + println(f11) + println(f12) + println(f13) + println(f14) + } +} diff --git a/test/pending/run/bug3050.scala b/test/files/run/bug3050.scala index aaec99ec14..d1f3f13bec 100644 --- a/test/pending/run/bug3050.scala +++ b/test/files/run/bug3050.scala @@ -4,6 +4,6 @@ object Test { try { ("": Any) match { case List(_*) => true } } catch { case _ => false } - assert(x == false) + assert(!x) } } diff --git a/test/files/run/bug3530.check b/test/files/run/bug3530.check index 633c15d9d7..1f906680e9 100644 --- a/test/files/run/bug3530.check +++ b/test/files/run/bug3530.check @@ -1 +1,12 @@ -Some List +two +three +list: 4 +list: 0 +list: 5 +not a list + +two +three +list: 4 +list: 0 +list: 5 diff --git a/test/files/run/bug3530.scala b/test/files/run/bug3530.scala index f2c0034691..f6f7fb4229 100644 --- a/test/files/run/bug3530.scala +++ b/test/files/run/bug3530.scala @@ -1,9 +1,35 @@ object Test { + def f(x: Any) = println(x match { + case List(_, _) => "two" + case List(_, _, _) => "three" + case xs @ List(_*) => "list: " + xs.length + case _ => "not a list" + }) + + def f2[T](x: List[T]) = println(x match { + case List(_, _) => "two" + case List(_, _, _) => "three" + case List(xs @ _*) => "list: " + xs.length + // bug: the default case is marked unreachable + // case _ => "not a list" + }) + def main(args: Array[String]) { - val list = List(1,2,3) - list match { - case List(_, _) => println("List with two elements") - case List(_*) => println("Some List") - } + f(List(1, 2)) + f(List('a', 'b', 'c')) + f(List('a', 'b', 'c', 'd')) + f(Nil) + f(List(1,2,3,4,5)) + f(null) + + println + + f2(List(1, 2)) + f2(List('a', 'b', 'c')) + f2(List('a', 'b', 'c', 'd')) + f2(Nil) + f2(List(1,2,3,4,5)) + // bug: this NPEs on xs.length + // f2(null) } }
\ No newline at end of file diff --git a/test/files/jvm/interpreter.scala b/test/pending/jvm/interpreter.scala index 752a129950..752a129950 100644 --- a/test/files/jvm/interpreter.scala +++ b/test/pending/jvm/interpreter.scala |