diff options
852 files changed, 5130 insertions, 3823 deletions
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 551100ae85..2451a52682 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -6,7 +6,7 @@ These guidelines are meant to be a living document that should be changed and ad This is the process for committing code to the Scala project. There are of course exceptions to these rules, for example minor changes to comments and documentation, fixing a broken build etc. -1. Make sure you have signed the [Scala CLA](http://www.scala-lang.org/sites/default/files/contributor_agreement.pdf), if not, sign it. +1. Make sure you have signed the [Scala CLA](http://typesafe.com/contribute/cla/scala), if not, sign it. 2. Before starting to work on a feature or a fix, it's good practice to ensure that: 1. There is a ticket for your work in the project's issue tracker. If not, create it first (perhaps given a thumbs up from the scala-internals mailing list first). 2. The ticket has been discussed and prioritized by the team. diff --git a/README.rst b/README.rst index c871adb908..004d7b63d0 100644 --- a/README.rst +++ b/README.rst @@ -189,15 +189,10 @@ In detail: - Scala live git source tree: http://github.com/scala/scala -- Contact form: - http://www.scala-lang.org/node/188 - - -If you are interested in contributing code, we ask you to complete and submit -to us the Scala Contributor License Agreement, which allows us to ensure that -all code submitted to the project is unencumbered by copyrights or patents. -The form is available at: -http://www.scala-lang.org/sites/default/files/contributor_agreement.pdf +If you are interested in contributing code, we ask you to sign the +[Scala Contributor License Agreement](http://typesafe.com/contribute/cla/scala), +which allows us to ensure that all code submitted to the project is +unencumbered by copyrights or patents. Before submitting a pull-request, please make sure you have followed the guidelines outlined in our `Pull Request Policy <https://github.com/scala/scala/wiki/Pull-Request-Policy>`_. @@ -224,6 +224,7 @@ TODO: <artifact:dependencies pathId="partest.extras.classpath" filesetId="partest.extras.fileset" versionsId="partest.extras.versions"> <dependency groupId="com.googlecode.java-diff-utils" artifactId="diffutils" version="1.3.0"/> + <dependency groupId="org.scala-tools.testing" artifactId="test-interface" version="0.5" /> </artifact:dependencies> <!-- BND support --> @@ -530,6 +531,7 @@ TODO: <pathelement location="${build-quick.dir}/classes/library"/> <pathelement location="${build-quick.dir}/classes/actors"/> <pathelement location="${build-quick.dir}/classes/scalacheck"/> + <path refid="partest.extras.classpath"/> </path> <path id="quick.scalap.build.path"> @@ -762,6 +764,7 @@ TODO: <stopwatch name="@{project}.timer"/> <mkdir dir="${@{project}-classes}"/> <javac + debug="true" srcdir="${src.dir}/@{project}" destdir="${@{project}-classes}" classpath="${@{project}-classes}" @@ -794,6 +797,7 @@ TODO: <sequential> <javac + debug="true" srcdir="${src.dir}/@{project}" destdir="${build-@{stage}.dir}/classes/@{destproject}" includes="**/*.java" diff --git a/lib/jline.jar.desired.sha1 b/lib/jline.jar.desired.sha1 index b0426130ac..1eb994cf1b 100644 --- a/lib/jline.jar.desired.sha1 +++ b/lib/jline.jar.desired.sha1 @@ -1 +1 @@ -a5261e70728c1847639e2b47d953441d0b217bcb *jline.jar +e87ad04fdffb5cd9b7aa9293596d9fdde086eccd ?jline.jar diff --git a/src/build/maven/maven-deploy.xml b/src/build/maven/maven-deploy.xml index bd946bf0f3..e70173319e 100644 --- a/src/build/maven/maven-deploy.xml +++ b/src/build/maven/maven-deploy.xml @@ -164,11 +164,7 @@ <attribute name="repository" /> <attribute name="version" /> <sequential> - <deploy-remote name="scala-library" version="@{version}" repository="@{repository}"> - <extra-attachments> - <artifact:attach type="jar" file="scala-library/scala-library-docs.jar" classifier="javadoc" /> - </extra-attachments> - </deploy-remote> + <deploy-remote name="scala-library" version="@{version}" repository="@{repository}"/> <deploy-remote name="jline" version="@{version}" repository="@{repository}"/> <deploy-remote name="scala-reflect" version="@{version}" repository="@{repository}"/> <deploy-remote name="scala-compiler" version="@{version}" repository="@{repository}" /> diff --git a/src/build/pack.xml b/src/build/pack.xml index 381d3f1931..20c4034107 100644 --- a/src/build/pack.xml +++ b/src/build/pack.xml @@ -112,8 +112,10 @@ MAIN DISTRIBUTION PACKAGING </target> <target name="pack-archives.latest.unix" depends="pack-archives.src" unless="os.win"> + <!-- be sure to use a relative symlink to make the distribution portable, + `resource` is relative to directory of `link` --> <symlink link="${dists.dir}/archives/scala-latest-sources.tgz" - resource="${dists.dir}/archives/scala-${version.number}-sources.tgz" + resource="scala-${version.number}-sources.tgz" overwrite="yes"/> </target> diff --git a/src/compiler/scala/reflect/macros/runtime/Aliases.scala b/src/compiler/scala/reflect/macros/runtime/Aliases.scala index ff870e728e..1c6703aeee 100644 --- a/src/compiler/scala/reflect/macros/runtime/Aliases.scala +++ b/src/compiler/scala/reflect/macros/runtime/Aliases.scala @@ -28,4 +28,8 @@ trait Aliases { override def typeTag[T](implicit ttag: TypeTag[T]) = ttag override def weakTypeOf[T](implicit attag: WeakTypeTag[T]): Type = attag.tpe override def typeOf[T](implicit ttag: TypeTag[T]): Type = ttag.tpe + + implicit class RichOpenImplicit(oi: universe.analyzer.OpenImplicit) { + def toImplicitCandidate = ImplicitCandidate(oi.info.pre, oi.info.sym, oi.pt, oi.tree) + } }
\ No newline at end of file diff --git a/src/compiler/scala/reflect/macros/runtime/Enclosures.scala b/src/compiler/scala/reflect/macros/runtime/Enclosures.scala index 8fe0b09700..f3f92550de 100644 --- a/src/compiler/scala/reflect/macros/runtime/Enclosures.scala +++ b/src/compiler/scala/reflect/macros/runtime/Enclosures.scala @@ -21,16 +21,16 @@ trait Enclosures { // vals are eager to simplify debugging // after all we wouldn't save that much time by making them lazy - val macroApplication: Tree = expandee - def enclosingPackage: PackageDef = strictEnclosure[PackageDef] - val enclosingClass: Tree = lenientEnclosure[ImplDef] - def enclosingImpl: ImplDef = strictEnclosure[ImplDef] - def enclosingTemplate: Template = strictEnclosure[Template] - val enclosingImplicits: List[(Type, Tree)] = site.openImplicits - val enclosingMacros: List[Context] = this :: universe.analyzer.openMacros // include self - val enclosingMethod: Tree = lenientEnclosure[DefDef] - def enclosingDef: DefDef = strictEnclosure[DefDef] - val enclosingPosition: Position = if (enclPoses.isEmpty) NoPosition else enclPoses.head.pos - val enclosingUnit: CompilationUnit = universe.currentRun.currentUnit - val enclosingRun: Run = universe.currentRun + val macroApplication: Tree = expandee + def enclosingPackage: PackageDef = strictEnclosure[PackageDef] + val enclosingClass: Tree = lenientEnclosure[ImplDef] + def enclosingImpl: ImplDef = strictEnclosure[ImplDef] + def enclosingTemplate: Template = strictEnclosure[Template] + val enclosingImplicits: List[ImplicitCandidate] = site.openImplicits.map(_.toImplicitCandidate) + val enclosingMacros: List[Context] = this :: universe.analyzer.openMacros // include self + val enclosingMethod: Tree = lenientEnclosure[DefDef] + def enclosingDef: DefDef = strictEnclosure[DefDef] + val enclosingPosition: Position = if (enclPoses.isEmpty) NoPosition else enclPoses.head.pos + val enclosingUnit: CompilationUnit = universe.currentRun.currentUnit + val enclosingRun: Run = universe.currentRun } diff --git a/src/compiler/scala/reflect/macros/runtime/Typers.scala b/src/compiler/scala/reflect/macros/runtime/Typers.scala index 398770ab35..4592f640bd 100644 --- a/src/compiler/scala/reflect/macros/runtime/Typers.scala +++ b/src/compiler/scala/reflect/macros/runtime/Typers.scala @@ -8,7 +8,7 @@ trait Typers { def openMacros: List[Context] = this :: universe.analyzer.openMacros - def openImplicits: List[(Type, Tree)] = callsiteTyper.context.openImplicits + def openImplicits: List[ImplicitCandidate] = callsiteTyper.context.openImplicits.map(_.toImplicitCandidate) /** * @see [[scala.tools.reflect.ToolBox.typeCheck]] @@ -37,30 +37,13 @@ trait Typers { def inferImplicitValue(pt: Type, silent: Boolean = true, withMacrosDisabled: Boolean = false, pos: Position = enclosingPosition): Tree = { macroLogVerbose("inferring implicit value of type %s, macros = %s".format(pt, !withMacrosDisabled)) - inferImplicit(universe.EmptyTree, pt, isView = false, silent = silent, withMacrosDisabled = withMacrosDisabled, pos = pos) + universe.analyzer.inferImplicit(universe.EmptyTree, pt, false, callsiteTyper.context, silent, withMacrosDisabled, pos, (pos, msg) => throw TypecheckException(pos, msg)) } def inferImplicitView(tree: Tree, from: Type, to: Type, silent: Boolean = true, withMacrosDisabled: Boolean = false, pos: Position = enclosingPosition): Tree = { macroLogVerbose("inferring implicit view from %s to %s for %s, macros = %s".format(from, to, tree, !withMacrosDisabled)) val viewTpe = universe.appliedType(universe.definitions.FunctionClass(1).toTypeConstructor, List(from, to)) - inferImplicit(tree, viewTpe, isView = true, silent = silent, withMacrosDisabled = withMacrosDisabled, pos = pos) - } - - private def inferImplicit(tree: Tree, pt: Type, isView: Boolean, silent: Boolean, withMacrosDisabled: Boolean, pos: Position): Tree = { - import universe.analyzer.SearchResult - val context = callsiteTyper.context - val wrapper1 = if (!withMacrosDisabled) (context.withMacrosEnabled[SearchResult] _) else (context.withMacrosDisabled[SearchResult] _) - def wrapper (inference: => SearchResult) = wrapper1(inference) - wrapper(universe.analyzer.inferImplicit(tree, pt, reportAmbiguous = true, isView = isView, context = context, saveAmbiguousDivergent = !silent, pos = pos)) match { - case failure if failure.tree.isEmpty => - macroLogVerbose("implicit search has failed. to find out the reason, turn on -Xlog-implicits") - context.firstError match { - case Some(err) => throw new TypecheckException(err.errPos, err.errMsg) - case None => universe.EmptyTree - } - case success => - success.tree - } + universe.analyzer.inferImplicit(tree, viewTpe, true, callsiteTyper.context, silent, withMacrosDisabled, pos, (pos, msg) => throw TypecheckException(pos, msg)) } def resetAllAttrs(tree: Tree): Tree = universe.resetAllAttrs(tree) diff --git a/src/compiler/scala/reflect/reify/package.scala b/src/compiler/scala/reflect/reify/package.scala index 78f85c2634..ae0288186b 100644 --- a/src/compiler/scala/reflect/reify/package.scala +++ b/src/compiler/scala/reflect/reify/package.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect import scala.reflect.macros.ReificationException import scala.tools.nsc.Global diff --git a/src/compiler/scala/reflect/reify/utils/Extractors.scala b/src/compiler/scala/reflect/reify/utils/Extractors.scala index 7338df1f72..d5f27dc119 100644 --- a/src/compiler/scala/reflect/reify/utils/Extractors.scala +++ b/src/compiler/scala/reflect/reify/utils/Extractors.scala @@ -11,7 +11,7 @@ trait Extractors { // Example of a reified tree for `reify(List(1, 2))`: // (also contains an example of a reified type as a third argument to the constructor of Expr) // { - // val $u: reflect.runtime.universe.type = scala.reflect.runtime.`package`.universe; + // val $u: scala.reflect.runtime.universe.type = scala.reflect.runtime.`package`.universe; // val $m: $u.Mirror = $u.runtimeMirror(Test.this.getClass().getClassLoader()); // $u.Expr[List[Int]]($m, { // final class $treecreator1 extends scala.reflect.api.TreeCreator { diff --git a/src/compiler/scala/tools/ant/Same.scala b/src/compiler/scala/tools/ant/Same.scala index 6362d28580..6036b238b6 100644 --- a/src/compiler/scala/tools/ant/Same.scala +++ b/src/compiler/scala/tools/ant/Same.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.tools.ant +package scala +package tools.ant import java.io.{File, FileInputStream} diff --git a/src/compiler/scala/tools/ant/sabbus/Break.scala b/src/compiler/scala/tools/ant/sabbus/Break.scala index 0b6701b6e9..b170ceaed8 100644 --- a/src/compiler/scala/tools/ant/sabbus/Break.scala +++ b/src/compiler/scala/tools/ant/sabbus/Break.scala @@ -7,7 +7,8 @@ \* */ -package scala.tools.ant.sabbus +package scala +package tools.ant.sabbus import org.apache.tools.ant.Task diff --git a/src/compiler/scala/tools/ant/sabbus/Make.scala b/src/compiler/scala/tools/ant/sabbus/Make.scala index 5274594f3d..027a828f03 100644 --- a/src/compiler/scala/tools/ant/sabbus/Make.scala +++ b/src/compiler/scala/tools/ant/sabbus/Make.scala @@ -7,7 +7,8 @@ \* */ -package scala.tools.ant.sabbus +package scala +package tools.ant.sabbus import java.io.File import org.apache.tools.ant.Task diff --git a/src/compiler/scala/tools/ant/sabbus/ScalacFork.scala b/src/compiler/scala/tools/ant/sabbus/ScalacFork.scala index 363c31f6c4..595b45ae51 100644 --- a/src/compiler/scala/tools/ant/sabbus/ScalacFork.scala +++ b/src/compiler/scala/tools/ant/sabbus/ScalacFork.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.tools.ant +package scala +package tools.ant package sabbus import java.io.{ File, FileWriter } diff --git a/src/compiler/scala/tools/ant/sabbus/Use.scala b/src/compiler/scala/tools/ant/sabbus/Use.scala index 5f50bb7908..a8736f228b 100644 --- a/src/compiler/scala/tools/ant/sabbus/Use.scala +++ b/src/compiler/scala/tools/ant/sabbus/Use.scala @@ -7,7 +7,8 @@ \* */ -package scala.tools.ant +package scala +package tools.ant package sabbus import java.io.File diff --git a/src/compiler/scala/tools/ant/templates/tool-windows.tmpl b/src/compiler/scala/tools/ant/templates/tool-windows.tmpl index 411a27b9c7..bd6cf561b9 100644 --- a/src/compiler/scala/tools/ant/templates/tool-windows.tmpl +++ b/src/compiler/scala/tools/ant/templates/tool-windows.tmpl @@ -14,8 +14,9 @@ set _LINE_TOOLCP= :another_param -if "%1%"=="-toolcp" ( - set _LINE_TOOLCP=%2% +rem Use "%~1" to handle spaces in paths. See http://ss64.com/nt/syntax-args.html +if "%~1"=="-toolcp" ( + set _LINE_TOOLCP=%~2 shift shift goto another_param diff --git a/src/compiler/scala/tools/cmd/Demo.scala b/src/compiler/scala/tools/cmd/Demo.scala index af818845bb..fc90140f8f 100644 --- a/src/compiler/scala/tools/cmd/Demo.scala +++ b/src/compiler/scala/tools/cmd/Demo.scala @@ -3,7 +3,8 @@ * @author Paul Phillips */ -package scala.tools +package scala +package tools package cmd /** A sample command specification for illustrative purposes. diff --git a/src/compiler/scala/tools/cmd/Interpolation.scala b/src/compiler/scala/tools/cmd/Interpolation.scala index abffd6bb2e..d1c798b621 100644 --- a/src/compiler/scala/tools/cmd/Interpolation.scala +++ b/src/compiler/scala/tools/cmd/Interpolation.scala @@ -3,7 +3,8 @@ * @author Paul Phillips */ -package scala.tools +package scala +package tools package cmd /** Interpolation logic for generated files. The idea is to be diff --git a/src/compiler/scala/tools/cmd/package.scala b/src/compiler/scala/tools/cmd/package.scala index d605ecae8f..c62a977950 100644 --- a/src/compiler/scala/tools/cmd/package.scala +++ b/src/compiler/scala/tools/cmd/package.scala @@ -3,7 +3,8 @@ * @author Paul Phillips */ -package scala.tools +package scala +package tools package object cmd { def returning[T](x: T)(f: T => Unit): T = { f(x) ; x } diff --git a/src/compiler/scala/tools/nsc/CompileClient.scala b/src/compiler/scala/tools/nsc/CompileClient.scala index 64f6758e73..3017d8c9cc 100644 --- a/src/compiler/scala/tools/nsc/CompileClient.scala +++ b/src/compiler/scala/tools/nsc/CompileClient.scala @@ -3,11 +3,12 @@ * @author Martin Odersky */ -package scala.tools.nsc +package scala +package tools.nsc import settings.FscSettings import scala.tools.util.CompileOutputCommon -import sys.SystemProperties.preferIPv4Stack +import scala.sys.SystemProperties.preferIPv4Stack /** The client part of the fsc offline compiler. Instead of compiling * things itself, it send requests to a CompileServer. diff --git a/src/compiler/scala/tools/nsc/Driver.scala b/src/compiler/scala/tools/nsc/Driver.scala index fbfed6110f..3ac27a42e8 100644 --- a/src/compiler/scala/tools/nsc/Driver.scala +++ b/src/compiler/scala/tools/nsc/Driver.scala @@ -1,4 +1,5 @@ -package scala.tools.nsc +package scala +package tools.nsc import scala.tools.nsc.reporters.ConsoleReporter import Properties.{ versionString, copyrightString, residentPromptString } diff --git a/src/compiler/scala/tools/nsc/Global.scala b/src/compiler/scala/tools/nsc/Global.scala index d0b59b53cc..f1fccd6069 100644 --- a/src/compiler/scala/tools/nsc/Global.scala +++ b/src/compiler/scala/tools/nsc/Global.scala @@ -3,7 +3,9 @@ * @author Martin Odersky */ -package scala.tools.nsc +package scala +package tools +package nsc import java.io.{ File, FileOutputStream, PrintWriter, IOException, FileNotFoundException } import java.nio.charset.{ Charset, CharsetDecoder, IllegalCharsetNameException, UnsupportedCharsetException } @@ -218,7 +220,7 @@ class Global(var currentSettings: Settings, var reporter: Reporter) // not deprecated yet, but a method called "error" imported into // nearly every trait really must go. For now using globalError. def error(msg: String) = globalError(msg) - def inform(msg: String) = reporter.echo(msg) + override def inform(msg: String) = reporter.echo(msg) override def globalError(msg: String) = reporter.error(NoPosition, msg) override def warning(msg: String) = if (settings.fatalWarnings) globalError(msg) diff --git a/src/compiler/scala/tools/nsc/MainTokenMetric.scala b/src/compiler/scala/tools/nsc/MainTokenMetric.scala index e2893204e0..84eb688b63 100644 --- a/src/compiler/scala/tools/nsc/MainTokenMetric.scala +++ b/src/compiler/scala/tools/nsc/MainTokenMetric.scala @@ -3,7 +3,8 @@ * @author Martin Odersky */ -package scala.tools.nsc +package scala +package tools.nsc import scala.tools.nsc.reporters.ConsoleReporter diff --git a/src/compiler/scala/tools/nsc/ScriptRunner.scala b/src/compiler/scala/tools/nsc/ScriptRunner.scala index 5f8bc71449..d553d71bf5 100644 --- a/src/compiler/scala/tools/nsc/ScriptRunner.scala +++ b/src/compiler/scala/tools/nsc/ScriptRunner.scala @@ -3,7 +3,8 @@ * @author Martin Odersky */ -package scala.tools.nsc +package scala +package tools.nsc import io.{ Directory, File, Path } import java.io.IOException diff --git a/src/compiler/scala/tools/nsc/ast/Printers.scala b/src/compiler/scala/tools/nsc/ast/Printers.scala index 72538bac08..89652c5a20 100644 --- a/src/compiler/scala/tools/nsc/ast/Printers.scala +++ b/src/compiler/scala/tools/nsc/ast/Printers.scala @@ -42,7 +42,7 @@ trait Printers extends scala.reflect.internal.Printers { this: Global => } } - // overflow cases missing from TreePrinter in reflect.api + // overflow cases missing from TreePrinter in scala.reflect.api override def xprintTree(treePrinter: super.TreePrinter, tree: Tree) = tree match { case DocDef(comment, definition) => treePrinter.print(comment.raw) diff --git a/src/compiler/scala/tools/nsc/ast/TreeBrowsers.scala b/src/compiler/scala/tools/nsc/ast/TreeBrowsers.scala index 0077ed0c84..1e70b7091b 100644 --- a/src/compiler/scala/tools/nsc/ast/TreeBrowsers.scala +++ b/src/compiler/scala/tools/nsc/ast/TreeBrowsers.scala @@ -3,7 +3,8 @@ * @author Martin Odersky */ -package scala.tools.nsc +package scala +package tools.nsc package ast import java.awt.{List => awtList, _} diff --git a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala index bd3af5f9a2..1dfb2f3bab 100644 --- a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala @@ -30,6 +30,9 @@ trait ParsersCommon extends ScannersCommon { val global : Global import global._ + def newLiteral(const: Any) = Literal(Constant(const)) + def literalUnit = newLiteral(()) + /** This is now an abstract class, only to work around the optimizer: * methods in traits are never inlined. */ @@ -57,7 +60,7 @@ trait ParsersCommon extends ScannersCommon { if (in.token == LPAREN) inParens(body) else { accept(LPAREN) ; alt } - @inline final def inParensOrUnit[T](body: => Tree): Tree = inParensOrError(body, Literal(Constant(()))) + @inline final def inParensOrUnit[T](body: => Tree): Tree = inParensOrError(body, literalUnit) @inline final def inParensOrNil[T](body: => List[T]): List[T] = inParensOrError(body, Nil) @inline final def inBraces[T](body: => T): T = { @@ -71,7 +74,7 @@ trait ParsersCommon extends ScannersCommon { else { accept(LBRACE) ; alt } @inline final def inBracesOrNil[T](body: => List[T]): List[T] = inBracesOrError(body, Nil) - @inline final def inBracesOrUnit[T](body: => Tree): Tree = inBracesOrError(body, Literal(Constant(()))) + @inline final def inBracesOrUnit[T](body: => Tree): Tree = inBracesOrError(body, literalUnit) @inline final def dropAnyBraces[T](body: => T): T = if (in.token == LBRACE) inBraces(body) else body @@ -355,7 +358,7 @@ self => /* If we see anything but the above, fail. */ return None } - Some(makePackaging(0, emptyPkg, newStmts)) + Some(makeEmptyPackage(0, newStmts)) } if (mainModuleName == newTermName(ScriptRunner.defaultScriptMain)) @@ -376,15 +379,13 @@ self => * } * }}} */ - - def emptyPkg = atPos(0, 0, 0) { Ident(nme.EMPTY_PACKAGE_NAME) } def emptyInit = DefDef( NoMods, nme.CONSTRUCTOR, Nil, ListOfNil, TypeTree(), - Block(List(Apply(gen.mkSuperInitCall, Nil)), Literal(Constant(()))) + Block(List(Apply(gen.mkSuperInitCall, Nil)), literalUnit) ) // def main @@ -395,11 +396,11 @@ self => // object Main def moduleName = newTermName(ScriptRunner scriptMain settings) - def moduleBody = Template(List(atPos(o2p(in.offset))(scalaAnyRefConstr)), emptyValDef, List(emptyInit, mainDef)) + def moduleBody = Template(atInPos(scalaAnyRefConstr) :: Nil, emptyValDef, List(emptyInit, mainDef)) def moduleDef = ModuleDef(NoMods, moduleName, moduleBody) // package <empty> { ... } - makePackaging(0, emptyPkg, List(moduleDef)) + makeEmptyPackage(0, moduleDef :: Nil) } /* --------------- PLACEHOLDERS ------------------------------------------- */ @@ -529,6 +530,10 @@ self => else syntaxError(in.offset, msg, skipIt) } + def syntaxErrorOrIncompleteAnd[T](msg: String, skipIt: Boolean)(and: T): T = { + syntaxErrorOrIncomplete(msg, skipIt) + and + } def expectedMsg(token: Int): String = token2string(token) + " expected but " +token2string(in.token) + " found." @@ -563,9 +568,9 @@ self => if (!isStatSeqEnd) acceptStatSep() - def errorTypeTree = TypeTree() setType ErrorType setPos o2p(in.offset) - def errorTermTree = Literal(Constant(null)) setPos o2p(in.offset) - def errorPatternTree = Ident(nme.WILDCARD) setPos o2p(in.offset) + def errorTypeTree = setInPos(TypeTree() setType ErrorType) + def errorTermTree = setInPos(newLiteral(null)) + def errorPatternTree = setInPos(Ident(nme.WILDCARD)) /** Check that type parameter is not by name or repeated. */ def checkNotByNameOrVarargs(tpt: Tree) = { @@ -607,6 +612,10 @@ self => } def isDefIntro = isTemplateIntro || isDclIntro + def isTopLevelIntro = in.token match { + case PACKAGE | IMPORT | AT => true + case _ => isTemplateIntro || isModifier + } def isNumericLit: Boolean = in.token match { case INTLIT | LONGLIT | FLOATLIT | DOUBLELIT => true @@ -666,6 +675,9 @@ self => def atPos[T <: Tree](pos: Position)(t: T): T = global.atPos(pos)(t) + def atInPos[T <: Tree](t: T): T = atPos(o2p(in.offset))(t) + def setInPos[T <: Tree](t: T): T = t setPos o2p(in.offset) + /** Convert tree to formal parameter list. */ def convertToParams(tree: Tree): List[ValDef] = tree match { case Parens(ts) => ts map convertToParam @@ -886,7 +898,7 @@ self => * }}} */ def compoundType(): Tree = compoundTypeRest( - if (in.token == LBRACE) atPos(o2p(in.offset))(scalaAnyRefConstr) + if (in.token == LBRACE) atInPos(scalaAnyRefConstr) else annotType() ) @@ -947,12 +959,11 @@ self => } /** Assumed (provisionally) to be TermNames. */ - def ident(skipIt: Boolean): Name = + def ident(skipIt: Boolean): Name = ( if (isIdent) rawIdent().encode - else { - syntaxErrorOrIncomplete(expectedMsg(IDENTIFIER), skipIt) - nme.ERROR - } + else syntaxErrorOrIncompleteAnd(expectedMsg(IDENTIFIER), skipIt)(nme.ERROR) + ) + def ident(): Name = ident(skipIt = true) def rawIdent(): Name = try in.name finally in.nextToken() @@ -1078,28 +1089,22 @@ self => * @note The returned tree does not yet have a position */ def literal(isNegated: Boolean = false, inPattern: Boolean = false): Tree = { - def finish(value: Any): Tree = { - val t = Literal(Constant(value)) - in.nextToken() - t - } + def finish(value: Any): Tree = try newLiteral(value) finally in.nextToken() if (in.token == SYMBOLLIT) Apply(scalaDot(nme.Symbol), List(finish(in.strVal))) else if (in.token == INTERPOLATIONID) interpolatedString(inPattern = inPattern) else finish(in.token match { - case CHARLIT => in.charVal - case INTLIT => in.intVal(isNegated).toInt - case LONGLIT => in.intVal(isNegated) - case FLOATLIT => in.floatVal(isNegated).toFloat - case DOUBLELIT => in.floatVal(isNegated) + case CHARLIT => in.charVal + case INTLIT => in.intVal(isNegated).toInt + case LONGLIT => in.intVal(isNegated) + case FLOATLIT => in.floatVal(isNegated).toFloat + case DOUBLELIT => in.floatVal(isNegated) case STRINGLIT | STRINGPART => in.strVal.intern() - case TRUE => true - case FALSE => false - case NULL => null - case _ => - syntaxErrorOrIncomplete("illegal literal", skipIt = true) - null + case TRUE => true + case FALSE => false + case NULL => null + case _ => syntaxErrorOrIncompleteAnd("illegal literal", skipIt = true)(null) }) } @@ -1112,18 +1117,15 @@ self => in.nextToken() while (in.token == STRINGPART) { partsBuf += literal() - exprBuf += { + exprBuf += ( if (inPattern) dropAnyBraces(pattern()) - else { - if (in.token == IDENTIFIER) atPos(in.offset)(Ident(ident())) - else if(in.token == LBRACE) expr() - else if(in.token == THIS) { in.nextToken(); atPos(in.offset)(This(tpnme.EMPTY)) } - else { - syntaxErrorOrIncomplete("error in interpolated string: identifier or block expected", skipIt = true) - EmptyTree - } + else in.token match { + case IDENTIFIER => atPos(in.offset)(Ident(ident())) + case LBRACE => expr() + case THIS => in.nextToken(); atPos(in.offset)(This(tpnme.EMPTY)) + case _ => syntaxErrorOrIncompleteAnd("error in interpolated string: identifier or block expected", skipIt = true)(EmptyTree) } - } + ) } if (in.token == STRINGLIT) partsBuf += literal() @@ -1195,7 +1197,7 @@ self => r } else { accept(LPAREN) - Literal(Constant(true)) + newLiteral(true) } } @@ -1249,7 +1251,7 @@ self => newLinesOpt() val thenp = expr() val elsep = if (in.token == ELSE) { in.nextToken(); expr() } - else Literal(Constant(())) + else literalUnit If(cond, thenp, elsep) } parseIf @@ -1323,7 +1325,7 @@ self => case RETURN => def parseReturn = atPos(in.skipToken()) { - Return(if (isExprIntro) expr() else Literal(Constant(()))) + Return(if (isExprIntro) expr() else literalUnit) } parseReturn case THROW => @@ -1511,8 +1513,7 @@ self => val cpos = r2p(tstart, tstart, in.lastOffset max tstart) makeNew(parents, self, stats, npos, cpos) case _ => - syntaxErrorOrIncomplete("illegal start of simple expression", skipIt = true) - errorTermTree + syntaxErrorOrIncompleteAnd("illegal start of simple expression", skipIt = true)(errorTermTree) } simpleExprRest(t, canApply = canApply) } @@ -1832,8 +1833,7 @@ self => } else { badStart } - syntaxErrorOrIncomplete(msg, skip) - errorPatternTree + syntaxErrorOrIncompleteAnd(msg, skip)(errorPatternTree) } /** {{{ @@ -1849,14 +1849,10 @@ self => * * XXX: Hook for IDE */ - def simplePattern(): Tree = { + def simplePattern(): Tree = ( // simple diagnostics for this entry point - def badStart(): Tree = { - syntaxErrorOrIncomplete("illegal start of simple pattern", skipIt = true) - errorPatternTree - } - simplePattern(badStart) - } + simplePattern(() => syntaxErrorOrIncompleteAnd("illegal start of simple pattern", skipIt = true)(errorPatternTree)) + ) def simplePattern(onError: () => Tree): Tree = { val start = in.offset in.token match { @@ -2526,7 +2522,7 @@ self => */ def constrExpr(vparamss: List[List[ValDef]]): Tree = if (in.token == LBRACE) constrBlock(vparamss) - else Block(List(selfInvocation(vparamss)), Literal(Constant(()))) + else Block(selfInvocation(vparamss) :: Nil, literalUnit) /** {{{ * SelfInvocation ::= this ArgumentExprs {ArgumentExprs} @@ -2556,7 +2552,7 @@ self => else Nil } accept(RBRACE) - Block(stats, Literal(Constant(()))) + Block(stats, literalUnit) } /** {{{ @@ -2579,8 +2575,7 @@ self => case SUPERTYPE | SUBTYPE | SEMI | NEWLINE | NEWLINES | COMMA | RBRACE => TypeDef(mods | Flags.DEFERRED, name, tparams, typeBounds()) case _ => - syntaxErrorOrIncomplete("`=', `>:', or `<:' expected", skipIt = true) - EmptyTree + syntaxErrorOrIncompleteAnd("`=', `>:', or `<:' expected", skipIt = true)(EmptyTree) } } } @@ -2613,8 +2608,7 @@ self => case CASEOBJECT => objectDef(pos, (mods | Flags.CASE) withPosition (Flags.CASE, tokenRange(in.prev /*scanner skips on 'case' to 'object', thus take prev*/))) case _ => - syntaxErrorOrIncomplete("expected start of definition", skipIt = true) - EmptyTree + syntaxErrorOrIncompleteAnd("expected start of definition", skipIt = true)(EmptyTree) } } @@ -2676,6 +2670,40 @@ self => } } + /** Create a tree representing a package object, converting + * {{{ + * package object foo { ... } + * }}} + * to + * {{{ + * package foo { + * object `package` { ... } + * } + * }}} + */ + def packageObjectDef(start: Offset): PackageDef = { + val defn = objectDef(in.offset, NoMods) + val module = copyModuleDef(defn)(name = nme.PACKAGEkw) + val pid = atPos(o2p(defn.pos.startOrPoint))(Ident(defn.name)) + + makePackaging(start, pid, module :: Nil) + } + def packageOrPackageObject(start: Offset): Tree = ( + if (in.token == OBJECT) + joinComment(packageObjectDef(start) :: Nil).head + else { + in.flushDoc + makePackaging(start, pkgQualId(), inBracesOrNil(topStatSeq())) + } + ) + // TODO - eliminate this and use "def packageObjectDef" (see call site of this + // method for small elaboration.) + def makePackageObject(start: Int, objDef: ModuleDef): PackageDef = objDef match { + case ModuleDef(mods, name, impl) => + makePackaging( + start, atPos(o2p(objDef.pos.startOrPoint)){ Ident(name) }, List(ModuleDef(mods, nme.PACKAGEkw, impl))) + } + /** {{{ * ClassParents ::= AnnotType {`(' [Exprs] `)'} {with AnnotType} * TraitParents ::= AnnotType {with AnnotType} @@ -2755,14 +2783,14 @@ self => def anyrefParents() = { val caseParents = if (mods.isCase) List(productConstr, serializableConstr) else Nil parents0 ::: caseParents match { - case Nil => List(atPos(o2p(in.offset))(scalaAnyRefConstr)) + case Nil => atInPos(scalaAnyRefConstr) :: Nil case ps => ps } } def anyvalConstructor() = ( // Not a well-formed constructor, has to be finished later - see note // regarding AnyVal constructor in AddInterfaces. - DefDef(NoMods, nme.CONSTRUCTOR, Nil, ListOfNil, TypeTree(), Block(Nil, Literal(Constant(())))) + DefDef(NoMods, nme.CONSTRUCTOR, Nil, ListOfNil, TypeTree(), Block(Nil, literalUnit)) ) val tstart0 = if (body.isEmpty && in.lastOffset < tstart) in.lastOffset else tstart @@ -2811,42 +2839,10 @@ self => def makePackaging(start: Int, pkg: Tree, stats: List[Tree]): PackageDef = pkg match { case x: RefTree => atPos(start, pkg.pos.point)(PackageDef(x, stats)) } -/* - pkg match { - case id @ Ident(_) => - PackageDef(id, stats) - case Select(qual, name) => // drop this to flatten packages - makePackaging(start, qual, List(PackageDef(Ident(name), stats))) - } - } -*/ - /** Create a tree representing a package object, converting - * {{{ - * package object foo { ... } - * }}} - * to - * {{{ - * package foo { - * object `package` { ... } - * } - * }}} - */ - def makePackageObject(start: Int, objDef: ModuleDef): PackageDef = objDef match { - case ModuleDef(mods, name, impl) => - makePackaging( - start, atPos(o2p(objDef.pos.startOrPoint)){ Ident(name) }, List(ModuleDef(mods, nme.PACKAGEkw, impl))) - } - - /** {{{ - * Packaging ::= package QualId [nl] `{' TopStatSeq `}' - * }}} - */ - def packaging(start: Int): Tree = { - val pkg = pkgQualId() - val stats = inBracesOrNil(topStatSeq()) - makePackaging(start, pkg, stats) - } + def makeEmptyPackage(start: Int, stats: List[Tree]): PackageDef = ( + makePackaging(start, atPos(start, start, start)(Ident(nme.EMPTY_PACKAGE_NAME)), stats) + ) /** {{{ * TopStatSeq ::= TopStat {semi TopStat} @@ -2862,22 +2858,15 @@ self => while (!isStatSeqEnd) { stats ++= (in.token match { case PACKAGE => - val start = in.skipToken() - if (in.token == OBJECT) - joinComment(List(makePackageObject(start, objectDef(in.offset, NoMods)))) - else { - in.flushDoc - List(packaging(start)) - } + packageOrPackageObject(in.skipToken()) :: Nil case IMPORT => in.flushDoc importClause() case x if x == AT || isTemplateIntro || isModifier => - joinComment(List(topLevelTmplDef)) + joinComment(topLevelTmplDef :: Nil) case _ => - if (!isStatSep) - syntaxErrorOrIncomplete("expected class or object definition", skipIt = true) - Nil + if (isStatSep) Nil + else syntaxErrorOrIncompleteAnd("expected class or object definition", skipIt = true)(Nil) }) acceptStatSepOpt() } @@ -2988,7 +2977,7 @@ self => else List(tmplDef(pos, mods)) in.token match { - case RBRACE | CASE => defs :+ (Literal(Constant(())) setPos o2p(in.offset)) + case RBRACE | CASE => defs :+ setInPos(literalUnit) case _ => defs } } @@ -3038,7 +3027,7 @@ self => * CompilationUnit ::= {package QualId semi} TopStatSeq * }}} */ - def compilationUnit(): Tree = checkNoEscapingPlaceholders { + def compilationUnit(): PackageDef = checkNoEscapingPlaceholders { def topstats(): List[Tree] = { val ts = new ListBuffer[Tree] while (in.token == SEMI) in.nextToken() @@ -3046,6 +3035,9 @@ self => if (in.token == PACKAGE) { in.nextToken() if (in.token == OBJECT) { + // TODO - this next line is supposed to be + // ts += packageObjectDef(start) + // but this broke a scaladoc test (run/diagrams-filtering.scala) somehow. ts ++= joinComment(List(makePackageObject(start, objectDef(in.offset, NoMods)))) if (in.token != EOF) { acceptStatSep() @@ -3074,8 +3066,8 @@ self => resetPackage() topstats() match { - case List(stat @ PackageDef(_, _)) => stat - case stats => + case (stat @ PackageDef(_, _)) :: Nil => stat + case stats => val start = if (stats forall (_ == EmptyTree)) 0 else { @@ -3084,7 +3076,7 @@ self => else 0 } - makePackaging(start, atPos(start, start, start) { Ident(nme.EMPTY_PACKAGE_NAME) }, stats) + makeEmptyPackage(start, stats) } } } diff --git a/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala b/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala index d22311afe9..c1a8b96cdf 100644 --- a/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala @@ -696,7 +696,7 @@ trait Scanners extends ScannersCommon { } } - @annotation.tailrec private def getStringPart(multiLine: Boolean): Unit = { + @scala.annotation.tailrec private def getStringPart(multiLine: Boolean): Unit = { def finishStringPart() = { setStrVal() token = STRINGPART diff --git a/src/compiler/scala/tools/nsc/ast/parser/SyntaxAnalyzer.scala b/src/compiler/scala/tools/nsc/ast/parser/SyntaxAnalyzer.scala index 80d70e6428..3a695c6f59 100644 --- a/src/compiler/scala/tools/nsc/ast/parser/SyntaxAnalyzer.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/SyntaxAnalyzer.scala @@ -11,30 +11,98 @@ import javac._ /** An nsc sub-component. */ abstract class SyntaxAnalyzer extends SubComponent with Parsers with MarkupParsers with Scanners with JavaParsers with JavaScanners { + import global._ val phaseName = "parser" - def newPhase(prev: Phase): StdPhase = new ParserPhase(prev) - class ParserPhase(prev: scala.tools.nsc.Phase) extends StdPhase(prev) { + abstract class MemberDefTraverser extends Traverser { + def onMember(defn: MemberDef): Unit + + private var depth: Int = 0 + private def lower[T](body: => T): T = { + depth += 1 + try body finally depth -= 1 + } + def currentDepth = depth + + /** Prune this tree and all trees beneath it. Can be overridden. */ + def prune(md: MemberDef): Boolean = ( + md.mods.isSynthetic + || md.mods.isParamAccessor + || nme.isConstructorName(md.name) + || (md.name containsName nme.ANON_CLASS_NAME) + ) + + override def traverse(t: Tree): Unit = t match { + case md: MemberDef if prune(md) => + case md @ PackageDef(_, stats) => traverseTrees(stats) + case md: ImplDef => onMember(md) ; lower(traverseTrees(md.impl.body)) + case md: ValOrDefDef => onMember(md) ; lower(traverse(md.rhs)) + case _ => super.traverse(t) + } + } + + class MemberPosReporter(unit: CompilationUnit) extends MemberDefTraverser { + private var outputFn: MemberDef => String = outputForScreen + val path = unit.source.file.path + + // If a single line, outputs the line; if it spans multiple lines + // outputs NN,NN with start and end lines, e.g. 15,25. + def outputPos(md: MemberDef): String = { + val pos = md.pos + val start = pos.focusStart.line + val end = pos.focusEnd.line + + if (start == end) "" + start else s"$start,$end" + } + def outputForSed(md: MemberDef): String = { + val pos_s = "%-12s" format outputPos(md) + "p" + s"$pos_s $path # ${md.keyword} ${md.name}" + } + def outputForScreen(md: MemberDef): String = { + val pos_s = "%-20s" format " " * currentDepth + outputPos(md) + s"$pos_s ${md.keyword} ${md.name}" + } + + def onMember(md: MemberDef) = println(outputFn(md)) + // It recognizes "sed" and "anything else". + def show(style: String) { + if (style == "sed") { + outputFn = outputForSed + traverse(unit.body) + } + else { + outputFn = outputForScreen + println(path) + traverse(unit.body) + } + println("") + } + } + + private def initialUnitBody(unit: CompilationUnit): Tree = { + if (unit.isJava) new JavaUnitParser(unit).parse() + else if (global.reporter.incompleteHandled) newUnitParser(unit).parse() + else newUnitParser(unit).smartParse() + } + + class ParserPhase(prev: Phase) extends StdPhase(prev) { override val checkable = false override val keepsTypeParams = false - def apply(unit: global.CompilationUnit) { - import global._ + def apply(unit: CompilationUnit) { informProgress("parsing " + unit) - // if the body is already filled in, do nothing + // if the body is already filled in, don't overwrite it // otherwise compileLate is going to overwrite bodies of synthetic source files - if (unit.body == EmptyTree) { - unit.body = - if (unit.isJava) new JavaUnitParser(unit).parse() - else if (reporter.incompleteHandled) newUnitParser(unit).parse() - else newUnitParser(unit).smartParse() - } + if (unit.body == EmptyTree) + unit.body = initialUnitBody(unit) if (settings.Yrangepos && !reporter.hasErrors) validatePositions(unit.body) + + if (settings.Ymemberpos.isSetByUser) + new MemberPosReporter(unit) show (style = settings.Ymemberpos.value) } } } - diff --git a/src/compiler/scala/tools/nsc/backend/ScalaPrimitives.scala b/src/compiler/scala/tools/nsc/backend/ScalaPrimitives.scala index 1f9862596c..2007d799df 100644 --- a/src/compiler/scala/tools/nsc/backend/ScalaPrimitives.scala +++ b/src/compiler/scala/tools/nsc/backend/ScalaPrimitives.scala @@ -3,7 +3,8 @@ * @author Martin Odersky */ -package scala.tools.nsc +package scala +package tools.nsc package backend import scala.collection.{ mutable, immutable } diff --git a/src/compiler/scala/tools/nsc/backend/icode/BasicBlocks.scala b/src/compiler/scala/tools/nsc/backend/icode/BasicBlocks.scala index 94fbba8066..16ee40280c 100644 --- a/src/compiler/scala/tools/nsc/backend/icode/BasicBlocks.scala +++ b/src/compiler/scala/tools/nsc/backend/icode/BasicBlocks.scala @@ -38,7 +38,7 @@ trait BasicBlocks { import BBFlags._ - def code = method.code + def code = if (method eq null) NoCode else method.code private final class SuccessorList() { private var successors: List[BasicBlock] = Nil diff --git a/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala b/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala index 31028e64d3..9c9c001f02 100644 --- a/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala +++ b/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala @@ -4,7 +4,8 @@ */ -package scala.tools.nsc +package scala +package tools.nsc package backend package icode diff --git a/src/compiler/scala/tools/nsc/backend/icode/Linearizers.scala b/src/compiler/scala/tools/nsc/backend/icode/Linearizers.scala index c5fe3228a3..54be9d18f1 100644 --- a/src/compiler/scala/tools/nsc/backend/icode/Linearizers.scala +++ b/src/compiler/scala/tools/nsc/backend/icode/Linearizers.scala @@ -4,7 +4,8 @@ */ -package scala.tools.nsc +package scala +package tools.nsc package backend package icode diff --git a/src/compiler/scala/tools/nsc/backend/icode/Members.scala b/src/compiler/scala/tools/nsc/backend/icode/Members.scala index c1cda2c863..4389afb2b7 100644 --- a/src/compiler/scala/tools/nsc/backend/icode/Members.scala +++ b/src/compiler/scala/tools/nsc/backend/icode/Members.scala @@ -3,7 +3,8 @@ * @author Martin Odersky */ -package scala.tools.nsc +package scala +package tools.nsc package backend package icode @@ -73,7 +74,7 @@ trait Members { ) startBlock = b.successors.head } - + blocks -= b assert(!blocks.contains(b)) method.exh filter (_ covers b) foreach (_.covered -= b) diff --git a/src/compiler/scala/tools/nsc/backend/icode/Opcodes.scala b/src/compiler/scala/tools/nsc/backend/icode/Opcodes.scala index ff118be3c4..925775adb9 100644 --- a/src/compiler/scala/tools/nsc/backend/icode/Opcodes.scala +++ b/src/compiler/scala/tools/nsc/backend/icode/Opcodes.scala @@ -3,7 +3,8 @@ * @author Martin Odersky */ -package scala.tools.nsc +package scala +package tools.nsc package backend package icode @@ -394,14 +395,14 @@ trait Opcodes { self: ICodes => override def category = mthdsCat } - + /** * A place holder entry that allows us to parse class files with invoke dynamic * instructions. Because the compiler doesn't yet really understand the * behavior of invokeDynamic, this op acts as a poison pill. Any attempt to analyze * this instruction will cause a failure. The only optimization that * should ever look at non-Scala generated icode is the inliner, and it - * has been modified to not examine any method with invokeDynamic + * has been modified to not examine any method with invokeDynamic * instructions. So if this poison pill ever causes problems then * there's been a serious misunderstanding */ diff --git a/src/compiler/scala/tools/nsc/backend/icode/analysis/CopyPropagation.scala b/src/compiler/scala/tools/nsc/backend/icode/analysis/CopyPropagation.scala index 338a07c872..192890a509 100644 --- a/src/compiler/scala/tools/nsc/backend/icode/analysis/CopyPropagation.scala +++ b/src/compiler/scala/tools/nsc/backend/icode/analysis/CopyPropagation.scala @@ -3,7 +3,8 @@ * @author Martin Odersky */ -package scala.tools.nsc +package scala +package tools.nsc package backend.icode.analysis import scala.collection.{ mutable, immutable } @@ -541,7 +542,8 @@ abstract class CopyPropagation { m.isGetter // abstract getters are still pure, as we 'know' final override def toString() = ( - method.blocks map { b => + if (method eq null) List("<null>") + else method.blocks map { b => "\nIN(%s):\t Bindings: %s".format(b.label, in(b).bindings) + "\nIN(%s):\t Stack: %s".format(b.label, in(b).stack) } diff --git a/src/compiler/scala/tools/nsc/backend/icode/analysis/DataFlowAnalysis.scala b/src/compiler/scala/tools/nsc/backend/icode/analysis/DataFlowAnalysis.scala index ebc2d33a62..a378998f8f 100644 --- a/src/compiler/scala/tools/nsc/backend/icode/analysis/DataFlowAnalysis.scala +++ b/src/compiler/scala/tools/nsc/backend/icode/analysis/DataFlowAnalysis.scala @@ -4,7 +4,8 @@ */ -package scala.tools.nsc +package scala +package tools.nsc package backend.icode.analysis import scala.collection.{ mutable, immutable } diff --git a/src/compiler/scala/tools/nsc/backend/icode/analysis/ReachingDefinitions.scala b/src/compiler/scala/tools/nsc/backend/icode/analysis/ReachingDefinitions.scala index 26b7bc50d8..fecd48ed27 100644 --- a/src/compiler/scala/tools/nsc/backend/icode/analysis/ReachingDefinitions.scala +++ b/src/compiler/scala/tools/nsc/backend/icode/analysis/ReachingDefinitions.scala @@ -240,7 +240,8 @@ abstract class ReachingDefinitions { findDefs(bb, idx, m, 0) override def toString: String = { - method.code.blocks map { b => + if (method eq null) "<null>" + else method.code.blocks map { b => " entry(%s) = %s\n".format(b, in(b)) + " exit(%s) = %s\n".format(b, out(b)) } mkString ("ReachingDefinitions {\n", "\n", "\n}") diff --git a/src/compiler/scala/tools/nsc/backend/icode/analysis/TypeFlowAnalysis.scala b/src/compiler/scala/tools/nsc/backend/icode/analysis/TypeFlowAnalysis.scala index 57380db7e7..7a53293384 100644 --- a/src/compiler/scala/tools/nsc/backend/icode/analysis/TypeFlowAnalysis.scala +++ b/src/compiler/scala/tools/nsc/backend/icode/analysis/TypeFlowAnalysis.scala @@ -3,7 +3,8 @@ * @author Martin Odersky */ -package scala.tools.nsc +package scala +package tools.nsc package backend.icode.analysis import scala.collection.{mutable, immutable} diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BytecodeWriters.scala b/src/compiler/scala/tools/nsc/backend/jvm/BytecodeWriters.scala index 66aed14d1c..0df828393d 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BytecodeWriters.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BytecodeWriters.scala @@ -8,7 +8,6 @@ package backend.jvm import java.io.{ DataOutputStream, FileOutputStream, IOException, OutputStream, File => JFile } import scala.tools.nsc.io._ -import scala.tools.nsc.util.ScalaClassLoader import java.util.jar.Attributes.Name import scala.language.postfixOps @@ -38,11 +37,22 @@ trait BytecodeWriters { for (part <- pathParts.init) dir = ensureDirectory(dir) subdirectoryNamed part ensureDirectory(dir) fileNamed pathParts.last + suffix } - private def getFile(sym: Symbol, clsName: String, suffix: String): AbstractFile = + def getFile(sym: Symbol, clsName: String, suffix: String): AbstractFile = getFile(outputDirectory(sym), clsName, suffix) + def factoryNonJarBytecodeWriter(): BytecodeWriter = { + val emitAsmp = settings.Ygenasmp.isSetByUser + val doDump = settings.Ydumpclasses.isSetByUser + (emitAsmp, doDump) match { + case (false, false) => new ClassBytecodeWriter { } + case (false, true ) => new ClassBytecodeWriter with DumpBytecodeWriter { } + case (true, false) => new ClassBytecodeWriter with AsmpBytecodeWriter + case (true, true ) => new ClassBytecodeWriter with AsmpBytecodeWriter with DumpBytecodeWriter { } + } + } + trait BytecodeWriter { - def writeClass(label: String, jclassName: String, jclassBytes: Array[Byte], sym: Symbol): Unit + def writeClass(label: String, jclassName: String, jclassBytes: Array[Byte], outfile: AbstractFile): Unit def close(): Unit = () } @@ -53,7 +63,9 @@ trait BytecodeWriters { ) val writer = new Jar(jfile).jarWriter(jarMainAttrs: _*) - def writeClass(label: String, jclassName: String, jclassBytes: Array[Byte], sym: Symbol) { + def writeClass(label: String, jclassName: String, jclassBytes: Array[Byte], outfile: AbstractFile) { + assert(outfile == null, + "The outfile formal param is there just because ClassBytecodeWriter overrides this method and uses it.") val path = jclassName + ".class" val out = writer.newOutputStream(path) @@ -65,9 +77,47 @@ trait BytecodeWriters { override def close() = writer.close() } + /* + * The ASM textual representation for bytecode overcomes disadvantages of javap ouput in three areas: + * (a) pickle dingbats undecipherable to the naked eye; + * (b) two constant pools, while having identical contents, are displayed differently due to physical layout. + * (c) stack maps (classfile version 50 and up) are displayed in encoded form by javap, + * their expansion by ASM is more readable. + * + * */ + trait AsmpBytecodeWriter extends BytecodeWriter { + import scala.tools.asm + + private val baseDir = Directory(settings.Ygenasmp.value).createDirectory() + + private def emitAsmp(jclassBytes: Array[Byte], asmpFile: io.File) { + val pw = asmpFile.printWriter() + try { + val cnode = new asm.tree.ClassNode() + val cr = new asm.ClassReader(jclassBytes) + cr.accept(cnode, 0) + val trace = new scala.tools.asm.util.TraceClassVisitor(new java.io.PrintWriter(new java.io.StringWriter())) + cnode.accept(trace) + trace.p.print(pw) + } + finally pw.close() + } + + abstract override def writeClass(label: String, jclassName: String, jclassBytes: Array[Byte], outfile: AbstractFile) { + super.writeClass(label, jclassName, jclassBytes, outfile) + + val segments = jclassName.split("[./]") + val asmpFile = segments.foldLeft(baseDir: Path)(_ / _) changeExtension "asmp" toFile; + + asmpFile.parent.createDirectory() + emitAsmp(jclassBytes, asmpFile) + } + } + trait ClassBytecodeWriter extends BytecodeWriter { - def writeClass(label: String, jclassName: String, jclassBytes: Array[Byte], sym: Symbol) { - val outfile = getFile(sym, jclassName, ".class") + def writeClass(label: String, jclassName: String, jclassBytes: Array[Byte], outfile: AbstractFile) { + assert(outfile != null, + "Precisely this override requires its invoker to hand out a non-null AbstractFile.") val outstream = new DataOutputStream(outfile.bufferedOutput) try outstream.write(jclassBytes, 0, jclassBytes.length) @@ -79,8 +129,8 @@ trait BytecodeWriters { trait DumpBytecodeWriter extends BytecodeWriter { val baseDir = Directory(settings.Ydumpclasses.value).createDirectory() - abstract override def writeClass(label: String, jclassName: String, jclassBytes: Array[Byte], sym: Symbol) { - super.writeClass(label, jclassName, jclassBytes, sym) + abstract override def writeClass(label: String, jclassName: String, jclassBytes: Array[Byte], outfile: AbstractFile) { + super.writeClass(label, jclassName, jclassBytes, outfile) val pathName = jclassName val dumpFile = pathName.split("[./]").foldLeft(baseDir: Path) (_ / _) changeExtension "class" toFile; diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala index 9603aab338..e50b73dcc3 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala @@ -3,7 +3,8 @@ * @author Martin Odersky */ -package scala.tools.nsc +package scala +package tools.nsc package backend.jvm import scala.collection.{ mutable, immutable } @@ -51,6 +52,22 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM { override def erasedTypes = true def apply(cls: IClass) = sys.error("no implementation") + // An AsmPhase starts and ends within a Run, thus the caches in question will get populated and cleared within a Run, too), SI-7422 + javaNameCache.clear() + javaNameCache ++= List( + NothingClass -> binarynme.RuntimeNothing, + RuntimeNothingClass -> binarynme.RuntimeNothing, + NullClass -> binarynme.RuntimeNull, + RuntimeNullClass -> binarynme.RuntimeNull + ) + + // unlike javaNameCache, reverseJavaName contains entries only for class symbols and their internal names. + reverseJavaName.clear() + reverseJavaName ++= List( + binarynme.RuntimeNothing.toString() -> RuntimeNothingClass, // RuntimeNothingClass is the bytecode-level return type of Scala methods with Nothing return-type. + binarynme.RuntimeNull.toString() -> RuntimeNullClass + ) + // Lazy val; can't have eager vals in Phase constructors which may // cause cycles before Global has finished initialization. lazy val BeanInfoAttr = rootMirror.getRequiredClass("scala.beans.BeanInfo") @@ -75,16 +92,7 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM { new DirectToJarfileWriter(f.file) - case _ => - if (settings.Ydumpclasses.isDefault) - new ClassBytecodeWriter { } - else - new ClassBytecodeWriter with DumpBytecodeWriter { } - // TODO A ScalapBytecodeWriter could take asm.util.Textifier as starting point. - // Three areas where javap ouput is less than ideal (e.g. when comparing versions of the same classfile) are: - // (a) unreadable pickle; - // (b) two constant pools, while having identical contents, are displayed differently due to physical layout. - // (c) stack maps (classfile version 50 and up) are displayed in encoded form by javap, their expansion makes more sense instead. + case _ => factoryNonJarBytecodeWriter() } } @@ -111,9 +119,10 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM { debuglog(s"Created new bytecode generator for ${classes.size} classes.") val bytecodeWriter = initBytecodeWriter(sortedClasses filter isJavaEntryPoint) - val plainCodeGen = new JPlainBuilder(bytecodeWriter) - val mirrorCodeGen = new JMirrorBuilder(bytecodeWriter) - val beanInfoCodeGen = new JBeanInfoBuilder(bytecodeWriter) + val needsOutfile = bytecodeWriter.isInstanceOf[ClassBytecodeWriter] + val plainCodeGen = new JPlainBuilder( bytecodeWriter, needsOutfile) + val mirrorCodeGen = new JMirrorBuilder( bytecodeWriter, needsOutfile) + val beanInfoCodeGen = new JBeanInfoBuilder(bytecodeWriter, needsOutfile) def emitFor(c: IClass) { if (isStaticModule(c.symbol) && isTopLevelModule(c.symbol)) { @@ -138,8 +147,6 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM { } bytecodeWriter.close() - classes.clear() - reverseJavaName.clear() /* don't javaNameCache.clear() because that causes the following tests to fail: * test/files/run/macro-repl-dontexpand.scala @@ -163,19 +170,10 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM { var pickledBytes = 0 // statistics - // Don't put this in per run caches. Contains entries for classes as well as members. - val javaNameCache = new mutable.WeakHashMap[Symbol, Name]() ++= List( - NothingClass -> binarynme.RuntimeNothing, - RuntimeNothingClass -> binarynme.RuntimeNothing, - NullClass -> binarynme.RuntimeNull, - RuntimeNullClass -> binarynme.RuntimeNull - ) + val javaNameCache = perRunCaches.newMap[Symbol, Name]() // unlike javaNameCache, reverseJavaName contains entries only for class symbols and their internal names. - val reverseJavaName = mutable.Map.empty[String, Symbol] ++= List( - binarynme.RuntimeNothing.toString() -> RuntimeNothingClass, // RuntimeNothingClass is the bytecode-level return type of Scala methods with Nothing return-type. - binarynme.RuntimeNull.toString() -> RuntimeNullClass - ) + val reverseJavaName = perRunCaches.newMap[String, Symbol]() private def mkFlags(args: Int*) = args.foldLeft(0)(_ | _) private def hasPublicBitSet(flags: Int) = (flags & asm.Opcodes.ACC_PUBLIC) != 0 @@ -379,7 +377,6 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM { private val classfileVersion: Int = settings.target.value match { case "jvm-1.5" => asm.Opcodes.V1_5 - case "jvm-1.5-asm" => asm.Opcodes.V1_5 case "jvm-1.6" => asm.Opcodes.V1_6 case "jvm-1.7" => asm.Opcodes.V1_7 } @@ -407,7 +404,7 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM { } /** basic functionality for class file building */ - abstract class JBuilder(bytecodeWriter: BytecodeWriter) { + abstract class JBuilder(bytecodeWriter: BytecodeWriter, needsOutfile: Boolean) { val EMPTY_STRING_ARRAY = Array.empty[String] @@ -465,7 +462,10 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM { def writeIfNotTooBig(label: String, jclassName: String, jclass: asm.ClassWriter, sym: Symbol) { try { val arr = jclass.toByteArray() - bytecodeWriter.writeClass(label, jclassName, arr, sym) + val outF: scala.tools.nsc.io.AbstractFile = { + if(needsOutfile) getFile(sym, jclassName, ".class") else null + } + bytecodeWriter.writeClass(label, jclassName, arr, outF) } catch { case e: java.lang.RuntimeException if(e.getMessage() == "Class file too large!") => // TODO check where ASM throws the equivalent of CodeSizeTooBigException @@ -540,7 +540,7 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM { collectInnerClass(sym) - val hasInternalName = (sym.isClass || (sym.isModule && !sym.isMethod)) + val hasInternalName = sym.isClass || sym.isModuleNotMethod val cachedJN = javaNameCache.getOrElseUpdate(sym, { if (hasInternalName) { sym.javaBinaryName } else { sym.javaSimpleName } @@ -696,7 +696,7 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM { /** functionality for building plain and mirror classes */ - abstract class JCommonBuilder(bytecodeWriter: BytecodeWriter) extends JBuilder(bytecodeWriter) { + abstract class JCommonBuilder(bytecodeWriter: BytecodeWriter, needsOutfile: Boolean) extends JBuilder(bytecodeWriter, needsOutfile) { def debugLevel = settings.debuginfo.indexOfChoice @@ -1246,8 +1246,8 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM { case class BlockInteval(start: BasicBlock, end: BasicBlock) /** builder of plain classes */ - class JPlainBuilder(bytecodeWriter: BytecodeWriter) - extends JCommonBuilder(bytecodeWriter) + class JPlainBuilder(bytecodeWriter: BytecodeWriter, needsOutfile: Boolean) + extends JCommonBuilder(bytecodeWriter, needsOutfile) with JAndroidBuilder { val MIN_SWITCH_DENSITY = 0.7 @@ -1625,6 +1625,7 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM { jmethod = clinitMethod jMethodName = CLASS_CONSTRUCTOR_NAME jmethod.visitCode() + computeLocalVarsIndex(m) genCode(m, emitVars = false, isStatic = true) jmethod.visitMaxs(0, 0) // just to follow protocol, dummy arguments jmethod.visitEnd() @@ -2880,7 +2881,7 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM { /** builder of mirror classes */ - class JMirrorBuilder(bytecodeWriter: BytecodeWriter) extends JCommonBuilder(bytecodeWriter) { + class JMirrorBuilder(bytecodeWriter: BytecodeWriter, needsOutfile: Boolean) extends JCommonBuilder(bytecodeWriter, needsOutfile) { private var cunit: CompilationUnit = _ def getCurrentCUnit(): CompilationUnit = cunit @@ -2932,7 +2933,7 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM { /** builder of bean info classes */ - class JBeanInfoBuilder(bytecodeWriter: BytecodeWriter) extends JBuilder(bytecodeWriter) { + class JBeanInfoBuilder(bytecodeWriter: BytecodeWriter, needsOutfile: Boolean) extends JBuilder(bytecodeWriter, needsOutfile) { /** * Generate a bean info class that describes the given class. diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenJVMASM.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenJVMASM.scala index 59df8e56c1..2c3bf26958 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/GenJVMASM.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/GenJVMASM.scala @@ -5,7 +5,6 @@ package scala.tools.nsc package backend.jvm -import scala.tools.nsc.io.AbstractFile import scala.tools.nsc.symtab._ /** Code shared between the erstwhile legacy backend (aka GenJVM) @@ -19,20 +18,6 @@ trait GenJVMASM { import icodes._ import definitions._ - protected def outputDirectory(sym: Symbol): AbstractFile = - settings.outputDirs outputDirFor enteringFlatten(sym.sourceFile) - - protected def getFile(base: AbstractFile, clsName: String, suffix: String): AbstractFile = { - var dir = base - val pathParts = clsName.split("[./]").toList - for (part <- pathParts.init) { - dir = dir.subdirectoryNamed(part) - } - dir.fileNamed(pathParts.last + suffix) - } - protected def getFile(sym: Symbol, clsName: String, suffix: String): AbstractFile = - getFile(outputDirectory(sym), clsName, suffix) - protected val ExcludedForwarderFlags = { import Flags._ // Should include DEFERRED but this breaks findMember. diff --git a/src/compiler/scala/tools/nsc/backend/opt/ClosureElimination.scala b/src/compiler/scala/tools/nsc/backend/opt/ClosureElimination.scala index aaf2c55dcd..bde17b28fc 100644 --- a/src/compiler/scala/tools/nsc/backend/opt/ClosureElimination.scala +++ b/src/compiler/scala/tools/nsc/backend/opt/ClosureElimination.scala @@ -71,8 +71,10 @@ abstract class ClosureElimination extends SubComponent { def name = phaseName val closser = new ClosureElim - override def apply(c: IClass): Unit = - closser analyzeClass c + override def apply(c: IClass): Unit = { + if (closser ne null) + closser analyzeClass c + } } /** diff --git a/src/compiler/scala/tools/nsc/backend/opt/ConstantOptimization.scala b/src/compiler/scala/tools/nsc/backend/opt/ConstantOptimization.scala index 8a85873e94..43c8527f41 100644 --- a/src/compiler/scala/tools/nsc/backend/opt/ConstantOptimization.scala +++ b/src/compiler/scala/tools/nsc/backend/opt/ConstantOptimization.scala @@ -3,7 +3,8 @@ * @author James Iry */ -package scala.tools.nsc +package scala +package tools.nsc package backend.opt import scala.tools.nsc.backend.icode.analysis.LubException diff --git a/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala b/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala index 1026e95fac..483bff6467 100644 --- a/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala +++ b/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala @@ -33,7 +33,7 @@ abstract class DeadCodeElimination extends SubComponent { val dce = new DeadCode() override def apply(c: IClass) { - if (settings.Xdce) + if (settings.Xdce && (dce ne null)) dce.analyzeClass(c) } } diff --git a/src/compiler/scala/tools/nsc/reporters/ConsoleReporter.scala b/src/compiler/scala/tools/nsc/reporters/ConsoleReporter.scala index bda195f9d3..fdb5c72c3d 100644 --- a/src/compiler/scala/tools/nsc/reporters/ConsoleReporter.scala +++ b/src/compiler/scala/tools/nsc/reporters/ConsoleReporter.scala @@ -3,7 +3,8 @@ * @author Martin Odersky */ -package scala.tools.nsc +package scala +package tools.nsc package reporters import java.io.{ BufferedReader, IOException, PrintWriter } diff --git a/src/compiler/scala/tools/nsc/settings/AbsScalaSettings.scala b/src/compiler/scala/tools/nsc/settings/AbsScalaSettings.scala index 783e249931..c9718f711a 100644 --- a/src/compiler/scala/tools/nsc/settings/AbsScalaSettings.scala +++ b/src/compiler/scala/tools/nsc/settings/AbsScalaSettings.scala @@ -3,7 +3,8 @@ * @author Paul Phillips */ -package scala.tools.nsc +package scala +package tools.nsc package settings trait AbsScalaSettings { diff --git a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala index e679fa6365..c105dcbdff 100644 --- a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala +++ b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala @@ -4,7 +4,8 @@ */ // $Id$ -package scala.tools +package scala +package tools package nsc package settings @@ -156,6 +157,7 @@ trait ScalaSettings extends AbsScalaSettings val Yshowsymkinds = BooleanSetting ("-Yshow-symkinds", "Print abbreviated symbol kinds next to symbol names.") val skip = PhasesSetting ("-Yskip", "Skip") val Ygenjavap = StringSetting ("-Ygen-javap", "dir", "Generate a parallel output directory of .javap files.", "") + val Ygenasmp = StringSetting ("-Ygen-asmp", "dir", "Generate a parallel output directory of .asmp files (ie ASM Textifier output).", "") val Ydumpclasses = StringSetting ("-Ydump-classes", "dir", "Dump the generated bytecode to .class files (useful for reflective compilation that utilizes in-memory classloaders).", "") val Ynosqueeze = BooleanSetting ("-Yno-squeeze", "Disable creation of compact code in matching.") val Ystatistics = BooleanSetting ("-Ystatistics", "Print compiler statistics.") andThen (scala.reflect.internal.util.Statistics.enabled = _) @@ -164,6 +166,7 @@ trait ScalaSettings extends AbsScalaSettings val refinementMethodDispatch = ChoiceSetting ("-Ystruct-dispatch", "policy", "structural method dispatch policy", List("no-cache", "mono-cache", "poly-cache", "invoke-dynamic"), "poly-cache") val Yrangepos = BooleanSetting ("-Yrangepos", "Use range positions for syntax trees.") + val Ymemberpos = StringSetting ("-Yshow-member-pos", "output style", "Show start and end positions of members", "") withPostSetHook (_ => Yrangepos.value = true) val Yreifycopypaste = BooleanSetting ("-Yreify-copypaste", "Dump the reified trees in copypasteable representation.") val Yreplsync = BooleanSetting ("-Yrepl-sync", "Do not use asynchronous code for repl startup") val Yreploutdir = StringSetting ("-Yrepl-outdir", "path", "Write repl-generated classfiles to given output directory (use \"\" to generate a temporary dir)" , "") diff --git a/src/compiler/scala/tools/nsc/settings/ScalaVersion.scala b/src/compiler/scala/tools/nsc/settings/ScalaVersion.scala index d6a0149411..da1cc0c4cf 100644 --- a/src/compiler/scala/tools/nsc/settings/ScalaVersion.scala +++ b/src/compiler/scala/tools/nsc/settings/ScalaVersion.scala @@ -4,7 +4,8 @@ */ // $Id$ -package scala.tools.nsc.settings +package scala +package tools.nsc.settings /** * Represents a single Scala version in a manner that @@ -19,7 +20,7 @@ abstract class ScalaVersion extends Ordered[ScalaVersion] { */ case object NoScalaVersion extends ScalaVersion { def unparse = "none" - + def compare(that: ScalaVersion): Int = that match { case NoScalaVersion => 0 case _ => 1 @@ -33,7 +34,7 @@ case object NoScalaVersion extends ScalaVersion { * to segregate builds */ case class SpecificScalaVersion(major: Int, minor: Int, rev: Int, build: ScalaBuild) extends ScalaVersion { - def unparse = s"${major}.${minor}.${rev}.${build.unparse}" + def unparse = s"${major}.${minor}.${rev}.${build.unparse}" def compare(that: ScalaVersion): Int = that match { case SpecificScalaVersion(thatMajor, thatMinor, thatRev, thatBuild) => @@ -48,7 +49,7 @@ case class SpecificScalaVersion(major: Int, minor: Int, rev: Int, build: ScalaBu else build compare thatBuild case AnyScalaVersion => 1 case NoScalaVersion => -1 - } + } } /** @@ -56,7 +57,7 @@ case class SpecificScalaVersion(major: Int, minor: Int, rev: Int, build: ScalaBu */ case object AnyScalaVersion extends ScalaVersion { def unparse = "any" - + def compare(that: ScalaVersion): Int = that match { case AnyScalaVersion => 0 case _ => -1 @@ -70,7 +71,7 @@ object ScalaVersion { private val dot = "\\." private val dash = "\\-" private def not(s:String) = s"[^${s}]" - private val R = s"((${not(dot)}*)(${dot}(${not(dot)}*)(${dot}(${not(dash)}*)(${dash}(.*))?)?)?)".r + private val R = s"((${not(dot)}*)(${dot}(${not(dot)}*)(${dot}(${not(dash)}*)(${dash}(.*))?)?)?)".r def apply(versionString : String, errorHandler: String => Unit): ScalaVersion = { def errorAndValue() = { @@ -82,41 +83,41 @@ object ScalaVersion { ) AnyScalaVersion } - + def toInt(s: String) = s match { case null | "" => 0 case _ => s.toInt } - + def isInt(s: String) = util.Try(toInt(s)).isSuccess - + def toBuild(s: String) = s match { case null | "FINAL" => Final case s if (s.toUpperCase.startsWith("RC") && isInt(s.substring(2))) => RC(toInt(s.substring(2))) case s if (s.toUpperCase.startsWith("M") && isInt(s.substring(1))) => Milestone(toInt(s.substring(1))) case _ => Development(s) } - + try versionString match { case "none" => NoScalaVersion case "any" => AnyScalaVersion - case R(_, majorS, _, minorS, _, revS, _, buildS) => + case R(_, majorS, _, minorS, _, revS, _, buildS) => SpecificScalaVersion(toInt(majorS), toInt(minorS), toInt(revS), toBuild(buildS)) - case _ => + case _ => errorAndValue() } catch { case e: NumberFormatException => errorAndValue() } } - - def apply(versionString: String): ScalaVersion = + + def apply(versionString: String): ScalaVersion = apply(versionString, msg => throw new NumberFormatException(msg)) - + /** * The version of the compiler running now */ val current = apply(util.Properties.versionNumberString) - + /** * The 2.8.0 version. */ @@ -126,7 +127,7 @@ object ScalaVersion { /** * Represents the data after the dash in major.minor.rev-build */ -abstract class ScalaBuild extends Ordered[ScalaBuild] { +abstract class ScalaBuild extends Ordered[ScalaBuild] { /** * Return a version of this build information that can be parsed back into the * same ScalaBuild @@ -138,7 +139,7 @@ abstract class ScalaBuild extends Ordered[ScalaBuild] { */ case class Development(id: String) extends ScalaBuild { def unparse = s"-${id}" - + def compare(that: ScalaBuild) = that match { // sorting two development builds based on id is reasonably valid for two versions created with the same schema // otherwise it's not correct, but since it's impossible to put a total ordering on development build versions @@ -154,7 +155,7 @@ case class Development(id: String) extends ScalaBuild { */ case object Final extends ScalaBuild { def unparse = "" - + def compare(that: ScalaBuild) = that match { case Final => 0 // a final is newer than anything other than a development build or another final @@ -168,14 +169,14 @@ case object Final extends ScalaBuild { */ case class RC(n: Int) extends ScalaBuild { def unparse = s"-RC${n}" - + def compare(that: ScalaBuild) = that match { // compare two rcs based on their RC numbers case RC(thatN) => n - thatN // an rc is older than anything other than a milestone or another rc case Milestone(_) => 1 - case _ => -1 - } + case _ => -1 + } } /** @@ -183,12 +184,12 @@ case class RC(n: Int) extends ScalaBuild { */ case class Milestone(n: Int) extends ScalaBuild { def unparse = s"-M${n}" - + def compare(that: ScalaBuild) = that match { // compare two milestones based on their milestone numbers case Milestone(thatN) => n - thatN // a milestone is older than anything other than another milestone case _ => -1 - - } + + } } diff --git a/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala b/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala index 250feb69bf..98fb6bd0ef 100644 --- a/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala +++ b/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala @@ -234,10 +234,14 @@ abstract class SymbolLoaders { } } if (!root.isEmptyPackageClass) { + // Only enter packages which contain a class or a non-empty package for (pkg <- classpath.packages) { - enterPackage(root, pkg.name, new PackageLoader(pkg)) + if (pkg.isEmptyOfClassfiles) { + log(s"Discarding $root/$pkg as it contains no classfiles.") + } + else + enterPackage(root, pkg.name, new PackageLoader(pkg)) } - openPackageModule(root) } } diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala b/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala index ce889f3ce3..42bf0f6b41 100644 --- a/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala +++ b/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala @@ -3,7 +3,8 @@ * @author Martin Odersky */ -package scala.tools.nsc +package scala +package tools.nsc package symtab package classfile diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala b/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala index 7aaeb56deb..52ebb3b0a2 100644 --- a/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala +++ b/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala @@ -3,7 +3,8 @@ * @author Iulian Dragos */ -package scala.tools.nsc +package scala +package tools.nsc package symtab package classfile diff --git a/src/compiler/scala/tools/nsc/transform/Constructors.scala b/src/compiler/scala/tools/nsc/transform/Constructors.scala index 06367009b6..5079108c27 100644 --- a/src/compiler/scala/tools/nsc/transform/Constructors.scala +++ b/src/compiler/scala/tools/nsc/transform/Constructors.scala @@ -81,7 +81,7 @@ abstract class Constructors extends Transform with ast.TreeDSL { val constrInfo: ConstrInfo = { stats find (_.symbol.isPrimaryConstructor) match { case Some(ddef @ DefDef(_, _, _, List(vparams), _, rhs @ Block(_, _))) => - ConstrInfo(ddef, vparams map (_.symbol), rhs) + ConstrInfo(ddef, vparams map (_.symbol), rhs) case x => // AnyVal constructor is OK assert(clazz eq AnyValClass, "no constructor in template: impl = " + impl) @@ -164,7 +164,8 @@ abstract class Constructors extends Transform with ast.TreeDSL { if (from.name != nme.OUTER || from.tpe.typeSymbol.isPrimitiveValueClass) result else localTyper.typedPos(to.pos) { - IF (from OBJ_EQ NULL) THEN Throw(NewFromConstructor(NPEConstructor)) ELSE result + // `throw null` has the same effect as `throw new NullPointerException`, see JVM spec on instruction `athrow` + IF (from OBJ_EQ NULL) THEN Throw(gen.mkZero(ThrowableClass.tpe)) ELSE result } } @@ -235,7 +236,7 @@ abstract class Constructors extends Transform with ast.TreeDSL { constrStatBuf += intoConstructor(impl.symbol, stat) } - // ----------- avoid making fields for symbols that are not accessed -------------- + // ----------- avoid making parameter-accessor fields for symbols accessed only within the primary constructor -------------- // A sorted set of symbols that are known to be accessed outside the primary constructor. val accessedSyms = new TreeSet[Symbol]((x, y) => x isLess y) @@ -243,6 +244,8 @@ abstract class Constructors extends Transform with ast.TreeDSL { // a list of outer accessor symbols and their bodies var outerAccessors: List[(Symbol, Tree)] = List() + val isDelayedInitSubclass = (clazz isSubClass DelayedInitClass) + // Could symbol's definition be omitted, provided it is not accessed? // This is the case if the symbol is defined in the current class, and // ( the symbol is an object private parameter accessor field, or @@ -250,12 +253,12 @@ abstract class Constructors extends Transform with ast.TreeDSL { def maybeOmittable(sym: Symbol) = sym.owner == clazz && ( sym.isParamAccessor && sym.isPrivateLocal || sym.isOuterAccessor && sym.owner.isEffectivelyFinal && !sym.isOverridingSymbol && - !(clazz isSubClass DelayedInitClass) + !isDelayedInitSubclass ) // Is symbol known to be accessed outside of the primary constructor, // or is it a symbol whose definition cannot be omitted anyway? - def mustbeKept(sym: Symbol) = !maybeOmittable(sym) || (accessedSyms contains sym) + def mustbeKept(sym: Symbol) = isDelayedInitSubclass || !maybeOmittable(sym) || (accessedSyms contains sym) // A traverser to set accessedSyms and outerAccessors val accessTraverser = new Traverser { @@ -379,12 +382,12 @@ abstract class Constructors extends Transform with ast.TreeDSL { * 'specInstance$' is added in phase specialize. */ def guardSpecializedInitializer(stats: List[Tree]): List[Tree] = if (settings.nospecialization.value) stats else { - // split the statements in presuper and postsuper - // var (prefix, postfix) = stats0.span(tree => !((tree.symbol ne null) && tree.symbol.isConstructor)) - // if (postfix.nonEmpty) { - // prefix = prefix :+ postfix.head - //postfix = postfix.tail - //} + // // split the statements in presuper and postsuper + // var (prefix, postfix) = stats0.span(tree => !((tree.symbol ne null) && tree.symbol.isConstructor)) + // if (postfix.nonEmpty) { + // prefix = prefix :+ postfix.head + // postfix = postfix.tail + // } if (usesSpecializedField && shouldGuard && stats.nonEmpty) { // save them for duplication in the specialized subclass @@ -414,76 +417,82 @@ abstract class Constructors extends Transform with ast.TreeDSL { } } else stats } -/* - def isInitDef(stat: Tree) = stat match { - case dd: DefDef => dd.symbol == delayedInitMethod - case _ => false - } -*/ - - /* Create a getter or a setter and enter into `clazz` scope */ - def addAccessor(sym: Symbol, name: TermName, flags: Long) = { - val m = clazz.newMethod(name, sym.pos, flags & ~(LOCAL | PRIVATE)) setPrivateWithin clazz - clazz.info.decls enter m - } - def addGetter(sym: Symbol): Symbol = { - val getr = addAccessor(sym, sym.getterName, getterFlags(sym.flags)) - getr setInfo MethodType(List(), sym.tpe) - defBuf += localTyper.typedPos(sym.pos)(DefDef(getr, Select(This(clazz), sym))) - getr - } - - def addSetter(sym: Symbol): Symbol = { - sym setFlag MUTABLE - val setr = addAccessor(sym, sym.setterName, setterFlags(sym.flags)) - setr setInfo MethodType(setr.newSyntheticValueParams(List(sym.tpe)), UnitClass.tpe) - defBuf += localTyper.typed { - //util.trace("adding setter def for "+setr) { - atPos(sym.pos) { - DefDef(setr, paramss => - Assign(Select(This(clazz), sym), Ident(paramss.head.head))) - }//} - } - setr - } + /* + * Translation scheme for DelayedInit + * ---------------------------------- + * + * Before returning, transformClassTemplate() rewrites DelayedInit subclasses. + * The list of statements that will end up in the primary constructor can be split into: + * + * (a) up to and including the super-constructor call. + * These statements can occur only in the (bytecode-level) primary constructor. + * + * (b) remaining statements + * + * The purpose of DelayedInit is leaving (b) out of the primary constructor and have their execution "delayed". + * + * The rewriting to achieve "delayed initialization" involves: + * (c) an additional, synthetic, public method encapsulating (b) + * (d) an additional, synthetic closure whose argless apply() just invokes (c) + * (e) after executing the statements in (a), + * the primary constructor instantiates (d) and passes it as argument + * to a `delayedInit()` invocation on the current instance. + * In turn, `delayedInit()` is a method defined as abstract in the `DelayedInit` trait + * so that it can be overridden (for an example see `scala.App`) + * + * The following helper methods prepare Trees as part of this rewriting: + * + * (f) `delayedEndpointDef()` prepares (c). + * A transformer, `constrStatTransformer`, is used to re-locate statements (b) from template-level + * to become statements in method (c). The main task here is re-formulating accesses to params + * of the primary constructors (to recap, (c) has zero-params) in terms of param-accessor fields. + * In a Delayed-Init subclass, each class-constructor gets a param-accessor field because `mustbeKept()` forces it. + * + * (g) `delayedInitClosure()` prepares (d) + * + * (h) `delayedInitCall()` prepares the `delayedInit()` invocation referred to in (e) + * + * Both (c) and (d) are added to the Template returned by `transformClassTemplate()` + * + * A note of historic interest: Previously the rewriting for DelayedInit would include in the closure body + * all of the delayed initialization sequence, which in turn required: + * - reformulating "accesses-on-this" into "accesses-on-outer", and + * - adding public getters and setters. + * + * @param stats the statements in (b) above + * + * @return the DefDef for (c) above + * + * */ + def delayedEndpointDef(stats: List[Tree]): DefDef = { - def ensureAccessor(sym: Symbol)(acc: => Symbol) = - if (sym.owner == clazz && !sym.isMethod && sym.isPrivate) { // there's an access to a naked field of the enclosing class - val getr = acc - getr makeNotPrivate clazz - getr - } else { - if (sym.owner == clazz) sym makeNotPrivate clazz - NoSymbol - } + val methodName = currentUnit.freshTermName("delayedEndpoint$" + clazz.fullNameAsName('$').toString + "$") + val methodSym = clazz.newMethod(methodName, impl.pos, SYNTHETIC | FINAL) + methodSym setInfoAndEnter MethodType(Nil, UnitClass.tpe) - def ensureGetter(sym: Symbol): Symbol = ensureAccessor(sym) { - val getr = sym.getter(clazz) - if (getr != NoSymbol) getr else addGetter(sym) - } + // changeOwner needed because the `stats` contained in the DefDef were owned by the template, not long ago. + val blk = Block(stats, gen.mkZero(UnitClass.tpe)).changeOwner(impl.symbol -> methodSym) + val delayedDD = localTyper typed { DefDef(methodSym, Nil, blk) } - def ensureSetter(sym: Symbol): Symbol = ensureAccessor(sym) { - var setr = sym.setter(clazz, hasExpandedName = false) - if (setr == NoSymbol) setr = sym.setter(clazz, hasExpandedName = true) - if (setr == NoSymbol) setr = addSetter(sym) - setr + delayedDD.asInstanceOf[DefDef] } - def delayedInitClosure(stats: List[Tree]) = - localTyper.typed { + /* @see overview at `delayedEndpointDef()` of the translation scheme for DelayedInit */ + def delayedInitClosure(delayedEndPointSym: MethodSymbol): ClassDef = { + val satelliteClass = localTyper.typed { atPos(impl.pos) { val closureClass = clazz.newClass(nme.delayedInitArg.toTypeName, impl.pos, SYNTHETIC | FINAL) val closureParents = List(AbstractFunctionClass(0).tpe) closureClass setInfoAndEnter new ClassInfoType(closureParents, newScope, closureClass) - val outerField = ( + val outerField: TermSymbol = ( closureClass newValue(nme.OUTER, impl.pos, PrivateLocal | PARAMACCESSOR) setInfoAndEnter clazz.tpe ) - val applyMethod = ( + val applyMethod: MethodSymbol = ( closureClass newMethod(nme.apply, impl.pos, FINAL) setInfoAndEnter MethodType(Nil, ObjectClass.tpe) @@ -492,58 +501,32 @@ abstract class Constructors extends Transform with ast.TreeDSL { val closureClassTyper = localTyper.atOwner(closureClass) val applyMethodTyper = closureClassTyper.atOwner(applyMethod) - val constrStatTransformer = new Transformer { - override def transform(tree: Tree): Tree = tree match { - case This(_) if tree.symbol == clazz => - applyMethodTyper.typed { - atPos(tree.pos) { - Select(This(closureClass), outerField) - } - } - case _ => - super.transform { - tree match { - case Select(qual, _) => - val getter = ensureGetter(tree.symbol) - if (getter != NoSymbol) - applyMethodTyper.typed { - atPos(tree.pos) { - Apply(Select(qual, getter), List()) - } - } - else tree - case Assign(lhs @ Select(qual, _), rhs) => - val setter = ensureSetter(lhs.symbol) - if (setter != NoSymbol) - applyMethodTyper.typed { - atPos(tree.pos) { - Apply(Select(qual, setter), List(rhs)) - } - } - else tree - case _ => - tree.changeOwner(impl.symbol -> applyMethod) - } - } + def applyMethodStat = + applyMethodTyper.typed { + atPos(impl.pos) { + val receiver = Select(This(closureClass), outerField) + Apply(Select(receiver, delayedEndPointSym), Nil) + } } - } - - def applyMethodStats = constrStatTransformer.transformTrees(stats) val applyMethodDef = DefDef( sym = applyMethod, vparamss = ListOfNil, - rhs = Block(applyMethodStats, gen.mkAttributedRef(BoxedUnit_UNIT))) + rhs = Block(applyMethodStat, gen.mkAttributedRef(BoxedUnit_UNIT))) ClassDef( sym = closureClass, constrMods = Modifiers(0), vparamss = List(List(outerFieldDef)), - body = List(applyMethodDef), + body = applyMethodDef :: Nil, superPos = impl.pos) } } + satelliteClass.asInstanceOf[ClassDef] + } + + /* @see overview at `delayedEndpointDef()` of the translation scheme for DelayedInit */ def delayedInitCall(closure: Tree) = localTyper.typedPos(impl.pos) { gen.mkMethodCall(This(clazz), delayedInitMethod, Nil, List(New(closure.symbol.tpe, This(clazz)))) } @@ -566,13 +549,18 @@ abstract class Constructors extends Transform with ast.TreeDSL { * See test case files/run/bug4680.scala, the output of which is wrong in many * particulars. */ - val needsDelayedInit = - (clazz isSubClass DelayedInitClass) /*&& !(defBuf exists isInitDef)*/ && remainingConstrStats.nonEmpty + val needsDelayedInit = (isDelayedInitSubclass && remainingConstrStats.nonEmpty) if (needsDelayedInit) { - val dicl = new ConstructorTransformer(unit) transform delayedInitClosure(remainingConstrStats) - defBuf += dicl - remainingConstrStats = List(delayedInitCall(dicl)) + val delayedHook: DefDef = delayedEndpointDef(remainingConstrStats) + defBuf += delayedHook + val hookCallerClass = { + // transform to make the closure-class' default constructor assign the the outer instance to its param-accessor field. + val drillDown = new ConstructorTransformer(unit) + drillDown transform delayedInitClosure(delayedHook.symbol.asInstanceOf[MethodSymbol]) + } + defBuf += hookCallerClass + remainingConstrStats = delayedInitCall(hookCallerClass) :: Nil } // Assemble final constructor @@ -594,12 +582,14 @@ abstract class Constructors extends Transform with ast.TreeDSL { deriveTemplate(impl)(_ => defBuf.toList filter (stat => mustbeKept(stat.symbol))) } // transformClassTemplate - override def transform(tree: Tree): Tree = + override def transform(tree: Tree): Tree = { tree match { case ClassDef(_,_,_,_) if !tree.symbol.isInterface && !isPrimitiveValueClass(tree.symbol) => deriveClassDef(tree)(transformClassTemplate) case _ => super.transform(tree) } + } + } // ConstructorTransformer } diff --git a/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala b/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala index 1aa5f10738..48263a496e 100644 --- a/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala +++ b/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala @@ -3,7 +3,8 @@ * @author Martin Odersky */ -package scala.tools.nsc +package scala +package tools.nsc package transform import symtab._ @@ -83,7 +84,7 @@ abstract class ExplicitOuter extends InfoTransform else findOrElse(clazz.info.decls)(_.outerSource == clazz)(NoSymbol) } def newOuterAccessor(clazz: Symbol) = { - val accFlags = SYNTHETIC | ARTIFACT | METHOD | STABLE | ( if (clazz.isTrait) DEFERRED else 0 ) + val accFlags = SYNTHETIC | ARTIFACT | STABLE | ( if (clazz.isTrait) DEFERRED else 0 ) val sym = clazz.newMethod(nme.OUTER, clazz.pos, accFlags) val restpe = if (clazz.isTrait) clazz.outerClass.tpe_* else clazz.outerClass.thisType diff --git a/src/compiler/scala/tools/nsc/transform/LambdaLift.scala b/src/compiler/scala/tools/nsc/transform/LambdaLift.scala index 6ff8792a45..868bbb1e42 100644 --- a/src/compiler/scala/tools/nsc/transform/LambdaLift.scala +++ b/src/compiler/scala/tools/nsc/transform/LambdaLift.scala @@ -32,6 +32,21 @@ abstract class LambdaLift extends InfoTransform { } } + /** scala.runtime.*Ref classes */ + private lazy val allRefClasses: Set[Symbol] = { + refClass.values.toSet ++ volatileRefClass.values.toSet ++ Set(VolatileObjectRefClass, ObjectRefClass) + } + + /** Each scala.runtime.*Ref class has a static method `create(value)` that simply instantiates the Ref to carry that value. */ + private lazy val refCreateMethod: Map[Symbol, Symbol] = { + mapFrom(allRefClasses.toList)(x => getMemberMethod(x.companionModule, nme.create)) + } + + /** Quite frequently a *Ref is initialized with its zero (e.g., null, 0.toByte, etc.) Method `zero()` of *Ref class encapsulates that pattern. */ + private lazy val refZeroMethod: Map[Symbol, Symbol] = { + mapFrom(allRefClasses.toList)(x => getMemberMethod(x.companionModule, nme.zero)) + } + def transformInfo(sym: Symbol, tp: Type): Type = if (sym.isCapturedVariable) capturedVariableType(sym, tpe = lifted(tp), erasedTypes = true) else lifted(tp) @@ -444,56 +459,21 @@ abstract class LambdaLift extends InfoTransform { case ValDef(mods, name, tpt, rhs) => if (sym.isCapturedVariable) { val tpt1 = TypeTree(sym.tpe) setPos tpt.pos - /* Creating a constructor argument if one isn't present. */ - val constructorArg = rhs match { - case EmptyTree => - sym.tpe.typeSymbol.primaryConstructor.info.paramTypes match { - case List(tp) => gen.mkZero(tp) - case _ => - debugwarn("Couldn't determine how to properly construct " + sym) - rhs - } - case arg => arg + + val refTypeSym = sym.tpe.typeSymbol + + val factoryCall = typer.typedPos(rhs.pos) { + rhs match { + case EmptyTree => + val zeroMSym = refZeroMethod(refTypeSym) + gen.mkMethodCall(zeroMSym, Nil) + case arg => + val createMSym = refCreateMethod(refTypeSym) + gen.mkMethodCall(createMSym, arg :: Nil) + } } - /* Wrap expr argument in new *Ref(..) constructor. But try/catch - * is a problem because a throw will clear the stack and post catch - * we would expect the partially-constructed object to be on the stack - * for the call to init. So we recursively - * search for "leaf" result expressions where we know its safe - * to put the new *Ref(..) constructor or, if all else fails, transform - * an expr to { val temp=expr; new *Ref(temp) }. - * The reason we narrowly look for try/catch in captured var definitions - * is because other try/catch expression have already been lifted - * see SI-6863 - */ - def refConstr(expr: Tree): Tree = typer.typedPos(expr.pos)(expr match { - // very simple expressions can be wrapped in a new *Ref(expr) because they can't have - // a try/catch in final expression position. - case Ident(_) | Apply(_, _) | Literal(_) | New(_) | Select(_, _) | Throw(_) | Assign(_, _) | ValDef(_, _, _, _) | Return(_) | EmptyTree => - New(sym.tpe, expr) - case Try(block, catches, finalizer) => - Try(refConstr(block), catches map refConstrCase, finalizer) - case Block(stats, expr) => - Block(stats, refConstr(expr)) - case If(cond, trueBranch, falseBranch) => - If(cond, refConstr(trueBranch), refConstr(falseBranch)) - case Match(selector, cases) => - Match(selector, cases map refConstrCase) - // if we can't figure out what else to do, turn expr into {val temp1 = expr; new *Ref(temp1)} to avoid - // any possibility of try/catch in the *Ref constructor. This should be a safe tranformation as a default - // though it potentially wastes a variable slot. In particular this case handles LabelDefs. - case _ => - debuglog("assigning expr to temp: " + (expr.pos)) - val tempSym = currentOwner.newValue(unit.freshTermName("temp"), expr.pos) setInfo expr.tpe - val tempDef = ValDef(tempSym, expr) setPos expr.pos - val tempRef = Ident(tempSym) setPos expr.pos - Block(tempDef, New(sym.tpe, tempRef)) - }) - def refConstrCase(cdef: CaseDef): CaseDef = - CaseDef(cdef.pat, cdef.guard, refConstr(cdef.body)) - - treeCopy.ValDef(tree, mods, name, tpt1, refConstr(constructorArg)) + treeCopy.ValDef(tree, mods, name, tpt1, factoryCall) } else tree case Return(Block(stats, value)) => Block(stats, treeCopy.Return(tree, value)) setType tree.tpe setPos tree.pos diff --git a/src/compiler/scala/tools/nsc/transform/Mixin.scala b/src/compiler/scala/tools/nsc/transform/Mixin.scala index 8774390c8c..7fe7947239 100644 --- a/src/compiler/scala/tools/nsc/transform/Mixin.scala +++ b/src/compiler/scala/tools/nsc/transform/Mixin.scala @@ -34,7 +34,7 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL { /** A member of a trait is implemented statically if its implementation after the * mixin transform is in the static implementation module. To be statically * implemented, a member must be a method that belonged to the trait's implementation class - * before (e.g. it is not abstract). Not statically implemented are + * before (i.e. it is not abstract). Not statically implemented are * - non-private modules: these are implemented directly in the mixin composition class * (private modules, on the other hand, are implemented statically, but their * module variable is not. all such private modules are lifted, because @@ -1037,7 +1037,7 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL { else if (!clazz.isTrait) { // This needs to be a def to avoid sharing trees def accessedRef = accessedReference(sym) - if (sym.hasAccessorFlag && (!sym.isDeferred || sym.hasFlag(lateDEFERRED))) { + if (isConcreteAccessor(sym)) { // add accessor definitions addDefDef(sym, { if (sym.isSetter) { diff --git a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala index 4b00c0efe9..90ca157090 100644 --- a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala +++ b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala @@ -3,7 +3,8 @@ * @author Iulian Dragos */ -package scala.tools.nsc +package scala +package tools.nsc package transform import scala.tools.nsc.symtab.Flags diff --git a/src/compiler/scala/tools/nsc/transform/TailCalls.scala b/src/compiler/scala/tools/nsc/transform/TailCalls.scala index 313f968e93..6f422fcc90 100644 --- a/src/compiler/scala/tools/nsc/transform/TailCalls.scala +++ b/src/compiler/scala/tools/nsc/transform/TailCalls.scala @@ -3,7 +3,8 @@ * @author Iulian Dragos */ -package scala.tools.nsc +package scala +package tools.nsc package transform import symtab.Flags @@ -87,98 +88,112 @@ abstract class TailCalls extends Transform { * </p> */ class TailCallElimination(unit: CompilationUnit) extends Transformer { - private val defaultReason = "it contains a recursive call not in tail position" + private def defaultReason = "it contains a recursive call not in tail position" + private val failPositions = perRunCaches.newMap[TailContext, Position]() withDefault (_.methodPos) + private val failReasons = perRunCaches.newMap[TailContext, String]() withDefaultValue defaultReason + private def tailrecFailure(ctx: TailContext) { + val method = ctx.method + val failReason = failReasons(ctx) + val failPos = failPositions(ctx) + + unit.error(failPos, s"could not optimize @tailrec annotated $method: $failReason") + } /** Has the label been accessed? Then its symbol is in this set. */ - private val accessed = new scala.collection.mutable.HashSet[Symbol]() + private val accessed = perRunCaches.newSet[Symbol]() // `accessed` was stored as boolean in the current context -- this is no longer tenable // with jumps to labels in tailpositions now considered in tailposition, // a downstream context may access the label, and the upstream one will be none the wiser // this is necessary because tail-calls may occur in places where syntactically they seem impossible // (since we now consider jumps to labels that are in tailposition, such as matchEnd(x) {x}) + sealed trait TailContext { + def method: Symbol // current method + def tparams: List[Symbol] // type parameters + def methodPos: Position // default position for failure reporting + def tailPos: Boolean // context is in tail position + def label: Symbol // new label, tail call target + def tailLabels: Set[Symbol] + + def enclosingType = method.enclClass.typeOfThis + def isEligible = method.isEffectivelyFinal + def isMandatory = method.hasAnnotation(TailrecClass) + def isTransformed = isEligible && accessed(label) + + def newThis(pos: Position) = { + def msg = "Creating new `this` during tailcalls\n method: %s\n current class: %s".format( + method.ownerChain.mkString(" -> "), + currentClass.ownerChain.mkString(" -> ") + ) + logResult(msg)(method.newValue(nme.THIS, pos, SYNTHETIC) setInfo currentClass.typeOfThis) + } + override def toString = s"${method.name} tparams=$tparams tailPos=$tailPos label=$label label info=${label.info}" + } - class Context() { - /** The current method */ - var method: Symbol = NoSymbol - - // symbols of label defs in this method that are in tail position - var tailLabels: Set[Symbol] = Set() - - /** The current tail-call label */ - var label: Symbol = NoSymbol - - /** The expected type arguments of self-recursive calls */ - var tparams: List[Symbol] = Nil - - /** Tells whether we are in a (possible) tail position */ - var tailPos = false - - /** The reason this method could not be optimized. */ - var failReason = defaultReason - var failPos = method.pos + object EmptyTailContext extends TailContext { + def method = NoSymbol + def tparams = Nil + def methodPos = NoPosition + def tailPos = false + def label = NoSymbol + def tailLabels = Set.empty[Symbol] + } - def this(that: Context) = { - this() - this.method = that.method - this.tparams = that.tparams - this.tailPos = that.tailPos - this.failPos = that.failPos - this.label = that.label - this.tailLabels = that.tailLabels + class DefDefTailContext(dd: DefDef) extends TailContext { + def method = dd.symbol + def tparams = dd.tparams map (_.symbol) + def methodPos = dd.pos + def tailPos = true + + lazy val label = mkLabel() + lazy val tailLabels = { + // labels are local to a method, so only traverse the rhs of a defdef + val collector = new TailPosLabelsTraverser + collector traverse dd.rhs + collector.tailLabels.toSet } - def this(dd: DefDef) { - this() - this.method = dd.symbol - this.tparams = dd.tparams map (_.symbol) - this.tailPos = true - this.failPos = dd.pos - - /* Create a new method symbol for the current method and store it in - * the label field. - */ - this.label = { - val label = method.newLabel(newTermName("_" + method.name), method.pos) - val thisParam = method.newSyntheticValueParam(currentClass.typeOfThis) - label setInfo MethodType(thisParam :: method.tpe.params, method.tpe.finalResultType) - } + + private def mkLabel() = { + val label = method.newLabel(newTermName("_" + method.name), method.pos) + val thisParam = method.newSyntheticValueParam(currentClass.typeOfThis) + label setInfo MethodType(thisParam :: method.tpe.params, method.tpe.finalResultType) if (isEligible) label substInfo (method.tpe.typeParams, tparams) - } - - def enclosingType = method.enclClass.typeOfThis - def isEligible = method.isEffectivelyFinal - // @tailrec annotation indicates mandatory transformation - def isMandatory = method.hasAnnotation(TailrecClass) - def isTransformed = isEligible && accessed(label) - def tailrecFailure() = unit.error(failPos, "could not optimize @tailrec annotated " + method + ": " + failReason) - def newThis(pos: Position) = logResult("Creating new `this` during tailcalls\n method: %s\n current class: %s".format( - method.ownerChain.mkString(" -> "), currentClass.ownerChain.mkString(" -> "))) { - method.newValue(nme.THIS, pos, SYNTHETIC) setInfo currentClass.typeOfThis + label } - - override def toString(): String = ( - "" + method.name + " tparams: " + tparams + " tailPos: " + tailPos + - " Label: " + label + " Label type: " + label.info - ) + private def isRecursiveCall(t: Tree) = { + val receiver = t.symbol + + ( (receiver != null) + && receiver.isMethod + && (method.name == receiver.name) + && (method.enclClass isSubClass receiver.enclClass) + ) + } + def containsRecursiveCall(t: Tree) = t exists isRecursiveCall } - - private var ctx: Context = new Context() - private def noTailContext() = { - val t = new Context(ctx) - t.tailPos = false - t + class ClonedTailContext(that: TailContext, override val tailPos: Boolean) extends TailContext { + def method = that.method + def tparams = that.tparams + def methodPos = that.methodPos + def tailLabels = that.tailLabels + def label = that.label } + private var ctx: TailContext = EmptyTailContext + private def noTailContext() = new ClonedTailContext(ctx, tailPos = false) + private def yesTailContext() = new ClonedTailContext(ctx, tailPos = true) + /** Rewrite this tree to contain no tail recursive calls */ - def transform(tree: Tree, nctx: Context): Tree = { + def transform(tree: Tree, nctx: TailContext): Tree = { val saved = ctx ctx = nctx try transform(tree) finally this.ctx = saved } + def yesTailTransform(tree: Tree): Tree = transform(tree, yesTailContext()) def noTailTransform(tree: Tree): Tree = transform(tree, noTailContext()) def noTailTransforms(trees: List[Tree]) = { val nctx = noTailContext() @@ -192,7 +207,6 @@ abstract class TailCalls extends Transform { case Select(qual, _) => qual case _ => EmptyTree } - def receiverIsSame = ctx.enclosingType.widen =:= receiver.tpe.widen def receiverIsSuper = ctx.enclosingType.widen <:< receiver.tpe.widen def isRecursiveCall = (ctx.method eq fun.symbol) && ctx.tailPos @@ -204,18 +218,16 @@ abstract class TailCalls extends Transform { */ def fail(reason: String) = { debuglog("Cannot rewrite recursive call at: " + fun.pos + " because: " + reason) - - ctx.failReason = reason + failReasons(ctx) = reason treeCopy.Apply(tree, noTailTransform(target), transformArgs) } /* Position of failure is that of the tree being considered. */ def failHere(reason: String) = { - ctx.failPos = fun.pos + failPositions(ctx) = fun.pos fail(reason) } def rewriteTailCall(recv: Tree): Tree = { debuglog("Rewriting tail recursive call: " + fun.pos.lineContent.trim) - accessed += ctx.label typedPos(fun.pos) { val args = mapWithIndex(transformArgs)((arg, i) => mkAttributedCastHack(arg, ctx.label.info.params(i + 1).tpe)) @@ -225,7 +237,7 @@ abstract class TailCalls extends Transform { if (!ctx.isEligible) fail("it is neither private nor final so can be overridden") else if (!isRecursiveCall) { - if (receiverIsSuper) failHere("it contains a recursive call targeting supertype " + receiver.tpe) + if (receiverIsSuper) failHere("it contains a recursive call targeting a supertype") else failHere(defaultReason) } else if (!matchesTypeArgs) failHere("it is called recursively with different type arguments") @@ -241,37 +253,23 @@ abstract class TailCalls extends Transform { super.transform(tree) - case dd @ DefDef(_, _, _, vparamss0, _, rhs0) if !dd.symbol.hasAccessorFlag => - val newCtx = new Context(dd) - def isRecursiveCall(t: Tree) = { - val sym = t.symbol - (sym != null) && { - sym.isMethod && (dd.symbol.name == sym.name) && (dd.symbol.enclClass isSubClass sym.enclClass) - } - } - if (newCtx.isMandatory) { - if (!rhs0.exists(isRecursiveCall)) { - unit.error(tree.pos, "@tailrec annotated method contains no recursive calls") - } - } - - // labels are local to a method, so only traverse the rhs of a defdef - val collectTailPosLabels = new TailPosLabelsTraverser - collectTailPosLabels traverse rhs0 - newCtx.tailLabels = collectTailPosLabels.tailLabels.toSet + case dd @ DefDef(_, name, _, vparamss0, _, rhs0) if !dd.symbol.hasAccessorFlag => + val newCtx = new DefDefTailContext(dd) + if (newCtx.isMandatory && !(newCtx containsRecursiveCall rhs0)) + unit.error(tree.pos, "@tailrec annotated method contains no recursive calls") - debuglog("Considering " + dd.name + " for tailcalls, with labels in tailpos: "+ newCtx.tailLabels) + debuglog(s"Considering $name for tailcalls, with labels in tailpos: ${newCtx.tailLabels}") val newRHS = transform(rhs0, newCtx) - deriveDefDef(tree){rhs => + deriveDefDef(tree) { rhs => if (newCtx.isTransformed) { /* We have rewritten the tree, but there may be nested recursive calls remaining. * If @tailrec is given we need to fail those now. */ if (newCtx.isMandatory) { for (t @ Apply(fn, _) <- newRHS ; if fn.symbol == newCtx.method) { - newCtx.failPos = t.pos - newCtx.tailrecFailure() + failPositions(newCtx) = t.pos + tailrecFailure(newCtx) } } val newThis = newCtx.newThis(tree.pos) @@ -283,8 +281,8 @@ abstract class TailCalls extends Transform { )) } else { - if (newCtx.isMandatory && newRHS.exists(isRecursiveCall)) - newCtx.tailrecFailure() + if (newCtx.isMandatory && (newCtx containsRecursiveCall newRHS)) + tailrecFailure(newCtx) newRHS } @@ -345,27 +343,25 @@ abstract class TailCalls extends Transform { case Apply(tapply @ TypeApply(fun, targs), vargs) => rewriteApply(tapply, fun, targs, vargs) - case Apply(fun, args) => - if (fun.symbol == Boolean_or || fun.symbol == Boolean_and) - treeCopy.Apply(tree, fun, transformTrees(args)) - else if (fun.symbol.isLabel && args.nonEmpty && args.tail.isEmpty && ctx.tailLabels(fun.symbol)) { - // this is to detect tailcalls in translated matches - // it's a one-argument call to a label that is in a tailposition and that looks like label(x) {x} - // thus, the argument to the call is in tailposition - val saved = ctx.tailPos - ctx.tailPos = true - debuglog("in tailpos label: "+ args.head) - val res = transform(args.head) - ctx.tailPos = saved - if (res ne args.head) { - // we tail-called -- TODO: shield from false-positives where we rewrite but don't tail-call - // must leave the jump to the original tailpos-label (fun)! - // there might be *a* tailcall *in* res, but it doesn't mean res *always* tailcalls - treeCopy.Apply(tree, fun, List(res)) - } - else rewriteApply(fun, fun, Nil, args) - } else rewriteApply(fun, fun, Nil, args) + case Apply(fun, args) if fun.symbol == Boolean_or || fun.symbol == Boolean_and => + treeCopy.Apply(tree, fun, transformTrees(args)) + + // this is to detect tailcalls in translated matches + // it's a one-argument call to a label that is in a tailposition and that looks like label(x) {x} + // thus, the argument to the call is in tailposition + case Apply(fun, args @ (arg :: Nil)) if fun.symbol.isLabel && ctx.tailLabels(fun.symbol) => + debuglog(s"in tailpos label: $arg") + val res = yesTailTransform(arg) + // we tail-called -- TODO: shield from false-positives where we rewrite but don't tail-call + // must leave the jump to the original tailpos-label (fun)! + // there might be *a* tailcall *in* res, but it doesn't mean res *always* tailcalls + if (res ne arg) + treeCopy.Apply(tree, fun, res :: Nil) + else + rewriteApply(fun, fun, Nil, args) + case Apply(fun, args) => + rewriteApply(fun, fun, Nil, args) case Alternative(_) | Star(_) | Bind(_, _) => sys.error("We should've never gotten inside a pattern") case Select(qual, name) => diff --git a/src/compiler/scala/tools/nsc/transform/UnCurry.scala b/src/compiler/scala/tools/nsc/transform/UnCurry.scala index 2f5cb23abb..d7be0ed180 100644 --- a/src/compiler/scala/tools/nsc/transform/UnCurry.scala +++ b/src/compiler/scala/tools/nsc/transform/UnCurry.scala @@ -3,7 +3,8 @@ * @author */ -package scala.tools.nsc +package scala +package tools.nsc package transform import symtab.Flags._ @@ -470,7 +471,7 @@ abstract class UnCurry extends InfoTransform val fn1 = withInPattern(value = false)(transform(fn)) val args1 = transformTrees(fn.symbol.name match { case nme.unapply => args - case nme.unapplySeq => transformArgs(tree.pos, fn.symbol, args, analyzer.unapplyTypeList(fn.pos, fn.symbol, fn.tpe, args.length)) + case nme.unapplySeq => transformArgs(tree.pos, fn.symbol, args, analyzer.unapplyTypeList(fn.pos, fn.symbol, fn.tpe, args)) case _ => sys.error("internal error: UnApply node has wrong symbol") }) treeCopy.UnApply(tree, fn1, args1) diff --git a/src/compiler/scala/tools/nsc/transform/patmat/Logic.scala b/src/compiler/scala/tools/nsc/transform/patmat/Logic.scala index 92b7700c04..069484ff65 100644 --- a/src/compiler/scala/tools/nsc/transform/patmat/Logic.scala +++ b/src/compiler/scala/tools/nsc/transform/patmat/Logic.scala @@ -4,7 +4,8 @@ * @author Adriaan Moors */ -package scala.tools.nsc.transform.patmat +package scala +package tools.nsc.transform.patmat import scala.language.postfixOps import scala.collection.mutable @@ -384,18 +385,35 @@ trait ScalaLogic extends Interface with Logic with TreeAndTypeAnalysis { // else debug.patmat("NOT implies: "+(lower, upper)) - /* does V = C preclude V having value `other`? - (1) V = null is an exclusive assignment, - (2) V = A and V = B, for A and B value constants, are mutually exclusive unless A == B - we err on the safe side, for example: - - assume `val X = 1; val Y = 1`, then - (2: Int) match { case X => case Y => <falsely considered reachable> } - - V = 1 does not preclude V = Int, or V = Any, it could be said to preclude V = String, but we don't model that - - (3) for types we could try to do something fancy, but be conservative and just say no + /** Does V=A preclude V=B? + * + * (0) A or B must be in the domain to draw any conclusions. + * + * For example, knowing the the scrutinee is *not* true does not + * statically exclude it from being `X`, because that is an opaque + * Boolean. + * + * val X = true + * (true: Boolean) match { case true => case X <reachable> } + * + * (1) V = null excludes assignment to any other constant (modulo point #0). This includes + * both values and type tests (which are both modelled here as `Const`) + * (2) V = A and V = B, for A and B domain constants, are mutually exclusive unless A == B + * + * (3) We only reason about test tests as being excluded by null assignments, otherwise we + * only consider value assignments. + * TODO: refine this, a == 0 excludes a: String, or `a: Int` excludes `a: String` + * (since no value can be of both types. See also SI-7211) + * + * NOTE: V = 1 does not preclude V = Int, or V = Any, it could be said to preclude + * V = String, but we don't model that. */ - def excludes(a: Const, b: Const): Boolean = - a != b && ((a == NullConst || b == NullConst) || (a.isValue && b.isValue)) + def excludes(a: Const, b: Const): Boolean = { + val bothInDomain = domain exists (d => d(a) && d(b)) + val eitherIsNull = a == NullConst || b == NullConst + val bothAreValues = a.isValue && b.isValue + bothInDomain && (eitherIsNull || bothAreValues) && (a != b) + } // if(r) debug.patmat("excludes : "+(a, a.tp, b, b.tp)) // else debug.patmat("NOT excludes: "+(a, b)) diff --git a/src/compiler/scala/tools/nsc/transform/patmat/PatternMatching.scala b/src/compiler/scala/tools/nsc/transform/patmat/PatternMatching.scala index 8be8b72130..63834ae51e 100644 --- a/src/compiler/scala/tools/nsc/transform/patmat/PatternMatching.scala +++ b/src/compiler/scala/tools/nsc/transform/patmat/PatternMatching.scala @@ -129,8 +129,9 @@ trait Interface extends ast.TreeDSL { /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /** Interface with user-defined match monad? - * if there's a `__match` in scope, we use this as the match strategy, assuming it conforms to MatchStrategy as defined below: + * if there's a <code>__match</code> in scope, we use this as the match strategy, assuming it conforms to MatchStrategy as defined below: + {{{ type Matcher[P[_], M[+_], A] = { def flatMap[B](f: P[A] => M[B]): M[B] def orElse[B >: A](alternative: => M[B]): M[B] @@ -144,12 +145,14 @@ trait Interface extends ast.TreeDSL { def one[T](x: P[T]): M[T] def guard[T](cond: P[Boolean], then: => P[T]): M[T] } + }}} * P and M are derived from one's signature (`def one[T](x: P[T]): M[T]`) - * if no `__match` is found, we assume the following implementation (and generate optimized code accordingly) + * if no <code>__match</code> is found, we assume the following implementation (and generate optimized code accordingly) + {{{ object __match extends MatchStrategy[({type Id[x] = x})#Id, Option] { def zero = None def one[T](x: T) = Some(x) @@ -157,6 +160,7 @@ trait Interface extends ast.TreeDSL { def guard[T](cond: Boolean, then: => T): Option[T] = if(cond) Some(then) else None def runOrElse[T, U](x: T)(f: T => Option[U]): U = f(x) getOrElse (throw new MatchError(x)) } + }}} */ trait MatchMonadInterface { diff --git a/src/compiler/scala/tools/nsc/typechecker/ConstantFolder.scala b/src/compiler/scala/tools/nsc/typechecker/ConstantFolder.scala index 65bfd8e34e..56ed0ee16c 100644 --- a/src/compiler/scala/tools/nsc/typechecker/ConstantFolder.scala +++ b/src/compiler/scala/tools/nsc/typechecker/ConstantFolder.scala @@ -3,7 +3,8 @@ * @author Martin Odersky */ -package scala.tools.nsc +package scala +package tools.nsc package typechecker import java.lang.ArithmeticException diff --git a/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala b/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala index 89fc55bc2c..e1e26cd8c9 100644 --- a/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala +++ b/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala @@ -21,47 +21,65 @@ trait ContextErrors { import global._ import definitions._ - object ErrorKinds extends Enumeration { - type ErrorKind = Value - val Normal, Access, Ambiguous, Divergent = Value - } - - import ErrorKinds.ErrorKind - - trait AbsTypeError extends Throwable { + abstract class AbsTypeError extends Throwable { def errPos: Position def errMsg: String - def kind: ErrorKind + override def toString() = "[Type error at:" + errPos + "] " + errMsg } - case class NormalTypeError(underlyingTree: Tree, errMsg: String, kind: ErrorKind = ErrorKinds.Normal) - extends AbsTypeError { - - def errPos:Position = underlyingTree.pos - override def toString() = "[Type error at:" + underlyingTree.pos + "] " + errMsg + abstract class TreeTypeError extends AbsTypeError { + def underlyingTree: Tree + def errPos = underlyingTree.pos } - case class SymbolTypeError(underlyingSym: Symbol, errMsg: String, kind: ErrorKind = ErrorKinds.Normal) + case class NormalTypeError(underlyingTree: Tree, errMsg: String) + extends TreeTypeError + + case class AccessTypeError(underlyingTree: Tree, errMsg: String) + extends TreeTypeError + + case class AmbiguousTypeError(errPos: Position, errMsg: String) + extends AbsTypeError + + case class SymbolTypeError(underlyingSym: Symbol, errMsg: String) extends AbsTypeError { def errPos = underlyingSym.pos } - case class TypeErrorWrapper(ex: TypeError, kind: ErrorKind = ErrorKinds.Normal) + case class TypeErrorWrapper(ex: TypeError) extends AbsTypeError { def errMsg = ex.msg def errPos = ex.pos } - case class TypeErrorWithUnderlyingTree(tree: Tree, ex: TypeError, kind: ErrorKind = ErrorKinds.Normal) + case class TypeErrorWithUnderlyingTree(tree: Tree, ex: TypeError) extends AbsTypeError { def errMsg = ex.msg def errPos = tree.pos } - case class AmbiguousTypeError(underlyingTree: Tree, errPos: Position, errMsg: String, kind: ErrorKind = ErrorKinds.Ambiguous) extends AbsTypeError + // Unlike other type errors diverging implicit expansion + // will be re-issued explicitly on failed implicit argument search. + // This is because we want to: + // 1) provide better error message than just "implicit not found" + // 2) provide the type of the implicit parameter for which we got diverging expansion + // (pt at the point of divergence gives less information to the user) + // Note: it is safe to delay error message generation in this case + // becasue we don't modify implicits' infos. + case class DivergentImplicitTypeError(underlyingTree: Tree, pt0: Type, sym: Symbol) + extends TreeTypeError { + def errMsg: String = errMsgForPt(pt0) + def withPt(pt: Type): AbsTypeError = this.copy(pt0 = pt) + private def errMsgForPt(pt: Type) = + s"diverging implicit expansion for type ${pt}\nstarting with ${sym.fullLocationString}" + } - case class PosAndMsgTypeError(errPos: Position, errMsg: String, kind: ErrorKind = ErrorKinds.Normal) extends AbsTypeError + case class AmbiguousImplicitTypeError(underlyingTree: Tree, errMsg: String) + extends TreeTypeError + + case class PosAndMsgTypeError(errPos: Position, errMsg: String) + extends AbsTypeError object ErrorUtils { def issueNormalTypeError(tree: Tree, msg: String)(implicit context: Context) { @@ -72,10 +90,6 @@ trait ContextErrors { issueTypeError(SymbolTypeError(sym, msg)) } - def issueDivergentImplicitsError(tree: Tree, msg: String)(implicit context: Context) { - issueTypeError(NormalTypeError(tree, msg, ErrorKinds.Divergent)) - } - def issueAmbiguousTypeError(pre: Type, sym1: Symbol, sym2: Symbol, err: AmbiguousTypeError)(implicit context: Context) { context.issueAmbiguousError(pre, sym1, sym2, err) } @@ -127,7 +141,7 @@ trait ContextErrors { } issueNormalTypeError(tree, "stable identifier required, but "+tree+" found." + ( - if (isStableExceptVolatile(tree)) addendum else "")) + if (treeInfo.hasVolatileType(tree)) addendum else "")) setError(tree) } @@ -592,6 +606,10 @@ trait ContextErrors { setError(tree) } + // typedPattern + def PatternMustBeValue(pat: Tree, pt: Type) = + issueNormalTypeError(pat, s"pattern must be a value: $pat"+ typePatternAdvice(pat.tpe.typeSymbol, pt.typeSymbol)) + // SelectFromTypeTree def TypeSelectionFromVolatileTypeError(tree: Tree, qual: Tree) = { val hiBound = qual.tpe.bounds.hi @@ -830,7 +848,7 @@ trait ContextErrors { underlyingSymbol(sym).fullLocationString + " cannot be accessed in " + location + explanation } - NormalTypeError(tree, errMsg, ErrorKinds.Access) + AccessTypeError(tree, errMsg) } def NoMethodInstanceError(fn: Tree, args: List[Tree], msg: String) = @@ -875,7 +893,7 @@ trait ContextErrors { "argument types " + argtpes.mkString("(", ",", ")") + (if (pt == WildcardType) "" else " and expected result type " + pt) val (pos, msg) = ambiguousErrorMsgPos(tree.pos, pre, best, firstCompeting, msg0) - issueAmbiguousTypeError(pre, best, firstCompeting, AmbiguousTypeError(tree, pos, msg)) + issueAmbiguousTypeError(pre, best, firstCompeting, AmbiguousTypeError(pos, msg)) setErrorOnLastTry(lastTry, tree) } else setError(tree) // do not even try further attempts because they should all fail // even if this is not the last attempt (because of the SO's possibility on the horizon) @@ -889,7 +907,7 @@ trait ContextErrors { def AmbiguousExprAlternativeError(tree: Tree, pre: Type, best: Symbol, firstCompeting: Symbol, pt: Type, lastTry: Boolean) = { val (pos, msg) = ambiguousErrorMsgPos(tree.pos, pre, best, firstCompeting, "expected type " + pt) - issueAmbiguousTypeError(pre, best, firstCompeting, AmbiguousTypeError(tree, pos, msg)) + issueAmbiguousTypeError(pre, best, firstCompeting, AmbiguousTypeError(pos, msg)) setErrorOnLastTry(lastTry, tree) } @@ -937,33 +955,10 @@ trait ContextErrors { def IncompatibleScrutineeTypeError(tree: Tree, pattp: Type, pt: Type) = issueNormalTypeError(tree, "scrutinee is incompatible with pattern type" + foundReqMsg(pattp, pt)) - def PatternTypeIncompatibleWithPtError2(pat: Tree, pt1: Type, pt: Type) = { - def errMsg = { - val sym = pat.tpe.typeSymbol - val clazz = sym.companionClass - val addendum = ( - if (sym.isModuleClass && clazz.isCaseClass && (clazz isSubClass pt1.typeSymbol)) { - // TODO: move these somewhere reusable. - val typeString = clazz.typeParams match { - case Nil => "" + clazz.name - case xs => xs map (_ => "_") mkString (clazz.name + "[", ",", "]") - } - val caseString = ( - clazz.caseFieldAccessors - map (_ => "_") // could use the actual param names here - mkString (clazz.name + "(", ",", ")") - ) - ( - "\nNote: if you intended to match against the class, try `case _: " + - typeString + "` or `case " + caseString + "`" - ) - } - else "" - ) - "pattern type is incompatible with expected type"+foundReqMsg(pat.tpe, pt) + addendum - } - issueNormalTypeError(pat, errMsg) - } + def PatternTypeIncompatibleWithPtError2(pat: Tree, pt1: Type, pt: Type) = + issueNormalTypeError(pat, + "pattern type is incompatible with expected type"+ foundReqMsg(pat.tpe, pt) + + typePatternAdvice(pat.tpe.typeSymbol, pt1.typeSymbol)) def PolyAlternativeError(tree: Tree, argtypes: List[Type], sym: Symbol, err: PolyAlternativeErrorKind.ErrorType) = { import PolyAlternativeErrorKind._ @@ -1174,7 +1169,7 @@ trait ContextErrors { if (explanation == "") "" else "\n" + explanation ) } - context.issueAmbiguousError(AmbiguousTypeError(tree, tree.pos, + context.issueAmbiguousError(AmbiguousImplicitTypeError(tree, if (isView) viewMsg else s"ambiguous implicit values:\n${coreMsg}match expected type $pt") ) @@ -1182,9 +1177,7 @@ trait ContextErrors { } def DivergingImplicitExpansionError(tree: Tree, pt: Type, sym: Symbol)(implicit context0: Context) = - issueDivergentImplicitsError(tree, - "diverging implicit expansion for type "+pt+"\nstarting with "+ - sym.fullLocationString) + issueTypeError(DivergentImplicitTypeError(tree, pt, sym)) } object NamesDefaultsErrorsGen { diff --git a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala index 538b3b3b6c..82e6de87e3 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala @@ -21,10 +21,7 @@ trait Contexts { self: Analyzer => object NoContext extends Context(EmptyTree, NoSymbol, EmptyScope, NoCompilationUnit, - outer = null /*We can't pass NoContext here, overriden below*/) { - - override val outer = this - + null) { // We can't pass the uninitialized `this`. Instead, we treat null specially in `Context#outer` enclClass = this enclMethod = this @@ -161,10 +158,13 @@ trait Contexts { self: Analyzer => * @param tree Tree associated with this context * @param owner The current owner * @param scope The current scope - * @param outer The next outer context. + * @param _outer The next outer context. */ class Context private[typechecker](val tree: Tree, val owner: Symbol, val scope: Scope, - val unit: CompilationUnit, val outer: Context) { + val unit: CompilationUnit, _outer: Context) { + private def outerIsNoContext = _outer eq null + final def outer: Context = if (outerIsNoContext) NoContext else _outer + /** The next outer context whose tree is a template or package definition */ var enclClass: Context = _ @@ -199,9 +199,10 @@ trait Contexts { self: Analyzer => private var _undetparams: List[Symbol] = List() + protected def outerDepth = if (outerIsNoContext) 0 else outer.depth + val depth: Int = { - val increasesDepth = isRootImport || (outer eq null) || (outer.scope != scope) - def outerDepth = if (outer eq null) 0 else outer.depth + val increasesDepth = isRootImport || outerIsNoContext || (outer.scope != scope) ( if (increasesDepth) 1 else 0 ) + outerDepth } @@ -212,7 +213,7 @@ trait Contexts { self: Analyzer => def isRootImport: Boolean = false /** Types for which implicit arguments are currently searched */ - var openImplicits: List[(Type,Tree)] = List() + var openImplicits: List[OpenImplicit] = List() /* For a named application block (`Tree`) the corresponding `NamedApplyInfo`. */ var namedApplyBlockInfo: Option[(Tree, NamedApplyInfo)] = None @@ -1138,22 +1139,15 @@ trait Contexts { self: Analyzer => /** A `Context` focussed on an `Import` tree */ trait ImportContext extends Context { - private def makeImpInfo = { - val info = new ImportInfo(tree.asInstanceOf[Import], outer.depth) - if (settings.lint && !info.isRootImport) // excludes java.lang/scala/Predef imports + private val impInfo: ImportInfo = { + val info = new ImportInfo(tree.asInstanceOf[Import], outerDepth) + if (settings.lint && !isRootImport) // excludes java.lang/scala/Predef imports allImportInfos(unit) ::= info info } - - private var _impInfo: ImportInfo = null // hand rolled lazy val, we don't need/want synchronization. - private def impInfo: ImportInfo = { - if (_impInfo eq null) _impInfo = makeImpInfo - _impInfo - } - override final def imports = impInfo :: super.imports override final def firstImport = Some(impInfo) - override final def isRootImport = impInfo.isRootImport + override final def isRootImport = !tree.pos.isDefined override final def toString = s"ImportContext { $impInfo; outer.owner = ${outer.owner} }" } @@ -1195,12 +1189,12 @@ trait Contexts { self: Analyzer => errorBuffer.clear() this } - def clearErrors(kind: ErrorKinds.ErrorKind): this.type = { - errorBuffer.retain(_.kind != kind) + def clearErrors(removeF: PartialFunction[AbsTypeError, Boolean]): this.type = { + errorBuffer.retain(!PartialFunction.cond(_)(removeF)) this } - def retainErrors(kind: ErrorKinds.ErrorKind): this.type = { - errorBuffer.retain(_.kind == kind) + def retainErrors(leaveF: PartialFunction[AbsTypeError, Boolean]): this.type = { + errorBuffer.retain(PartialFunction.cond(_)(leaveF)) this } def clearAllWarnings(): this.type = { @@ -1227,8 +1221,6 @@ trait Contexts { self: Analyzer => def isExplicitImport(name: Name): Boolean = tree.selectors exists (_.rename == name.toTermName) - final def isRootImport: Boolean = !tree.pos.isDefined - /** The symbol with name `name` imported from import clause `tree`. */ def importedSymbol(name: Name): Symbol = importedSymbol(name, requireExplicit = false) diff --git a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala index b0c8baae20..05db86635a 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala @@ -8,7 +8,8 @@ //todo: disallow C#D in superclass //todo: treat :::= correctly -package scala.tools.nsc +package scala +package tools.nsc package typechecker import scala.annotation.tailrec @@ -80,8 +81,11 @@ trait Implicits { printTyping("typing implicit: %s %s".format(tree, context.undetparamsString)) val implicitSearchContext = context.makeImplicit(reportAmbiguous) val result = new ImplicitSearch(tree, pt, isView, implicitSearchContext, pos).bestImplicit - if (saveAmbiguousDivergent && implicitSearchContext.hasErrors) { - context.updateBuffer(implicitSearchContext.reportBuffer.errors.filter(err => err.kind == ErrorKinds.Ambiguous || err.kind == ErrorKinds.Divergent)) + if (result.isFailure && saveAmbiguousDivergent && implicitSearchContext.hasErrors) { + context.updateBuffer(implicitSearchContext.reportBuffer.errors.collect { + case dte: DivergentImplicitTypeError => dte + case ate: AmbiguousImplicitTypeError => ate + }) debuglog("update buffer: " + implicitSearchContext.reportBuffer.errors) } printInference("[infer implicit] inferred " + result) @@ -96,6 +100,21 @@ trait Implicits { result } + /** A friendly wrapper over inferImplicit to be used in macro contexts and toolboxes. + */ + def inferImplicit(tree: Tree, pt: Type, isView: Boolean, context: Context, silent: Boolean, withMacrosDisabled: Boolean, pos: Position, onError: (Position, String) => Unit): Tree = { + val wrapper1 = if (!withMacrosDisabled) (context.withMacrosEnabled[SearchResult] _) else (context.withMacrosDisabled[SearchResult] _) + def wrapper(inference: => SearchResult) = wrapper1(inference) + val result = wrapper(inferImplicit(tree, pt, reportAmbiguous = true, isView = isView, context = context, saveAmbiguousDivergent = !silent, pos = pos)) + if (result.isFailure && !silent) { + val err = context.firstError + val errPos = err.map(_.errPos).getOrElse(pos) + val errMsg = err.map(_.errMsg).getOrElse("implicit search has failed. to find out the reason, turn on -Xlog-implicits") + onError(errPos, errMsg) + } + result.tree + } + /** Find all views from type `tp` (in which `tpars` are free) * * Note that the trees in the search results in the returned list share the same type variables. @@ -152,6 +171,7 @@ trait Implicits { def isFailure = false def isAmbiguousFailure = false + def isDivergent = false final def isSuccess = !isFailure } @@ -159,6 +179,11 @@ trait Implicits { override def isFailure = true } + lazy val DivergentSearchFailure = new SearchResult(EmptyTree, EmptyTreeTypeSubstituter) { + override def isFailure = true + override def isDivergent = true + } + lazy val AmbiguousSearchFailure = new SearchResult(EmptyTree, EmptyTreeTypeSubstituter) { override def isFailure = true override def isAmbiguousFailure = true @@ -208,9 +233,16 @@ trait Implicits { case _ => false } override def hashCode = name.## + pre.## + sym.## - override def toString = name + ": " + tpe + override def toString = ( + if (tpeCache eq null) name + ": ?" + else name + ": " + tpe + ) } + /** A class which is used to track pending implicits to prevent infinite implicit searches. + */ + case class OpenImplicit(info: ImplicitInfo, pt: Type, tree: Tree) + /** A sentinel indicating no implicit was found */ val NoImplicitInfo = new ImplicitInfo(null, NoType, NoSymbol) { // equals used to be implemented in ImplicitInfo with an `if(this eq NoImplicitInfo)` @@ -394,25 +426,33 @@ trait Implicits { * @pre `info.tpe` does not contain an error */ private def typedImplicit(info: ImplicitInfo, ptChecked: Boolean, isLocal: Boolean): SearchResult = { - (context.openImplicits find { case (tp, tree1) => tree1.symbol == tree.symbol && dominates(pt, tp)}) match { + // SI-7167 let implicit macros decide what amounts for a divergent implicit search + // imagine a macro writer which wants to synthesize a complex implicit Complex[T] by making recursive calls to Complex[U] for its parts + // e.g. we have `class Foo(val bar: Bar)` and `class Bar(val x: Int)` + // then it's quite reasonable for the macro writer to synthesize Complex[Foo] by calling `inferImplicitValue(typeOf[Complex[Bar])` + // however if we didn't insert the `info.sym.isMacro` check here, then under some circumstances + // (e.g. as described here http://groups.google.com/group/scala-internals/browse_thread/thread/545462b377b0ac0a) + // `dominates` might decide that `Bar` dominates `Foo` and therefore a recursive implicit search should be prohibited + // now when we yield control of divergent expansions to the macro writer, what happens next? + // in the worst case, if the macro writer is careless, we'll get a StackOverflowException from repeated macro calls + // otherwise, the macro writer could check `c.openMacros` and `c.openImplicits` and do `c.abort` when expansions are deemed to be divergent + // upon receiving `c.abort` the typechecker will decide that the corresponding implicit search has failed + // which will fail the entire stack of implicit searches, producing a nice error message provided by the programmer + (context.openImplicits find { case OpenImplicit(info, tp, tree1) => !info.sym.isMacro && tree1.symbol == tree.symbol && dominates(pt, tp)}) match { case Some(pending) => //println("Pending implicit "+pending+" dominates "+pt+"/"+undetParams) //@MDEBUG - throw DivergentImplicit + DivergentSearchFailure case None => try { - context.openImplicits = (pt, tree) :: context.openImplicits + context.openImplicits = OpenImplicit(info, pt, tree) :: context.openImplicits // println(" "*context.openImplicits.length+"typed implicit "+info+" for "+pt) //@MDEBUG - typedImplicit0(info, ptChecked, isLocal) - } catch { - case ex: DivergentImplicit => + val result = typedImplicit0(info, ptChecked, isLocal) + if (result.isDivergent) { //println("DivergentImplicit for pt:"+ pt +", open implicits:"+context.openImplicits) //@MDEBUG - if (context.openImplicits.tail.isEmpty) { - if (!(pt.isErroneous)) - DivergingImplicitExpansionError(tree, pt, info.sym)(context) - SearchFailure - } else { - throw DivergentImplicit - } + if (context.openImplicits.tail.isEmpty && !pt.isErroneous) + DivergingImplicitExpansionError(tree, pt, info.sym)(context) + } + result } finally { context.openImplicits = context.openImplicits.tail } @@ -588,7 +628,7 @@ trait Implicits { case Some(err) => log("implicit adapt failed: " + err.errMsg) return fail(err.errMsg) - case None => + case None => } if (Statistics.canEnable) Statistics.incCounter(typedImplicits) @@ -637,7 +677,7 @@ trait Implicits { context.firstError match { case Some(err) => return fail("type parameters weren't correctly instantiated outside of the implicit tree: " + err.errMsg) - case None => + case None => } // filter out failures from type inference, don't want to remove them from undetParams! @@ -676,7 +716,7 @@ trait Implicits { context.firstError match { case Some(err) => fail("typing TypeApply reported errors for the implicit tree: " + err.errMsg) - case None => + case None => val result = new SearchResult(itree2, subst) if (Statistics.canEnable) Statistics.incCounter(foundImplicits) printInference("[success] found %s for pt %s".format(result, ptInstantiated)) @@ -789,15 +829,20 @@ trait Implicits { /** Preventing a divergent implicit from terminating implicit search, * so that if there is a best candidate it can still be selected. */ - private var divergence = false - private val divergenceHandler: PartialFunction[Throwable, SearchResult] = { - var remaining = 1; - { case x: DivergentImplicit if remaining > 0 => - remaining -= 1 - divergence = true - log("discarding divergent implicit during implicit search") + object DivergentImplicitRecovery { + // symbol of the implicit that caused the divergence. + // Initially null, will be saved on first diverging expansion. + private var implicitSym: Symbol = _ + private var countdown: Int = 1 + + def sym: Symbol = implicitSym + def apply(search: SearchResult, i: ImplicitInfo): SearchResult = + if (search.isDivergent && countdown > 0) { + countdown -= 1 + implicitSym = i.sym + log("discarding divergent implicit ${implicitSym} during implicit search") SearchFailure - } + } else search } /** Sorted list of eligible implicits. @@ -826,15 +871,15 @@ trait Implicits { @tailrec private def rankImplicits(pending: Infos, acc: Infos): Infos = pending match { case Nil => acc case i :: is => - def tryImplicitInfo(i: ImplicitInfo) = - try typedImplicit(i, ptChecked = true, isLocal) - catch divergenceHandler - - tryImplicitInfo(i) match { + DivergentImplicitRecovery(typedImplicit(i, ptChecked = true, isLocal), i) match { + case sr if sr.isDivergent => + Nil case sr if sr.isFailure => // We don't want errors that occur during checking implicit info // to influence the check of further infos. - context.reportBuffer.retainErrors(ErrorKinds.Divergent) + context.reportBuffer.retainErrors { + case err: DivergentImplicitTypeError => true + } rankImplicits(is, acc) case newBest => best = newBest @@ -882,10 +927,9 @@ trait Implicits { /* If there is no winner, and we witnessed and caught divergence, * now we can throw it for the error message. */ - if (divergence) - throw DivergentImplicit - - if (invalidImplicits.nonEmpty) + if (DivergentImplicitRecovery.sym != null) { + DivergingImplicitExpansionError(tree, pt, DivergentImplicitRecovery.sym)(context) + } else if (invalidImplicits.nonEmpty) setAddendum(pos, () => "\n Note: implicit "+invalidImplicits.head+" is not applicable here"+ " because it comes after the application point and it lacks an explicit result type") @@ -1438,6 +1482,3 @@ object ImplicitsStats { val implicitCacheAccs = Statistics.newCounter ("implicit cache accesses", "typer") val implicitCacheHits = Statistics.newSubCounter("implicit cache hits", implicitCacheAccs) } - -class DivergentImplicit extends Exception -object DivergentImplicit extends DivergentImplicit diff --git a/src/compiler/scala/tools/nsc/typechecker/Infer.scala b/src/compiler/scala/tools/nsc/typechecker/Infer.scala index 6645d05968..aaa6c66630 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Infer.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Infer.scala @@ -38,10 +38,7 @@ trait Infer extends Checkable { * @param removeRepeated allows keeping repeated parameter (if there's one argument). Used in NamesDefaults. */ def formalTypes(formals: List[Type], nargs: Int, removeByName: Boolean = true, removeRepeated: Boolean = true): List[Type] = { - val formals1 = if (removeByName) formals mapConserve { - case TypeRef(_, ByNameParamClass, List(arg)) => arg - case formal => formal - } else formals + val formals1 = if (removeByName) formals mapConserve dropByName else formals if (isVarArgTypes(formals1) && (removeRepeated || formals.length != nargs)) { val ft = formals1.last.dealiasWiden.typeArgs.head formals1.init ::: (for (i <- List.range(formals1.length - 1, nargs)) yield ft) @@ -72,6 +69,10 @@ trait Infer extends Checkable { * * `formals` are the formal types before expanding a potential repeated parameter (must come last in `formals`, if at all) * + * @param nbSubPats The number of arguments to the extractor pattern + * @param effectiveNbSubPats `nbSubPats`, unless there is one sub-pattern which, after unwrapping + * bind patterns, is a Tuple pattern, in which case it is the number of + * elements. Used to issue warnings about binding a `TupleN` to a single value. * @throws TypeError when the unapply[Seq] definition is ill-typed * @returns (null, null) when the expected number of sub-patterns cannot be satisfied by the given extractor * @@ -101,7 +102,8 @@ trait Infer extends Checkable { * `T_1, ..., T_m, U, ..., U`. Here, `U` is repeated `n-m` times. * */ - def extractorFormalTypes(pos: Position, resTp: Type, nbSubPats: Int, unappSym: Symbol): (List[Type], List[Type]) = { + def extractorFormalTypes(pos: Position, resTp: Type, nbSubPats: Int, + unappSym: Symbol, effectiveNbSubPats: Int): (List[Type], List[Type]) = { val isUnapplySeq = unappSym.name == nme.unapplySeq val booleanExtractor = resTp.typeSymbolDirect == BooleanClass @@ -131,8 +133,9 @@ trait Infer extends Checkable { else if (optionArgs.nonEmpty) if (nbSubPats == 1) { val productArity = productArgs.size - if (productArity > 1 && settings.lint) - global.currentUnit.warning(pos, s"extractor pattern binds a single value to a Product${productArity} of type ${optionArgs.head}") + if (productArity > 1 && productArity != effectiveNbSubPats && settings.lint) + global.currentUnit.warning(pos, + s"extractor pattern binds a single value to a Product${productArity} of type ${optionArgs.head}") optionArgs } // TODO: update spec to reflect we allow any ProductN, not just TupleN @@ -412,10 +415,9 @@ trait Infer extends Checkable { * since that induces a tie between m(=>A) and m(=>A,B*) [SI-3761] */ private def isCompatible(tp: Type, pt: Type): Boolean = { - def isCompatibleByName(tp: Type, pt: Type): Boolean = pt match { - case TypeRef(_, ByNameParamClass, List(res)) if !isByNameParamType(tp) => isCompatible(tp, res) - case _ => false - } + def isCompatibleByName(tp: Type, pt: Type): Boolean = ( + isByNameParamType(pt) && !isByNameParamType(tp) && isCompatible(tp, dropByName(pt)) + ) val tp1 = normalize(tp) (tp1 weak_<:< pt) || isCoercible(tp1, pt) || isCompatibleByName(tp, pt) } diff --git a/src/compiler/scala/tools/nsc/typechecker/Macros.scala b/src/compiler/scala/tools/nsc/typechecker/Macros.scala index d07297bb35..ecae55562b 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Macros.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Macros.scala @@ -394,7 +394,7 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces { case Fallback(fallback) => typer.typed1(fallback, EXPRmode, WildcardType) case Delayed(delayed) => - delayed + typer.instantiate(delayed, EXPRmode, WildcardType) case Skipped(skipped) => skipped case Failure(failure) => @@ -778,6 +778,29 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces { expanded2 } } + override def onDelayed(delayed: Tree) = { + // If we've been delayed (i.e. bailed out of the expansion because of undetermined type params present in the expandee), + // then there are two possible situations we're in: + // 1) We're in POLYmode, when the typer tests the waters wrt type inference + // (e.g. as in typedArgToPoly in doTypedApply). + // 2) We're out of POLYmode, which means that the typer is out of tricks to infer our type + // (e.g. if we're an argument to a function call, then this means that no previous argument lists + // can determine our type variables for us). + // + // Situation #1 is okay for us, since there's no pressure. In POLYmode we're just verifying that + // there's nothing outrageously wrong with our undetermined type params (from what I understand!). + // + // Situation #2 requires measures to be taken. If we're in it, then noone's going to help us infer + // the undetermined type params. Therefore we need to do something ourselves or otherwise this + // expandee will forever remaing not expanded (see SI-5692). A traditional way out of this conundrum + // is to call `instantiate` and let the inferencer try to find the way out. It works for simple cases, + // but sometimes, if the inferencer lacks information, it will be forced to approximate. This prevents + // an important class of macros, fundep materializers, from working, which I perceive is a problem we need to solve. + // For details see SI-7470. + val shouldInstantiate = typer.context.undetparams.nonEmpty && !mode.inPolyMode + if (shouldInstantiate) typer.instantiatePossiblyExpectingUnit(delayed, mode, pt) + else delayed + } } expander(expandee) } diff --git a/src/compiler/scala/tools/nsc/typechecker/Namers.scala b/src/compiler/scala/tools/nsc/typechecker/Namers.scala index 541d60c16d..55f144da13 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Namers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Namers.scala @@ -1342,13 +1342,16 @@ trait Namers extends MethodSynthesis { private def importSig(imp: Import) = { val Import(expr, selectors) = imp val expr1 = typer.typedQualifier(expr) - typer checkStable expr1 + if (expr1.symbol != null && expr1.symbol.isRootPackage) RootImportError(imp) if (expr1.isErrorTyped) ErrorType else { + if (!treeInfo.isStableIdentifierPattern(expr1)) + typer.TyperErrorGen.UnstableTreeError(expr1) + val newImport = treeCopy.Import(imp, expr1, selectors).asInstanceOf[Import] checkSelectors(newImport) transformed(imp) = newImport diff --git a/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala b/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala index e22e2c603a..ecbc471fbe 100644 --- a/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala +++ b/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala @@ -202,7 +202,7 @@ trait NamesDefaults { self: Analyzer => if (module == NoSymbol) None else { val ref = atPos(pos.focus)(gen.mkAttributedRef(pre, module)) - if (module.isStable && pre.isStable) // fixes #4524. the type checker does the same for + if (treeInfo.admitsTypeSelection(ref)) // fixes #4524. the type checker does the same for ref.setType(singleType(pre, module)) // typedSelect, it calls "stabilize" on the result. Some(ref) } @@ -466,10 +466,7 @@ trait NamesDefaults { self: Analyzer => val udp = context.undetparams context.savingUndeterminedTypeParams(reportAmbiguous = false) { val subst = new SubstTypeMap(udp, udp map (_ => WildcardType)) { - override def apply(tp: Type): Type = super.apply(tp match { - case TypeRef(_, ByNameParamClass, x :: Nil) => x - case _ => tp - }) + override def apply(tp: Type): Type = super.apply(dropByName(tp)) } // This throws an exception which is caught in `tryTypedApply` (as it // uses `silent`) - unfortunately, tryTypedApply recovers from the diff --git a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala index c462b8f8ef..bbba786c0c 100644 --- a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala +++ b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala @@ -59,7 +59,22 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans override def changesBaseClasses = false override def transformInfo(sym: Symbol, tp: Type): Type = { - if (sym.isModule && !sym.isStatic) sym setFlag (lateMETHOD | STABLE) + // !!! This is a sketchy way to do things. + // It would be better to replace the module symbol with a method symbol + // rather than creating this module/method hybrid which must be special + // cased all over the place. Look for the call sites which use(d) some + // variation of "isMethod && !isModule", which to an observer looks like + // a nonsensical condition. (It is now "isModuleNotMethod".) + if (sym.isModule && !sym.isStatic) { + sym setFlag lateMETHOD | STABLE + // Note that this as far as we can see it works equally well + // to set the METHOD flag here and dump lateMETHOD, but it does + // mean that under separate compilation the typer will see + // modules as methods (albeit stable ones with singleton types.) + // So for now lateMETHOD lives while we try to convince ourselves + // we can live without it or deliver that info some other way. + log(s"Stabilizing module method for ${sym.fullLocationString}") + } super.transformInfo(sym, tp) } @@ -144,7 +159,8 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans // This has become noisy with implicit classes. if (settings.lint && settings.developer) { clazz.info.decls filter (x => x.isImplicit && x.typeParams.nonEmpty) foreach { sym => - val alts = clazz.info.decl(sym.name).alternatives + // implicit classes leave both a module symbol and a method symbol as residue + val alts = clazz.info.decl(sym.name).alternatives filterNot (_.isModule) if (alts.size > 1) alts foreach (x => unit.warning(x.pos, "parameterized overloaded implicit methods are not visible as view bounds")) } @@ -495,7 +511,10 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans } if (member.isStable && !otherTp.isVolatile) { - if (memberTp.isVolatile) + // (1.4), pt 2 -- member.isStable && memberTp.isVolatile started being possible after SI-6815 + // (before SI-6815, !symbol.tpe.isVolatile was implied by symbol.isStable) + // TODO: allow overriding when @uncheckedStable? + if (memberTp.isVolatile) overrideError("has a volatile type; cannot override a member with non-volatile type") else memberTp.dealiasWiden.resultType match { case rt: RefinedType if !(rt =:= otherTp) && !(checkedCombinations contains rt.parents) => @@ -965,12 +984,15 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans val s = fn.symbol (s == Object_==) || (s == Object_!=) || (s == Any_==) || (s == Any_!=) } + def haveSubclassRelationship = (actual isSubClass receiver) || (receiver isSubClass actual) + // Whether the operands+operator represent a warnable combo (assuming anyrefs) // Looking for comparisons performed with ==/!= in combination with either an // equals method inherited from Object or a case class synthetic equals (for // which we know the logic.) def isWarnable = isReferenceOp || (isUsingDefaultScalaOp && isUsingWarnableEquals) def isEitherNullable = (NullClass.tpe <:< receiver.info) || (NullClass.tpe <:< actual.info) + def isEitherValueClass = actual.isDerivedValueClass || receiver.isDerivedValueClass def isBoolean(s: Symbol) = unboxedValueClass(s) == BooleanClass def isUnit(s: Symbol) = unboxedValueClass(s) == UnitClass def isNumeric(s: Symbol) = isNumericValueClass(unboxedValueClass(s)) || isAnyNumber(s) @@ -982,6 +1004,12 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans // used to short-circuit unrelatedTypes check if both sides are special def isSpecial(s: Symbol) = isMaybeAnyValue(s) || isAnyNumber(s) val nullCount = onSyms(_ filter (_ == NullClass) size) + def isNonsenseValueClassCompare = ( + !haveSubclassRelationship + && isUsingDefaultScalaOp + && isEitherValueClass + && !isCaseEquals + ) def nonSensibleWarning(what: String, alwaysEqual: Boolean) = { val msg = alwaysEqual == (name == nme.EQ || name == nme.eq) @@ -993,10 +1021,13 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans def nonSensiblyNeq() = nonSensible("", false) def nonSensiblyNew() = nonSensibleWarning("a fresh object", false) + def unrelatedMsg = name match { + case nme.EQ | nme.eq => "never compare equal" + case _ => "always compare unequal" + } def unrelatedTypes() = { - val msg = if (name == nme.EQ || name == nme.eq) - "never compare equal" else "always compare unequal" - unit.warning(pos, typesString + " are unrelated: they will most likely " + msg) + val weaselWord = if (isEitherValueClass) "" else " most likely" + unit.warning(pos, s"$typesString are unrelated: they will$weaselWord $unrelatedMsg") } if (nullCount == 2) // null == null @@ -1035,15 +1066,19 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans } } + // warn if one but not the other is a derived value class + // this is especially important to enable transitioning from + // regular to value classes without silent failures. + if (isNonsenseValueClassCompare) + unrelatedTypes() // possibleNumericCount is insufficient or this will warn on e.g. Boolean == j.l.Boolean - if (isWarnable && nullCount == 0 && !(isSpecial(receiver) && isSpecial(actual))) { + else if (isWarnable && nullCount == 0 && !(isSpecial(receiver) && isSpecial(actual))) { // better to have lubbed and lost def warnIfLubless(): Unit = { val common = global.lub(List(actual.tpe, receiver.tpe)) if (ObjectClass.tpe <:< common) unrelatedTypes() } - def eitherSubclasses = (actual isSubClass receiver) || (receiver isSubClass actual) // warn if actual has a case parent that is not same as receiver's; // if actual is not a case, then warn if no common supertype, as below if (isCaseEquals) { @@ -1056,14 +1091,12 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans //else // if a class, it must be super to thisCase (and receiver) since not <: thisCase if (!actual.isTrait && !(receiver isSubClass actual)) nonSensiblyNeq() - else if (!eitherSubclasses) warnIfLubless() + else if (!haveSubclassRelationship) warnIfLubless() case _ => } } - else if (actual isSubClass receiver) () - else if (receiver isSubClass actual) () // warn only if they have no common supertype below Object - else { + else if (!haveSubclassRelationship) { warnIfLubless() } } @@ -1261,6 +1294,16 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans } } + private def checkDelayedInitSelect(qual: Tree, sym: Symbol, pos: Position) = { + def isLikelyUninitialized = ( + (sym.owner isSubClass DelayedInitClass) + && !qual.tpe.isInstanceOf[ThisType] + && sym.accessedOrSelf.isVal + ) + if (settings.lint.value && isLikelyUninitialized) + unit.warning(pos, s"Selecting ${sym} from ${sym.owner}, which extends scala.DelayedInit, is likely to yield an uninitialized value") + } + private def lessAccessible(otherSym: Symbol, memberSym: Symbol): Boolean = ( (otherSym != NoSymbol) && !otherSym.isProtected @@ -1464,6 +1507,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans if(settings.Xmigration.value != NoScalaVersion) checkMigration(sym, tree.pos) checkCompileTimeOnly(sym, tree.pos) + checkDelayedInitSelect(qual, sym, tree.pos) if (sym eq NoSymbol) devWarning("Select node has NoSymbol! " + tree + " / " + tree.tpe) diff --git a/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala b/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala index e22dc73b53..3f7e6d7665 100644 --- a/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala +++ b/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala @@ -4,7 +4,8 @@ * @author Martin Odersky */ -package scala.tools.nsc +package scala +package tools.nsc package typechecker import scala.collection.{ mutable, immutable } @@ -64,8 +65,8 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT debuglog(s"add super acc ${sym.fullLocationString} to $clazz") val acc = clazz.newMethod(supername, sel.pos, SUPERACCESSOR | PRIVATE | ARTIFACT) setAlias sym val tpe = clazz.thisType memberType sym match { - case t if sym.isModule && !sym.isMethod => NullaryMethodType(t) - case t => t + case t if sym.isModuleNotMethod => NullaryMethodType(t) + case t => t } acc setInfoAndEnter (tpe cloneInfo acc) // Diagnostic for SI-7091 diff --git a/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala b/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala index 5f45fead91..5146cf6fa7 100644 --- a/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala +++ b/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala @@ -271,6 +271,24 @@ trait TypeDiagnostics { ) } + def typePatternAdvice(sym: Symbol, ptSym: Symbol) = { + val clazz = if (sym.isModuleClass) sym.companionClass else sym + val caseString = + if (clazz.isCaseClass && (clazz isSubClass ptSym)) + ( clazz.caseFieldAccessors + map (_ => "_") // could use the actual param names here + mkString (s"`case ${clazz.name}(", ",", ")`") + ) + else + "`case _: " + (clazz.typeParams match { + case Nil => "" + clazz.name + case xs => xs map (_ => "_") mkString (clazz.name + "[", ",", "]") + })+ "`" + + "\nNote: if you intended to match against the class, try "+ caseString + + } + case class TypeDiag(tp: Type, sym: Symbol) extends Ordered[TypeDiag] { // save the name because it will be mutated until it has been // distinguished from the other types in the same error message diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala index 20b19b55cc..bb1dc10f0b 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala @@ -9,7 +9,8 @@ // Added: Thu Apr 12 18:23:58 2007 //todo: disallow C#D in superclass //todo: treat :::= correctly -package scala.tools.nsc +package scala +package tools.nsc package typechecker import scala.collection.mutable @@ -150,15 +151,19 @@ trait Typers extends Adaptations with Tags { } else { mkArg = gen.mkNamedArg // don't pass the default argument (if any) here, but start emitting named arguments for the following args if (!param.hasDefault && !paramFailed) { - context.reportBuffer.errors.find(_.kind == ErrorKinds.Divergent) match { - case Some(divergentImplicit) => + context.reportBuffer.errors.collectFirst { + case dte: DivergentImplicitTypeError => dte + } match { + case Some(divergent) => // DivergentImplicit error has higher priority than "no implicit found" // no need to issue the problem again if we are still in silent mode if (context.reportErrors) { - context.issue(divergentImplicit) - context.reportBuffer.clearErrors(ErrorKinds.Divergent) + context.issue(divergent.withPt(paramTp)) + context.reportBuffer.clearErrors { + case dte: DivergentImplicitTypeError => true + } } - case None => + case _ => NoImplicitFoundError(fun, param) } paramFailed = true @@ -245,29 +250,6 @@ trait Typers extends Adaptations with Tags { case _ => tp } - /** Check that `tree` is a stable expression. - */ - def checkStable(tree: Tree): Tree = ( - if (treeInfo.isExprSafeToInline(tree)) tree - else if (tree.isErrorTyped) tree - else UnstableTreeError(tree) - ) - - /** Would tree be a stable (i.e. a pure expression) if the type - * of its symbol was not volatile? - */ - protected def isStableExceptVolatile(tree: Tree) = { - tree.hasSymbolField && tree.symbol != NoSymbol && tree.tpe.isVolatile && - { val savedTpe = tree.symbol.info - val savedSTABLE = tree.symbol getFlag STABLE - tree.symbol setInfo AnyRefClass.tpe - tree.symbol setFlag STABLE - val result = treeInfo.isExprSafeToInline(tree) - tree.symbol setInfo savedTpe - tree.symbol setFlag savedSTABLE - result - } - } private def errorNotClass(tpt: Tree, found: Type) = { ClassTypeRequiredError(tpt, found); false } private def errorNotStable(tpt: Tree, found: Type) = { TypeNotAStablePrefixError(tpt, found); false } @@ -582,7 +564,7 @@ trait Typers extends Adaptations with Tags { } /** Post-process an identifier or selection node, performing the following: - * 1. Check that non-function pattern expressions are stable + * 1. Check that non-function pattern expressions are stable (ignoring volatility concerns -- SI-6815) * 2. Check that packages and static modules are not used as values * 3. Turn tree type into stable type if possible and required by context. * 4. Give getClass calls a more precise type based on the type of the target of the call. @@ -597,17 +579,19 @@ trait Typers extends Adaptations with Tags { if (tree.isErrorTyped) tree else if (mode.inPatternNotFunMode && tree.isTerm) { // (1) if (sym.isValue) { - val tree1 = checkStable(tree) - // A module reference in a pattern has type Foo.type, not "object Foo" - if (sym.isModule && !sym.isMethod) tree1 setType singleType(pre, sym) - else tree1 + if (tree.isErrorTyped) tree + else if (treeInfo.isStableIdentifierPattern(tree)) { + // A module reference in a pattern has type Foo.type, not "object Foo" + if (sym.isModuleNotMethod) tree setType singleType(pre, sym) + else tree + } else UnstableTreeError(tree) } else fail() } else if ((mode & (EXPRmode | QUALmode)) == EXPRmode && !sym.isValue && !phase.erasedTypes) { // (2) fail() } else { - if (sym.isStable && pre.isStable && !isByNameParamType(tree.tpe) && - (isStableContext(tree, mode, pt) || sym.isModule && !sym.isMethod)) + if (treeInfo.admitsTypeSelection(tree) && + (isStableContext(tree, mode, pt) || sym.isModuleNotMethod)) tree.setType(singleType(pre, sym)) // To fully benefit from special casing the return type of // getClass, we have to catch it immediately so expressions @@ -1086,7 +1070,6 @@ trait Typers extends Adaptations with Tags { instantiateToMethodType(mt) case _ => - def vanillaAdapt(tree: Tree) = { def shouldInsertApply(tree: Tree) = mode.inAll(EXPRmode | FUNmode) && (tree.tpe match { case _: MethodType | _: OverloadedType | _: PolyType => false case _ => applyPossible @@ -1102,16 +1085,15 @@ trait Typers extends Adaptations with Tags { } if (tree.isType) adaptType() + else if (mode.inExprModeButNot(FUNmode) && treeInfo.isMacroApplication(tree)) + macroExpandApply(this, tree, mode, pt) else if (mode.inAll(PATTERNmode | FUNmode)) adaptConstrPattern() else if (shouldInsertApply(tree)) insertApply() - else if (!context.undetparams.isEmpty && !mode.inPolyMode) { // (9) + else if (context.undetparams.nonEmpty && !mode.inPolyMode) { // (9) assert(!mode.inHKMode, mode) //@M - if (mode.inExprModeButNot(FUNmode) && pt.typeSymbol == UnitClass) - instantiateExpectingUnit(tree, mode) - else - instantiate(tree, mode, pt) + instantiatePossiblyExpectingUnit(tree, mode, pt) } else if (tree.tpe <:< pt) { tree } else { @@ -1237,9 +1219,6 @@ trait Typers extends Adaptations with Tags { fallBack } } - val tree1 = if (mode.inExprModeButNot(FUNmode) && treeInfo.isMacroApplication(tree)) macroExpandApply(this, tree, mode, pt) else tree - if (tree == tree1) vanillaAdapt(tree1) else tree1 - } } def instantiate(tree: Tree, mode: Mode, pt: Type): Tree = { @@ -1259,6 +1238,13 @@ trait Typers extends Adaptations with Tags { } } + def instantiatePossiblyExpectingUnit(tree: Tree, mode: Mode, pt: Type): Tree = { + if (mode.inExprModeButNot(FUNmode) && pt.typeSymbol == UnitClass) + instantiateExpectingUnit(tree, mode) + else + instantiate(tree, mode, pt) + } + private def isAdaptableWithView(qual: Tree) = { val qtpe = qual.tpe.widen ( !isPastTyper @@ -1627,22 +1613,27 @@ trait Typers extends Adaptations with Tags { /** Makes sure that the first type tree in the list of parent types is always a class. * If the first parent is a trait, prepend its supertype to the list until it's a class. -*/ - private def normalizeFirstParent(parents: List[Tree]): List[Tree] = parents match { - case first :: rest if treeInfo.isTraitRef(first) => - def explode(supertpt: Tree, acc: List[Tree]): List[Tree] = { - if (treeInfo.isTraitRef(supertpt)) { - val supertpt1 = typedType(supertpt) - if (!supertpt1.isErrorTyped) { - val supersupertpt = TypeTree(supertpt1.tpe.firstParent) setPos supertpt.pos.focus - return explode(supersupertpt, supertpt1 :: acc) - } - } - if (supertpt.tpe.typeSymbol == AnyClass) supertpt setType AnyRefClass.tpe - supertpt :: acc - } - explode(first, Nil) ++ rest - case _ => parents + */ + private def normalizeFirstParent(parents: List[Tree]): List[Tree] = { + @annotation.tailrec + def explode0(parents: List[Tree]): List[Tree] = { + val supertpt :: rest = parents // parents is always non-empty here - it only grows + if (supertpt.tpe.typeSymbol == AnyClass) { + supertpt setType AnyRefTpe + parents + } else if (treeInfo isTraitRef supertpt) { + val supertpt1 = typedType(supertpt) + def supersuper = TypeTree(supertpt1.tpe.firstParent) setPos supertpt.pos.focus + if (supertpt1.isErrorTyped) rest + else explode0(supersuper :: supertpt1 :: rest) + } else parents + } + + def explode(parents: List[Tree]) = + if (treeInfo isTraitRef parents.head) explode0(parents) + else parents + + if (parents.isEmpty) Nil else explode(parents) } /** Certain parents are added in the parser before it is known whether @@ -3401,8 +3392,8 @@ trait Typers extends Adaptations with Tags { else { val resTp = fun1.tpe.finalResultType.dealiasWiden val nbSubPats = args.length - - val (formals, formalsExpanded) = extractorFormalTypes(fun0.pos, resTp, nbSubPats, fun1.symbol) + val (formals, formalsExpanded) = + extractorFormalTypes(fun0.pos, resTp, nbSubPats, fun1.symbol, treeInfo.effectivePatternArity(args)) if (formals == null) duplErrorTree(WrongNumberOfArgsError(tree, fun)) else { val args1 = typedArgs(args, mode, formals, formalsExpanded) @@ -4429,6 +4420,7 @@ trait Typers extends Adaptations with Tags { } def normalTypedApply(tree: Tree, fun: Tree, args: List[Tree]) = { + // TODO: replace `fun.symbol.isStable` by `treeInfo.isStableIdentifierPattern(fun)` val stableApplication = (fun.symbol ne null) && fun.symbol.isMethod && fun.symbol.isStable val funpt = if (isPatternMode) pt else WildcardType val appStart = if (Statistics.canEnable) Statistics.startTimer(failedApplyNanos) else null @@ -4682,12 +4674,11 @@ trait Typers extends Adaptations with Tags { case SelectFromTypeTree(_, _) => treeCopy.SelectFromTypeTree(tree, qual, name) } val (result, accessibleError) = silent(_.makeAccessible(tree1, sym, qual.tpe, qual)) match { + case SilentTypeError(err: AccessTypeError) => + (tree1, Some(err)) case SilentTypeError(err) => - if (err.kind != ErrorKinds.Access) { - context issue err - return setError(tree) - } - else (tree1, Some(err)) + context issue err + return setError(tree) case SilentResultValue(treeAndPre) => (stabilize(treeAndPre._1, treeAndPre._2, mode, pt), None) } @@ -4732,16 +4723,20 @@ trait Typers extends Adaptations with Tags { typedSelect(tree, qual1, nme.CONSTRUCTOR) case _ => if (Statistics.canEnable) Statistics.incCounter(typedSelectCount) - var qual1 = checkDead(typedQualifier(qual, mode)) - if (name.isTypeName) qual1 = checkStable(qual1) + val qualTyped = checkDead(typedQualifier(qual, mode)) + val qualStableOrError = + if (qualTyped.isErrorTyped || !name.isTypeName || treeInfo.admitsTypeSelection(qualTyped)) + qualTyped + else + UnstableTreeError(qualTyped) val tree1 = // temporarily use `filter` and an alternative for `withFilter` if (name == nme.withFilter) - silent(_ => typedSelect(tree, qual1, name)) orElse { _ => - silent(_ => typed1(Select(qual1, nme.filter) setPos tree.pos, mode, pt)) match { + silent(_ => typedSelect(tree, qualStableOrError, name)) orElse { _ => + silent(_ => typed1(Select(qualStableOrError, nme.filter) setPos tree.pos, mode, pt)) match { case SilentResultValue(result2) => unit.deprecationWarning( - tree.pos, "`withFilter' method does not yet exist on " + qual1.tpe.widen + + tree.pos, "`withFilter' method does not yet exist on " + qualStableOrError.tpe.widen + ", using `filter' method instead") result2 case SilentTypeError(err) => @@ -4749,14 +4744,14 @@ trait Typers extends Adaptations with Tags { } } else - typedSelect(tree, qual1, name) + typedSelect(tree, qualStableOrError, name) if (tree.isInstanceOf[PostfixSelect]) checkFeature(tree.pos, PostfixOpsFeature, name.decode) if (tree1.symbol != null && tree1.symbol.isOnlyRefinementMember) checkFeature(tree1.pos, ReflectiveCallsFeature, tree1.symbol.toString) - if (qual1.hasSymbolWhich(_.isRootPackage)) treeCopy.Ident(tree1, name) + if (qualStableOrError.hasSymbolWhich(_.isRootPackage)) treeCopy.Ident(tree1, name) else tree1 } } @@ -4943,7 +4938,7 @@ trait Typers extends Adaptations with Tags { def typedUnApply(tree: UnApply) = { val fun1 = typed(tree.fun) - val tpes = formalTypes(unapplyTypeList(tree.fun.pos, tree.fun.symbol, fun1.tpe, tree.args.length), tree.args.length) + val tpes = formalTypes(unapplyTypeList(tree.fun.pos, tree.fun.symbol, fun1.tpe, tree.args), tree.args.length) val args1 = map2(tree.args, tpes)(typedPattern) treeCopy.UnApply(tree, fun1, args1) setType pt } @@ -5149,12 +5144,16 @@ trait Typers extends Adaptations with Tags { } def typedSingletonTypeTree(tree: SingletonTypeTree) = { - val ref1 = checkStable( - context.withImplicitsDisabled( + val refTyped = + context.withImplicitsDisabled { typed(tree.ref, EXPRmode | QUALmode | (mode & TYPEPATmode), AnyRefClass.tpe) - ) - ) - tree setType ref1.tpe.resultType + } + + if (!refTyped.isErrorTyped) + tree setType refTyped.tpe.resultType + + if (treeInfo.admitsTypeSelection(refTyped)) tree + else UnstableTreeError(refTyped) } def typedSelectFromTypeTree(tree: SelectFromTypeTree) = { @@ -5387,7 +5386,10 @@ trait Typers extends Adaptations with Tags { // as a compromise, context.enrichmentEnabled tells adaptToMember to go ahead and enrich, // but arbitrary conversions (in adapt) are disabled // TODO: can we achieve the pattern matching bit of the string interpolation SIP without this? - typingInPattern(context.withImplicitsDisabledAllowEnrichment(typed(tree, PATTERNmode, pt))) + typingInPattern(context.withImplicitsDisabledAllowEnrichment(typed(tree, PATTERNmode, pt))) match { + case tpt if tpt.isType => PatternMustBeValue(tpt, pt); tpt + case pat => pat + } } /** Types a (fully parameterized) type tree */ diff --git a/src/compiler/scala/tools/nsc/typechecker/Unapplies.scala b/src/compiler/scala/tools/nsc/typechecker/Unapplies.scala index d55dce70c7..af3f772f79 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Unapplies.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Unapplies.scala @@ -33,12 +33,13 @@ trait Unapplies extends ast.TreeDSL /** returns type list for return type of the extraction * @see extractorFormalTypes */ - def unapplyTypeList(pos: Position, ufn: Symbol, ufntpe: Type, nbSubPats: Int) = { + def unapplyTypeList(pos: Position, ufn: Symbol, ufntpe: Type, args: List[Tree]) = { assert(ufn.isMethod, ufn) + val nbSubPats = args.length //Console.println("utl "+ufntpe+" "+ufntpe.typeSymbol) ufn.name match { case nme.unapply | nme.unapplySeq => - val (formals, _) = extractorFormalTypes(pos, unapplyUnwrap(ufntpe), nbSubPats, ufn) + val (formals, _) = extractorFormalTypes(pos, unapplyUnwrap(ufntpe), nbSubPats, ufn, treeInfo.effectivePatternArity(args)) if (formals == null) throw new TypeError(s"$ufn of type $ufntpe cannot extract $nbSubPats sub-patterns") else formals case _ => throw new TypeError(ufn+" is not an unapply or unapplySeq") diff --git a/src/compiler/scala/tools/nsc/util/ClassPath.scala b/src/compiler/scala/tools/nsc/util/ClassPath.scala index 7f9b81e1ec..536a281e6c 100644 --- a/src/compiler/scala/tools/nsc/util/ClassPath.scala +++ b/src/compiler/scala/tools/nsc/util/ClassPath.scala @@ -211,6 +211,8 @@ abstract class ClassPath[T] { def validPackage(name: String) = (name != "META-INF") && (name != "") && (name.charAt(0) != '.') def validSourceFile(name: String) = endsScala(name) || endsJava(name) + def isEmptyOfClassfiles: Boolean = classes.isEmpty && packages.forall(_.isEmptyOfClassfiles) + /** * Find a ClassRep given a class name of the form "package.subpackage.ClassName". * Does not support nested classes on .NET diff --git a/src/compiler/scala/tools/nsc/util/JavaCharArrayReader.scala b/src/compiler/scala/tools/nsc/util/JavaCharArrayReader.scala index 26d19906c2..58a5442465 100644 --- a/src/compiler/scala/tools/nsc/util/JavaCharArrayReader.scala +++ b/src/compiler/scala/tools/nsc/util/JavaCharArrayReader.scala @@ -3,7 +3,8 @@ * @author Martin Odersky */ -package scala.tools.nsc +package scala +package tools.nsc package util import scala.reflect.internal.Chars._ diff --git a/src/compiler/scala/tools/nsc/util/ShowPickled.scala b/src/compiler/scala/tools/nsc/util/ShowPickled.scala index 76b1394b85..f9d706ae55 100644 --- a/src/compiler/scala/tools/nsc/util/ShowPickled.scala +++ b/src/compiler/scala/tools/nsc/util/ShowPickled.scala @@ -3,7 +3,8 @@ * @author Martin Odersky */ -package scala.tools +package scala +package tools package nsc package util diff --git a/src/compiler/scala/tools/nsc/util/package.scala b/src/compiler/scala/tools/nsc/util/package.scala index 039fec8605..5faa2f7513 100644 --- a/src/compiler/scala/tools/nsc/util/package.scala +++ b/src/compiler/scala/tools/nsc/util/package.scala @@ -3,7 +3,9 @@ * @author Paul Phillips */ -package scala.tools.nsc +package scala +package tools +package nsc import java.io.{ OutputStream, PrintStream, ByteArrayOutputStream, PrintWriter, StringWriter } diff --git a/src/compiler/scala/tools/reflect/ToolBoxFactory.scala b/src/compiler/scala/tools/reflect/ToolBoxFactory.scala index 66dda2b530..f81ec610ef 100644 --- a/src/compiler/scala/tools/reflect/ToolBoxFactory.scala +++ b/src/compiler/scala/tools/reflect/ToolBoxFactory.scala @@ -1,4 +1,5 @@ -package scala.tools +package scala +package tools package reflect import scala.tools.nsc.EXPRmode @@ -180,17 +181,7 @@ abstract class ToolBoxFactory[U <: JavaUniverse](val u: U) { factorySelf => transformDuringTyper(tree, withImplicitViewsDisabled = false, withMacrosDisabled = withMacrosDisabled)( (currentTyper, tree) => { trace("inferring implicit %s (macros = %s): ".format(if (isView) "view" else "value", !withMacrosDisabled))(showAttributed(pt, true, true, settings.Yshowsymkinds.value)) - val context = currentTyper.context - analyzer.inferImplicit(tree, pt, reportAmbiguous = true, isView = isView, context = context, saveAmbiguousDivergent = !silent, pos = pos) match { - case failure if failure.tree.isEmpty => - trace("implicit search has failed. to find out the reason, turn on -Xlog-implicits: ")(failure.tree) - context.firstError foreach { err => - throw ToolBoxError("reflective implicit search has failed: %s".format(err.errMsg)) - } - EmptyTree - case success => - success.tree - } + analyzer.inferImplicit(tree, pt, isView, currentTyper.context, silent, withMacrosDisabled, pos, (pos, msg) => throw ToolBoxError(msg)) }) def compile(expr0: Tree): () => Any = { diff --git a/src/compiler/scala/tools/util/PathResolver.scala b/src/compiler/scala/tools/util/PathResolver.scala index 8d65c40a01..863cbc5c1a 100644 --- a/src/compiler/scala/tools/util/PathResolver.scala +++ b/src/compiler/scala/tools/util/PathResolver.scala @@ -3,13 +3,14 @@ * @author Paul Phillips */ -package scala.tools +package scala +package tools package util import scala.tools.reflect.WrappedProperties.AccessControl -import nsc.{ Settings, GenericRunnerSettings } -import nsc.util.{ ClassPath, JavaClassPath, ScalaClassLoader } -import nsc.io.{ File, Directory, Path, AbstractFile } +import scala.tools.nsc.{ Settings, GenericRunnerSettings } +import scala.tools.nsc.util.{ ClassPath, JavaClassPath, ScalaClassLoader } +import scala.tools.nsc.io.{ File, Directory, Path, AbstractFile } import ClassPath.{ JavaContext, DefaultJavaContext, join, split } import PartialFunction.condOpt import scala.language.postfixOps diff --git a/src/compiler/scala/tools/util/SocketServer.scala b/src/compiler/scala/tools/util/SocketServer.scala index 7da9479dab..1d39a59cf4 100644 --- a/src/compiler/scala/tools/util/SocketServer.scala +++ b/src/compiler/scala/tools/util/SocketServer.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.tools.util +package scala +package tools.util import java.net.{ ServerSocket, SocketException, SocketTimeoutException } import java.io.{ PrintWriter, BufferedReader } diff --git a/src/interactive/scala/tools/nsc/interactive/CompilerControl.scala b/src/interactive/scala/tools/nsc/interactive/CompilerControl.scala index b4d3fd8aa0..c38c7c8257 100644 --- a/src/interactive/scala/tools/nsc/interactive/CompilerControl.scala +++ b/src/interactive/scala/tools/nsc/interactive/CompilerControl.scala @@ -295,6 +295,9 @@ trait CompilerControl { self: Global => val tpe: Type val accessible: Boolean def implicitlyAdded = false + + private def accessible_s = if (accessible) "" else "[inaccessible] " + def infoString = s"$accessible_s${sym.defStringSeenAs(tpe)}" } case class TypeMember( diff --git a/src/interactive/scala/tools/nsc/interactive/Global.scala b/src/interactive/scala/tools/nsc/interactive/Global.scala index 43b8bd2738..6a833ab864 100644 --- a/src/interactive/scala/tools/nsc/interactive/Global.scala +++ b/src/interactive/scala/tools/nsc/interactive/Global.scala @@ -15,7 +15,7 @@ import scala.reflect.internal.util.{ SourceFile, BatchSourceFile, Position, NoPo import scala.tools.nsc.reporters._ import scala.tools.nsc.symtab._ import scala.tools.nsc.doc.ScaladocAnalyzer -import scala.tools.nsc.typechecker.{ Analyzer, DivergentImplicit } +import scala.tools.nsc.typechecker.Analyzer import symtab.Flags.{ACCESSOR, PARAMACCESSOR} import scala.annotation.{ elidable, tailrec } import scala.language.implicitConversions @@ -905,9 +905,9 @@ class Global(settings: Settings, _reporter: Reporter, projectName: String = "") /** Implements CompilerControl.askDocComment */ private[interactive] def getDocComment(sym: Symbol, source: SourceFile, site: Symbol, fragments: List[(Symbol,SourceFile)], response: Response[(String, String, Position)]) { - informIDE(s"getDocComment $sym at $source site $site") + informIDE(s"getDocComment $sym at $source, site $site") respond(response) { - withTempUnits(fragments.toList.unzip._2){ units => + withTempUnits(fragments.unzip._2){ units => for((sym, src) <- fragments) { val mirror = findMirrorSymbol(sym, units(src)) if (mirror ne NoSymbol) forceDocComment(mirror, units(src)) @@ -920,17 +920,19 @@ class Global(settings: Settings, _reporter: Reporter, projectName: String = "") } } } + // New typer run to remove temp units and drop per-run caches that might refer to symbols entered from temp units. + newTyperRun() } def stabilizedType(tree: Tree): Type = tree match { - case Ident(_) if tree.symbol.isStable => + case Ident(_) if treeInfo.admitsTypeSelection(tree) => singleType(NoPrefix, tree.symbol) - case Select(qual, _) if qual.tpe != null && tree.symbol.isStable => + case Select(qual, _) if treeInfo.admitsTypeSelection(tree) => singleType(qual.tpe, tree.symbol) case Import(expr, selectors) => tree.symbol.info match { case analyzer.ImportType(expr) => expr match { - case s@Select(qual, name) => singleType(qual.tpe, s.symbol) + case s@Select(qual, name) if treeInfo.admitsTypeSelection(expr) => singleType(qual.tpe, s.symbol) case i : Ident => i.tpe case _ => tree.tpe } @@ -1033,23 +1035,21 @@ class Global(settings: Settings, _reporter: Reporter, projectName: String = "") } private def typeMembers(pos: Position): Stream[List[TypeMember]] = { - var tree = typedTreeAt(pos) - - // if tree consists of just x. or x.fo where fo is not yet a full member name - // ignore the selection and look in just x. - tree match { - case Select(qual, name) if tree.tpe == ErrorType => tree = qual - case _ => + // Choosing which tree will tell us the type members at the given position: + // If pos leads to an Import, type the expr + // If pos leads to a Select, type the qualifier as long as it is not erroneous + // (this implies discarding the possibly incomplete name in the Select node) + // Otherwise, type the tree found at 'pos' directly. + val tree0 = typedTreeAt(pos) match { + case sel @ Select(qual, _) if sel.tpe == ErrorType => qual + case Import(expr, _) => expr + case t => t } - val context = doLocateContext(pos) - - if (tree.tpe == null) - // TODO: guard with try/catch to deal with ill-typed qualifiers. - tree = analyzer.newTyper(context).typedQualifier(tree) + // TODO: guard with try/catch to deal with ill-typed qualifiers. + val tree = if (tree0.tpe eq null) analyzer newTyper context typedQualifier tree0 else tree0 debugLog("typeMembers at "+tree+" "+tree.tpe) - val superAccess = tree.isInstanceOf[Super] val members = new Members[TypeMember] @@ -1210,9 +1210,6 @@ class Global(settings: Settings, _reporter: Reporter, projectName: String = "") case ex: TypeError => debugLog("type error caught: "+ex) alt - case ex: DivergentImplicit => - debugLog("divergent implicit caught: "+ex) - alt } } diff --git a/src/interactive/scala/tools/nsc/interactive/Picklers.scala b/src/interactive/scala/tools/nsc/interactive/Picklers.scala index b184afd0f5..900a06333d 100644 --- a/src/interactive/scala/tools/nsc/interactive/Picklers.scala +++ b/src/interactive/scala/tools/nsc/interactive/Picklers.scala @@ -96,7 +96,7 @@ trait Picklers { self: Global => if (!sym.isRoot) { ownerNames(sym.owner, buf) buf += (if (sym.isModuleClass) sym.sourceModule else sym).name - if (!sym.isType && !sym.isStable) { + if (!sym.isType && !sym.isStable) { // TODO: what's the reasoning behind this condition!? val sym1 = sym.owner.info.decl(sym.name) if (sym1.isOverloaded) { val index = sym1.alternatives.indexOf(sym) diff --git a/src/interactive/scala/tools/nsc/interactive/REPL.scala b/src/interactive/scala/tools/nsc/interactive/REPL.scala index 432400ecd2..daa1c21c4a 100644 --- a/src/interactive/scala/tools/nsc/interactive/REPL.scala +++ b/src/interactive/scala/tools/nsc/interactive/REPL.scala @@ -2,7 +2,8 @@ * Copyright 2009-2013 Typesafe/Scala Solutions and LAMP/EPFL * @author Martin Odersky */ -package scala.tools.nsc +package scala +package tools.nsc package interactive import scala.reflect.internal.util._ diff --git a/src/interactive/scala/tools/nsc/interactive/ScratchPadMaker.scala b/src/interactive/scala/tools/nsc/interactive/ScratchPadMaker.scala index 7af9174704..ae70a74b60 100644 --- a/src/interactive/scala/tools/nsc/interactive/ScratchPadMaker.scala +++ b/src/interactive/scala/tools/nsc/interactive/ScratchPadMaker.scala @@ -1,4 +1,5 @@ -package scala.tools.nsc +package scala +package tools.nsc package interactive import scala.reflect.internal.util.{SourceFile, BatchSourceFile, RangePosition} diff --git a/src/interactive/scala/tools/nsc/interactive/tests/Tester.scala b/src/interactive/scala/tools/nsc/interactive/tests/Tester.scala index 8a47c1df37..a678c41718 100644 --- a/src/interactive/scala/tools/nsc/interactive/tests/Tester.scala +++ b/src/interactive/scala/tools/nsc/interactive/tests/Tester.scala @@ -2,7 +2,8 @@ * Copyright 2009-2013 Typesafe/Scala Solutions and LAMP/EPFL * @author Martin Odersky */ -package scala.tools.nsc +package scala +package tools.nsc package interactive package tests diff --git a/src/interactive/scala/tools/nsc/interactive/tests/core/CoreTestDefs.scala b/src/interactive/scala/tools/nsc/interactive/tests/core/CoreTestDefs.scala index c0ad245091..08d84af8f5 100644 --- a/src/interactive/scala/tools/nsc/interactive/tests/core/CoreTestDefs.scala +++ b/src/interactive/scala/tools/nsc/interactive/tests/core/CoreTestDefs.scala @@ -16,21 +16,18 @@ private[tests] trait CoreTestDefs extends PresentationCompilerTestDef with AskCompletionAt { - def memberPrinter(member: compiler.Member): String = - "[accessible: %5s] ".format(member.accessible) + "`" + (member.sym.toString.trim + member.tpe.toString()).trim + "`" - override def runTest() { askAllSources(CompletionMarker) { pos => askCompletionAt(pos) } { (pos, members) => withResponseDelimiter { - reporter.println("[response] aksTypeCompletion at " + format(pos)) + reporter.println("[response] askCompletionAt " + format(pos)) // we skip getClass because it changed signature between 1.5 and 1.6, so there is no // universal check file that we can provide for this to work reporter.println("retrieved %d members".format(members.size)) compiler ask { () => val filtered = members.filterNot(member => (member.sym.name string_== "getClass") || member.sym.isConstructor) - reporter.println(filtered.map(memberPrinter).sortBy(_.toString()).mkString("\n")) + reporter println (filtered.map(_.infoString).sorted mkString "\n") } } } @@ -48,7 +45,7 @@ private[tests] trait CoreTestDefs askTypeAt(pos) } { (pos, tree) => withResponseDelimiter { - reporter.println("[response] askTypeAt at " + format(pos)) + reporter.println("[response] askTypeAt " + format(pos)) compiler.ask(() => reporter.println(tree)) } } diff --git a/src/jline/build.sbt b/src/jline/build.sbt index 4fc3bab28a..873f7574f1 100644 --- a/src/jline/build.sbt +++ b/src/jline/build.sbt @@ -4,9 +4,9 @@ name := "jline" organization := "org.scala-lang" -version := "2.10.0-SNAPSHOT" +version := "2.11.0-SNAPSHOT" -scalaVersion := "2.9.0-1" +scalaVersion := "2.10.1" // Only need these because of weird testing jline issues. retrieveManaged := true @@ -14,11 +14,11 @@ retrieveManaged := true parallelExecution in Test := false libraryDependencies ++= Seq( - "org.fusesource.jansi" % "jansi" % "1.4", - "com.novocode" % "junit-interface" % "0.7" % "test->default" + "org.fusesource.jansi" % "jansi" % "1.10", + "com.novocode" % "junit-interface" % "0.9" % "test->default" ) -javacOptions ++= Seq("-target", "1.5") +javacOptions ++= Seq("-source", "1.5", "-target", "1.5") proguardOptions ++= Seq( "-dontshrink", diff --git a/src/jline/manual-test.sh b/src/jline/manual-test.sh index aa5131c903..744e1756e8 100755 --- a/src/jline/manual-test.sh +++ b/src/jline/manual-test.sh @@ -3,6 +3,7 @@ # Apparently the jline bundled with sbt interferes with testing some # changes: for instance after changing the keybindings I kept seeing # failures until I realized what was happening and bypassed sbt, like this. +CP=lib_managed/jars/com.novocode/junit-interface/junit-interface-0.9.jar:lib_managed/jars/junit/junit-dep/junit-dep-4.8.2.jar:lib_managed/jars/org.fusesource.jansi/jansi/jansi-1.10.jar:lib_managed/jars/org.hamcrest/hamcrest-core/hamcrest-core-1.1.jar:lib_managed/jars/org.scala-tools.testing/test-interface/test-interface-0.5.jar:target/scala-2.10/test-classes:target/scala-2.10/jline_2.10-2.11.0-SNAPSHOT.min.jar -java -cp lib_managed/jar/com.novocode/junit-interface/junit-interface-0.5.jar:lib_managed/jar/junit/junit/junit-4.8.1.jar:lib_managed/jar/org.fusesource.jansi/jansi/jansi-1.4.jar:lib_managed/jar/org.scala-tools.testing/test-interface/test-interface-0.5.jar:target/scala-2.9.0.1/test-classes:target/scala-2.9.0.1/jline_2.9.0-1-2.10.0-SNAPSHOT.jar \ -org.junit.runner.JUnitCore scala.tools.jline.console.EditLineTest +sbt proguard +java -cp $CP org.junit.runner.JUnitCore scala.tools.jline.console.EditLineTest diff --git a/src/jline/project/build.properties b/src/jline/project/build.properties new file mode 100644 index 0000000000..9b860e23c5 --- /dev/null +++ b/src/jline/project/build.properties @@ -0,0 +1 @@ +sbt.version=0.12.3 diff --git a/src/jline/project/plugins.sbt b/src/jline/project/plugins.sbt new file mode 100644 index 0000000000..9c13de92d8 --- /dev/null +++ b/src/jline/project/plugins.sbt @@ -0,0 +1,3 @@ +resolvers += Resolver.url("sbt-plugin-releases-scalasbt", url("http://repo.scala-sbt.org/scalasbt/sbt-plugin-releases/"))(Resolver.ivyStylePatterns) + +addSbtPlugin("org.scala-sbt" % "xsbt-proguard-plugin" % "0.1.3") diff --git a/src/jline/project/plugins/build.sbt b/src/jline/project/plugins/build.sbt deleted file mode 100644 index 0e0f27b1eb..0000000000 --- a/src/jline/project/plugins/build.sbt +++ /dev/null @@ -1,5 +0,0 @@ -resolvers += "Proguard plugin repo" at "http://siasia.github.com/maven2" - -libraryDependencies <<= (libraryDependencies, appConfiguration) { (deps, app) => - deps :+ "com.github.siasia" %% "xsbt-proguard-plugin" % app.provider.id.version -} diff --git a/src/library/scala/collection/BitSet.scala b/src/library/scala/collection/BitSet.scala index 6985563da2..e255e96140 100644 --- a/src/library/scala/collection/BitSet.scala +++ b/src/library/scala/collection/BitSet.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection import generic._ diff --git a/src/library/scala/collection/BitSetLike.scala b/src/library/scala/collection/BitSetLike.scala index 9c4e710558..f11f3757a6 100644 --- a/src/library/scala/collection/BitSetLike.scala +++ b/src/library/scala/collection/BitSetLike.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection import BitSetLike._ import mutable.StringBuilder diff --git a/src/library/scala/collection/BufferedIterator.scala b/src/library/scala/collection/BufferedIterator.scala index 741bca4e46..e6e97d584c 100644 --- a/src/library/scala/collection/BufferedIterator.scala +++ b/src/library/scala/collection/BufferedIterator.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection /** Buffered iterators are iterators which provide a method `head` * that inspects the next element without discarding it. diff --git a/src/library/scala/collection/CustomParallelizable.scala b/src/library/scala/collection/CustomParallelizable.scala index 53fe32b89f..cbeb28d643 100644 --- a/src/library/scala/collection/CustomParallelizable.scala +++ b/src/library/scala/collection/CustomParallelizable.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection import parallel.Combiner diff --git a/src/library/scala/collection/DefaultMap.scala b/src/library/scala/collection/DefaultMap.scala index bbd6b2c2fc..8afda7cfcf 100644 --- a/src/library/scala/collection/DefaultMap.scala +++ b/src/library/scala/collection/DefaultMap.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection /** A default map which implements the `+` and `-` methods of maps. * diff --git a/src/library/scala/collection/GenIterable.scala b/src/library/scala/collection/GenIterable.scala index b4e7a14ade..6fd4158726 100644 --- a/src/library/scala/collection/GenIterable.scala +++ b/src/library/scala/collection/GenIterable.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection import generic._ diff --git a/src/library/scala/collection/GenIterableLike.scala b/src/library/scala/collection/GenIterableLike.scala index ceb97707e1..1dbb54ddc7 100644 --- a/src/library/scala/collection/GenIterableLike.scala +++ b/src/library/scala/collection/GenIterableLike.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection import generic.{ CanBuildFrom => CBF } diff --git a/src/library/scala/collection/GenIterableView.scala b/src/library/scala/collection/GenIterableView.scala index 5ab48efdf3..cd052ddf79 100644 --- a/src/library/scala/collection/GenIterableView.scala +++ b/src/library/scala/collection/GenIterableView.scala @@ -6,6 +6,7 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection trait GenIterableView[+A, +Coll] extends GenIterableViewLike[A, Coll, GenIterableView[A, Coll]] { } diff --git a/src/library/scala/collection/GenIterableViewLike.scala b/src/library/scala/collection/GenIterableViewLike.scala index e8d264cdd4..b519e99ae5 100644 --- a/src/library/scala/collection/GenIterableViewLike.scala +++ b/src/library/scala/collection/GenIterableViewLike.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection trait GenIterableViewLike[+A, +Coll, diff --git a/src/library/scala/collection/GenMap.scala b/src/library/scala/collection/GenMap.scala index f7b2ae4d70..3d7427981d 100644 --- a/src/library/scala/collection/GenMap.scala +++ b/src/library/scala/collection/GenMap.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection import generic._ diff --git a/src/library/scala/collection/GenMapLike.scala b/src/library/scala/collection/GenMapLike.scala index 367377a59c..4e7d359251 100644 --- a/src/library/scala/collection/GenMapLike.scala +++ b/src/library/scala/collection/GenMapLike.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection /** A trait for all maps upon which operations may be * implemented in parallel. diff --git a/src/library/scala/collection/GenSeq.scala b/src/library/scala/collection/GenSeq.scala index 4c5488d7e2..480562cab5 100644 --- a/src/library/scala/collection/GenSeq.scala +++ b/src/library/scala/collection/GenSeq.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection import generic._ diff --git a/src/library/scala/collection/GenSeqLike.scala b/src/library/scala/collection/GenSeqLike.scala index 78d63348c0..27b75c0491 100644 --- a/src/library/scala/collection/GenSeqLike.scala +++ b/src/library/scala/collection/GenSeqLike.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection import generic._ diff --git a/src/library/scala/collection/GenSeqView.scala b/src/library/scala/collection/GenSeqView.scala index 423f8e305e..0a214832ad 100644 --- a/src/library/scala/collection/GenSeqView.scala +++ b/src/library/scala/collection/GenSeqView.scala @@ -6,6 +6,7 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection trait GenSeqView[+A, +Coll] extends GenSeqViewLike[A, Coll, GenSeqView[A, Coll]] { } diff --git a/src/library/scala/collection/GenSeqViewLike.scala b/src/library/scala/collection/GenSeqViewLike.scala index 51600218ad..d3af953f72 100644 --- a/src/library/scala/collection/GenSeqViewLike.scala +++ b/src/library/scala/collection/GenSeqViewLike.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection diff --git a/src/library/scala/collection/GenSet.scala b/src/library/scala/collection/GenSet.scala index 832177b128..2467860095 100644 --- a/src/library/scala/collection/GenSet.scala +++ b/src/library/scala/collection/GenSet.scala @@ -7,7 +7,8 @@ \* */ -package scala.collection +package scala +package collection import generic._ diff --git a/src/library/scala/collection/GenSetLike.scala b/src/library/scala/collection/GenSetLike.scala index f22a7c8f09..c5355e58ec 100644 --- a/src/library/scala/collection/GenSetLike.scala +++ b/src/library/scala/collection/GenSetLike.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection /** A template trait for sets which may possibly diff --git a/src/library/scala/collection/GenTraversable.scala b/src/library/scala/collection/GenTraversable.scala index 3db2dd77a9..b700f49cf6 100644 --- a/src/library/scala/collection/GenTraversable.scala +++ b/src/library/scala/collection/GenTraversable.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection import generic._ diff --git a/src/library/scala/collection/GenTraversableLike.scala b/src/library/scala/collection/GenTraversableLike.scala index 1080c54325..f4aa063d8a 100644 --- a/src/library/scala/collection/GenTraversableLike.scala +++ b/src/library/scala/collection/GenTraversableLike.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection import generic._ diff --git a/src/library/scala/collection/GenTraversableOnce.scala b/src/library/scala/collection/GenTraversableOnce.scala index a05ee0fb54..d966c7324b 100644 --- a/src/library/scala/collection/GenTraversableOnce.scala +++ b/src/library/scala/collection/GenTraversableOnce.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection import scala.reflect.ClassTag import scala.collection.generic.CanBuildFrom diff --git a/src/library/scala/collection/GenTraversableView.scala b/src/library/scala/collection/GenTraversableView.scala index 1d98eff8c1..7d9a6e9777 100644 --- a/src/library/scala/collection/GenTraversableView.scala +++ b/src/library/scala/collection/GenTraversableView.scala @@ -6,6 +6,7 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection trait GenTraversableView[+A, +Coll] extends GenTraversableViewLike[A, Coll, GenTraversableView[A, Coll]] { } diff --git a/src/library/scala/collection/GenTraversableViewLike.scala b/src/library/scala/collection/GenTraversableViewLike.scala index 8c9607663b..dde18a7a32 100644 --- a/src/library/scala/collection/GenTraversableViewLike.scala +++ b/src/library/scala/collection/GenTraversableViewLike.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection import generic._ diff --git a/src/library/scala/collection/IndexedSeq.scala b/src/library/scala/collection/IndexedSeq.scala index 0b6e640537..1a33026101 100644 --- a/src/library/scala/collection/IndexedSeq.scala +++ b/src/library/scala/collection/IndexedSeq.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection import generic._ import mutable.Builder diff --git a/src/library/scala/collection/IndexedSeqLike.scala b/src/library/scala/collection/IndexedSeqLike.scala index 473202a8eb..18c9175ee1 100644 --- a/src/library/scala/collection/IndexedSeqLike.scala +++ b/src/library/scala/collection/IndexedSeqLike.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection import mutable.ArrayBuffer import scala.annotation.tailrec diff --git a/src/library/scala/collection/Iterable.scala b/src/library/scala/collection/Iterable.scala index 09c9ce122c..973efc447e 100644 --- a/src/library/scala/collection/Iterable.scala +++ b/src/library/scala/collection/Iterable.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection import generic._ import mutable.Builder diff --git a/src/library/scala/collection/IterableProxy.scala b/src/library/scala/collection/IterableProxy.scala index ddb2502965..3a0e2ab115 100644 --- a/src/library/scala/collection/IterableProxy.scala +++ b/src/library/scala/collection/IterableProxy.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection /** This trait implements a proxy for iterable objects. It forwards all calls * to a different iterable object. diff --git a/src/library/scala/collection/IterableProxyLike.scala b/src/library/scala/collection/IterableProxyLike.scala index 6968a54399..9b8f6f3742 100644 --- a/src/library/scala/collection/IterableProxyLike.scala +++ b/src/library/scala/collection/IterableProxyLike.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection import generic._ import mutable.Buffer diff --git a/src/library/scala/collection/IterableView.scala b/src/library/scala/collection/IterableView.scala index 985556e0d4..1d631739aa 100644 --- a/src/library/scala/collection/IterableView.scala +++ b/src/library/scala/collection/IterableView.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection import generic._ import TraversableView.NoBuilder diff --git a/src/library/scala/collection/IterableViewLike.scala b/src/library/scala/collection/IterableViewLike.scala index b195ae4bc7..236bfd154c 100644 --- a/src/library/scala/collection/IterableViewLike.scala +++ b/src/library/scala/collection/IterableViewLike.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection import generic._ import immutable.Stream diff --git a/src/library/scala/collection/JavaConversions.scala b/src/library/scala/collection/JavaConversions.scala index 3cb7edacd6..b527b34f10 100644 --- a/src/library/scala/collection/JavaConversions.scala +++ b/src/library/scala/collection/JavaConversions.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection import convert._ diff --git a/src/library/scala/collection/JavaConverters.scala b/src/library/scala/collection/JavaConverters.scala index 7700d90560..80dbf4b19d 100755 --- a/src/library/scala/collection/JavaConverters.scala +++ b/src/library/scala/collection/JavaConverters.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection import convert._ diff --git a/src/library/scala/collection/LinearSeq.scala b/src/library/scala/collection/LinearSeq.scala index e52a1936fe..1e4975a0a7 100644 --- a/src/library/scala/collection/LinearSeq.scala +++ b/src/library/scala/collection/LinearSeq.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection import generic._ import mutable.Builder diff --git a/src/library/scala/collection/LinearSeqLike.scala b/src/library/scala/collection/LinearSeqLike.scala index a4bb194f8a..ff7985bf0d 100644 --- a/src/library/scala/collection/LinearSeqLike.scala +++ b/src/library/scala/collection/LinearSeqLike.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection import immutable.List import scala.annotation.tailrec diff --git a/src/library/scala/collection/LinearSeqOptimized.scala b/src/library/scala/collection/LinearSeqOptimized.scala index 9cf37981f4..21bfedf5de 100755 --- a/src/library/scala/collection/LinearSeqOptimized.scala +++ b/src/library/scala/collection/LinearSeqOptimized.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection import mutable.ListBuffer import immutable.List diff --git a/src/library/scala/collection/Map.scala b/src/library/scala/collection/Map.scala index 18ad20a855..f37c0993d4 100644 --- a/src/library/scala/collection/Map.scala +++ b/src/library/scala/collection/Map.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection import generic._ diff --git a/src/library/scala/collection/MapLike.scala b/src/library/scala/collection/MapLike.scala index cc0129202f..5ec7d5c615 100644 --- a/src/library/scala/collection/MapLike.scala +++ b/src/library/scala/collection/MapLike.scala @@ -6,8 +6,8 @@ ** |/ ** \* */ - -package scala.collection +package scala +package collection import generic._ import mutable.{ Builder, MapBuilder } diff --git a/src/library/scala/collection/MapProxy.scala b/src/library/scala/collection/MapProxy.scala index e85d306e6f..941c1f5a4a 100644 --- a/src/library/scala/collection/MapProxy.scala +++ b/src/library/scala/collection/MapProxy.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection /** This is a simple wrapper class for [[scala.collection.Map]]. * It is most useful for assembling customized map abstractions diff --git a/src/library/scala/collection/MapProxyLike.scala b/src/library/scala/collection/MapProxyLike.scala index ad09f7b970..44481131aa 100644 --- a/src/library/scala/collection/MapProxyLike.scala +++ b/src/library/scala/collection/MapProxyLike.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection // Methods could be printed by cat MapLike.scala | egrep '^ (override )?def' diff --git a/src/library/scala/collection/Parallel.scala b/src/library/scala/collection/Parallel.scala index 6731f74bea..174e3ab75e 100644 --- a/src/library/scala/collection/Parallel.scala +++ b/src/library/scala/collection/Parallel.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection /** A marker trait for collections which have their operations parallelised. * diff --git a/src/library/scala/collection/Parallelizable.scala b/src/library/scala/collection/Parallelizable.scala index 626dfa4032..b737752458 100644 --- a/src/library/scala/collection/Parallelizable.scala +++ b/src/library/scala/collection/Parallelizable.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection import parallel.Combiner diff --git a/src/library/scala/collection/Searching.scala b/src/library/scala/collection/Searching.scala index 8957771988..fec4bbf502 100644 --- a/src/library/scala/collection/Searching.scala +++ b/src/library/scala/collection/Searching.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection import scala.language.implicitConversions import scala.annotation.tailrec diff --git a/src/library/scala/collection/Seq.scala b/src/library/scala/collection/Seq.scala index 33e66c0874..b21acdd9b7 100644 --- a/src/library/scala/collection/Seq.scala +++ b/src/library/scala/collection/Seq.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection import generic._ import mutable.Builder diff --git a/src/library/scala/collection/SeqExtractors.scala b/src/library/scala/collection/SeqExtractors.scala index 20ea7f54b7..2398313c77 100644 --- a/src/library/scala/collection/SeqExtractors.scala +++ b/src/library/scala/collection/SeqExtractors.scala @@ -1,4 +1,5 @@ -package scala.collection +package scala +package collection /** An extractor used to head/tail deconstruct sequences. */ object +: { diff --git a/src/library/scala/collection/SeqProxy.scala b/src/library/scala/collection/SeqProxy.scala index 1f8dc4aad1..9c5424a3a6 100644 --- a/src/library/scala/collection/SeqProxy.scala +++ b/src/library/scala/collection/SeqProxy.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection /** This trait implements a proxy for sequence objects. It forwards * all calls to a different sequence object. diff --git a/src/library/scala/collection/SeqProxyLike.scala b/src/library/scala/collection/SeqProxyLike.scala index ee88ee3da3..161b23d3f8 100644 --- a/src/library/scala/collection/SeqProxyLike.scala +++ b/src/library/scala/collection/SeqProxyLike.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection import generic._ diff --git a/src/library/scala/collection/SeqView.scala b/src/library/scala/collection/SeqView.scala index c26124cf6f..40dfd50212 100644 --- a/src/library/scala/collection/SeqView.scala +++ b/src/library/scala/collection/SeqView.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection import generic._ import TraversableView.NoBuilder diff --git a/src/library/scala/collection/SeqViewLike.scala b/src/library/scala/collection/SeqViewLike.scala index 27536791a2..1194cd7199 100644 --- a/src/library/scala/collection/SeqViewLike.scala +++ b/src/library/scala/collection/SeqViewLike.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection import generic._ import Seq.fill diff --git a/src/library/scala/collection/Set.scala b/src/library/scala/collection/Set.scala index c304323d28..46d5dfa056 100644 --- a/src/library/scala/collection/Set.scala +++ b/src/library/scala/collection/Set.scala @@ -6,8 +6,8 @@ ** |/ ** \* */ - -package scala.collection +package scala +package collection import generic._ diff --git a/src/library/scala/collection/SetLike.scala b/src/library/scala/collection/SetLike.scala index 9fd24317f2..0c5c7e0b29 100644 --- a/src/library/scala/collection/SetLike.scala +++ b/src/library/scala/collection/SetLike.scala @@ -6,8 +6,8 @@ ** |/ ** \* */ - -package scala.collection +package scala +package collection import generic._ import mutable.{ Builder, SetBuilder } diff --git a/src/library/scala/collection/SetProxy.scala b/src/library/scala/collection/SetProxy.scala index 08075a7121..f9f38f148a 100644 --- a/src/library/scala/collection/SetProxy.scala +++ b/src/library/scala/collection/SetProxy.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection /** This is a simple wrapper class for [[scala.collection.Set]]. * It is most useful for assembling customized set abstractions diff --git a/src/library/scala/collection/SetProxyLike.scala b/src/library/scala/collection/SetProxyLike.scala index 265d1c4806..ac3d34dbab 100644 --- a/src/library/scala/collection/SetProxyLike.scala +++ b/src/library/scala/collection/SetProxyLike.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection // Methods could be printed by cat SetLike.scala | egrep '^ (override )?def' diff --git a/src/library/scala/collection/SortedMap.scala b/src/library/scala/collection/SortedMap.scala index 86fcfac94d..0705a1e9e0 100644 --- a/src/library/scala/collection/SortedMap.scala +++ b/src/library/scala/collection/SortedMap.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection import generic._ import mutable.Builder diff --git a/src/library/scala/collection/SortedMapLike.scala b/src/library/scala/collection/SortedMapLike.scala index 934ed831f5..3fc8b0dadc 100644 --- a/src/library/scala/collection/SortedMapLike.scala +++ b/src/library/scala/collection/SortedMapLike.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection import generic._ diff --git a/src/library/scala/collection/SortedSet.scala b/src/library/scala/collection/SortedSet.scala index 2d5d4fb55e..43189d2e8c 100644 --- a/src/library/scala/collection/SortedSet.scala +++ b/src/library/scala/collection/SortedSet.scala @@ -7,7 +7,8 @@ \* */ -package scala.collection +package scala +package collection import generic._ /** A sorted set. diff --git a/src/library/scala/collection/SortedSetLike.scala b/src/library/scala/collection/SortedSetLike.scala index 6d1d1ac111..eb2ac38c59 100644 --- a/src/library/scala/collection/SortedSetLike.scala +++ b/src/library/scala/collection/SortedSetLike.scala @@ -7,7 +7,8 @@ \* */ -package scala.collection +package scala +package collection import generic._ /** A template for sets which are sorted. diff --git a/src/library/scala/collection/Traversable.scala b/src/library/scala/collection/Traversable.scala index 4ca2095f4c..61d9a42f04 100644 --- a/src/library/scala/collection/Traversable.scala +++ b/src/library/scala/collection/Traversable.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection import generic._ import mutable.Builder diff --git a/src/library/scala/collection/TraversableLike.scala b/src/library/scala/collection/TraversableLike.scala index fdbc5e9857..00f4de82cd 100644 --- a/src/library/scala/collection/TraversableLike.scala +++ b/src/library/scala/collection/TraversableLike.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection import generic._ import mutable.{ Builder } diff --git a/src/library/scala/collection/TraversableOnce.scala b/src/library/scala/collection/TraversableOnce.scala index fcca2da437..526c36dda7 100644 --- a/src/library/scala/collection/TraversableOnce.scala +++ b/src/library/scala/collection/TraversableOnce.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection import mutable.{ Buffer, Builder, ListBuffer, ArrayBuffer } import generic.CanBuildFrom diff --git a/src/library/scala/collection/TraversableProxy.scala b/src/library/scala/collection/TraversableProxy.scala index 568298a9d9..65936da0e4 100644 --- a/src/library/scala/collection/TraversableProxy.scala +++ b/src/library/scala/collection/TraversableProxy.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection // Methods could be printed by cat TraversableLike.scala | egrep '^ (override )?def' diff --git a/src/library/scala/collection/TraversableProxyLike.scala b/src/library/scala/collection/TraversableProxyLike.scala index 8896cd1b0f..77d651c5f2 100644 --- a/src/library/scala/collection/TraversableProxyLike.scala +++ b/src/library/scala/collection/TraversableProxyLike.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection import generic._ import mutable.{Buffer, StringBuilder} diff --git a/src/library/scala/collection/TraversableView.scala b/src/library/scala/collection/TraversableView.scala index af219084b8..bbb5bde464 100644 --- a/src/library/scala/collection/TraversableView.scala +++ b/src/library/scala/collection/TraversableView.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection import generic._ import mutable.Builder diff --git a/src/library/scala/collection/TraversableViewLike.scala b/src/library/scala/collection/TraversableViewLike.scala index 36f6210ef4..c507e000ee 100644 --- a/src/library/scala/collection/TraversableViewLike.scala +++ b/src/library/scala/collection/TraversableViewLike.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection import generic._ import mutable.{ Builder, ArrayBuffer } diff --git a/src/library/scala/collection/concurrent/Map.scala b/src/library/scala/collection/concurrent/Map.scala index b2276ce5aa..02e5dd01f5 100644 --- a/src/library/scala/collection/concurrent/Map.scala +++ b/src/library/scala/collection/concurrent/Map.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection.concurrent +package scala +package collection.concurrent /** A template trait for mutable maps that allow concurrent access. * diff --git a/src/library/scala/collection/concurrent/TrieMap.scala b/src/library/scala/collection/concurrent/TrieMap.scala index 4eeacd7377..0b5ceeb1c7 100644 --- a/src/library/scala/collection/concurrent/TrieMap.scala +++ b/src/library/scala/collection/concurrent/TrieMap.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package concurrent import java.util.concurrent.atomic._ @@ -428,10 +429,10 @@ extends MainNode[K, V] with KVNode[K, V] { } -private[collection] final class LNode[K, V](final val listmap: ImmutableListMap[K, V]) +private[collection] final class LNode[K, V](final val listmap: immutable.ListMap[K, V]) extends MainNode[K, V] { - def this(k: K, v: V) = this(ImmutableListMap(k -> v)) - def this(k1: K, v1: V, k2: K, v2: V) = this(ImmutableListMap(k1 -> v1, k2 -> v2)) + def this(k: K, v: V) = this(immutable.ListMap(k -> v)) + def this(k1: K, v1: V, k2: K, v2: V) = this(immutable.ListMap(k1 -> v1, k2 -> v2)) def inserted(k: K, v: V) = new LNode(listmap + ((k, v))) def removed(k: K, ct: TrieMap[K, V]): MainNode[K, V] = { val updmap = listmap - k diff --git a/src/library/scala/collection/convert/DecorateAsJava.scala b/src/library/scala/collection/convert/DecorateAsJava.scala index 7447c1bbaf..498bdc5943 100644 --- a/src/library/scala/collection/convert/DecorateAsJava.scala +++ b/src/library/scala/collection/convert/DecorateAsJava.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package convert import java.{ lang => jl, util => ju }, java.util.{ concurrent => juc } diff --git a/src/library/scala/collection/convert/DecorateAsScala.scala b/src/library/scala/collection/convert/DecorateAsScala.scala index 90e8dded6e..c724831c54 100644 --- a/src/library/scala/collection/convert/DecorateAsScala.scala +++ b/src/library/scala/collection/convert/DecorateAsScala.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package convert import java.{ lang => jl, util => ju }, java.util.{ concurrent => juc } diff --git a/src/library/scala/collection/convert/Decorators.scala b/src/library/scala/collection/convert/Decorators.scala index f004e4712b..d232fa04e1 100644 --- a/src/library/scala/collection/convert/Decorators.scala +++ b/src/library/scala/collection/convert/Decorators.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package convert import java.{ util => ju } diff --git a/src/library/scala/collection/convert/WrapAsJava.scala b/src/library/scala/collection/convert/WrapAsJava.scala index 9665ffa045..e75a0e2981 100644 --- a/src/library/scala/collection/convert/WrapAsJava.scala +++ b/src/library/scala/collection/convert/WrapAsJava.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package convert import java.{ lang => jl, util => ju }, java.util.{ concurrent => juc } diff --git a/src/library/scala/collection/convert/WrapAsScala.scala b/src/library/scala/collection/convert/WrapAsScala.scala index f43eae10d6..d4ab451b0d 100644 --- a/src/library/scala/collection/convert/WrapAsScala.scala +++ b/src/library/scala/collection/convert/WrapAsScala.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package convert import java.{ lang => jl, util => ju }, java.util.{ concurrent => juc } diff --git a/src/library/scala/collection/convert/Wrappers.scala b/src/library/scala/collection/convert/Wrappers.scala index 69e9a8fff4..4410ddc7d8 100644 --- a/src/library/scala/collection/convert/Wrappers.scala +++ b/src/library/scala/collection/convert/Wrappers.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package convert import java.{ lang => jl, util => ju }, java.util.{ concurrent => juc } diff --git a/src/library/scala/collection/convert/package.scala b/src/library/scala/collection/convert/package.scala index ea66101aca..13970f9a3e 100644 --- a/src/library/scala/collection/convert/package.scala +++ b/src/library/scala/collection/convert/package.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package object convert { val decorateAsJava = new DecorateAsJava { } diff --git a/src/library/scala/collection/generic/BitOperations.scala b/src/library/scala/collection/generic/BitOperations.scala index c45ebcf982..d430ece2f5 100644 --- a/src/library/scala/collection/generic/BitOperations.scala +++ b/src/library/scala/collection/generic/BitOperations.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package generic /** Some bit operations. diff --git a/src/library/scala/collection/generic/BitSetFactory.scala b/src/library/scala/collection/generic/BitSetFactory.scala index 46e2d29612..2e3aae31ac 100644 --- a/src/library/scala/collection/generic/BitSetFactory.scala +++ b/src/library/scala/collection/generic/BitSetFactory.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package generic import scala.collection._ diff --git a/src/library/scala/collection/generic/CanBuildFrom.scala b/src/library/scala/collection/generic/CanBuildFrom.scala index 73fd4fc026..24e5b2a1dd 100644 --- a/src/library/scala/collection/generic/CanBuildFrom.scala +++ b/src/library/scala/collection/generic/CanBuildFrom.scala @@ -7,7 +7,8 @@ \* */ -package scala.collection +package scala +package collection package generic import mutable.Builder diff --git a/src/library/scala/collection/generic/CanCombineFrom.scala b/src/library/scala/collection/generic/CanCombineFrom.scala index 9ca3332ba0..7f70b4580a 100644 --- a/src/library/scala/collection/generic/CanCombineFrom.scala +++ b/src/library/scala/collection/generic/CanCombineFrom.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package generic import scala.collection.parallel._ diff --git a/src/library/scala/collection/generic/ClassTagTraversableFactory.scala b/src/library/scala/collection/generic/ClassTagTraversableFactory.scala index 85cdbd7276..e3db40123d 100644 --- a/src/library/scala/collection/generic/ClassTagTraversableFactory.scala +++ b/src/library/scala/collection/generic/ClassTagTraversableFactory.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package generic import scala.language.higherKinds diff --git a/src/library/scala/collection/generic/Clearable.scala b/src/library/scala/collection/generic/Clearable.scala index a04ecb2a68..3c496051c4 100644 --- a/src/library/scala/collection/generic/Clearable.scala +++ b/src/library/scala/collection/generic/Clearable.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package generic /** This trait forms part of collections that can be cleared diff --git a/src/library/scala/collection/generic/FilterMonadic.scala b/src/library/scala/collection/generic/FilterMonadic.scala index e21f0be898..8aefbdb926 100755 --- a/src/library/scala/collection/generic/FilterMonadic.scala +++ b/src/library/scala/collection/generic/FilterMonadic.scala @@ -6,8 +6,9 @@ ** |/ ** \* */ -package scala.collection.generic - +package scala +package collection +package generic /** A template trait that contains just the `map`, `flatMap`, `foreach` and `withFilter` methods * of trait `TraversableLike`. diff --git a/src/library/scala/collection/generic/GenMapFactory.scala b/src/library/scala/collection/generic/GenMapFactory.scala index 5a183c307b..ae3150115f 100644 --- a/src/library/scala/collection/generic/GenMapFactory.scala +++ b/src/library/scala/collection/generic/GenMapFactory.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package generic import mutable.{Builder, MapBuilder} diff --git a/src/library/scala/collection/generic/GenSeqFactory.scala b/src/library/scala/collection/generic/GenSeqFactory.scala index dd375c567c..6afbb2e2fb 100644 --- a/src/library/scala/collection/generic/GenSeqFactory.scala +++ b/src/library/scala/collection/generic/GenSeqFactory.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package generic import scala.language.higherKinds diff --git a/src/library/scala/collection/generic/GenSetFactory.scala b/src/library/scala/collection/generic/GenSetFactory.scala index 9774805cf8..800f66eb53 100644 --- a/src/library/scala/collection/generic/GenSetFactory.scala +++ b/src/library/scala/collection/generic/GenSetFactory.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package generic import mutable.Builder diff --git a/src/library/scala/collection/generic/GenTraversableFactory.scala b/src/library/scala/collection/generic/GenTraversableFactory.scala index 0e1a5534c0..2092c0c5f5 100644 --- a/src/library/scala/collection/generic/GenTraversableFactory.scala +++ b/src/library/scala/collection/generic/GenTraversableFactory.scala @@ -7,7 +7,8 @@ \* */ -package scala.collection +package scala +package collection package generic import scala.language.higherKinds diff --git a/src/library/scala/collection/generic/GenericClassTagCompanion.scala b/src/library/scala/collection/generic/GenericClassTagCompanion.scala index cdfee5252f..a8ac2bf738 100644 --- a/src/library/scala/collection/generic/GenericClassTagCompanion.scala +++ b/src/library/scala/collection/generic/GenericClassTagCompanion.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package generic import mutable.Builder diff --git a/src/library/scala/collection/generic/GenericClassTagTraversableTemplate.scala b/src/library/scala/collection/generic/GenericClassTagTraversableTemplate.scala index f327710848..090cd729a4 100644 --- a/src/library/scala/collection/generic/GenericClassTagTraversableTemplate.scala +++ b/src/library/scala/collection/generic/GenericClassTagTraversableTemplate.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package generic import mutable.Builder diff --git a/src/library/scala/collection/generic/GenericCompanion.scala b/src/library/scala/collection/generic/GenericCompanion.scala index 66052d0e6f..67d0a9c7f7 100644 --- a/src/library/scala/collection/generic/GenericCompanion.scala +++ b/src/library/scala/collection/generic/GenericCompanion.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package generic import mutable.Builder diff --git a/src/library/scala/collection/generic/GenericOrderedCompanion.scala b/src/library/scala/collection/generic/GenericOrderedCompanion.scala index 7a0c0a63e8..5b328bff6c 100644 --- a/src/library/scala/collection/generic/GenericOrderedCompanion.scala +++ b/src/library/scala/collection/generic/GenericOrderedCompanion.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package generic import mutable.Builder diff --git a/src/library/scala/collection/generic/GenericOrderedTraversableTemplate.scala b/src/library/scala/collection/generic/GenericOrderedTraversableTemplate.scala index a624e8ca93..c1a41ce7c4 100644 --- a/src/library/scala/collection/generic/GenericOrderedTraversableTemplate.scala +++ b/src/library/scala/collection/generic/GenericOrderedTraversableTemplate.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package generic import mutable.Builder diff --git a/src/library/scala/collection/generic/GenericParCompanion.scala b/src/library/scala/collection/generic/GenericParCompanion.scala index bb39461e7e..432b9135f8 100644 --- a/src/library/scala/collection/generic/GenericParCompanion.scala +++ b/src/library/scala/collection/generic/GenericParCompanion.scala @@ -6,7 +6,9 @@ ** |/ ** \* */ -package scala.collection.generic +package scala +package collection +package generic import scala.collection.parallel.Combiner import scala.collection.parallel.ParIterable diff --git a/src/library/scala/collection/generic/GenericParTemplate.scala b/src/library/scala/collection/generic/GenericParTemplate.scala index 94c76630d6..b9b7043270 100644 --- a/src/library/scala/collection/generic/GenericParTemplate.scala +++ b/src/library/scala/collection/generic/GenericParTemplate.scala @@ -6,7 +6,9 @@ ** |/ ** \* */ -package scala.collection.generic +package scala +package collection +package generic import scala.collection.parallel.Combiner import scala.collection.parallel.ParIterable diff --git a/src/library/scala/collection/generic/GenericSeqCompanion.scala b/src/library/scala/collection/generic/GenericSeqCompanion.scala index 8b2f8a0fcb..34b20f23a2 100644 --- a/src/library/scala/collection/generic/GenericSeqCompanion.scala +++ b/src/library/scala/collection/generic/GenericSeqCompanion.scala @@ -7,7 +7,8 @@ \* */ -package scala.collection +package scala +package collection package generic import scala.language.higherKinds diff --git a/src/library/scala/collection/generic/GenericSetTemplate.scala b/src/library/scala/collection/generic/GenericSetTemplate.scala index ecfdcffbc5..2cadd14948 100644 --- a/src/library/scala/collection/generic/GenericSetTemplate.scala +++ b/src/library/scala/collection/generic/GenericSetTemplate.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package generic import scala.language.higherKinds /** diff --git a/src/library/scala/collection/generic/GenericTraversableTemplate.scala b/src/library/scala/collection/generic/GenericTraversableTemplate.scala index 908aa5b126..cd48cd23f4 100644 --- a/src/library/scala/collection/generic/GenericTraversableTemplate.scala +++ b/src/library/scala/collection/generic/GenericTraversableTemplate.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package generic import mutable.Builder @@ -73,11 +74,20 @@ trait GenericTraversableTemplate[+A, +CC[X] <: GenTraversable[X]] extends HasNew /** Converts this $coll of pairs into two collections of the first and second * half of each pair. * + * {{{ + * val xs = $Coll( + * (1, "one"), + * (2, "two"), + * (3, "three")).unzip + * // xs == ($Coll(1, 2, 3), + * // $Coll(one, two, three)) + * }}} + * * @tparam A1 the type of the first half of the element pairs * @tparam A2 the type of the second half of the element pairs * @param asPair an implicit conversion which asserts that the element type * of this $coll is a pair. - * @return a pair ${coll}s, containing the first, respectively second + * @return a pair of ${coll}s, containing the first, respectively second * half of each element pair of this $coll. */ def unzip[A1, A2](implicit asPair: A => (A1, A2)): (CC[A1], CC[A2]) = { @@ -94,12 +104,22 @@ trait GenericTraversableTemplate[+A, +CC[X] <: GenTraversable[X]] extends HasNew /** Converts this $coll of triples into three collections of the first, second, * and third element of each triple. * + * {{{ + * val xs = $Coll( + * (1, "one", '1'), + * (2, "two", '2'), + * (3, "three", '3')).unzip3 + * // xs == ($Coll(1, 2, 3), + * // $Coll(one, two, three), + * // $Coll(1, 2, 3)) + * }}} + * * @tparam A1 the type of the first member of the element triples * @tparam A2 the type of the second member of the element triples * @tparam A3 the type of the third member of the element triples * @param asTriple an implicit conversion which asserts that the element type * of this $coll is a triple. - * @return a triple ${coll}s, containing the first, second, respectively + * @return a triple of ${coll}s, containing the first, second, respectively * third member of each element triple of this $coll. */ def unzip3[A1, A2, A3](implicit asTriple: A => (A1, A2, A3)): (CC[A1], CC[A2], CC[A3]) = { @@ -133,10 +153,16 @@ trait GenericTraversableTemplate[+A, +CC[X] <: GenTraversable[X]] extends HasNew * static type of $coll. For example: * * {{{ - * val xs = List(Set(1, 2, 3), Set(1, 2, 3)) + * val xs = List( + * Set(1, 2, 3), + * Set(1, 2, 3) + * ).flatten * // xs == List(1, 2, 3, 1, 2, 3) * - * val ys = Set(List(1, 2, 3), List(3, 2, 1)) + * val ys = Set( + * List(1, 2, 3), + * List(3, 2, 1) + * ).flatten * // ys == Set(1, 2, 3) * }}} */ @@ -150,6 +176,27 @@ trait GenericTraversableTemplate[+A, +CC[X] <: GenTraversable[X]] extends HasNew /** Transposes this $coll of traversable collections into * a $coll of ${coll}s. * + * The resulting collection's type will be guided by the + * static type of $coll. For example: + * + * {{{ + * val xs = List( + * Set(1, 2, 3), + * Set(4, 5, 6)).transpose + * // xs == List( + * // List(1, 4), + * // List(2, 5), + * // List(3, 6)) + * + * val ys = Vector( + * List(1, 2, 3), + * List(4, 5, 6)).transpose + * // ys == Vector( + * // Vector(1, 4), + * // Vector(2, 5), + * // Vector(3, 6)) + * }}} + * * @tparam B the type of the elements of each traversable collection. * @param asTraversable an implicit conversion which asserts that the * element type of this $coll is a `Traversable`. diff --git a/src/library/scala/collection/generic/Growable.scala b/src/library/scala/collection/generic/Growable.scala index 52a0d32de1..254d4566be 100644 --- a/src/library/scala/collection/generic/Growable.scala +++ b/src/library/scala/collection/generic/Growable.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package generic import scala.annotation.tailrec @@ -47,15 +48,15 @@ trait Growable[-A] extends Clearable { * @return the $coll itself. */ def ++=(xs: TraversableOnce[A]): this.type = { - @tailrec def loop(xs: collection.LinearSeq[A]) { + @tailrec def loop(xs: scala.collection.LinearSeq[A]) { if (xs.nonEmpty) { this += xs.head loop(xs.tail) } } xs.seq match { - case xs: collection.LinearSeq[_] => loop(xs) - case xs => xs foreach += + case xs: scala.collection.LinearSeq[_] => loop(xs) + case xs => xs foreach += } this } diff --git a/src/library/scala/collection/generic/HasNewBuilder.scala b/src/library/scala/collection/generic/HasNewBuilder.scala index 1a981b487f..aa0ce6698d 100755 --- a/src/library/scala/collection/generic/HasNewBuilder.scala +++ b/src/library/scala/collection/generic/HasNewBuilder.scala @@ -5,7 +5,8 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ -package scala.collection +package scala +package collection package generic import mutable.Builder diff --git a/src/library/scala/collection/generic/HasNewCombiner.scala b/src/library/scala/collection/generic/HasNewCombiner.scala index 1ecfba19af..99a0722c3d 100644 --- a/src/library/scala/collection/generic/HasNewCombiner.scala +++ b/src/library/scala/collection/generic/HasNewCombiner.scala @@ -6,7 +6,9 @@ ** |/ ** \* */ -package scala.collection.generic +package scala +package collection +package generic import scala.collection.parallel.Combiner diff --git a/src/library/scala/collection/generic/ImmutableMapFactory.scala b/src/library/scala/collection/generic/ImmutableMapFactory.scala index 4ce50a31f9..7d857bf1b4 100644 --- a/src/library/scala/collection/generic/ImmutableMapFactory.scala +++ b/src/library/scala/collection/generic/ImmutableMapFactory.scala @@ -7,7 +7,8 @@ \* */ -package scala.collection +package scala +package collection package generic import scala.language.higherKinds diff --git a/src/library/scala/collection/generic/ImmutableSetFactory.scala b/src/library/scala/collection/generic/ImmutableSetFactory.scala index 2e960e670d..f4d4e061bb 100644 --- a/src/library/scala/collection/generic/ImmutableSetFactory.scala +++ b/src/library/scala/collection/generic/ImmutableSetFactory.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package generic import mutable.{ Builder, SetBuilder } diff --git a/src/library/scala/collection/generic/ImmutableSortedMapFactory.scala b/src/library/scala/collection/generic/ImmutableSortedMapFactory.scala index 7743fc2281..730e58a527 100644 --- a/src/library/scala/collection/generic/ImmutableSortedMapFactory.scala +++ b/src/library/scala/collection/generic/ImmutableSortedMapFactory.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package generic import scala.language.higherKinds diff --git a/src/library/scala/collection/generic/ImmutableSortedSetFactory.scala b/src/library/scala/collection/generic/ImmutableSortedSetFactory.scala index 9914557b51..1fd4a8c99d 100644 --- a/src/library/scala/collection/generic/ImmutableSortedSetFactory.scala +++ b/src/library/scala/collection/generic/ImmutableSortedSetFactory.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package generic import scala.language.higherKinds diff --git a/src/library/scala/collection/generic/IndexedSeqFactory.scala b/src/library/scala/collection/generic/IndexedSeqFactory.scala index e86d163b3c..ddc0141aa9 100644 --- a/src/library/scala/collection/generic/IndexedSeqFactory.scala +++ b/src/library/scala/collection/generic/IndexedSeqFactory.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package generic import language.higherKinds diff --git a/src/library/scala/collection/generic/IsSeqLike.scala b/src/library/scala/collection/generic/IsSeqLike.scala index d1dffdf8cf..189aea4632 100644 --- a/src/library/scala/collection/generic/IsSeqLike.scala +++ b/src/library/scala/collection/generic/IsSeqLike.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package generic /** Type class witnessing that a collection representation type `Repr` has @@ -41,7 +42,7 @@ trait IsSeqLike[Repr] { } object IsSeqLike { - import language.higherKinds + import scala.language.higherKinds implicit val stringRepr: IsSeqLike[String] { type A = Char } = new IsSeqLike[String] { diff --git a/src/library/scala/collection/generic/IsTraversableLike.scala b/src/library/scala/collection/generic/IsTraversableLike.scala index c70772d8f9..22cef555cc 100644 --- a/src/library/scala/collection/generic/IsTraversableLike.scala +++ b/src/library/scala/collection/generic/IsTraversableLike.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package generic /** A trait which can be used to avoid code duplication when defining extension diff --git a/src/library/scala/collection/generic/IsTraversableOnce.scala b/src/library/scala/collection/generic/IsTraversableOnce.scala index bb5404c92d..3ee586ae63 100644 --- a/src/library/scala/collection/generic/IsTraversableOnce.scala +++ b/src/library/scala/collection/generic/IsTraversableOnce.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package generic /** Type class witnessing that a collection representation type `Repr` has diff --git a/src/library/scala/collection/generic/IterableForwarder.scala b/src/library/scala/collection/generic/IterableForwarder.scala index 8feace3f8b..5a54ed7f78 100644 --- a/src/library/scala/collection/generic/IterableForwarder.scala +++ b/src/library/scala/collection/generic/IterableForwarder.scala @@ -6,7 +6,9 @@ ** |/ ** \* */ -package scala.collection.generic +package scala +package collection +package generic import scala.collection._ diff --git a/src/library/scala/collection/generic/MapFactory.scala b/src/library/scala/collection/generic/MapFactory.scala index 565850bee2..b9f3d4b010 100644 --- a/src/library/scala/collection/generic/MapFactory.scala +++ b/src/library/scala/collection/generic/MapFactory.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package generic diff --git a/src/library/scala/collection/generic/MutableMapFactory.scala b/src/library/scala/collection/generic/MutableMapFactory.scala index ac139cc80c..14c5b6bac3 100644 --- a/src/library/scala/collection/generic/MutableMapFactory.scala +++ b/src/library/scala/collection/generic/MutableMapFactory.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package generic import mutable.Builder diff --git a/src/library/scala/collection/generic/MutableSetFactory.scala b/src/library/scala/collection/generic/MutableSetFactory.scala index 9c69d53608..63944657fc 100644 --- a/src/library/scala/collection/generic/MutableSetFactory.scala +++ b/src/library/scala/collection/generic/MutableSetFactory.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package generic import mutable.{ Builder, GrowingBuilder } diff --git a/src/library/scala/collection/generic/MutableSortedSetFactory.scala b/src/library/scala/collection/generic/MutableSortedSetFactory.scala index b9be83c3c4..0339a523e9 100644 --- a/src/library/scala/collection/generic/MutableSortedSetFactory.scala +++ b/src/library/scala/collection/generic/MutableSortedSetFactory.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package generic import scala.collection.mutable.{ Builder, GrowingBuilder } diff --git a/src/library/scala/collection/generic/OrderedTraversableFactory.scala b/src/library/scala/collection/generic/OrderedTraversableFactory.scala index a2de108721..7657aff2aa 100644 --- a/src/library/scala/collection/generic/OrderedTraversableFactory.scala +++ b/src/library/scala/collection/generic/OrderedTraversableFactory.scala @@ -7,7 +7,8 @@ \* */ -package scala.collection +package scala +package collection package generic import scala.language.higherKinds diff --git a/src/library/scala/collection/generic/ParFactory.scala b/src/library/scala/collection/generic/ParFactory.scala index bb88d26dec..486e2a115e 100644 --- a/src/library/scala/collection/generic/ParFactory.scala +++ b/src/library/scala/collection/generic/ParFactory.scala @@ -6,7 +6,9 @@ ** |/ ** \* */ -package scala.collection.generic +package scala +package collection +package generic import scala.collection.parallel.ParIterable import scala.collection.parallel.Combiner diff --git a/src/library/scala/collection/generic/ParMapFactory.scala b/src/library/scala/collection/generic/ParMapFactory.scala index 0a6b08ae34..70797c83e2 100644 --- a/src/library/scala/collection/generic/ParMapFactory.scala +++ b/src/library/scala/collection/generic/ParMapFactory.scala @@ -6,7 +6,9 @@ ** |/ ** \* */ -package scala.collection.generic +package scala +package collection +package generic import scala.collection.parallel.ParMap import scala.collection.parallel.ParMapLike diff --git a/src/library/scala/collection/generic/ParSetFactory.scala b/src/library/scala/collection/generic/ParSetFactory.scala index 3727ab89f7..4320635ae6 100644 --- a/src/library/scala/collection/generic/ParSetFactory.scala +++ b/src/library/scala/collection/generic/ParSetFactory.scala @@ -6,7 +6,9 @@ ** |/ ** \* */ -package scala.collection.generic +package scala +package collection +package generic import scala.collection.mutable.Builder import scala.collection.parallel.Combiner diff --git a/src/library/scala/collection/generic/SeqFactory.scala b/src/library/scala/collection/generic/SeqFactory.scala index a66074741a..35cce11a79 100644 --- a/src/library/scala/collection/generic/SeqFactory.scala +++ b/src/library/scala/collection/generic/SeqFactory.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package generic import scala.language.higherKinds diff --git a/src/library/scala/collection/generic/SeqForwarder.scala b/src/library/scala/collection/generic/SeqForwarder.scala index aafaffc159..c23b818c00 100644 --- a/src/library/scala/collection/generic/SeqForwarder.scala +++ b/src/library/scala/collection/generic/SeqForwarder.scala @@ -6,7 +6,9 @@ ** |/ ** \* */ -package scala.collection.generic +package scala +package collection +package generic import scala.collection._ import scala.collection.immutable.Range diff --git a/src/library/scala/collection/generic/SetFactory.scala b/src/library/scala/collection/generic/SetFactory.scala index e9bbde92f3..fcd8d00c18 100644 --- a/src/library/scala/collection/generic/SetFactory.scala +++ b/src/library/scala/collection/generic/SetFactory.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package generic import mutable.Builder diff --git a/src/library/scala/collection/generic/Shrinkable.scala b/src/library/scala/collection/generic/Shrinkable.scala index b00048fd5d..b7412afde0 100644 --- a/src/library/scala/collection/generic/Shrinkable.scala +++ b/src/library/scala/collection/generic/Shrinkable.scala @@ -7,7 +7,8 @@ \* */ -package scala.collection +package scala +package collection package generic /** This trait forms part of collections that can be reduced diff --git a/src/library/scala/collection/generic/Signalling.scala b/src/library/scala/collection/generic/Signalling.scala index 442a7c126e..e62eb6ff09 100644 --- a/src/library/scala/collection/generic/Signalling.scala +++ b/src/library/scala/collection/generic/Signalling.scala @@ -6,7 +6,9 @@ ** |/ ** \* */ -package scala.collection.generic +package scala +package collection +package generic import java.util.concurrent.atomic.AtomicInteger diff --git a/src/library/scala/collection/generic/Sizing.scala b/src/library/scala/collection/generic/Sizing.scala index 1191259b3a..73584ce82e 100644 --- a/src/library/scala/collection/generic/Sizing.scala +++ b/src/library/scala/collection/generic/Sizing.scala @@ -6,7 +6,9 @@ ** |/ ** \* */ -package scala.collection.generic +package scala +package collection +package generic /** A trait for objects which have a size. */ diff --git a/src/library/scala/collection/generic/SliceInterval.scala b/src/library/scala/collection/generic/SliceInterval.scala index 244e960454..82acdd1371 100644 --- a/src/library/scala/collection/generic/SliceInterval.scala +++ b/src/library/scala/collection/generic/SliceInterval.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package generic /** A container for the endpoints of a collection slice. diff --git a/src/library/scala/collection/generic/Sorted.scala b/src/library/scala/collection/generic/Sorted.scala index 2c3d200d01..3876da3275 100644 --- a/src/library/scala/collection/generic/Sorted.scala +++ b/src/library/scala/collection/generic/Sorted.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package generic /** Any collection (including maps) whose keys (or elements) are ordered. diff --git a/src/library/scala/collection/generic/SortedMapFactory.scala b/src/library/scala/collection/generic/SortedMapFactory.scala index fb3fe0fcb6..afa11e9ab1 100644 --- a/src/library/scala/collection/generic/SortedMapFactory.scala +++ b/src/library/scala/collection/generic/SortedMapFactory.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package generic import mutable.{Builder, MapBuilder} diff --git a/src/library/scala/collection/generic/SortedSetFactory.scala b/src/library/scala/collection/generic/SortedSetFactory.scala index f48e1c69e1..c734830e0b 100644 --- a/src/library/scala/collection/generic/SortedSetFactory.scala +++ b/src/library/scala/collection/generic/SortedSetFactory.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package generic import mutable.{Builder, SetBuilder} diff --git a/src/library/scala/collection/generic/Subtractable.scala b/src/library/scala/collection/generic/Subtractable.scala index e0fe07a0a4..32a9000296 100644 --- a/src/library/scala/collection/generic/Subtractable.scala +++ b/src/library/scala/collection/generic/Subtractable.scala @@ -7,7 +7,8 @@ \* */ -package scala.collection +package scala +package collection package generic diff --git a/src/library/scala/collection/generic/TraversableFactory.scala b/src/library/scala/collection/generic/TraversableFactory.scala index 5d1c9d17e2..ad6d8fd198 100644 --- a/src/library/scala/collection/generic/TraversableFactory.scala +++ b/src/library/scala/collection/generic/TraversableFactory.scala @@ -7,7 +7,8 @@ \* */ -package scala.collection +package scala +package collection package generic import scala.language.higherKinds diff --git a/src/library/scala/collection/generic/TraversableForwarder.scala b/src/library/scala/collection/generic/TraversableForwarder.scala index 2662018feb..c71368bba0 100644 --- a/src/library/scala/collection/generic/TraversableForwarder.scala +++ b/src/library/scala/collection/generic/TraversableForwarder.scala @@ -6,7 +6,9 @@ ** |/ ** \* */ -package scala.collection.generic +package scala +package collection +package generic import scala.collection._ import mutable.{ Buffer, StringBuilder } diff --git a/src/library/scala/collection/generic/package.scala b/src/library/scala/collection/generic/package.scala index dd47b7ace6..1beb4a8599 100644 --- a/src/library/scala/collection/generic/package.scala +++ b/src/library/scala/collection/generic/package.scala @@ -1,4 +1,5 @@ -package scala.collection +package scala +package collection import generic.CanBuildFrom import scala.language.higherKinds diff --git a/src/library/scala/collection/immutable/BitSet.scala b/src/library/scala/collection/immutable/BitSet.scala index 1da6edd740..70543aa3a6 100644 --- a/src/library/scala/collection/immutable/BitSet.scala +++ b/src/library/scala/collection/immutable/BitSet.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package immutable import generic._ diff --git a/src/library/scala/collection/immutable/DefaultMap.scala b/src/library/scala/collection/immutable/DefaultMap.scala index 5ae5ef66fb..42a03e90ee 100755 --- a/src/library/scala/collection/immutable/DefaultMap.scala +++ b/src/library/scala/collection/immutable/DefaultMap.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package immutable /** A default map which implements the `+` and `-` diff --git a/src/library/scala/collection/immutable/IndexedSeq.scala b/src/library/scala/collection/immutable/IndexedSeq.scala index 9316ff5e72..33170fdd59 100644 --- a/src/library/scala/collection/immutable/IndexedSeq.scala +++ b/src/library/scala/collection/immutable/IndexedSeq.scala @@ -7,7 +7,8 @@ \* */ -package scala.collection +package scala +package collection package immutable import generic._ diff --git a/src/library/scala/collection/immutable/Iterable.scala b/src/library/scala/collection/immutable/Iterable.scala index cc64d8ff3c..6e4eb1e45f 100644 --- a/src/library/scala/collection/immutable/Iterable.scala +++ b/src/library/scala/collection/immutable/Iterable.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package immutable import generic._ diff --git a/src/library/scala/collection/immutable/LinearSeq.scala b/src/library/scala/collection/immutable/LinearSeq.scala index 5ede6d90d0..2109bd5211 100644 --- a/src/library/scala/collection/immutable/LinearSeq.scala +++ b/src/library/scala/collection/immutable/LinearSeq.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package immutable import generic._ diff --git a/src/library/scala/collection/immutable/List.scala b/src/library/scala/collection/immutable/List.scala index f3559f7d26..c01694960c 100644 --- a/src/library/scala/collection/immutable/List.scala +++ b/src/library/scala/collection/immutable/List.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package immutable import generic._ diff --git a/src/library/scala/collection/immutable/ListMap.scala b/src/library/scala/collection/immutable/ListMap.scala index 75817350e5..47593a07ab 100644 --- a/src/library/scala/collection/immutable/ListMap.scala +++ b/src/library/scala/collection/immutable/ListMap.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package immutable import generic._ diff --git a/src/library/scala/collection/immutable/ListSet.scala b/src/library/scala/collection/immutable/ListSet.scala index def3d7eb23..5836321010 100644 --- a/src/library/scala/collection/immutable/ListSet.scala +++ b/src/library/scala/collection/immutable/ListSet.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package immutable import generic._ diff --git a/src/library/scala/collection/immutable/Map.scala b/src/library/scala/collection/immutable/Map.scala index 2ebf5035e1..a3f5c85961 100644 --- a/src/library/scala/collection/immutable/Map.scala +++ b/src/library/scala/collection/immutable/Map.scala @@ -7,7 +7,8 @@ \* */ -package scala.collection +package scala +package collection package immutable import generic._ diff --git a/src/library/scala/collection/immutable/MapLike.scala b/src/library/scala/collection/immutable/MapLike.scala index 1c2ab1c662..f6041464e7 100644 --- a/src/library/scala/collection/immutable/MapLike.scala +++ b/src/library/scala/collection/immutable/MapLike.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package immutable import generic._ diff --git a/src/library/scala/collection/immutable/MapProxy.scala b/src/library/scala/collection/immutable/MapProxy.scala index f3f04ec346..f9f19c021d 100644 --- a/src/library/scala/collection/immutable/MapProxy.scala +++ b/src/library/scala/collection/immutable/MapProxy.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package immutable /** diff --git a/src/library/scala/collection/immutable/NumericRange.scala b/src/library/scala/collection/immutable/NumericRange.scala index 5842ff30e6..486c2b6c8f 100644 --- a/src/library/scala/collection/immutable/NumericRange.scala +++ b/src/library/scala/collection/immutable/NumericRange.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package immutable import mutable.{ Builder, ListBuffer } diff --git a/src/library/scala/collection/immutable/PagedSeq.scala b/src/library/scala/collection/immutable/PagedSeq.scala index 4069f6f0e4..e190d022d7 100644 --- a/src/library/scala/collection/immutable/PagedSeq.scala +++ b/src/library/scala/collection/immutable/PagedSeq.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package immutable import java.io._ diff --git a/src/library/scala/collection/immutable/Queue.scala b/src/library/scala/collection/immutable/Queue.scala index 7d2ff95792..c55b46bf05 100644 --- a/src/library/scala/collection/immutable/Queue.scala +++ b/src/library/scala/collection/immutable/Queue.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package immutable import generic._ diff --git a/src/library/scala/collection/immutable/Range.scala b/src/library/scala/collection/immutable/Range.scala index 243e3fcb91..09f8143b55 100644 --- a/src/library/scala/collection/immutable/Range.scala +++ b/src/library/scala/collection/immutable/Range.scala @@ -7,7 +7,8 @@ \* */ -package scala.collection.immutable +package scala +package collection.immutable import scala.collection.parallel.immutable.ParRange @@ -81,14 +82,14 @@ extends scala.collection.AbstractSeq[Int] override def min[A1 >: Int](implicit ord: Ordering[A1]): Int = if (ord eq Ordering.Int) { - if (step > 0) start + if (step > 0) head else last } else super.min(ord) override def max[A1 >: Int](implicit ord: Ordering[A1]): Int = if (ord eq Ordering.Int) { if (step > 0) last - else start + else head } else super.max(ord) protected def copy(start: Int, end: Int, step: Int): Range = new Range(start, end, step) diff --git a/src/library/scala/collection/immutable/Seq.scala b/src/library/scala/collection/immutable/Seq.scala index 14610aea33..38855ca6b0 100644 --- a/src/library/scala/collection/immutable/Seq.scala +++ b/src/library/scala/collection/immutable/Seq.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package immutable import generic._ diff --git a/src/library/scala/collection/immutable/Set.scala b/src/library/scala/collection/immutable/Set.scala index 8433c2b002..2c96f4c194 100644 --- a/src/library/scala/collection/immutable/Set.scala +++ b/src/library/scala/collection/immutable/Set.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package immutable import generic._ diff --git a/src/library/scala/collection/immutable/SetProxy.scala b/src/library/scala/collection/immutable/SetProxy.scala index 06c6843181..9e25678435 100644 --- a/src/library/scala/collection/immutable/SetProxy.scala +++ b/src/library/scala/collection/immutable/SetProxy.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package immutable /** This is a simple wrapper class for <a href="Set.html" diff --git a/src/library/scala/collection/immutable/SortedMap.scala b/src/library/scala/collection/immutable/SortedMap.scala index 73cc55df00..4b9fa81a8c 100644 --- a/src/library/scala/collection/immutable/SortedMap.scala +++ b/src/library/scala/collection/immutable/SortedMap.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package immutable import generic._ diff --git a/src/library/scala/collection/immutable/SortedSet.scala b/src/library/scala/collection/immutable/SortedSet.scala index 3f75d50555..4a8859a7ab 100644 --- a/src/library/scala/collection/immutable/SortedSet.scala +++ b/src/library/scala/collection/immutable/SortedSet.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package immutable import generic._ diff --git a/src/library/scala/collection/immutable/Stack.scala b/src/library/scala/collection/immutable/Stack.scala index 357e9a123c..65a34e2310 100644 --- a/src/library/scala/collection/immutable/Stack.scala +++ b/src/library/scala/collection/immutable/Stack.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package immutable import generic._ diff --git a/src/library/scala/collection/immutable/Stream.scala b/src/library/scala/collection/immutable/Stream.scala index 0770bd3175..5e1de44749 100644 --- a/src/library/scala/collection/immutable/Stream.scala +++ b/src/library/scala/collection/immutable/Stream.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package immutable import generic._ @@ -183,10 +184,12 @@ import scala.language.implicitConversions * @define orderDependentFold * @define willTerminateInf Note: lazily evaluated; will terminate for infinite-sized collections. */ +@deprecatedInheritance("This class will be sealed.", "2.11.0") abstract class Stream[+A] extends AbstractSeq[A] with LinearSeq[A] with GenericTraversableTemplate[A, Stream] - with LinearSeqOptimized[A, Stream[A]] { + with LinearSeqOptimized[A, Stream[A]] + with Serializable { self => override def companion: GenericCompanion[Stream] = Stream @@ -1048,7 +1051,7 @@ object Stream extends SeqFactory[Stream] { def result: Stream[A] = parts.toStream flatMap (_.toStream) } - object Empty extends Stream[Nothing] with Serializable { + object Empty extends Stream[Nothing] { override def isEmpty = true override def head = throw new NoSuchElementException("head of empty stream") override def tail = throw new UnsupportedOperationException("tail of empty stream") @@ -1099,7 +1102,7 @@ object Stream extends SeqFactory[Stream] { /** A lazy cons cell, from which streams are built. */ @SerialVersionUID(-602202424901551803L) - final class Cons[+A](hd: A, tl: => Stream[A]) extends Stream[A] with Serializable { + final class Cons[+A](hd: A, tl: => Stream[A]) extends Stream[A] { override def isEmpty = false override def head = hd @volatile private[this] var tlVal: Stream[A] = _ diff --git a/src/library/scala/collection/immutable/StreamView.scala b/src/library/scala/collection/immutable/StreamView.scala index 5a24b77eb3..127ed76eb5 100644 --- a/src/library/scala/collection/immutable/StreamView.scala +++ b/src/library/scala/collection/immutable/StreamView.scala @@ -1,4 +1,5 @@ -package scala.collection +package scala +package collection package immutable trait StreamView[+A, +Coll] extends StreamViewLike[A, Coll, StreamView[A, Coll]] { } diff --git a/src/library/scala/collection/immutable/StreamViewLike.scala b/src/library/scala/collection/immutable/StreamViewLike.scala index 236308da2e..ccab032cfd 100644 --- a/src/library/scala/collection/immutable/StreamViewLike.scala +++ b/src/library/scala/collection/immutable/StreamViewLike.scala @@ -1,4 +1,5 @@ -package scala.collection +package scala +package collection package immutable import generic._ diff --git a/src/library/scala/collection/immutable/StringLike.scala b/src/library/scala/collection/immutable/StringLike.scala index 389e1579f2..4768413e75 100644 --- a/src/library/scala/collection/immutable/StringLike.scala +++ b/src/library/scala/collection/immutable/StringLike.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package immutable import mutable.Builder diff --git a/src/library/scala/collection/immutable/StringOps.scala b/src/library/scala/collection/immutable/StringOps.scala index 16c1f96cc2..6737692fb1 100644 --- a/src/library/scala/collection/immutable/StringOps.scala +++ b/src/library/scala/collection/immutable/StringOps.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package immutable import mutable.StringBuilder diff --git a/src/library/scala/collection/immutable/Traversable.scala b/src/library/scala/collection/immutable/Traversable.scala index 5188343011..775d635fae 100644 --- a/src/library/scala/collection/immutable/Traversable.scala +++ b/src/library/scala/collection/immutable/Traversable.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package immutable import generic._ diff --git a/src/library/scala/collection/immutable/TreeMap.scala b/src/library/scala/collection/immutable/TreeMap.scala index 5085039da5..4d2ec579db 100644 --- a/src/library/scala/collection/immutable/TreeMap.scala +++ b/src/library/scala/collection/immutable/TreeMap.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package immutable import generic._ diff --git a/src/library/scala/collection/immutable/TreeSet.scala b/src/library/scala/collection/immutable/TreeSet.scala index e25d16408a..dfe1a833ef 100644 --- a/src/library/scala/collection/immutable/TreeSet.scala +++ b/src/library/scala/collection/immutable/TreeSet.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package immutable import generic._ diff --git a/src/library/scala/collection/immutable/TrieIterator.scala b/src/library/scala/collection/immutable/TrieIterator.scala index dbe013d6e8..d7335e80f1 100644 --- a/src/library/scala/collection/immutable/TrieIterator.scala +++ b/src/library/scala/collection/immutable/TrieIterator.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package immutable import HashMap.{ HashTrieMap, HashMapCollision1, HashMap1 } diff --git a/src/library/scala/collection/immutable/WrappedString.scala b/src/library/scala/collection/immutable/WrappedString.scala index edcab31f33..d6bebf9ef5 100644 --- a/src/library/scala/collection/immutable/WrappedString.scala +++ b/src/library/scala/collection/immutable/WrappedString.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package immutable import generic._ diff --git a/src/library/scala/collection/mutable/AVLTree.scala b/src/library/scala/collection/mutable/AVLTree.scala index dd7a94d677..d2205f9994 100644 --- a/src/library/scala/collection/mutable/AVLTree.scala +++ b/src/library/scala/collection/mutable/AVLTree.scala @@ -10,7 +10,6 @@ package scala package collection package mutable - /** * An immutable AVL Tree implementation used by mutable.TreeSet * diff --git a/src/library/scala/collection/mutable/ArrayBuffer.scala b/src/library/scala/collection/mutable/ArrayBuffer.scala index f1cfd2d69a..2d43b352c5 100644 --- a/src/library/scala/collection/mutable/ArrayBuffer.scala +++ b/src/library/scala/collection/mutable/ArrayBuffer.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package mutable import generic._ diff --git a/src/library/scala/collection/mutable/ArrayBuilder.scala b/src/library/scala/collection/mutable/ArrayBuilder.scala index 2fe3e91d68..65b4d52a60 100644 --- a/src/library/scala/collection/mutable/ArrayBuilder.scala +++ b/src/library/scala/collection/mutable/ArrayBuilder.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package mutable import scala.reflect.ClassTag diff --git a/src/library/scala/collection/mutable/ArrayLike.scala b/src/library/scala/collection/mutable/ArrayLike.scala index 40017aa08e..4a6820856d 100644 --- a/src/library/scala/collection/mutable/ArrayLike.scala +++ b/src/library/scala/collection/mutable/ArrayLike.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package mutable /** A common supertrait of `ArrayOps` and `WrappedArray` that factors out most diff --git a/src/library/scala/collection/mutable/ArraySeq.scala b/src/library/scala/collection/mutable/ArraySeq.scala index 334b26ae03..577a838315 100644 --- a/src/library/scala/collection/mutable/ArraySeq.scala +++ b/src/library/scala/collection/mutable/ArraySeq.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package mutable import generic._ diff --git a/src/library/scala/collection/mutable/BitSet.scala b/src/library/scala/collection/mutable/BitSet.scala index 29c341590d..f252a0bfeb 100644 --- a/src/library/scala/collection/mutable/BitSet.scala +++ b/src/library/scala/collection/mutable/BitSet.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package mutable import generic._ diff --git a/src/library/scala/collection/mutable/Buffer.scala b/src/library/scala/collection/mutable/Buffer.scala index 230799c6f3..d2e33badbe 100644 --- a/src/library/scala/collection/mutable/Buffer.scala +++ b/src/library/scala/collection/mutable/Buffer.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package mutable import generic._ diff --git a/src/library/scala/collection/mutable/BufferLike.scala b/src/library/scala/collection/mutable/BufferLike.scala index 322522fdd2..4b3d3bc1cf 100644 --- a/src/library/scala/collection/mutable/BufferLike.scala +++ b/src/library/scala/collection/mutable/BufferLike.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package mutable import generic._ diff --git a/src/library/scala/collection/mutable/BufferProxy.scala b/src/library/scala/collection/mutable/BufferProxy.scala index d3f96f69ad..14946cdfd8 100644 --- a/src/library/scala/collection/mutable/BufferProxy.scala +++ b/src/library/scala/collection/mutable/BufferProxy.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package mutable import script._ diff --git a/src/library/scala/collection/mutable/Cloneable.scala b/src/library/scala/collection/mutable/Cloneable.scala index dadcd36257..8b2f3f70de 100644 --- a/src/library/scala/collection/mutable/Cloneable.scala +++ b/src/library/scala/collection/mutable/Cloneable.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package mutable /** A trait for cloneable collections. diff --git a/src/library/scala/collection/mutable/DefaultEntry.scala b/src/library/scala/collection/mutable/DefaultEntry.scala index f14cb4ac2b..66db45866c 100644 --- a/src/library/scala/collection/mutable/DefaultEntry.scala +++ b/src/library/scala/collection/mutable/DefaultEntry.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package mutable /** Class used internally for default map model. diff --git a/src/library/scala/collection/mutable/DefaultMapModel.scala b/src/library/scala/collection/mutable/DefaultMapModel.scala index 903f117466..4dfae047c3 100644 --- a/src/library/scala/collection/mutable/DefaultMapModel.scala +++ b/src/library/scala/collection/mutable/DefaultMapModel.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package mutable /** This class is used internally. It implements the mutable `Map` diff --git a/src/library/scala/collection/mutable/DoubleLinkedList.scala b/src/library/scala/collection/mutable/DoubleLinkedList.scala index a106794912..8654a91cf1 100644 --- a/src/library/scala/collection/mutable/DoubleLinkedList.scala +++ b/src/library/scala/collection/mutable/DoubleLinkedList.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package mutable import generic._ diff --git a/src/library/scala/collection/mutable/DoubleLinkedListLike.scala b/src/library/scala/collection/mutable/DoubleLinkedListLike.scala index 3f223f30ec..776ac76c45 100644 --- a/src/library/scala/collection/mutable/DoubleLinkedListLike.scala +++ b/src/library/scala/collection/mutable/DoubleLinkedListLike.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package mutable import scala.annotation.migration diff --git a/src/library/scala/collection/mutable/FlatHashTable.scala b/src/library/scala/collection/mutable/FlatHashTable.scala index 49a9427588..1cdf150cb8 100644 --- a/src/library/scala/collection/mutable/FlatHashTable.scala +++ b/src/library/scala/collection/mutable/FlatHashTable.scala @@ -6,11 +6,10 @@ ** |/ ** \* */ - -package scala.collection +package scala +package collection package mutable - /** An implementation class backing a `HashSet`. * * This trait is used internally. It can be mixed in with various collections relying on diff --git a/src/library/scala/collection/mutable/GrowingBuilder.scala b/src/library/scala/collection/mutable/GrowingBuilder.scala index ba7ea60df1..c4b5e546aa 100644 --- a/src/library/scala/collection/mutable/GrowingBuilder.scala +++ b/src/library/scala/collection/mutable/GrowingBuilder.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package mutable import generic._ diff --git a/src/library/scala/collection/mutable/HashEntry.scala b/src/library/scala/collection/mutable/HashEntry.scala index 5cd976eb47..4c0f6a93e8 100644 --- a/src/library/scala/collection/mutable/HashEntry.scala +++ b/src/library/scala/collection/mutable/HashEntry.scala @@ -5,7 +5,8 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ -package scala.collection +package scala +package collection package mutable /** Class used internally. diff --git a/src/library/scala/collection/mutable/HashMap.scala b/src/library/scala/collection/mutable/HashMap.scala index 3ec84a17ab..6fca75ffea 100644 --- a/src/library/scala/collection/mutable/HashMap.scala +++ b/src/library/scala/collection/mutable/HashMap.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package mutable import generic._ diff --git a/src/library/scala/collection/mutable/HashSet.scala b/src/library/scala/collection/mutable/HashSet.scala index 753f7f8d01..886fee5a59 100644 --- a/src/library/scala/collection/mutable/HashSet.scala +++ b/src/library/scala/collection/mutable/HashSet.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package mutable import generic._ diff --git a/src/library/scala/collection/mutable/HashTable.scala b/src/library/scala/collection/mutable/HashTable.scala index 37d2b51a91..0479b51830 100644 --- a/src/library/scala/collection/mutable/HashTable.scala +++ b/src/library/scala/collection/mutable/HashTable.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package mutable /** This class can be used to construct data structures that are based diff --git a/src/library/scala/collection/mutable/History.scala b/src/library/scala/collection/mutable/History.scala index 34e8f7d5b8..19148c0ac2 100644 --- a/src/library/scala/collection/mutable/History.scala +++ b/src/library/scala/collection/mutable/History.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package mutable diff --git a/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala b/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala index 755eea831f..88e9e9db8f 100644 --- a/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala +++ b/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package mutable import scala.annotation.migration diff --git a/src/library/scala/collection/mutable/ImmutableSetAdaptor.scala b/src/library/scala/collection/mutable/ImmutableSetAdaptor.scala index 42c757d3bf..3e64747832 100644 --- a/src/library/scala/collection/mutable/ImmutableSetAdaptor.scala +++ b/src/library/scala/collection/mutable/ImmutableSetAdaptor.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package mutable diff --git a/src/library/scala/collection/mutable/IndexedSeq.scala b/src/library/scala/collection/mutable/IndexedSeq.scala index 4d094e697b..3d9630eea7 100644 --- a/src/library/scala/collection/mutable/IndexedSeq.scala +++ b/src/library/scala/collection/mutable/IndexedSeq.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package mutable import generic._ diff --git a/src/library/scala/collection/mutable/IndexedSeqLike.scala b/src/library/scala/collection/mutable/IndexedSeqLike.scala index 7b582eb5cb..4cf794c32f 100644 --- a/src/library/scala/collection/mutable/IndexedSeqLike.scala +++ b/src/library/scala/collection/mutable/IndexedSeqLike.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package mutable /** A subtrait of scala.collection.IndexedSeq which represents sequences diff --git a/src/library/scala/collection/mutable/IndexedSeqOptimized.scala b/src/library/scala/collection/mutable/IndexedSeqOptimized.scala index 80b527a7b9..09f0712862 100755 --- a/src/library/scala/collection/mutable/IndexedSeqOptimized.scala +++ b/src/library/scala/collection/mutable/IndexedSeqOptimized.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package mutable /** A subtrait of scala.collection.IndexedSeq which represents sequences diff --git a/src/library/scala/collection/mutable/IndexedSeqView.scala b/src/library/scala/collection/mutable/IndexedSeqView.scala index a88ed8f123..36c1076b87 100644 --- a/src/library/scala/collection/mutable/IndexedSeqView.scala +++ b/src/library/scala/collection/mutable/IndexedSeqView.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package mutable import generic._ diff --git a/src/library/scala/collection/mutable/Iterable.scala b/src/library/scala/collection/mutable/Iterable.scala index b79453e4e9..f7a794e357 100644 --- a/src/library/scala/collection/mutable/Iterable.scala +++ b/src/library/scala/collection/mutable/Iterable.scala @@ -5,7 +5,8 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ -package scala.collection +package scala +package collection package mutable import generic._ diff --git a/src/library/scala/collection/mutable/LazyBuilder.scala b/src/library/scala/collection/mutable/LazyBuilder.scala index 0b56c86ac4..ebee38b77f 100644 --- a/src/library/scala/collection/mutable/LazyBuilder.scala +++ b/src/library/scala/collection/mutable/LazyBuilder.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package mutable /** A builder that constructs its result lazily. Iterators or iterables to diff --git a/src/library/scala/collection/mutable/LinearSeq.scala b/src/library/scala/collection/mutable/LinearSeq.scala index f241a2f6d4..3fa10042ef 100644 --- a/src/library/scala/collection/mutable/LinearSeq.scala +++ b/src/library/scala/collection/mutable/LinearSeq.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package mutable import generic._ diff --git a/src/library/scala/collection/mutable/LinkedEntry.scala b/src/library/scala/collection/mutable/LinkedEntry.scala index e4e29122d8..296e7fde18 100644 --- a/src/library/scala/collection/mutable/LinkedEntry.scala +++ b/src/library/scala/collection/mutable/LinkedEntry.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package mutable /** Class for the linked hash map entry, used internally. diff --git a/src/library/scala/collection/mutable/LinkedHashMap.scala b/src/library/scala/collection/mutable/LinkedHashMap.scala index 14f30d74e8..536f320402 100644 --- a/src/library/scala/collection/mutable/LinkedHashMap.scala +++ b/src/library/scala/collection/mutable/LinkedHashMap.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package mutable import generic._ diff --git a/src/library/scala/collection/mutable/LinkedHashSet.scala b/src/library/scala/collection/mutable/LinkedHashSet.scala index 5641a78d46..d89566793f 100644 --- a/src/library/scala/collection/mutable/LinkedHashSet.scala +++ b/src/library/scala/collection/mutable/LinkedHashSet.scala @@ -7,7 +7,8 @@ \* */ -package scala.collection +package scala +package collection package mutable import generic._ diff --git a/src/library/scala/collection/mutable/LinkedList.scala b/src/library/scala/collection/mutable/LinkedList.scala index 29e6fdd375..a772f86d78 100644 --- a/src/library/scala/collection/mutable/LinkedList.scala +++ b/src/library/scala/collection/mutable/LinkedList.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package mutable import generic._ diff --git a/src/library/scala/collection/mutable/LinkedListLike.scala b/src/library/scala/collection/mutable/LinkedListLike.scala index 3003080060..6d4565026f 100644 --- a/src/library/scala/collection/mutable/LinkedListLike.scala +++ b/src/library/scala/collection/mutable/LinkedListLike.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package mutable import scala.annotation.tailrec diff --git a/src/library/scala/collection/mutable/ListBuffer.scala b/src/library/scala/collection/mutable/ListBuffer.scala index af1d7e4183..7f54692c8b 100644 --- a/src/library/scala/collection/mutable/ListBuffer.scala +++ b/src/library/scala/collection/mutable/ListBuffer.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package mutable import generic._ @@ -261,7 +262,7 @@ final class ListBuffer[A] * @param n the index which refers to the first element to remove. * @param count the number of elements to remove. */ - @annotation.migration("Invalid input values will be rejected in future releases.", "2.11") + @scala.annotation.migration("Invalid input values will be rejected in future releases.", "2.11") override def remove(n: Int, count: Int) { if (n >= len) return diff --git a/src/library/scala/collection/mutable/ListMap.scala b/src/library/scala/collection/mutable/ListMap.scala index 7f05deffc8..0b5d34cd81 100644 --- a/src/library/scala/collection/mutable/ListMap.scala +++ b/src/library/scala/collection/mutable/ListMap.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package mutable import generic._ diff --git a/src/library/scala/collection/mutable/Map.scala b/src/library/scala/collection/mutable/Map.scala index f68e4004f2..7280aaec25 100644 --- a/src/library/scala/collection/mutable/Map.scala +++ b/src/library/scala/collection/mutable/Map.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package mutable import generic._ diff --git a/src/library/scala/collection/mutable/MapBuilder.scala b/src/library/scala/collection/mutable/MapBuilder.scala index 8468e09e4d..a5a6b12ea9 100644 --- a/src/library/scala/collection/mutable/MapBuilder.scala +++ b/src/library/scala/collection/mutable/MapBuilder.scala @@ -7,7 +7,8 @@ \* */ -package scala.collection +package scala +package collection package mutable /** The canonical builder for immutable maps, working with the map's `+` method diff --git a/src/library/scala/collection/mutable/MapLike.scala b/src/library/scala/collection/mutable/MapLike.scala index 49d1e039f0..dbe32fdb79 100644 --- a/src/library/scala/collection/mutable/MapLike.scala +++ b/src/library/scala/collection/mutable/MapLike.scala @@ -7,12 +7,13 @@ \* */ -package scala.collection +package scala +package collection package mutable import generic._ import scala.annotation.migration -import parallel.mutable.ParMap +import scala.collection.parallel.mutable.ParMap /** A template trait for mutable maps. * $mapNote diff --git a/src/library/scala/collection/mutable/MapProxy.scala b/src/library/scala/collection/mutable/MapProxy.scala index c730e2b7c8..e4f106731c 100644 --- a/src/library/scala/collection/mutable/MapProxy.scala +++ b/src/library/scala/collection/mutable/MapProxy.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package mutable /** diff --git a/src/library/scala/collection/mutable/MultiMap.scala b/src/library/scala/collection/mutable/MultiMap.scala index 4635bfbe64..78dfc35268 100644 --- a/src/library/scala/collection/mutable/MultiMap.scala +++ b/src/library/scala/collection/mutable/MultiMap.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package mutable diff --git a/src/library/scala/collection/mutable/MutableList.scala b/src/library/scala/collection/mutable/MutableList.scala index 03110569c4..5727b12975 100644 --- a/src/library/scala/collection/mutable/MutableList.scala +++ b/src/library/scala/collection/mutable/MutableList.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package mutable import generic._ diff --git a/src/library/scala/collection/mutable/ObservableBuffer.scala b/src/library/scala/collection/mutable/ObservableBuffer.scala index 7a2fce9128..7fe794caaf 100644 --- a/src/library/scala/collection/mutable/ObservableBuffer.scala +++ b/src/library/scala/collection/mutable/ObservableBuffer.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package mutable import script._ diff --git a/src/library/scala/collection/mutable/ObservableMap.scala b/src/library/scala/collection/mutable/ObservableMap.scala index 3544275300..0dec6fa516 100644 --- a/src/library/scala/collection/mutable/ObservableMap.scala +++ b/src/library/scala/collection/mutable/ObservableMap.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package mutable import script._ diff --git a/src/library/scala/collection/mutable/ObservableSet.scala b/src/library/scala/collection/mutable/ObservableSet.scala index 81580316ff..acb6d92c8c 100644 --- a/src/library/scala/collection/mutable/ObservableSet.scala +++ b/src/library/scala/collection/mutable/ObservableSet.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package mutable import script._ diff --git a/src/library/scala/collection/mutable/PriorityQueue.scala b/src/library/scala/collection/mutable/PriorityQueue.scala index 4e8b923155..b5b1c1d006 100644 --- a/src/library/scala/collection/mutable/PriorityQueue.scala +++ b/src/library/scala/collection/mutable/PriorityQueue.scala @@ -6,9 +6,8 @@ ** |/ ** \* */ - - -package scala.collection +package scala +package collection package mutable import generic._ diff --git a/src/library/scala/collection/mutable/PriorityQueueProxy.scala b/src/library/scala/collection/mutable/PriorityQueueProxy.scala index ee54370731..4cb49be9b8 100644 --- a/src/library/scala/collection/mutable/PriorityQueueProxy.scala +++ b/src/library/scala/collection/mutable/PriorityQueueProxy.scala @@ -7,7 +7,8 @@ \* */ -package scala.collection +package scala +package collection package mutable /** This class servers as a proxy for priority queues. The diff --git a/src/library/scala/collection/mutable/Publisher.scala b/src/library/scala/collection/mutable/Publisher.scala index 8c2ef0d3a3..22bbea16ef 100644 --- a/src/library/scala/collection/mutable/Publisher.scala +++ b/src/library/scala/collection/mutable/Publisher.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package mutable diff --git a/src/library/scala/collection/mutable/Queue.scala b/src/library/scala/collection/mutable/Queue.scala index f1a5723818..e80aae2171 100644 --- a/src/library/scala/collection/mutable/Queue.scala +++ b/src/library/scala/collection/mutable/Queue.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package mutable import generic._ diff --git a/src/library/scala/collection/mutable/QueueProxy.scala b/src/library/scala/collection/mutable/QueueProxy.scala index 051b1219cd..bfc5edbeff 100644 --- a/src/library/scala/collection/mutable/QueueProxy.scala +++ b/src/library/scala/collection/mutable/QueueProxy.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package mutable /** `Queue` objects implement data structures that allow to diff --git a/src/library/scala/collection/mutable/RevertibleHistory.scala b/src/library/scala/collection/mutable/RevertibleHistory.scala index 9b8554669b..725a8113ec 100644 --- a/src/library/scala/collection/mutable/RevertibleHistory.scala +++ b/src/library/scala/collection/mutable/RevertibleHistory.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package mutable diff --git a/src/library/scala/collection/mutable/Seq.scala b/src/library/scala/collection/mutable/Seq.scala index 9d9399ebb4..11fbdd13f3 100644 --- a/src/library/scala/collection/mutable/Seq.scala +++ b/src/library/scala/collection/mutable/Seq.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package mutable import generic._ diff --git a/src/library/scala/collection/mutable/SeqLike.scala b/src/library/scala/collection/mutable/SeqLike.scala index ddfde536c9..6987066f2b 100644 --- a/src/library/scala/collection/mutable/SeqLike.scala +++ b/src/library/scala/collection/mutable/SeqLike.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package mutable import parallel.mutable.ParSeq diff --git a/src/library/scala/collection/mutable/Set.scala b/src/library/scala/collection/mutable/Set.scala index 023ff63056..4439880976 100644 --- a/src/library/scala/collection/mutable/Set.scala +++ b/src/library/scala/collection/mutable/Set.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package mutable import generic._ diff --git a/src/library/scala/collection/mutable/SetBuilder.scala b/src/library/scala/collection/mutable/SetBuilder.scala index 40f0b8932c..01bfdc96ed 100644 --- a/src/library/scala/collection/mutable/SetBuilder.scala +++ b/src/library/scala/collection/mutable/SetBuilder.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package mutable /** The canonical builder for mutable Sets. diff --git a/src/library/scala/collection/mutable/SetLike.scala b/src/library/scala/collection/mutable/SetLike.scala index 8dfcde16ce..073bc59f61 100644 --- a/src/library/scala/collection/mutable/SetLike.scala +++ b/src/library/scala/collection/mutable/SetLike.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package mutable import generic._ diff --git a/src/library/scala/collection/mutable/SetProxy.scala b/src/library/scala/collection/mutable/SetProxy.scala index c9f297509f..9568a54276 100644 --- a/src/library/scala/collection/mutable/SetProxy.scala +++ b/src/library/scala/collection/mutable/SetProxy.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package mutable /** This is a simple wrapper class for [[scala.collection.mutable.Set]]. diff --git a/src/library/scala/collection/mutable/SortedSet.scala b/src/library/scala/collection/mutable/SortedSet.scala index 41f2c6e39f..0f2fa75abd 100644 --- a/src/library/scala/collection/mutable/SortedSet.scala +++ b/src/library/scala/collection/mutable/SortedSet.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package mutable import generic._ diff --git a/src/library/scala/collection/mutable/Stack.scala b/src/library/scala/collection/mutable/Stack.scala index 6eef250f9d..34c6d1fbb9 100644 --- a/src/library/scala/collection/mutable/Stack.scala +++ b/src/library/scala/collection/mutable/Stack.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package mutable import generic._ diff --git a/src/library/scala/collection/mutable/StackProxy.scala b/src/library/scala/collection/mutable/StackProxy.scala index 8792738339..7d776b99c3 100644 --- a/src/library/scala/collection/mutable/StackProxy.scala +++ b/src/library/scala/collection/mutable/StackProxy.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package mutable /** A stack implements a data structure which allows to store and retrieve diff --git a/src/library/scala/collection/mutable/StringBuilder.scala b/src/library/scala/collection/mutable/StringBuilder.scala index 4d269a95b1..cfabd9171c 100644 --- a/src/library/scala/collection/mutable/StringBuilder.scala +++ b/src/library/scala/collection/mutable/StringBuilder.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package mutable import java.lang.{ StringBuilder => JavaStringBuilder } diff --git a/src/library/scala/collection/mutable/Subscriber.scala b/src/library/scala/collection/mutable/Subscriber.scala index 35d31d7316..c2aa9be72d 100644 --- a/src/library/scala/collection/mutable/Subscriber.scala +++ b/src/library/scala/collection/mutable/Subscriber.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package mutable /** `Subscriber[A, B]` objects may subscribe to events of type `A` diff --git a/src/library/scala/collection/mutable/SynchronizedBuffer.scala b/src/library/scala/collection/mutable/SynchronizedBuffer.scala index 14ec85b906..b97191137f 100644 --- a/src/library/scala/collection/mutable/SynchronizedBuffer.scala +++ b/src/library/scala/collection/mutable/SynchronizedBuffer.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package mutable import script._ diff --git a/src/library/scala/collection/mutable/SynchronizedMap.scala b/src/library/scala/collection/mutable/SynchronizedMap.scala index 5a3562cb22..643701eda9 100644 --- a/src/library/scala/collection/mutable/SynchronizedMap.scala +++ b/src/library/scala/collection/mutable/SynchronizedMap.scala @@ -6,9 +6,8 @@ ** |/ ** \* */ - - -package scala.collection +package scala +package collection package mutable import scala.annotation.migration diff --git a/src/library/scala/collection/mutable/SynchronizedPriorityQueue.scala b/src/library/scala/collection/mutable/SynchronizedPriorityQueue.scala index 52e55677bd..05676597db 100644 --- a/src/library/scala/collection/mutable/SynchronizedPriorityQueue.scala +++ b/src/library/scala/collection/mutable/SynchronizedPriorityQueue.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package mutable /** This class implements synchronized priority queues using a binary heap. diff --git a/src/library/scala/collection/mutable/SynchronizedQueue.scala b/src/library/scala/collection/mutable/SynchronizedQueue.scala index 57beab39b6..263c06b439 100644 --- a/src/library/scala/collection/mutable/SynchronizedQueue.scala +++ b/src/library/scala/collection/mutable/SynchronizedQueue.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package mutable diff --git a/src/library/scala/collection/mutable/SynchronizedSet.scala b/src/library/scala/collection/mutable/SynchronizedSet.scala index 27a696895d..441efea5fb 100644 --- a/src/library/scala/collection/mutable/SynchronizedSet.scala +++ b/src/library/scala/collection/mutable/SynchronizedSet.scala @@ -7,7 +7,8 @@ \* */ -package scala.collection +package scala +package collection package mutable import script._ diff --git a/src/library/scala/collection/mutable/SynchronizedStack.scala b/src/library/scala/collection/mutable/SynchronizedStack.scala index 09cdcca99e..c92a68ffde 100644 --- a/src/library/scala/collection/mutable/SynchronizedStack.scala +++ b/src/library/scala/collection/mutable/SynchronizedStack.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package mutable diff --git a/src/library/scala/collection/mutable/Traversable.scala b/src/library/scala/collection/mutable/Traversable.scala index e36ffc847f..d7ea376d28 100644 --- a/src/library/scala/collection/mutable/Traversable.scala +++ b/src/library/scala/collection/mutable/Traversable.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package mutable import generic._ diff --git a/src/library/scala/collection/mutable/TreeSet.scala b/src/library/scala/collection/mutable/TreeSet.scala index 147bc85383..ea5b859367 100644 --- a/src/library/scala/collection/mutable/TreeSet.scala +++ b/src/library/scala/collection/mutable/TreeSet.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package mutable import generic._ diff --git a/src/library/scala/collection/mutable/Undoable.scala b/src/library/scala/collection/mutable/Undoable.scala index 0c0e8fed3e..482d618165 100644 --- a/src/library/scala/collection/mutable/Undoable.scala +++ b/src/library/scala/collection/mutable/Undoable.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package mutable diff --git a/src/library/scala/collection/mutable/UnrolledBuffer.scala b/src/library/scala/collection/mutable/UnrolledBuffer.scala index ac634f43aa..292705c02a 100644 --- a/src/library/scala/collection/mutable/UnrolledBuffer.scala +++ b/src/library/scala/collection/mutable/UnrolledBuffer.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection.mutable +package scala +package collection.mutable import scala.collection.AbstractIterator import scala.collection.Iterator diff --git a/src/library/scala/collection/mutable/WeakHashMap.scala b/src/library/scala/collection/mutable/WeakHashMap.scala index 70e428c9b6..433d054bfc 100644 --- a/src/library/scala/collection/mutable/WeakHashMap.scala +++ b/src/library/scala/collection/mutable/WeakHashMap.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package mutable import generic._ diff --git a/src/library/scala/collection/mutable/WrappedArray.scala b/src/library/scala/collection/mutable/WrappedArray.scala index b83724090c..53fca9f779 100644 --- a/src/library/scala/collection/mutable/WrappedArray.scala +++ b/src/library/scala/collection/mutable/WrappedArray.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package mutable import scala.reflect.ClassTag diff --git a/src/library/scala/collection/mutable/WrappedArrayBuilder.scala b/src/library/scala/collection/mutable/WrappedArrayBuilder.scala index 55328a5d3d..bfe95a11ab 100644 --- a/src/library/scala/collection/mutable/WrappedArrayBuilder.scala +++ b/src/library/scala/collection/mutable/WrappedArrayBuilder.scala @@ -8,7 +8,8 @@ -package scala.collection +package scala +package collection package mutable import scala.reflect.ClassTag diff --git a/src/library/scala/collection/parallel/Combiner.scala b/src/library/scala/collection/parallel/Combiner.scala index 00e20e7616..68df572517 100644 --- a/src/library/scala/collection/parallel/Combiner.scala +++ b/src/library/scala/collection/parallel/Combiner.scala @@ -7,7 +7,8 @@ \* */ -package scala.collection.parallel +package scala +package collection.parallel import scala.collection.Parallel @@ -33,11 +34,11 @@ import scala.collection.generic.Sizing * @since 2.9 */ trait Combiner[-Elem, +To] extends Builder[Elem, To] with Sizing with Parallel { - + @transient @volatile var _combinerTaskSupport = defaultTaskSupport - + def combinerTaskSupport = { val cts = _combinerTaskSupport if (cts eq null) { @@ -45,9 +46,9 @@ trait Combiner[-Elem, +To] extends Builder[Elem, To] with Sizing with Parallel { defaultTaskSupport } else cts } - + def combinerTaskSupport_=(cts: TaskSupport) = _combinerTaskSupport = cts - + /** Combines the contents of the receiver builder and the `other` builder, * producing a new builder containing both their elements. * @@ -81,7 +82,7 @@ trait Combiner[-Elem, +To] extends Builder[Elem, To] with Sizing with Parallel { * By default, this method returns `false`. */ def canBeShared: Boolean = false - + /** Constructs the result and sets the appropriate tasksupport object to the resulting collection * if this is applicable. */ @@ -89,7 +90,7 @@ trait Combiner[-Elem, +To] extends Builder[Elem, To] with Sizing with Parallel { val res = result() setTaskSupport(res, combinerTaskSupport) } - + } diff --git a/src/library/scala/collection/parallel/ParIterable.scala b/src/library/scala/collection/parallel/ParIterable.scala index f170b944eb..2ceeb18eef 100644 --- a/src/library/scala/collection/parallel/ParIterable.scala +++ b/src/library/scala/collection/parallel/ParIterable.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection.parallel +package scala +package collection.parallel import scala.collection.GenIterable import scala.collection.generic._ diff --git a/src/library/scala/collection/parallel/ParIterableLike.scala b/src/library/scala/collection/parallel/ParIterableLike.scala index 961556faff..a0b42f248e 100644 --- a/src/library/scala/collection/parallel/ParIterableLike.scala +++ b/src/library/scala/collection/parallel/ParIterableLike.scala @@ -6,11 +6,8 @@ ** |/ ** \* */ - -package scala.collection.parallel - - - +package scala +package collection.parallel import scala.collection.mutable.Builder import scala.collection.mutable.ArrayBuffer diff --git a/src/library/scala/collection/parallel/ParIterableView.scala b/src/library/scala/collection/parallel/ParIterableView.scala index 7644e1bd12..6dce19db19 100644 --- a/src/library/scala/collection/parallel/ParIterableView.scala +++ b/src/library/scala/collection/parallel/ParIterableView.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection.parallel +package scala +package collection.parallel import scala.collection.{ Parallel, IterableView, GenIterableView, Iterator } import scala.collection.generic.CanCombineFrom diff --git a/src/library/scala/collection/parallel/ParIterableViewLike.scala b/src/library/scala/collection/parallel/ParIterableViewLike.scala index 0567e7b396..1ec0ff9c32 100644 --- a/src/library/scala/collection/parallel/ParIterableViewLike.scala +++ b/src/library/scala/collection/parallel/ParIterableViewLike.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection.parallel +package scala +package collection.parallel import scala.collection.Parallel import scala.collection.{ IterableView, IterableViewLike } diff --git a/src/library/scala/collection/parallel/ParMap.scala b/src/library/scala/collection/parallel/ParMap.scala index 1f27ae830a..9f92e6c1e8 100644 --- a/src/library/scala/collection/parallel/ParMap.scala +++ b/src/library/scala/collection/parallel/ParMap.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection.parallel +package scala +package collection.parallel import scala.collection.Map import scala.collection.GenMap diff --git a/src/library/scala/collection/parallel/ParMapLike.scala b/src/library/scala/collection/parallel/ParMapLike.scala index 798ba71b95..ee14324c41 100644 --- a/src/library/scala/collection/parallel/ParMapLike.scala +++ b/src/library/scala/collection/parallel/ParMapLike.scala @@ -7,7 +7,8 @@ \* */ -package scala.collection.parallel +package scala +package collection.parallel diff --git a/src/library/scala/collection/parallel/ParSeq.scala b/src/library/scala/collection/parallel/ParSeq.scala index dee523ad89..b4a30e5dc2 100644 --- a/src/library/scala/collection/parallel/ParSeq.scala +++ b/src/library/scala/collection/parallel/ParSeq.scala @@ -6,10 +6,8 @@ ** |/ ** \* */ - -package scala.collection.parallel - - +package scala +package collection.parallel import scala.collection.generic.GenericCompanion import scala.collection.generic.GenericParCompanion @@ -53,26 +51,3 @@ object ParSeq extends ParFactory[ParSeq] { def newCombiner[T]: Combiner[T, ParSeq[T]] = ParArrayCombiner[T] } - - - - - - - - - - - - - - - - - - - - - - - diff --git a/src/library/scala/collection/parallel/ParSeqLike.scala b/src/library/scala/collection/parallel/ParSeqLike.scala index 68bc1bc12c..6693e30fcd 100644 --- a/src/library/scala/collection/parallel/ParSeqLike.scala +++ b/src/library/scala/collection/parallel/ParSeqLike.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection.parallel +package scala +package collection.parallel import scala.collection.{ Parallel, SeqLike, GenSeqLike, GenSeq, GenIterable, Iterator } import scala.collection.generic.DefaultSignalling diff --git a/src/library/scala/collection/parallel/ParSeqView.scala b/src/library/scala/collection/parallel/ParSeqView.scala index 9acc4b0b73..b80994514b 100644 --- a/src/library/scala/collection/parallel/ParSeqView.scala +++ b/src/library/scala/collection/parallel/ParSeqView.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection.parallel +package scala +package collection.parallel import scala.collection.{ SeqView, Parallel, Iterator } import scala.collection.generic.CanCombineFrom diff --git a/src/library/scala/collection/parallel/ParSeqViewLike.scala b/src/library/scala/collection/parallel/ParSeqViewLike.scala index f3dbe20e67..9d30a052de 100644 --- a/src/library/scala/collection/parallel/ParSeqViewLike.scala +++ b/src/library/scala/collection/parallel/ParSeqViewLike.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection.parallel +package scala +package collection.parallel import scala.collection.{ Parallel, SeqView, SeqViewLike, GenSeqView, GenSeqViewLike, GenSeq } import scala.collection.{ GenIterable, GenTraversable, GenTraversableOnce, Iterator } diff --git a/src/library/scala/collection/parallel/ParSet.scala b/src/library/scala/collection/parallel/ParSet.scala index bc6d5c6245..ba3d23f0e4 100644 --- a/src/library/scala/collection/parallel/ParSet.scala +++ b/src/library/scala/collection/parallel/ParSet.scala @@ -6,17 +6,10 @@ ** |/ ** \* */ +package scala +package collection +package parallel -package scala.collection.parallel - - - - - - - -import scala.collection.Set -import scala.collection.GenSet import scala.collection.generic._ /** A template trait for parallel sets. @@ -29,12 +22,12 @@ import scala.collection.generic._ * @since 2.9 */ trait ParSet[T] -extends GenSet[T] + extends GenSet[T] with GenericParTemplate[T, ParSet] with ParIterable[T] with ParSetLike[T, ParSet[T], Set[T]] -{ -self => +{ self => + override def empty: ParSet[T] = mutable.ParHashSet[T]() //protected[this] override def newCombiner: Combiner[T, ParSet[T]] = ParSet.newCombiner[T] @@ -44,39 +37,8 @@ self => override def stringPrefix = "ParSet" } - - object ParSet extends ParSetFactory[ParSet] { def newCombiner[T]: Combiner[T, ParSet[T]] = mutable.ParHashSetCombiner[T] implicit def canBuildFrom[T]: CanCombineFrom[Coll, T, ParSet[T]] = new GenericCanCombineFrom[T] } - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/src/library/scala/collection/parallel/ParSetLike.scala b/src/library/scala/collection/parallel/ParSetLike.scala index 20a5f693ce..a50d2ae430 100644 --- a/src/library/scala/collection/parallel/ParSetLike.scala +++ b/src/library/scala/collection/parallel/ParSetLike.scala @@ -7,7 +7,8 @@ \* */ -package scala.collection.parallel +package scala +package collection.parallel diff --git a/src/library/scala/collection/parallel/PreciseSplitter.scala b/src/library/scala/collection/parallel/PreciseSplitter.scala index 42563f4dc9..2eb202ce05 100644 --- a/src/library/scala/collection/parallel/PreciseSplitter.scala +++ b/src/library/scala/collection/parallel/PreciseSplitter.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection.parallel +package scala +package collection.parallel import scala.collection.Seq diff --git a/src/library/scala/collection/parallel/RemainsIterator.scala b/src/library/scala/collection/parallel/RemainsIterator.scala index a3a47e2e40..5f2ceac0e0 100644 --- a/src/library/scala/collection/parallel/RemainsIterator.scala +++ b/src/library/scala/collection/parallel/RemainsIterator.scala @@ -6,10 +6,8 @@ ** |/ ** \* */ - -package scala.collection.parallel - - +package scala +package collection.parallel import scala.collection.Parallel import scala.collection.generic.Signalling @@ -21,8 +19,6 @@ import scala.collection.Iterator.empty import scala.collection.GenTraversableOnce import scala.collection.parallel.immutable.repetition - - private[collection] trait RemainsIterator[+T] extends Iterator[T] { /** The number of elements this iterator has yet to iterate. * This method doesn't change the state of the iterator. @@ -35,7 +31,6 @@ private[collection] trait RemainsIterator[+T] extends Iterator[T] { def isRemainingCheap = true } - /** Augments iterators with additional methods, mostly transformers, * assuming they iterate an iterable collection. * @@ -532,10 +527,8 @@ self => } def zipAllParSeq[S, U >: T, R >: S](that: SeqSplitter[S], thisElem: U, thatElem: R) = new ZippedAll[U, R](that, thisElem, thatElem) - } - /** Parallel sequence iterators allow splitting into arbitrary subsets. * * @tparam T type of the elements iterated. @@ -676,37 +669,3 @@ self => def patchParSeq[U >: T](from: Int, patchElems: SeqSplitter[U], replaced: Int) = new Patched(from, patchElems, replaced) } - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/src/library/scala/collection/parallel/Splitter.scala b/src/library/scala/collection/parallel/Splitter.scala index 458742df96..8329f15d88 100644 --- a/src/library/scala/collection/parallel/Splitter.scala +++ b/src/library/scala/collection/parallel/Splitter.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection.parallel +package scala +package collection.parallel import scala.collection.{ Seq, Iterator } diff --git a/src/library/scala/collection/parallel/TaskSupport.scala b/src/library/scala/collection/parallel/TaskSupport.scala index 1ab41bd296..84bb5e425b 100644 --- a/src/library/scala/collection/parallel/TaskSupport.scala +++ b/src/library/scala/collection/parallel/TaskSupport.scala @@ -7,7 +7,8 @@ \* */ -package scala.collection.parallel +package scala +package collection.parallel diff --git a/src/library/scala/collection/parallel/Tasks.scala b/src/library/scala/collection/parallel/Tasks.scala index 487b3d46d3..b23131c773 100644 --- a/src/library/scala/collection/parallel/Tasks.scala +++ b/src/library/scala/collection/parallel/Tasks.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection.parallel +package scala +package collection.parallel diff --git a/src/library/scala/collection/parallel/immutable/ParHashMap.scala b/src/library/scala/collection/parallel/immutable/ParHashMap.scala index f3be47ea03..854d0ba918 100644 --- a/src/library/scala/collection/parallel/immutable/ParHashMap.scala +++ b/src/library/scala/collection/parallel/immutable/ParHashMap.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection.parallel.immutable +package scala +package collection.parallel.immutable diff --git a/src/library/scala/collection/parallel/immutable/ParHashSet.scala b/src/library/scala/collection/parallel/immutable/ParHashSet.scala index 4f34993b85..65a632470e 100644 --- a/src/library/scala/collection/parallel/immutable/ParHashSet.scala +++ b/src/library/scala/collection/parallel/immutable/ParHashSet.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection.parallel.immutable +package scala +package collection.parallel.immutable diff --git a/src/library/scala/collection/parallel/immutable/ParIterable.scala b/src/library/scala/collection/parallel/immutable/ParIterable.scala index ec07e44c4d..417622facc 100644 --- a/src/library/scala/collection/parallel/immutable/ParIterable.scala +++ b/src/library/scala/collection/parallel/immutable/ParIterable.scala @@ -6,13 +6,11 @@ ** |/ ** \* */ - -package scala.collection +package scala +package collection package parallel.immutable - import scala.collection.generic._ - import scala.collection.parallel.ParIterableLike import scala.collection.parallel.Combiner @@ -28,22 +26,18 @@ import scala.collection.parallel.Combiner * @since 2.9 */ trait ParIterable[+T] -extends scala.collection/*.immutable*/.GenIterable[T] +extends scala.collection.GenIterable[T] with scala.collection.parallel.ParIterable[T] with GenericParTemplate[T, ParIterable] with ParIterableLike[T, ParIterable[T], scala.collection.immutable.Iterable[T]] with Immutable { override def companion: GenericCompanion[ParIterable] with GenericParCompanion[ParIterable] = ParIterable - // if `immutable.ParIterableLike` is introduced, please move these 4 methods there override def toIterable: ParIterable[T] = this - override def toSeq: ParSeq[T] = toParCollection[T, ParSeq[T]](() => ParSeq.newCombiner[T]) - } - /** $factoryInfo */ object ParIterable extends ParFactory[ParIterable] { @@ -51,21 +45,5 @@ object ParIterable extends ParFactory[ParIterable] { new GenericCanCombineFrom[T] def newBuilder[T]: Combiner[T, ParIterable[T]] = ParVector.newBuilder[T] - def newCombiner[T]: Combiner[T, ParIterable[T]] = ParVector.newCombiner[T] - } - - - - - - - - - - - - - - diff --git a/src/library/scala/collection/parallel/immutable/ParMap.scala b/src/library/scala/collection/parallel/immutable/ParMap.scala index e904a7616b..4d99006d0f 100644 --- a/src/library/scala/collection/parallel/immutable/ParMap.scala +++ b/src/library/scala/collection/parallel/immutable/ParMap.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package parallel.immutable import scala.collection.generic.ParMapFactory diff --git a/src/library/scala/collection/parallel/immutable/ParRange.scala b/src/library/scala/collection/parallel/immutable/ParRange.scala index 78bbad5933..ec90de3a7d 100644 --- a/src/library/scala/collection/parallel/immutable/ParRange.scala +++ b/src/library/scala/collection/parallel/immutable/ParRange.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection.parallel.immutable +package scala +package collection.parallel.immutable import scala.collection.immutable.Range import scala.collection.parallel.Combiner @@ -106,7 +107,7 @@ self => cb } } - + } object ParRange { diff --git a/src/library/scala/collection/parallel/immutable/ParSeq.scala b/src/library/scala/collection/parallel/immutable/ParSeq.scala index b54a5f0205..6e98b3102d 100644 --- a/src/library/scala/collection/parallel/immutable/ParSeq.scala +++ b/src/library/scala/collection/parallel/immutable/ParSeq.scala @@ -7,7 +7,8 @@ \* */ -package scala.collection +package scala +package collection package parallel.immutable diff --git a/src/library/scala/collection/parallel/immutable/ParSet.scala b/src/library/scala/collection/parallel/immutable/ParSet.scala index aba8486ab5..7837d6f264 100644 --- a/src/library/scala/collection/parallel/immutable/ParSet.scala +++ b/src/library/scala/collection/parallel/immutable/ParSet.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package parallel.immutable import scala.collection.generic._ diff --git a/src/library/scala/collection/parallel/immutable/ParVector.scala b/src/library/scala/collection/parallel/immutable/ParVector.scala index 1ee7f4ae69..548e7112c7 100644 --- a/src/library/scala/collection/parallel/immutable/ParVector.scala +++ b/src/library/scala/collection/parallel/immutable/ParVector.scala @@ -7,7 +7,8 @@ \* */ -package scala.collection +package scala +package collection package parallel.immutable diff --git a/src/library/scala/collection/parallel/immutable/package.scala b/src/library/scala/collection/parallel/immutable/package.scala index 5ca0724ffc..8fd84eaf4d 100644 --- a/src/library/scala/collection/parallel/immutable/package.scala +++ b/src/library/scala/collection/parallel/immutable/package.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection.parallel +package scala +package collection.parallel package immutable { /** A (parallel) sequence consisting of `length` elements `elem`. Used in the `padTo` method. diff --git a/src/library/scala/collection/parallel/mutable/LazyCombiner.scala b/src/library/scala/collection/parallel/mutable/LazyCombiner.scala index 12b2bc5008..cc25b5b4b2 100644 --- a/src/library/scala/collection/parallel/mutable/LazyCombiner.scala +++ b/src/library/scala/collection/parallel/mutable/LazyCombiner.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection.parallel.mutable +package scala +package collection.parallel.mutable import scala.collection.generic.Growable import scala.collection.generic.Sizing diff --git a/src/library/scala/collection/parallel/mutable/ParArray.scala b/src/library/scala/collection/parallel/mutable/ParArray.scala index f9563cacc7..d0d022db4b 100644 --- a/src/library/scala/collection/parallel/mutable/ParArray.scala +++ b/src/library/scala/collection/parallel/mutable/ParArray.scala @@ -29,8 +29,6 @@ import scala.collection.mutable.Builder import scala.collection.GenTraversableOnce import scala.reflect.ClassTag - - /** Parallel sequence holding elements in a linear array. * * `ParArray` is a parallel sequence with a predefined size. The size of the array @@ -702,7 +700,7 @@ object ParArray extends ParFactory[ParArray] { private def wrapOrRebuild[T](arr: AnyRef, sz: Int) = arr match { case arr: Array[AnyRef] => new ParArray[T](new ExposedArraySeq[T](arr, sz)) - case _ => new ParArray[T](new ExposedArraySeq[T](runtime.ScalaRunTime.toObjectArray(arr), sz)) + case _ => new ParArray[T](new ExposedArraySeq[T](scala.runtime.ScalaRunTime.toObjectArray(arr), sz)) } def createFromCopy[T <: AnyRef : ClassTag](arr: Array[T]): ParArray[T] = { @@ -720,27 +718,3 @@ object ParArray extends ParFactory[ParArray] { } } - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/src/library/scala/collection/parallel/mutable/ParFlatHashTable.scala b/src/library/scala/collection/parallel/mutable/ParFlatHashTable.scala index aa790dd548..afc2d6e987 100644 --- a/src/library/scala/collection/parallel/mutable/ParFlatHashTable.scala +++ b/src/library/scala/collection/parallel/mutable/ParFlatHashTable.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package parallel.mutable import scala.collection.parallel.IterableSplitter diff --git a/src/library/scala/collection/parallel/mutable/ParHashMap.scala b/src/library/scala/collection/parallel/mutable/ParHashMap.scala index e94db89865..42a3302c91 100644 --- a/src/library/scala/collection/parallel/mutable/ParHashMap.scala +++ b/src/library/scala/collection/parallel/mutable/ParHashMap.scala @@ -7,7 +7,8 @@ \* */ -package scala.collection.parallel +package scala +package collection.parallel package mutable diff --git a/src/library/scala/collection/parallel/mutable/ParHashSet.scala b/src/library/scala/collection/parallel/mutable/ParHashSet.scala index 0287171369..1e3d57e0e5 100644 --- a/src/library/scala/collection/parallel/mutable/ParHashSet.scala +++ b/src/library/scala/collection/parallel/mutable/ParHashSet.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection.parallel.mutable +package scala +package collection.parallel.mutable diff --git a/src/library/scala/collection/parallel/mutable/ParHashTable.scala b/src/library/scala/collection/parallel/mutable/ParHashTable.scala index 5aa1dba17c..a6fada3d42 100644 --- a/src/library/scala/collection/parallel/mutable/ParHashTable.scala +++ b/src/library/scala/collection/parallel/mutable/ParHashTable.scala @@ -7,7 +7,8 @@ \* */ -package scala.collection +package scala +package collection package parallel.mutable diff --git a/src/library/scala/collection/parallel/mutable/ParIterable.scala b/src/library/scala/collection/parallel/mutable/ParIterable.scala index d76e4b1745..4659149106 100644 --- a/src/library/scala/collection/parallel/mutable/ParIterable.scala +++ b/src/library/scala/collection/parallel/mutable/ParIterable.scala @@ -6,12 +6,12 @@ ** |/ ** \* */ -package scala.collection.parallel.mutable - +package scala +package collection +package parallel.mutable import scala.collection.generic._ -import scala.collection.parallel.ParIterableLike -import scala.collection.parallel.Combiner +import scala.collection.parallel.{ ParIterableLike, Combiner } /** A template trait for mutable parallel iterable collections. * @@ -24,7 +24,7 @@ import scala.collection.parallel.Combiner * @author Aleksandar Prokopec * @since 2.9 */ -trait ParIterable[T] extends scala.collection/*.mutable*/.GenIterable[T] +trait ParIterable[T] extends scala.collection.GenIterable[T] with scala.collection.parallel.ParIterable[T] with GenericParTemplate[T, ParIterable] with ParIterableLike[T, ParIterable[T], Iterable[T]] @@ -43,24 +43,8 @@ trait ParIterable[T] extends scala.collection/*.mutable*/.GenIterable[T] /** $factoryInfo */ object ParIterable extends ParFactory[ParIterable] { - implicit def canBuildFrom[T]: CanCombineFrom[Coll, T, ParIterable[T]] = - new GenericCanCombineFrom[T] + implicit def canBuildFrom[T]: CanCombineFrom[Coll, T, ParIterable[T]] = new GenericCanCombineFrom[T] def newBuilder[T]: Combiner[T, ParIterable[T]] = ParArrayCombiner[T] - def newCombiner[T]: Combiner[T, ParIterable[T]] = ParArrayCombiner[T] } - - - - - - - - - - - - - - diff --git a/src/library/scala/collection/parallel/mutable/ParMap.scala b/src/library/scala/collection/parallel/mutable/ParMap.scala index 2250a38466..e43e72e559 100644 --- a/src/library/scala/collection/parallel/mutable/ParMap.scala +++ b/src/library/scala/collection/parallel/mutable/ParMap.scala @@ -6,17 +6,13 @@ ** |/ ** \* */ - -package scala.collection.parallel.mutable - - - +package scala +package collection +package parallel.mutable import scala.collection.generic._ import scala.collection.parallel.Combiner - - /** A template trait for mutable parallel maps. * * $sideeffects @@ -28,11 +24,11 @@ import scala.collection.parallel.Combiner * @since 2.9 */ trait ParMap[K, V] -extends scala.collection/*.mutable*/.GenMap[K, V] - with scala.collection.parallel.ParMap[K, V] - with /* mutable */ ParIterable[(K, V)] +extends GenMap[K, V] + with parallel.ParMap[K, V] + with ParIterable[(K, V)] with GenericParMapTemplate[K, V, ParMap] - with /* mutable */ ParMapLike[K, V, ParMap[K, V], scala.collection.mutable.Map[K, V]] + with ParMapLike[K, V, ParMap[K, V], mutable.Map[K, V]] { protected[this] override def newCombiner: Combiner[(K, V), ParMap[K, V]] = ParMap.newCombiner[K, V] @@ -63,11 +59,8 @@ extends scala.collection/*.mutable*/.GenMap[K, V] * @return a wrapper of the map with a default value */ def withDefaultValue(d: V): scala.collection.parallel.mutable.ParMap[K, V] = new ParMap.WithDefault[K, V](this, x => d) - } - - object ParMap extends ParMapFactory[ParMap] { def empty[K, V]: ParMap[K, V] = new ParHashMap[K, V] @@ -94,22 +87,3 @@ object ParMap extends ParMapFactory[ParMap] { override def withDefaultValue(d: V): ParMap[K, V] = new WithDefault[K, V](underlying, x => d) } } - - - - - - - - - - - - - - - - - - - diff --git a/src/library/scala/collection/parallel/mutable/ParMapLike.scala b/src/library/scala/collection/parallel/mutable/ParMapLike.scala index 08bc706c8a..d96b5482fe 100644 --- a/src/library/scala/collection/parallel/mutable/ParMapLike.scala +++ b/src/library/scala/collection/parallel/mutable/ParMapLike.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection.parallel +package scala +package collection.parallel package mutable diff --git a/src/library/scala/collection/parallel/mutable/ParSeq.scala b/src/library/scala/collection/parallel/mutable/ParSeq.scala index 8a55ab83f1..35be2669f8 100644 --- a/src/library/scala/collection/parallel/mutable/ParSeq.scala +++ b/src/library/scala/collection/parallel/mutable/ParSeq.scala @@ -6,9 +6,8 @@ ** |/ ** \* */ - -package scala.collection.parallel.mutable - +package scala +package collection.parallel.mutable import scala.collection.generic.GenericParTemplate import scala.collection.generic.GenericCompanion @@ -51,18 +50,3 @@ object ParSeq extends ParFactory[ParSeq] { def newCombiner[T]: Combiner[T, ParSeq[T]] = ParArrayCombiner[T] } - - - - - - - - - - - - - - - diff --git a/src/library/scala/collection/parallel/mutable/ParSet.scala b/src/library/scala/collection/parallel/mutable/ParSet.scala index ca41852512..9367f1424d 100644 --- a/src/library/scala/collection/parallel/mutable/ParSet.scala +++ b/src/library/scala/collection/parallel/mutable/ParSet.scala @@ -6,10 +6,8 @@ ** |/ ** \* */ - -package scala.collection.parallel.mutable - - +package scala +package collection.parallel.mutable import scala.collection.generic._ import scala.collection.parallel.Combiner @@ -46,4 +44,3 @@ object ParSet extends ParSetFactory[ParSet] { override def newCombiner[T]: Combiner[T, ParSet[T]] = ParHashSet.newCombiner } - diff --git a/src/library/scala/collection/parallel/mutable/ParSetLike.scala b/src/library/scala/collection/parallel/mutable/ParSetLike.scala index 0941229124..1cfc14b094 100644 --- a/src/library/scala/collection/parallel/mutable/ParSetLike.scala +++ b/src/library/scala/collection/parallel/mutable/ParSetLike.scala @@ -7,7 +7,8 @@ \* */ -package scala.collection +package scala +package collection package parallel.mutable import scala.collection.mutable.Cloneable diff --git a/src/library/scala/collection/parallel/mutable/ParTrieMap.scala b/src/library/scala/collection/parallel/mutable/ParTrieMap.scala index 60f4709a8c..82f2717132 100644 --- a/src/library/scala/collection/parallel/mutable/ParTrieMap.scala +++ b/src/library/scala/collection/parallel/mutable/ParTrieMap.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection.parallel.mutable +package scala +package collection.parallel.mutable diff --git a/src/library/scala/collection/parallel/mutable/ResizableParArrayCombiner.scala b/src/library/scala/collection/parallel/mutable/ResizableParArrayCombiner.scala index 0b9b51bc5b..79322c85b1 100644 --- a/src/library/scala/collection/parallel/mutable/ResizableParArrayCombiner.scala +++ b/src/library/scala/collection/parallel/mutable/ResizableParArrayCombiner.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection.parallel.mutable +package scala +package collection.parallel.mutable diff --git a/src/library/scala/collection/parallel/mutable/UnrolledParArrayCombiner.scala b/src/library/scala/collection/parallel/mutable/UnrolledParArrayCombiner.scala index 7766f07e23..6b6ea03a6d 100644 --- a/src/library/scala/collection/parallel/mutable/UnrolledParArrayCombiner.scala +++ b/src/library/scala/collection/parallel/mutable/UnrolledParArrayCombiner.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection.parallel.mutable +package scala +package collection.parallel.mutable import scala.collection.generic.Sizing import scala.collection.mutable.ArraySeq diff --git a/src/library/scala/collection/parallel/mutable/package.scala b/src/library/scala/collection/parallel/mutable/package.scala index 2494d0907e..81121d9398 100644 --- a/src/library/scala/collection/parallel/mutable/package.scala +++ b/src/library/scala/collection/parallel/mutable/package.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection.parallel +package scala +package collection.parallel import scala.collection.mutable.ArrayBuffer import scala.collection.mutable.ArraySeq diff --git a/src/library/scala/collection/script/Location.scala b/src/library/scala/collection/script/Location.scala index cd64fa2d73..e485737972 100644 --- a/src/library/scala/collection/script/Location.scala +++ b/src/library/scala/collection/script/Location.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package script /** Class `Location` describes locations in messages implemented by diff --git a/src/library/scala/collection/script/Message.scala b/src/library/scala/collection/script/Message.scala index 7428cd2b81..dc3e74e170 100644 --- a/src/library/scala/collection/script/Message.scala +++ b/src/library/scala/collection/script/Message.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package script import mutable.ArrayBuffer diff --git a/src/library/scala/collection/script/Scriptable.scala b/src/library/scala/collection/script/Scriptable.scala index ceaf19a464..110a0f4d82 100644 --- a/src/library/scala/collection/script/Scriptable.scala +++ b/src/library/scala/collection/script/Scriptable.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.collection +package scala +package collection package script /** Classes that mix in the `Scriptable` class allow messages to be sent to diff --git a/src/library/scala/compat/Platform.scala b/src/library/scala/compat/Platform.scala index 88cb1506ae..875d811b9b 100644 --- a/src/library/scala/compat/Platform.scala +++ b/src/library/scala/compat/Platform.scala @@ -6,9 +6,8 @@ ** |/ ** \* */ - - -package scala.compat +package scala +package compat import java.lang.System diff --git a/src/library/scala/concurrent/Future.scala b/src/library/scala/concurrent/Future.scala index 95b393dd0e..c444050e3d 100644 --- a/src/library/scala/concurrent/Future.scala +++ b/src/library/scala/concurrent/Future.scala @@ -71,7 +71,7 @@ import scala.reflect.ClassTag * val g = future { 3 } * val h = for { * x: Int <- f // returns Future(5) - * y: Int <- g // returns Future(5) + * y: Int <- g // returns Future(3) * } yield x + y * }}} * diff --git a/src/library/scala/concurrent/FutureTaskRunner.scala b/src/library/scala/concurrent/FutureTaskRunner.scala index 9e27ce65b9..089e67cedd 100644 --- a/src/library/scala/concurrent/FutureTaskRunner.scala +++ b/src/library/scala/concurrent/FutureTaskRunner.scala @@ -16,7 +16,7 @@ import scala.language.{implicitConversions, higherKinds} * @author Philipp Haller */ @deprecated("Use `ExecutionContext` instead.", "2.10.0") -trait FutureTaskRunner extends TaskRunner { +private[scala] trait FutureTaskRunner extends TaskRunner { /** The type of the futures that the underlying task runner supports. */ diff --git a/src/library/scala/concurrent/ManagedBlocker.scala b/src/library/scala/concurrent/ManagedBlocker.scala index 7b2966c663..b5a6e21893 100644 --- a/src/library/scala/concurrent/ManagedBlocker.scala +++ b/src/library/scala/concurrent/ManagedBlocker.scala @@ -13,7 +13,7 @@ package scala.concurrent * @author Philipp Haller */ @deprecated("Use `blocking` instead.", "2.10.0") -trait ManagedBlocker { +private[scala] trait ManagedBlocker { /** * Possibly blocks the current thread, for example waiting for diff --git a/src/library/scala/concurrent/SyncVar.scala b/src/library/scala/concurrent/SyncVar.scala index 6d25ffe19e..d22471ac0f 100644 --- a/src/library/scala/concurrent/SyncVar.scala +++ b/src/library/scala/concurrent/SyncVar.scala @@ -79,7 +79,7 @@ class SyncVar[A] { // whether or not the SyncVar is already defined. So, set has been // deprecated in order to eventually be able to make "setting" private @deprecated("Use `put` instead, as `set` is potentionally error-prone", "2.10.0") - def set(x: A): Unit = setVal(x) + private[scala] def set(x: A): Unit = setVal(x) /** Places a value in the SyncVar. If the SyncVar already has a stored value, * it waits until another thread takes it */ @@ -98,7 +98,7 @@ class SyncVar[A] { // whether or not the SyncVar is already defined. So, unset has been // deprecated in order to eventually be able to make "unsetting" private @deprecated("Use `take` instead, as `unset` is potentionally error-prone", "2.10.0") - def unset(): Unit = synchronized { + private[scala] def unset(): Unit = synchronized { isDefined = false value = None notifyAll() diff --git a/src/library/scala/concurrent/TaskRunner.scala b/src/library/scala/concurrent/TaskRunner.scala index a939a3f070..98c212d9fa 100644 --- a/src/library/scala/concurrent/TaskRunner.scala +++ b/src/library/scala/concurrent/TaskRunner.scala @@ -15,7 +15,7 @@ import scala.language.{higherKinds, implicitConversions} * @author Philipp Haller */ @deprecated("Use `ExecutionContext` instead.", "2.10.0") -trait TaskRunner { +private[scala] trait TaskRunner { type Task[T] diff --git a/src/library/scala/concurrent/ThreadPoolRunner.scala b/src/library/scala/concurrent/ThreadPoolRunner.scala index afa14ed2fa..7784681f71 100644 --- a/src/library/scala/concurrent/ThreadPoolRunner.scala +++ b/src/library/scala/concurrent/ThreadPoolRunner.scala @@ -17,7 +17,7 @@ import scala.language.implicitConversions * @author Philipp Haller */ @deprecated("Use `ExecutionContext` instead.", "2.10.0") -trait ThreadPoolRunner extends FutureTaskRunner { +private[scala] trait ThreadPoolRunner extends FutureTaskRunner { type Task[T] = Callable[T] with Runnable type Future[T] = java.util.concurrent.Future[T] diff --git a/src/library/scala/concurrent/duration/Duration.scala b/src/library/scala/concurrent/duration/Duration.scala index cbc31a7eed..a24266bf19 100644 --- a/src/library/scala/concurrent/duration/Duration.scala +++ b/src/library/scala/concurrent/duration/Duration.scala @@ -664,8 +664,8 @@ final class FiniteDuration(val length: Long, val unit: TimeUnit) extends Duratio * Long.MinValue is not a legal `length` anyway. */ private def safeMul(_a: Long, _b: Long): Long = { - val a = math.abs(_a) - val b = math.abs(_b) + val a = scala.math.abs(_a) + val b = scala.math.abs(_b) import java.lang.Long.{ numberOfLeadingZeros => leading } if (leading(a) + leading(b) < 64) throw new IllegalArgumentException("multiplication overflow") val product = a * b diff --git a/src/library/scala/io/Codec.scala b/src/library/scala/io/Codec.scala index bda4234460..60f99199cb 100644 --- a/src/library/scala/io/Codec.scala +++ b/src/library/scala/io/Codec.scala @@ -6,8 +6,8 @@ ** |/ ** \* */ - -package scala.io +package scala +package io import java.nio.charset.{ Charset, CharsetDecoder, CharsetEncoder, CharacterCodingException, CodingErrorAction => Action } import scala.annotation.migration diff --git a/src/library/scala/io/Position.scala b/src/library/scala/io/Position.scala index b96349803d..85149223ee 100644 --- a/src/library/scala/io/Position.scala +++ b/src/library/scala/io/Position.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.io +package scala +package io /** The object Position provides convenience methods to encode * line and column number in one single integer. The encoded line diff --git a/src/library/scala/io/Source.scala b/src/library/scala/io/Source.scala index f976c7eb0a..74c3e06839 100644 --- a/src/library/scala/io/Source.scala +++ b/src/library/scala/io/Source.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.io +package scala +package io import scala.collection.AbstractIterator import java.io.{ FileInputStream, InputStream, PrintStream, File => JFile } diff --git a/src/library/scala/math/BigDecimal.scala b/src/library/scala/math/BigDecimal.scala index c5e5699468..f75cfad882 100644 --- a/src/library/scala/math/BigDecimal.scala +++ b/src/library/scala/math/BigDecimal.scala @@ -7,7 +7,8 @@ \* */ -package scala.math +package scala +package math import java.{ lang => jl } import java.math.{ MathContext, BigDecimal => BigDec } diff --git a/src/library/scala/math/BigInt.scala b/src/library/scala/math/BigInt.scala index 719099b405..4673aa5d48 100644 --- a/src/library/scala/math/BigInt.scala +++ b/src/library/scala/math/BigInt.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.math +package scala +package math import java.math.BigInteger import scala.language.implicitConversions diff --git a/src/library/scala/math/Equiv.scala b/src/library/scala/math/Equiv.scala index 5f5e049941..45b2b3629d 100644 --- a/src/library/scala/math/Equiv.scala +++ b/src/library/scala/math/Equiv.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.math +package scala +package math import java.util.Comparator diff --git a/src/library/scala/math/Fractional.scala b/src/library/scala/math/Fractional.scala index ca33675b0a..b7e0ed5471 100644 --- a/src/library/scala/math/Fractional.scala +++ b/src/library/scala/math/Fractional.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.math +package scala +package math import scala.language.implicitConversions diff --git a/src/library/scala/math/Integral.scala b/src/library/scala/math/Integral.scala index f3684c4e5d..ff1f695f6d 100644 --- a/src/library/scala/math/Integral.scala +++ b/src/library/scala/math/Integral.scala @@ -8,7 +8,8 @@ -package scala.math +package scala +package math import scala.language.implicitConversions diff --git a/src/library/scala/math/Numeric.scala b/src/library/scala/math/Numeric.scala index 5a76f4f5f2..cb9f9deb70 100644 --- a/src/library/scala/math/Numeric.scala +++ b/src/library/scala/math/Numeric.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.math +package scala +package math import scala.language.implicitConversions diff --git a/src/library/scala/math/Ordered.scala b/src/library/scala/math/Ordered.scala index e8be92eb4a..51f2765a63 100644 --- a/src/library/scala/math/Ordered.scala +++ b/src/library/scala/math/Ordered.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.math +package scala +package math import scala.language.implicitConversions diff --git a/src/library/scala/math/PartialOrdering.scala b/src/library/scala/math/PartialOrdering.scala index a9e317d536..9e35381528 100644 --- a/src/library/scala/math/PartialOrdering.scala +++ b/src/library/scala/math/PartialOrdering.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.math +package scala +package math /** A trait for representing partial orderings. It is important to * distinguish between a type that has a partial order and a representation diff --git a/src/library/scala/math/PartiallyOrdered.scala b/src/library/scala/math/PartiallyOrdered.scala index 7823e5b396..f58210d6a7 100644 --- a/src/library/scala/math/PartiallyOrdered.scala +++ b/src/library/scala/math/PartiallyOrdered.scala @@ -8,7 +8,8 @@ -package scala.math +package scala +package math /** A class for partially ordered data. * diff --git a/src/library/scala/math/ScalaNumber.java b/src/library/scala/math/ScalaNumber.java index 7345147b0d..f03ba7bf08 100644 --- a/src/library/scala/math/ScalaNumber.java +++ b/src/library/scala/math/ScalaNumber.java @@ -6,8 +6,6 @@ ** |/ ** \* */ - - package scala.math; /** A marker class for Number types introduced by Scala diff --git a/src/library/scala/math/ScalaNumericConversions.scala b/src/library/scala/math/ScalaNumericConversions.scala index e748841c12..336991781e 100644 --- a/src/library/scala/math/ScalaNumericConversions.scala +++ b/src/library/scala/math/ScalaNumericConversions.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.math +package scala +package math /** A slightly more specific conversion trait for classes which * extend ScalaNumber (which excludes value classes.) diff --git a/src/library/scala/reflect/ClassManifestDeprecatedApis.scala b/src/library/scala/reflect/ClassManifestDeprecatedApis.scala index 0a3d818fb9..798746851a 100644 --- a/src/library/scala/reflect/ClassManifestDeprecatedApis.scala +++ b/src/library/scala/reflect/ClassManifestDeprecatedApis.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.reflect +package scala +package reflect import scala.collection.mutable.{ WrappedArray, ArrayBuilder } import java.lang.{ Class => jClass } diff --git a/src/library/scala/reflect/Manifest.scala b/src/library/scala/reflect/Manifest.scala index f62d0ecd16..3bc76da295 100644 --- a/src/library/scala/reflect/Manifest.scala +++ b/src/library/scala/reflect/Manifest.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.reflect +package scala +package reflect import scala.collection.mutable.{ ArrayBuilder, WrappedArray } diff --git a/src/library/scala/reflect/NoManifest.scala b/src/library/scala/reflect/NoManifest.scala index 61bc5e28d3..2ef946c80c 100644 --- a/src/library/scala/reflect/NoManifest.scala +++ b/src/library/scala/reflect/NoManifest.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.reflect +package scala +package reflect /** One of the branches of an [[scala.reflect.OptManifest]]. */ diff --git a/src/library/scala/reflect/OptManifest.scala b/src/library/scala/reflect/OptManifest.scala index 5e373c7318..b69f55483c 100644 --- a/src/library/scala/reflect/OptManifest.scala +++ b/src/library/scala/reflect/OptManifest.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.reflect +package scala +package reflect /** A `OptManifest[T]` is an optional [[scala.reflect.Manifest]]. * diff --git a/src/library/scala/runtime/AbstractPartialFunction.scala b/src/library/scala/runtime/AbstractPartialFunction.scala index 57f8e2603b..e3516bc4d9 100644 --- a/src/library/scala/runtime/AbstractPartialFunction.scala +++ b/src/library/scala/runtime/AbstractPartialFunction.scala @@ -6,7 +6,10 @@ ** |/ ** \* */ -package scala.runtime +package scala +package runtime + +import scala.annotation.unspecialized /** `AbstractPartialFunction` reformulates all operations of its supertrait `PartialFunction` * in terms of `isDefinedAt` and `applyOrElse`. diff --git a/src/library/scala/runtime/BooleanRef.java b/src/library/scala/runtime/BooleanRef.java index 889db31e2a..92e8055351 100644 --- a/src/library/scala/runtime/BooleanRef.java +++ b/src/library/scala/runtime/BooleanRef.java @@ -17,4 +17,7 @@ public class BooleanRef implements java.io.Serializable { public boolean elem; public BooleanRef(boolean elem) { this.elem = elem; } public String toString() { return String.valueOf(elem); } + + public static BooleanRef create(boolean e) { return new BooleanRef(e); } + public static BooleanRef zero() { return new BooleanRef(false); } } diff --git a/src/library/scala/runtime/Boxed.scala b/src/library/scala/runtime/Boxed.scala index 8b531076ac..855f0ff41a 100644 --- a/src/library/scala/runtime/Boxed.scala +++ b/src/library/scala/runtime/Boxed.scala @@ -8,7 +8,9 @@ -package scala.runtime +package scala +package runtime + trait Boxed { diff --git a/src/library/scala/runtime/ByteRef.java b/src/library/scala/runtime/ByteRef.java index cc10611e26..27d3259db3 100644 --- a/src/library/scala/runtime/ByteRef.java +++ b/src/library/scala/runtime/ByteRef.java @@ -17,4 +17,7 @@ public class ByteRef implements java.io.Serializable { public byte elem; public ByteRef(byte elem) { this.elem = elem; } public String toString() { return java.lang.Byte.toString(elem); } + + public static ByteRef create(byte e) { return new ByteRef(e); } + public static ByteRef zero() { return new ByteRef((byte)0); } } diff --git a/src/library/scala/runtime/CharRef.java b/src/library/scala/runtime/CharRef.java index 03d3337b3d..31956f5b55 100644 --- a/src/library/scala/runtime/CharRef.java +++ b/src/library/scala/runtime/CharRef.java @@ -17,4 +17,7 @@ public class CharRef implements java.io.Serializable { public char elem; public CharRef(char elem) { this.elem = elem; } public String toString() { return java.lang.Character.toString(elem); } + + public static CharRef create(char e) { return new CharRef(e); } + public static CharRef zero() { return new CharRef((char)0); } } diff --git a/src/library/scala/runtime/DoubleRef.java b/src/library/scala/runtime/DoubleRef.java index 317198ee48..0c7d9156d6 100644 --- a/src/library/scala/runtime/DoubleRef.java +++ b/src/library/scala/runtime/DoubleRef.java @@ -17,4 +17,7 @@ public class DoubleRef implements java.io.Serializable { public double elem; public DoubleRef(double elem) { this.elem = elem; } public String toString() { return java.lang.Double.toString(elem); } + + public static DoubleRef create(double e) { return new DoubleRef(e); } + public static DoubleRef zero() { return new DoubleRef(0); } } diff --git a/src/library/scala/runtime/FloatRef.java b/src/library/scala/runtime/FloatRef.java index e26b89be60..f0e1d5f8f3 100644 --- a/src/library/scala/runtime/FloatRef.java +++ b/src/library/scala/runtime/FloatRef.java @@ -17,4 +17,7 @@ public class FloatRef implements java.io.Serializable { public float elem; public FloatRef(float elem) { this.elem = elem; } public String toString() { return java.lang.Float.toString(elem); } + + public static FloatRef create(float e) { return new FloatRef(e); } + public static FloatRef zero() { return new FloatRef(0); } } diff --git a/src/library/scala/runtime/IntRef.java b/src/library/scala/runtime/IntRef.java index edb6fafe94..adcf474aae 100644 --- a/src/library/scala/runtime/IntRef.java +++ b/src/library/scala/runtime/IntRef.java @@ -17,4 +17,7 @@ public class IntRef implements java.io.Serializable { public int elem; public IntRef(int elem) { this.elem = elem; } public String toString() { return java.lang.Integer.toString(elem); } + + public static IntRef create(int e) { return new IntRef(e); } + public static IntRef zero() { return new IntRef(0); } } diff --git a/src/library/scala/runtime/LongRef.java b/src/library/scala/runtime/LongRef.java index 12004b5bb5..51426ab8f6 100644 --- a/src/library/scala/runtime/LongRef.java +++ b/src/library/scala/runtime/LongRef.java @@ -17,4 +17,7 @@ public class LongRef implements java.io.Serializable { public long elem; public LongRef(long elem) { this.elem = elem; } public String toString() { return java.lang.Long.toString(elem); } + + public static LongRef create(long e) { return new LongRef(e); } + public static LongRef zero() { return new LongRef(0); } } diff --git a/src/library/scala/runtime/MethodCache.scala b/src/library/scala/runtime/MethodCache.scala index 217b51893b..bbf80593db 100644 --- a/src/library/scala/runtime/MethodCache.scala +++ b/src/library/scala/runtime/MethodCache.scala @@ -6,7 +6,9 @@ ** |/ ** \* */ -package scala.runtime +package scala +package runtime + import java.lang.reflect.{ Method => JMethod } import java.lang.{ Class => JClass } diff --git a/src/library/scala/runtime/NonLocalReturnControl.scala b/src/library/scala/runtime/NonLocalReturnControl.scala index b9525ef419..16b2fec6d7 100644 --- a/src/library/scala/runtime/NonLocalReturnControl.scala +++ b/src/library/scala/runtime/NonLocalReturnControl.scala @@ -6,7 +6,9 @@ ** |/ ** \* */ -package scala.runtime +package scala +package runtime + import scala.util.control.ControlThrowable diff --git a/src/library/scala/runtime/Nothing$.scala b/src/library/scala/runtime/Nothing$.scala index 04fcc55a1c..4ecc536223 100644 --- a/src/library/scala/runtime/Nothing$.scala +++ b/src/library/scala/runtime/Nothing$.scala @@ -6,7 +6,9 @@ ** |/ ** \* */ -package scala.runtime +package scala +package runtime + /** * Dummy class which exist only to satisfy the JVM. It corresponds diff --git a/src/library/scala/runtime/Null$.scala b/src/library/scala/runtime/Null$.scala index 25b797a606..1b7685c507 100644 --- a/src/library/scala/runtime/Null$.scala +++ b/src/library/scala/runtime/Null$.scala @@ -6,7 +6,9 @@ ** |/ ** \* */ -package scala.runtime +package scala +package runtime + /** * Dummy class which exist only to satisfy the JVM. It corresponds to diff --git a/src/library/scala/runtime/ObjectRef.java b/src/library/scala/runtime/ObjectRef.java index c8298b8b21..c553c780a8 100644 --- a/src/library/scala/runtime/ObjectRef.java +++ b/src/library/scala/runtime/ObjectRef.java @@ -17,4 +17,7 @@ public class ObjectRef<T> implements java.io.Serializable { public T elem; public ObjectRef(T elem) { this.elem = elem; } public String toString() { return String.valueOf(elem); } + + public static <U> ObjectRef create(U e) { return new ObjectRef(e); } + public static ObjectRef zero() { return new ObjectRef(null); } } diff --git a/src/library/scala/runtime/RichBoolean.scala b/src/library/scala/runtime/RichBoolean.scala index 97e2b77f96..4f867960a0 100644 --- a/src/library/scala/runtime/RichBoolean.scala +++ b/src/library/scala/runtime/RichBoolean.scala @@ -6,7 +6,9 @@ ** |/ ** \* */ -package scala.runtime +package scala +package runtime + final class RichBoolean(val self: Boolean) extends AnyVal with OrderedProxy[Boolean] { protected def ord = scala.math.Ordering.Boolean diff --git a/src/library/scala/runtime/RichByte.scala b/src/library/scala/runtime/RichByte.scala index ca578620cf..ea23cb8867 100644 --- a/src/library/scala/runtime/RichByte.scala +++ b/src/library/scala/runtime/RichByte.scala @@ -6,7 +6,9 @@ ** |/ ** \* */ -package scala.runtime +package scala +package runtime + final class RichByte(val self: Byte) extends AnyVal with ScalaWholeNumberProxy[Byte] { protected def num = scala.math.Numeric.ByteIsIntegral diff --git a/src/library/scala/runtime/RichChar.scala b/src/library/scala/runtime/RichChar.scala index 5124ca00de..c069fd1fef 100644 --- a/src/library/scala/runtime/RichChar.scala +++ b/src/library/scala/runtime/RichChar.scala @@ -6,7 +6,9 @@ ** |/ ** \* */ -package scala.runtime +package scala +package runtime + import java.lang.Character diff --git a/src/library/scala/runtime/RichException.scala b/src/library/scala/runtime/RichException.scala index cf4eb71ded..f01788a4e9 100644 --- a/src/library/scala/runtime/RichException.scala +++ b/src/library/scala/runtime/RichException.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.runtime +package scala +package runtime import scala.compat.Platform.EOL diff --git a/src/library/scala/runtime/RichInt.scala b/src/library/scala/runtime/RichInt.scala index 192f94f939..a39710b146 100644 --- a/src/library/scala/runtime/RichInt.scala +++ b/src/library/scala/runtime/RichInt.scala @@ -6,7 +6,9 @@ ** |/ ** \* */ -package scala.runtime +package scala +package runtime + import scala.collection.immutable.Range diff --git a/src/library/scala/runtime/RichLong.scala b/src/library/scala/runtime/RichLong.scala index ce2d1fdcbd..e5b39b1c09 100644 --- a/src/library/scala/runtime/RichLong.scala +++ b/src/library/scala/runtime/RichLong.scala @@ -6,7 +6,9 @@ ** |/ ** \* */ -package scala.runtime +package scala +package runtime + final class RichLong(val self: Long) extends AnyVal with IntegralProxy[Long] { protected def num = scala.math.Numeric.LongIsIntegral diff --git a/src/library/scala/runtime/RichShort.scala b/src/library/scala/runtime/RichShort.scala index aa24dd2ba6..3e5d8781ff 100644 --- a/src/library/scala/runtime/RichShort.scala +++ b/src/library/scala/runtime/RichShort.scala @@ -6,7 +6,9 @@ ** |/ ** \* */ -package scala.runtime +package scala +package runtime + final class RichShort(val self: Short) extends AnyVal with ScalaWholeNumberProxy[Short] { protected def num = scala.math.Numeric.ShortIsIntegral diff --git a/src/library/scala/runtime/ScalaNumberProxy.scala b/src/library/scala/runtime/ScalaNumberProxy.scala index e8460a203b..6ea6448b1a 100644 --- a/src/library/scala/runtime/ScalaNumberProxy.scala +++ b/src/library/scala/runtime/ScalaNumberProxy.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.runtime +package scala +package runtime import scala.collection.{ mutable, immutable } import scala.math.{ ScalaNumericConversions, ScalaNumericAnyConversions } diff --git a/src/library/scala/runtime/ShortRef.java b/src/library/scala/runtime/ShortRef.java index 461b521e5f..e5e8de3d8b 100644 --- a/src/library/scala/runtime/ShortRef.java +++ b/src/library/scala/runtime/ShortRef.java @@ -17,4 +17,7 @@ public class ShortRef implements java.io.Serializable { public short elem; public ShortRef(short elem) { this.elem = elem; } public String toString() { return java.lang.Short.toString(elem); } + + public static ShortRef create(short e) { return new ShortRef(e); } + public static ShortRef zero() { return new ShortRef((short)0); } } diff --git a/src/library/scala/runtime/StringAdd.scala b/src/library/scala/runtime/StringAdd.scala index 1456d9a4e4..d5b51a6e92 100644 --- a/src/library/scala/runtime/StringAdd.scala +++ b/src/library/scala/runtime/StringAdd.scala @@ -6,7 +6,9 @@ ** ** \* */ -package scala.runtime +package scala +package runtime + /** A wrapper class that adds string concatenation `+` to any value */ @deprecated("Use Predef.StringAdd", "2.11.0") diff --git a/src/library/scala/runtime/StringFormat.scala b/src/library/scala/runtime/StringFormat.scala index 21e5efd1fc..de32ac7e86 100644 --- a/src/library/scala/runtime/StringFormat.scala +++ b/src/library/scala/runtime/StringFormat.scala @@ -6,7 +6,9 @@ ** ** \* */ -package scala.runtime +package scala +package runtime + /** A wrapper class that adds a `formatted` operation to any value */ diff --git a/src/library/scala/runtime/Tuple2Zipped.scala b/src/library/scala/runtime/Tuple2Zipped.scala index bde69a0f54..b28f6d4269 100644 --- a/src/library/scala/runtime/Tuple2Zipped.scala +++ b/src/library/scala/runtime/Tuple2Zipped.scala @@ -6,7 +6,9 @@ ** |/ ** \* */ -package scala.runtime +package scala +package runtime + import scala.collection.{ TraversableLike, IterableLike } import scala.collection.generic.{ CanBuildFrom => CBF } diff --git a/src/library/scala/runtime/Tuple3Zipped.scala b/src/library/scala/runtime/Tuple3Zipped.scala index 34da42462a..7c501380a3 100644 --- a/src/library/scala/runtime/Tuple3Zipped.scala +++ b/src/library/scala/runtime/Tuple3Zipped.scala @@ -6,7 +6,9 @@ ** |/ ** \* */ -package scala.runtime +package scala +package runtime + import scala.collection.{ TraversableLike, IterableLike } import scala.collection.generic.{ CanBuildFrom => CBF } diff --git a/src/library/scala/runtime/VolatileBooleanRef.java b/src/library/scala/runtime/VolatileBooleanRef.java index e3bd182345..ef5b691118 100755 --- a/src/library/scala/runtime/VolatileBooleanRef.java +++ b/src/library/scala/runtime/VolatileBooleanRef.java @@ -17,4 +17,7 @@ public class VolatileBooleanRef implements java.io.Serializable { volatile public boolean elem; public VolatileBooleanRef(boolean elem) { this.elem = elem; } public String toString() { return String.valueOf(elem); } + + public static VolatileBooleanRef create(boolean e) { return new VolatileBooleanRef(e); } + public static VolatileBooleanRef zero() { return new VolatileBooleanRef(false); } } diff --git a/src/library/scala/runtime/VolatileByteRef.java b/src/library/scala/runtime/VolatileByteRef.java index 034b003017..d792b0a386 100755 --- a/src/library/scala/runtime/VolatileByteRef.java +++ b/src/library/scala/runtime/VolatileByteRef.java @@ -17,4 +17,7 @@ public class VolatileByteRef implements java.io.Serializable { volatile public byte elem; public VolatileByteRef(byte elem) { this.elem = elem; } public String toString() { return java.lang.Byte.toString(elem); } + + public static VolatileByteRef create(byte e) { return new VolatileByteRef(e); } + public static VolatileByteRef zero() { return new VolatileByteRef((byte)0); } } diff --git a/src/library/scala/runtime/VolatileCharRef.java b/src/library/scala/runtime/VolatileCharRef.java index f90648c5e9..555b171283 100755 --- a/src/library/scala/runtime/VolatileCharRef.java +++ b/src/library/scala/runtime/VolatileCharRef.java @@ -17,4 +17,7 @@ public class VolatileCharRef implements java.io.Serializable { volatile public char elem; public VolatileCharRef(char elem) { this.elem = elem; } public String toString() { return java.lang.Character.toString(elem); } + + public static VolatileCharRef create(char e) { return new VolatileCharRef(e); } + public static VolatileCharRef zero() { return new VolatileCharRef((char)0); } } diff --git a/src/library/scala/runtime/VolatileDoubleRef.java b/src/library/scala/runtime/VolatileDoubleRef.java index d47c9578c6..1932055c6a 100755 --- a/src/library/scala/runtime/VolatileDoubleRef.java +++ b/src/library/scala/runtime/VolatileDoubleRef.java @@ -16,4 +16,7 @@ public class VolatileDoubleRef implements java.io.Serializable { volatile public double elem; public VolatileDoubleRef(double elem) { this.elem = elem; } public String toString() { return java.lang.Double.toString(elem); } + + public static VolatileDoubleRef create(double e) { return new VolatileDoubleRef(e); } + public static VolatileDoubleRef zero() { return new VolatileDoubleRef(0); } } diff --git a/src/library/scala/runtime/VolatileFloatRef.java b/src/library/scala/runtime/VolatileFloatRef.java index 97da95f7cc..3a81be1146 100755 --- a/src/library/scala/runtime/VolatileFloatRef.java +++ b/src/library/scala/runtime/VolatileFloatRef.java @@ -17,4 +17,7 @@ public class VolatileFloatRef implements java.io.Serializable { volatile public float elem; public VolatileFloatRef(float elem) { this.elem = elem; } public String toString() { return java.lang.Float.toString(elem); } + + public static VolatileFloatRef create(float e) { return new VolatileFloatRef(e); } + public static VolatileFloatRef zero() { return new VolatileFloatRef(0); } } diff --git a/src/library/scala/runtime/VolatileIntRef.java b/src/library/scala/runtime/VolatileIntRef.java index e8a68a1a9a..ae015bc8b1 100755 --- a/src/library/scala/runtime/VolatileIntRef.java +++ b/src/library/scala/runtime/VolatileIntRef.java @@ -16,4 +16,7 @@ public class VolatileIntRef implements java.io.Serializable { volatile public int elem; public VolatileIntRef(int elem) { this.elem = elem; } public String toString() { return java.lang.Integer.toString(elem); } + + public static VolatileIntRef create(int e) { return new VolatileIntRef(e); } + public static VolatileIntRef zero() { return new VolatileIntRef(0); } } diff --git a/src/library/scala/runtime/VolatileLongRef.java b/src/library/scala/runtime/VolatileLongRef.java index 80e627cd4b..e596f5aa69 100755 --- a/src/library/scala/runtime/VolatileLongRef.java +++ b/src/library/scala/runtime/VolatileLongRef.java @@ -17,4 +17,7 @@ public class VolatileLongRef implements java.io.Serializable { volatile public long elem; public VolatileLongRef(long elem) { this.elem = elem; } public String toString() { return java.lang.Long.toString(elem); } + + public static VolatileLongRef create(long e) { return new VolatileLongRef(e); } + public static VolatileLongRef zero() { return new VolatileLongRef(0); } } diff --git a/src/library/scala/runtime/VolatileObjectRef.java b/src/library/scala/runtime/VolatileObjectRef.java index 848b0632ea..9f1f3ac0cf 100755 --- a/src/library/scala/runtime/VolatileObjectRef.java +++ b/src/library/scala/runtime/VolatileObjectRef.java @@ -17,4 +17,7 @@ public class VolatileObjectRef<T> implements java.io.Serializable { volatile public T elem; public VolatileObjectRef(T elem) { this.elem = elem; } public String toString() { return String.valueOf(elem); } + + public static <U> VolatileObjectRef create(U e) { return new VolatileObjectRef(e); } + public static VolatileObjectRef zero() { return new VolatileObjectRef(null); } } diff --git a/src/library/scala/runtime/VolatileShortRef.java b/src/library/scala/runtime/VolatileShortRef.java index 4e91d0dc70..0a2825941f 100755 --- a/src/library/scala/runtime/VolatileShortRef.java +++ b/src/library/scala/runtime/VolatileShortRef.java @@ -17,4 +17,7 @@ public class VolatileShortRef implements java.io.Serializable { volatile public short elem; public VolatileShortRef(short elem) { this.elem = elem; } public String toString() { return java.lang.Short.toString(elem); } + + public static VolatileShortRef create(short e) { return new VolatileShortRef(e); } + public static VolatileShortRef zero() { return new VolatileShortRef((short)0); } } diff --git a/src/library/scala/sys/BooleanProp.scala b/src/library/scala/sys/BooleanProp.scala index e3c25bbd11..74b0a9077b 100644 --- a/src/library/scala/sys/BooleanProp.scala +++ b/src/library/scala/sys/BooleanProp.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.sys +package scala +package sys import scala.language.implicitConversions diff --git a/src/library/scala/sys/PropImpl.scala b/src/library/scala/sys/PropImpl.scala index b50e0e18a7..3b451ab1d9 100644 --- a/src/library/scala/sys/PropImpl.scala +++ b/src/library/scala/sys/PropImpl.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.sys +package scala +package sys import scala.collection.mutable diff --git a/src/library/scala/sys/ShutdownHookThread.scala b/src/library/scala/sys/ShutdownHookThread.scala index a8f4871870..6018ac852b 100644 --- a/src/library/scala/sys/ShutdownHookThread.scala +++ b/src/library/scala/sys/ShutdownHookThread.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.sys +package scala +package sys /** A minimal Thread wrapper to enhance shutdown hooks. It knows * how to unregister itself. diff --git a/src/library/scala/sys/SystemProperties.scala b/src/library/scala/sys/SystemProperties.scala index 294be5cd71..39f66f5030 100644 --- a/src/library/scala/sys/SystemProperties.scala +++ b/src/library/scala/sys/SystemProperties.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.sys +package scala +package sys import scala.collection.{ mutable, Iterator } import scala.collection.JavaConverters._ diff --git a/src/library/scala/sys/process/BasicIO.scala b/src/library/scala/sys/process/BasicIO.scala index e2c4f13830..58517de402 100644 --- a/src/library/scala/sys/process/BasicIO.scala +++ b/src/library/scala/sys/process/BasicIO.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.sys +package scala +package sys package process import processInternal._ diff --git a/src/library/scala/sys/process/Process.scala b/src/library/scala/sys/process/Process.scala index 715b364e08..402183a1f0 100644 --- a/src/library/scala/sys/process/Process.scala +++ b/src/library/scala/sys/process/Process.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.sys +package scala +package sys package process import processInternal._ diff --git a/src/library/scala/sys/process/ProcessBuilder.scala b/src/library/scala/sys/process/ProcessBuilder.scala index 5d89e45001..c8e548c76b 100644 --- a/src/library/scala/sys/process/ProcessBuilder.scala +++ b/src/library/scala/sys/process/ProcessBuilder.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.sys +package scala +package sys package process import processInternal._ diff --git a/src/library/scala/sys/process/ProcessBuilderImpl.scala b/src/library/scala/sys/process/ProcessBuilderImpl.scala index 91e267d5e4..adf6d1e724 100644 --- a/src/library/scala/sys/process/ProcessBuilderImpl.scala +++ b/src/library/scala/sys/process/ProcessBuilderImpl.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.sys +package scala +package sys package process import processInternal._ diff --git a/src/library/scala/sys/process/ProcessIO.scala b/src/library/scala/sys/process/ProcessIO.scala index f5b26680d9..eedf667c88 100644 --- a/src/library/scala/sys/process/ProcessIO.scala +++ b/src/library/scala/sys/process/ProcessIO.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.sys +package scala +package sys package process import processInternal._ diff --git a/src/library/scala/sys/process/ProcessImpl.scala b/src/library/scala/sys/process/ProcessImpl.scala index c64ba246fc..7a5fc4ef9b 100644 --- a/src/library/scala/sys/process/ProcessImpl.scala +++ b/src/library/scala/sys/process/ProcessImpl.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.sys +package scala +package sys package process import processInternal._ diff --git a/src/library/scala/sys/process/ProcessLogger.scala b/src/library/scala/sys/process/ProcessLogger.scala index a4acb065d0..ae347221ef 100644 --- a/src/library/scala/sys/process/ProcessLogger.scala +++ b/src/library/scala/sys/process/ProcessLogger.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.sys +package scala +package sys package process import java.io._ diff --git a/src/library/scala/util/DynamicVariable.scala b/src/library/scala/util/DynamicVariable.scala index 52cba6850d..963fe1c497 100644 --- a/src/library/scala/util/DynamicVariable.scala +++ b/src/library/scala/util/DynamicVariable.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.util +package scala +package util import java.lang.InheritableThreadLocal diff --git a/src/library/scala/util/Either.scala b/src/library/scala/util/Either.scala index 5cd35ab6d9..1ed3f4becb 100644 --- a/src/library/scala/util/Either.scala +++ b/src/library/scala/util/Either.scala @@ -8,7 +8,8 @@ -package scala.util +package scala +package util import scala.language.implicitConversions diff --git a/src/library/scala/util/MurmurHash.scala b/src/library/scala/util/MurmurHash.scala deleted file mode 100644 index b82259c217..0000000000 --- a/src/library/scala/util/MurmurHash.scala +++ /dev/null @@ -1,197 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2013, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - -package scala.util - -/** An implementation of Austin Appleby's MurmurHash 3.0 algorithm - * (32 bit version); reference: http://code.google.com/p/smhasher - * - * This is the hash used by collections and case classes (including - * tuples). - * - * @author Rex Kerr - * @version 2.9 - * @since 2.9 - */ - -import java.lang.Integer.{ rotateLeft => rotl } -import scala.collection.Iterator - -/** A class designed to generate well-distributed non-cryptographic - * hashes. It is designed to be passed to a collection's foreach method, - * or can take individual hash values with append. Its own hash code is - * set equal to the hash code of whatever it is hashing. - */ -@deprecated("Use the object MurmurHash3 instead.", "2.10.0") -class MurmurHash[@specialized(Int,Long,Float,Double) T](seed: Int) extends (T => Unit) { - import MurmurHash._ - - private var h = startHash(seed) - private var c = hiddenMagicA - private var k = hiddenMagicB - private var hashed = false - private var hashvalue = h - - /** Begin a new hash using the same seed. */ - def reset() { - h = startHash(seed) - c = hiddenMagicA - k = hiddenMagicB - hashed = false - } - - /** Incorporate the hash value of one item. */ - def apply(t: T) { - h = extendHash(h,t.##,c,k) - c = nextMagicA(c) - k = nextMagicB(k) - hashed = false - } - - /** Incorporate a known hash value. */ - def append(i: Int) { - h = extendHash(h,i,c,k) - c = nextMagicA(c) - k = nextMagicB(k) - hashed = false - } - - /** Retrieve the hash value */ - def hash = { - if (!hashed) { - hashvalue = finalizeHash(h) - hashed = true - } - hashvalue - } - override def hashCode = hash -} - -/** An object designed to generate well-distributed non-cryptographic - * hashes. It is designed to hash a collection of integers; along with - * the integers to hash, it generates two magic streams of integers to - * increase the distribution of repetitive input sequences. Thus, - * three methods need to be called at each step (to start and to - * incorporate a new integer) to update the values. Only one method - * needs to be called to finalize the hash. - */ -@deprecated("Use the object MurmurHash3 instead.", "2.10.0") -object MurmurHash { - // Magic values used for MurmurHash's 32 bit hash. - // Don't change these without consulting a hashing expert! - final private val visibleMagic = 0x971e137b - final private val hiddenMagicA = 0x95543787 - final private val hiddenMagicB = 0x2ad7eb25 - final private val visibleMixer = 0x52dce729 - final private val hiddenMixerA = 0x7b7d159c - final private val hiddenMixerB = 0x6bce6396 - final private val finalMixer1 = 0x85ebca6b - final private val finalMixer2 = 0xc2b2ae35 - - // Arbitrary values used for hashing certain classes - final private val seedString = 0xf7ca7fd2 - final private val seedArray = 0x3c074a61 - - /** The first 23 magic integers from the first stream are stored here */ - val storedMagicA = - Iterator.iterate(hiddenMagicA)(nextMagicA).take(23).toArray - - /** The first 23 magic integers from the second stream are stored here */ - val storedMagicB = - Iterator.iterate(hiddenMagicB)(nextMagicB).take(23).toArray - - /** Begin a new hash with a seed value. */ - def startHash(seed: Int) = seed ^ visibleMagic - - /** The initial magic integers in the first stream. */ - def startMagicA = hiddenMagicA - - /** The initial magic integer in the second stream. */ - def startMagicB = hiddenMagicB - - /** Incorporates a new value into an existing hash. - * - * @param hash the prior hash value - * @param value the new value to incorporate - * @param magicA a magic integer from the stream - * @param magicB a magic integer from a different stream - * @return the updated hash value - */ - def extendHash(hash: Int, value: Int, magicA: Int, magicB: Int) = { - (hash ^ rotl(value*magicA,11)*magicB)*3 + visibleMixer - } - - /** Given a magic integer from the first stream, compute the next */ - def nextMagicA(magicA: Int) = magicA*5 + hiddenMixerA - - /** Given a magic integer from the second stream, compute the next */ - def nextMagicB(magicB: Int) = magicB*5 + hiddenMixerB - - /** Once all hashes have been incorporated, this performs a final mixing */ - def finalizeHash(hash: Int) = { - var i = (hash ^ (hash>>>16)) - i *= finalMixer1 - i ^= (i >>> 13) - i *= finalMixer2 - i ^= (i >>> 16) - i - } - - /** Compute a high-quality hash of an array */ - def arrayHash[@specialized T](a: Array[T]) = { - var h = startHash(a.length * seedArray) - var c = hiddenMagicA - var k = hiddenMagicB - var j = 0 - while (j < a.length) { - h = extendHash(h, a(j).##, c, k) - c = nextMagicA(c) - k = nextMagicB(k) - j += 1 - } - finalizeHash(h) - } - - /** Compute a high-quality hash of a string */ - def stringHash(s: String) = { - var h = startHash(s.length * seedString) - var c = hiddenMagicA - var k = hiddenMagicB - var j = 0 - while (j+1 < s.length) { - val i = (s.charAt(j)<<16) + s.charAt(j+1) - h = extendHash(h,i,c,k) - c = nextMagicA(c) - k = nextMagicB(k) - j += 2 - } - if (j < s.length) h = extendHash(h,s.charAt(j),c,k) - finalizeHash(h) - } - - /** Compute a hash that is symmetric in its arguments--that is, - * where the order of appearance of elements does not matter. - * This is useful for hashing sets, for example. - */ - def symmetricHash[T](xs: scala.collection.TraversableOnce[T], seed: Int) = { - var a,b,n = 0 - var c = 1 - xs.seq.foreach(i => { - val h = i.## - a += h - b ^= h - if (h != 0) c *= h - n += 1 - }) - var h = startHash(seed * n) - h = extendHash(h, a, storedMagicA(0), storedMagicB(0)) - h = extendHash(h, b, storedMagicA(1), storedMagicB(1)) - h = extendHash(h, c, storedMagicA(2), storedMagicB(2)) - finalizeHash(h) - } -} diff --git a/src/library/scala/util/Properties.scala b/src/library/scala/util/Properties.scala index cc145134c4..d2d473bf98 100644 --- a/src/library/scala/util/Properties.scala +++ b/src/library/scala/util/Properties.scala @@ -7,7 +7,8 @@ \* */ -package scala.util +package scala +package util import java.io.{ IOException, PrintWriter } import java.util.jar.Attributes.{ Name => AttributeName } @@ -72,7 +73,7 @@ private[scala] trait PropertiesTrait { * it is an RC, Beta, etc. or was built from source, or if the version * cannot be read. */ - val releaseVersion = + val releaseVersion = for { v <- scalaPropOrNone("maven.version.number") if !(v endsWith "-SNAPSHOT") @@ -86,7 +87,7 @@ private[scala] trait PropertiesTrait { * @return Some(version) if this is a non-final version, None if this * is a final release or the version cannot be read. */ - val developmentVersion = + val developmentVersion = for { v <- scalaPropOrNone("maven.version.number") if v endsWith "-SNAPSHOT" diff --git a/src/library/scala/util/Random.scala b/src/library/scala/util/Random.scala index b3a8617f15..8d68c5be38 100644 --- a/src/library/scala/util/Random.scala +++ b/src/library/scala/util/Random.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.util +package scala +package util import scala.collection.mutable.ArrayBuffer import scala.collection.generic.CanBuildFrom diff --git a/src/library/scala/util/Try.scala b/src/library/scala/util/Try.scala index fbfeb7d4d9..89db57a55e 100644 --- a/src/library/scala/util/Try.scala +++ b/src/library/scala/util/Try.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.util +package scala +package util import scala.collection.Seq import scala.util.control.NonFatal diff --git a/src/library/scala/util/control/Breaks.scala b/src/library/scala/util/control/Breaks.scala index 89e1b58d95..5524b10afa 100644 --- a/src/library/scala/util/control/Breaks.scala +++ b/src/library/scala/util/control/Breaks.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.util.control +package scala +package util.control /** A class that can be instantiated for the break control abstraction. * Example usage: diff --git a/src/library/scala/util/control/ControlThrowable.scala b/src/library/scala/util/control/ControlThrowable.scala index 33c90c5815..7ed3d95cd3 100644 --- a/src/library/scala/util/control/ControlThrowable.scala +++ b/src/library/scala/util/control/ControlThrowable.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.util.control +package scala +package util.control /** A marker trait indicating that the `Throwable` it is mixed into is * intended for flow control. diff --git a/src/library/scala/util/control/Exception.scala b/src/library/scala/util/control/Exception.scala index b97914c4b1..be6d03a145 100644 --- a/src/library/scala/util/control/Exception.scala +++ b/src/library/scala/util/control/Exception.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.util +package scala +package util package control import scala.collection.immutable.List diff --git a/src/library/scala/util/control/NonFatal.scala b/src/library/scala/util/control/NonFatal.scala index 74478f2a49..11fb988e8e 100644 --- a/src/library/scala/util/control/NonFatal.scala +++ b/src/library/scala/util/control/NonFatal.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.util.control +package scala +package util.control /** * Extractor of non-fatal Throwables. Will not match fatal errors like `VirtualMachineError` diff --git a/src/library/scala/util/control/TailCalls.scala b/src/library/scala/util/control/TailCalls.scala index 955cee7657..ba3044c718 100644 --- a/src/library/scala/util/control/TailCalls.scala +++ b/src/library/scala/util/control/TailCalls.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.util.control +package scala +package util.control /** Methods exported by this object implement tail calls via trampolining. * Tail calling methods have to return their result using `done` or call the diff --git a/src/library/scala/util/hashing/ByteswapHashing.scala b/src/library/scala/util/hashing/ByteswapHashing.scala index a96945788c..470479725b 100644 --- a/src/library/scala/util/hashing/ByteswapHashing.scala +++ b/src/library/scala/util/hashing/ByteswapHashing.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.util.hashing +package scala +package util.hashing @@ -16,20 +17,20 @@ package scala.util.hashing /** A fast multiplicative hash by Phil Bagwell. */ final class ByteswapHashing[T] extends Hashing[T] { - + def hash(v: T) = byteswap32(v.##) - + } object ByteswapHashing { - + private class Chained[T](h: Hashing[T]) extends Hashing[T] { def hash(v: T) = byteswap32(h.hash(v)) } - + /** Composes another `Hashing` with the Byteswap hash. */ def chain[T](h: Hashing[T]): Hashing[T] = new Chained(h) - + } diff --git a/src/library/scala/util/hashing/Hashing.scala b/src/library/scala/util/hashing/Hashing.scala index b57f858bed..2b72c1dbe3 100644 --- a/src/library/scala/util/hashing/Hashing.scala +++ b/src/library/scala/util/hashing/Hashing.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.util.hashing +package scala +package util.hashing import scala.annotation.implicitNotFound diff --git a/src/library/scala/util/hashing/MurmurHash3.scala b/src/library/scala/util/hashing/MurmurHash3.scala index 0aa7e6f1cb..c38d0f4da5 100644 --- a/src/library/scala/util/hashing/MurmurHash3.scala +++ b/src/library/scala/util/hashing/MurmurHash3.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.util.hashing +package scala +package util.hashing import java.lang.Integer.{ rotateLeft => rotl } @@ -274,12 +275,4 @@ object MurmurHash3 extends MurmurHash3 { finalizeHash(h, n) } */ - - @deprecated("Use unorderedHash", "2.10.0") - final def symmetricHash[T](xs: scala.collection.GenTraversableOnce[T], seed: Int = symmetricSeed): Int = - unorderedHash(xs.seq, seed) - - @deprecated("Use orderedHash", "2.10.0") - final def traversableHash[T](xs: scala.collection.GenTraversableOnce[T], seed: Int = traversableSeed): Int = - orderedHash(xs.seq, seed) } diff --git a/src/library/scala/util/hashing/package.scala b/src/library/scala/util/hashing/package.scala index 7d38f151f9..2c8e0154fc 100644 --- a/src/library/scala/util/hashing/package.scala +++ b/src/library/scala/util/hashing/package.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.util +package scala +package util @@ -14,7 +15,7 @@ package scala.util package object hashing { - + /** Fast multiplicative hash with a nice distribution. */ def byteswap32(v: Int): Int = { @@ -22,7 +23,7 @@ package object hashing { hc = java.lang.Integer.reverseBytes(hc) hc * 0x9e3775cd } - + /** Fast multiplicative hash with a nice distribution * for 64-bit values. */ @@ -31,5 +32,5 @@ package object hashing { hc = java.lang.Long.reverseBytes(hc) hc * 0x9e3775cd9e3775cdL } - + } diff --git a/src/library/scala/util/logging/ConsoleLogger.scala b/src/library/scala/util/logging/ConsoleLogger.scala deleted file mode 100644 index 74f058b4ec..0000000000 --- a/src/library/scala/util/logging/ConsoleLogger.scala +++ /dev/null @@ -1,26 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2013, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - - - -package scala.util.logging - -/** - * The trait `ConsoleLogger` is mixed into a concrete class who - * has class `Logged` among its base classes. - * - * @author Burak Emir - * @version 1.0 - */ -@deprecated("This class will be removed.", "2.10.0") -trait ConsoleLogger extends Logged { - - /** logs argument to Console using [[scala.Console.println]] - */ - override def log(msg: String): Unit = Console.println(msg) -} diff --git a/src/library/scala/util/logging/Logged.scala b/src/library/scala/util/logging/Logged.scala deleted file mode 100644 index f2661d3206..0000000000 --- a/src/library/scala/util/logging/Logged.scala +++ /dev/null @@ -1,33 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2013, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - -package scala.util.logging - -/** Mixing in Logged indicates that a class provides support for logging. - * - * For instance: - * {{{ - * // The developer of the library writes: - * class MyClass extends Logged { - * // do stuff, call log - * } - * - * // The user of the library instantiates: - * val x = new MyClass() with ConsoleLogger - * }}} - * and the logging is sent to the [[scala.util.logging.ConsoleLogger]] object. - */ -@deprecated("This class will be removed.", "2.10.0") -trait Logged { - /** This method should log the message given as argument somewhere - * as a side-effect. - * - * @param msg message to be logged - */ - def log(msg: String): Unit = {} -} diff --git a/src/library/scala/util/matching/Regex.scala b/src/library/scala/util/matching/Regex.scala index 981d9af02f..8eac0a2520 100644 --- a/src/library/scala/util/matching/Regex.scala +++ b/src/library/scala/util/matching/Regex.scala @@ -28,7 +28,8 @@ * into a [[java.lang.String]]. * */ -package scala.util.matching +package scala +package util.matching import scala.collection.AbstractIterator import java.util.regex.{ Pattern, Matcher } @@ -204,6 +205,20 @@ class Regex private[matching](val pattern: Pattern, groupNames: String*) extends else if (m.matcher.pattern == this.pattern) Some(1 to m.groupCount map m.group) else unapplySeq(m.matched) + /** Tries to match target. + * @param target The string to match + * @return The matches + */ + @deprecated("Extracting a match result from anything but a CharSequence or Match is deprecated", "2.11.0") + def unapplySeq(target: Any): Option[List[String]] = target match { + case s: CharSequence => + val m = pattern matcher s + if (runMatcher(m)) Some((1 to m.groupCount).toList map m.group) + else None + case m: Match => unapplySeq(m.matched) + case _ => None + } + // @see UnanchoredRegex protected def runMatcher(m: Matcher) = m.matches() diff --git a/src/library/scala/util/parsing/ast/AbstractSyntax.scala b/src/library/scala/util/parsing/ast/AbstractSyntax.scala deleted file mode 100644 index 30b20d71c6..0000000000 --- a/src/library/scala/util/parsing/ast/AbstractSyntax.scala +++ /dev/null @@ -1,32 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2006-2013, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - -package scala.util.parsing.ast - -import scala.util.parsing.input.Positional - -/** This component provides the core abstractions for representing an Abstract Syntax Tree - * - * @author Adriaan Moors - */ -@deprecated("This class will be removed", "2.10.0") -trait AbstractSyntax { - /** The base class for elements of the abstract syntax tree. - */ - trait Element extends Positional - - /** The base class for elements in the AST that represent names [[scala.util.parsing.ast.Binders]]. - */ - trait NameElement extends Element { - def name: String - override def equals(that: Any): Boolean = that match { - case n: NameElement => n.name == name - case _ => false - } - } -} diff --git a/src/library/scala/util/parsing/ast/Binders.scala b/src/library/scala/util/parsing/ast/Binders.scala deleted file mode 100644 index a6ad1907c2..0000000000 --- a/src/library/scala/util/parsing/ast/Binders.scala +++ /dev/null @@ -1,347 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2006-2013, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - -package scala.util.parsing.ast - -import scala.collection.AbstractIterable -import scala.collection.mutable -import scala.language.implicitConversions - -//DISCLAIMER: this code is highly experimental! - - // TODO: avoid clashes when substituting - // TODO: check binders in the same scope are distinct - -/** This trait provides the core ''Scrap-Your-Boilerplate'' abstractions as - * well as implementations for common datatypes. - * - * (Based on Ralf Lämmel's [[http://homepages.cwi.nl/~ralf/syb3/ SYB papers]].) - * - * @author Adriaan Moors - */ -@deprecated("This class will be removed", "2.10.0") -trait Mappable { - trait Mapper { def apply[T <% Mappable[T]](x: T): T } /* TODO: having type `Forall T. T => T` is too strict: - sometimes we want to allow `Forall T >: precision. T => T` for some type `precision`, so that, - beneath a certain threshold, we have some leeway. - concretely: to use gmap for substitution, we simply require that ast nodes are mapped to ast nodes, - we can't require that the type is preserved precisely: a Name may map to e.g., a MethodCall - */ - - trait Mappable[T] { - // one-layer traversal - def gmap(f: Mapper): T - // everywhere f x = f (gmapT (everywhere f) x) - def everywhere(f: Mapper)(implicit c: T => Mappable[T]): T = - f(gmap(new Mapper { def apply[T <% Mappable[T]](x: T): T = x.everywhere(f)})) - } - - implicit def StringIsMappable(s: String): Mappable[String] = - new Mappable[String] { - def gmap(f: Mapper): String = f(s) - } - - implicit def ListIsMappable[t <% Mappable[t]](xs: List[t]): Mappable[List[t]] = - new Mappable[List[t]] { - def gmap(f: Mapper): List[t] = (for (x <- xs) yield f(x)).toList - } - - implicit def OptionIsMappable[t <% Mappable[t]](xs: Option[t]): Mappable[Option[t]] = - new Mappable[Option[t]] { - def gmap(f: Mapper): Option[t] = (for (x <- xs) yield f(x)) - } -} - -/** This component provides functionality for enforcing variable binding - * during parse-time. - * - * When parsing simple languages, like Featherweight Scala, these parser - * combinators will fully enforce the binding discipline. When names are - * allowed to be left unqualified, these mechanisms would have to be - * complemented by an extra phase that resolves names that couldn't be - * resolved using the naive binding rules. (Maybe some machinery to - * model `implicit` binders (e.g., `this` and imported qualifiers) - * and selection on a binder will suffice?) - * - * @author Adriaan Moors - */ -trait Binders extends AbstractSyntax with Mappable { - /** A `Scope` keeps track of one or more syntactic elements that represent bound names. - * The elements it contains share the same scope and must all be distinct, as determined by `==`. - * - * A `NameElement` `n` in the AST that is conceptually bound by a `Scope` `s`, is replaced by a - * `BoundElement(n, s)`. (For example, in `val x:Int=x+1`, the first `x` is modelled by a - * Scope `s` that contains `x` and the second `x` is represented by a `BoundElement(x, s)`) - * The term (`x+1`) in scope of the Scope becomes an `UnderBinder(s, x+1)`. - * - * A `NameElement` `n` is bound by a `Scope` `s` if it is wrapped as a `BoundElement(n, s)`, and - * `s` has a binder element that is semantically equal (`equals` or `==`) to `n`. - * - * A `Scope` is represented textually by its list of binder elements, followed by the scope's `id`. - * For example: `[x, y]!1` represents the scope with `id` `1` and binder elements `x` and `y`. - * (`id` is solely used for this textual representation.) - */ - class Scope[binderType <: NameElement] extends AbstractIterable[binderType] with Iterable[binderType] { - private val substitution: mutable.Map[binderType, Element] = - new mutable.LinkedHashMap[binderType, Element] // a LinkedHashMap is ordered by insertion order -- important! - - /** Returns a unique number identifying this Scope (only used for representation purposes). */ - val id: Int = _Binder.genId - - /** Returns the binders in this scope. - * For a typical let-binding, this is just the variable name. For an argument list to a method body, - * there is one binder per formal argument. - */ - def iterator = substitution.keysIterator - - /** Return the `i`th binder in this scope. */ - def apply(i: Int): binderType = this.iterator.toList(i) - - /** Returns true if this container has a binder equal (as determined by `==`) to `b`. */ - def binds(b: binderType): Boolean = substitution.contains(b) - - def indexFor(b: binderType): Option[Int] = { - val iter = this.iterator.zipWithIndex - for ((that, count) <- iter) { - if (that.name == b.name) // TODO: why do name equals and structural equals differ? - return Some(count + 1) - else - Console.println(that+"!="+b) - } - - None - } - - /** Adds a new binder, for example the variable name in a local variable declaration. - * - * @param b a new binder that is distinct from the existing binders in this scope, - * and shares their conceptual scope. `canAddBinder(b)` must hold. - * @return `binds(b)` and `getElementFor(b) eq b` will hold. - */ - def addBinder(b: binderType) { substitution += Pair(b, b) } - - // TODO: strengthen this condition so that no binders may be added after this scope has been - // linked to its `UnderBinder` (i.e., while parsing, BoundElements may be added to the Scope - // associated to the UnderBinder, but after that, no changes are allowed, except for substitution)? - /** `canAddElement` indicates whether `b` may be added to this scope. - * - * - * @return true if `b` had not been added yet - */ - def canAddBinder(b: binderType): Boolean = !binds(b) - - /** ''Replaces'' the bound occurrences of a contained binder by their new value. - * The bound occurrences of `b` are not actually replaced; the scope keeps track - * of a substitution that maps every binder to its current value. Since a `BoundElement` is - * a proxy for the element it is bound to by its binder, `substitute` may thus be thought of - * as replacing all the bound occurrences of the given binder `b` by their new value `value`. - * - * @param b the binder whose bound occurrences should be given a new value. `binds(b)` must hold. - * @param value the new value for the bound occurrences of `b` - * @return `getElementFor(b) eq value` will hold. - */ - def substitute(b: binderType, value: Element): Unit = substitution(b) = value - - /** Returns the current value for the bound occurrences of `b`. - * - * @param b the contained binder whose current value should be returned `binds(b)` must hold. - */ - def getElementFor(b: binderType): Element = substitution(b) - - override def toString: String = this.iterator.toList.mkString("[",", ","]")+"!"+id // TODO show substitution? - - /** Returns a list of strings that represent the binder elements, each tagged with this scope's id. */ - def bindersToString: List[String] = (for(b <- this.iterator) yield b+"!"+id).toList - - /** Return a new inheriting scope that won't check whether binding is respected until the scope is left (so as to support forward references). */ - def allowForwardRef: Scope[binderType] = this // TODO - - /** Return a nested scope -- binders entered into it won't be visible in this scope, but if this scope allows forward references, - * the binding in the returned scope also does, and thus the check that all variables are bound is deferred until this scope is left. - */ - def nested: Scope[binderType] = this // TODO - - def onEnter() {} - def onLeft() {} - } - - - trait BindingSensitive { - // would like to specify this as one method: - // def alpha_==[t <: NameElement](other: BoundElement[t]): Boolean - // def alpha_==[bt <: binderType, st <: elementT](other: UnderBinder[bt, st]): Boolean - } - - /** A `BoundElement` is bound in a certain scope `scope`, which keeps track of the actual element that - * `el` stands for. - * - * A `BoundElement` is represented textually by its bound element, followed by its scope's `id`. - * For example: `x@1` represents the variable `x` that is bound in the scope with `id` `1`. - * - * @note `scope.binds(el)` holds before and after. - */ - case class BoundElement[boundElement <: NameElement](el: boundElement, scope: Scope[boundElement]) extends NameElement with Proxy with BindingSensitive { - /** Returns the element this `BoundElement` stands for. - * The `Proxy` trait ensures `equals`, `hashCode` and `toString` are forwarded to - * the result of this method. - */ - def self: Element = scope.getElementFor(el) - - def name = self.asInstanceOf[NameElement].name // TODO: this is only safe when substituted to a NameElement, which certainly isn't required -- I want dynamic inheritance! :) - - // decorate element's representation with the id of the scope it's bound in - override def toString: String = super.toString+"@"+scope.id - - def alpha_==[t <: NameElement](other: BoundElement[t]): Boolean = scope.indexFor(el) == other.scope.indexFor(other.el) - } - - /** A variable that escaped its scope (i.e., a free variable) -- we don't deal very well with these yet. */ - class UnboundElement[N <: NameElement](private val el: N) extends NameElement { - def name = el.name+"@??" - } - - // this is useless, as Element is a supertype of BoundElement --> the coercion will never be inferred - // if we knew a more specific type for the element that the bound element represents, this could make sense - // implicit def BoundElementProxy[t <: NameElement](e: BoundElement[t]): Element = e.self - - /** Represents an element with variables that are bound in a certain scope. */ - class UnderBinder[binderType <: NameElement, elementT <% Mappable[elementT]](val scope: Scope[binderType], private[Binders] val element: elementT) extends Element with BindingSensitive { - override def toString: String = "(" + scope.toString + ") in { "+element.toString+" }" - - /** Alpha-equivalence -- TODO - * Returns true if the `element` of the `other` `UnderBinder` is equal to this `element` up to alpha-conversion. - * - * That is, regular equality is used for all elements but `BoundElement`s: such an element is - * equal to a `BoundElement` in `other` if their binders are equal. Binders are equal if they - * are at the same index in their respective scope. - * - * Example: - * {{{ - * UnderBinder([x, y]!1, x@1) alpha_== UnderBinder([a, b]!2, a@2) - * ! (UnderBinder([x, y]!1, y@1) alpha_== UnderBinder([a, b]!2, a@2)) - * }}} - */ - /*def alpha_==[bt <: binderType, st <: elementT](other: UnderBinder[bt, st]): Boolean = { - var result = true - - // TODO: generic zip or gmap2 - element.gmap2(other.element, new Mapper2 { - def apply[s <% Mappable[s], t <% Mappable[t]](x :{s, t}): {s, t} = x match { - case {be1: BoundElement[_], be2: BoundElement[_]} => result == result && be1.alpha_==(be2) // monadic gmap (cheating using state directly) - case {ub1: UnderBinder[_, _], ub2: UnderBinder[_, _]} => result == result && be1.alpha_==(be2) - case {a, b} => result == result && a.equals(b) - }; x - }) - }*/ - - def cloneElementWithSubst(subst: Map[NameElement, NameElement]) = element.gmap(new Mapper { def apply[t <% Mappable[t]](x :t): t = x match{ - case substable: NameElement if subst.contains(substable) => subst.get(substable).asInstanceOf[t] // TODO: wrong... substitution is not (necessarily) the identity function - //Console.println("substed: "+substable+"-> "+subst.get(substable)+")"); - case x => x // Console.println("subst: "+x+"(keys: "+subst.keys+")");x - }}) - - // TODO - def cloneElementNoBoundElements = element.gmap(new Mapper { def apply[t <% Mappable[t]](x :t): t = x match{ - case BoundElement(el, _) => new UnboundElement(el).asInstanceOf[t] // TODO: precision stuff - case x => x - }}) - - def extract: elementT = cloneElementNoBoundElements - def extract(subst: Map[NameElement, NameElement]): elementT = cloneElementWithSubst(subst) - - /** Get a string representation of element, normally we don't allow direct access to element, but just getting a string representation is ok. */ - def elementToString: String = element.toString - } - - //SYB type class instances - implicit def UnderBinderIsMappable[bt <: NameElement <% Mappable[bt], st <% Mappable[st]](ub: UnderBinder[bt, st]): Mappable[UnderBinder[bt, st]] = - new Mappable[UnderBinder[bt, st]] { - def gmap(f: Mapper): UnderBinder[bt, st] = UnderBinder(f(ub.scope), f(ub.element)) - } - - implicit def ScopeIsMappable[bt <: NameElement <% Mappable[bt]](scope: Scope[bt]): Mappable[Scope[bt]] = - new Mappable[Scope[bt]] { - def gmap(f: Mapper): Scope[bt] = { val newScope = new Scope[bt]() - for(b <- scope) newScope.addBinder(f(b)) - newScope - } - } - - implicit def NameElementIsMappable(self: NameElement): Mappable[NameElement] = new Mappable[NameElement] { - def gmap(f: Mapper): NameElement = self match { - case BoundElement(el, scope) => BoundElement(f(el), f(scope)) - case _ => UserNameElementIsMappable(self).gmap(f) - } - } - - def UserNameElementIsMappable[t <: NameElement](self: t): Mappable[t] - - object UnderBinder { - def apply[binderType <: NameElement, elementT <% Mappable[elementT]](scope: Scope[binderType], element: elementT) = new UnderBinder(scope, element) - def unit[bt <: NameElement, elementT <% Mappable[elementT]](x: elementT) = UnderBinder(new Scope[bt](), x) - } - - /** If a list of `UnderBinder`s all have the same scope, they can be turned in to an `UnderBinder` - * containing a list of the elements in the original `UnderBinder`. - * - * The name `sequence` comes from the fact that this method's type is equal to the type of monadic sequence. - * - * @note `!orig.isEmpty` implies `orig.forall(ub => ub.scope eq orig(0).scope)` - * - */ - def sequence[bt <: NameElement, st <% Mappable[st]](orig: List[UnderBinder[bt, st]]): UnderBinder[bt, List[st]] = - if(orig.isEmpty) UnderBinder.unit(Nil) - else UnderBinder(orig(0).scope, orig.map(_.element)) - - // couldn't come up with a better name... - def unsequence[bt <: NameElement, st <% Mappable[st]](orig: UnderBinder[bt, List[st]]): List[UnderBinder[bt, st]] = - orig.element.map(sc => UnderBinder(orig.scope, sc)) - - //TODO: more documentation - /** An environment that maps a `NameElement` to the scope in which it is bound. - * This can be used to model scoping during parsing. - * - * @note This class uses similar techniques as described by ''Burak Emir'' in - * [[http://library.epfl.ch/theses/?nr=3899 Object-oriented pattern matching]], - * but uses `==` instead of `eq`, thus types can't be unified in general. - */ - abstract class BinderEnv { - def apply[A <: NameElement](v: A): Option[Scope[A]] - def extend[a <: NameElement](v : a, x : Scope[a]) = new BinderEnv { - def apply[b <: NameElement](w : b): Option[Scope[b]] = - if(w == v) Some(x.asInstanceOf[Scope[b]]) - else BinderEnv.this.apply(w) - } - } - - object EmptyBinderEnv extends BinderEnv { - def apply[A <: NameElement](v: A): Option[Scope[A]] = None - } - - // TODO: move this to some utility object higher in the scala hierarchy? - /** Returns a given result, but executes the supplied closure before returning. - * (The effect of this closure does not influence the returned value.) - */ - trait ReturnAndDo[T]{ - /** - * @param block code to be executed, purely for its side-effects - */ - def andDo(block: => Unit): T - } - - def return_[T](result: T): ReturnAndDo[T] = - new ReturnAndDo[T] { - val r = result - def andDo(block: => Unit): T = {block; r} - } - - private object _Binder { - private var currentId = 0 - private[Binders] def genId = return_(currentId) andDo {currentId=currentId+1} - } -} diff --git a/src/library/scala/util/parsing/combinator/ImplicitConversions.scala b/src/library/scala/util/parsing/combinator/ImplicitConversions.scala index ad06749c0d..0683ea927d 100644 --- a/src/library/scala/util/parsing/combinator/ImplicitConversions.scala +++ b/src/library/scala/util/parsing/combinator/ImplicitConversions.scala @@ -7,7 +7,8 @@ \* */ -package scala.util.parsing.combinator +package scala +package util.parsing.combinator import scala.language.implicitConversions diff --git a/src/library/scala/util/parsing/combinator/JavaTokenParsers.scala b/src/library/scala/util/parsing/combinator/JavaTokenParsers.scala index 89832d3fb2..01288a182e 100644 --- a/src/library/scala/util/parsing/combinator/JavaTokenParsers.scala +++ b/src/library/scala/util/parsing/combinator/JavaTokenParsers.scala @@ -7,7 +7,8 @@ \* */ -package scala.util.parsing.combinator +package scala +package util.parsing.combinator import scala.annotation.migration diff --git a/src/library/scala/util/parsing/combinator/PackratParsers.scala b/src/library/scala/util/parsing/combinator/PackratParsers.scala index cd0907e40f..a11dd18e62 100644 --- a/src/library/scala/util/parsing/combinator/PackratParsers.scala +++ b/src/library/scala/util/parsing/combinator/PackratParsers.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.util.parsing.combinator +package scala +package util.parsing.combinator import scala.util.parsing.input.{ Reader, Position } import scala.collection.mutable diff --git a/src/library/scala/util/parsing/combinator/Parsers.scala b/src/library/scala/util/parsing/combinator/Parsers.scala index 542a781b60..4602c3cc53 100644 --- a/src/library/scala/util/parsing/combinator/Parsers.scala +++ b/src/library/scala/util/parsing/combinator/Parsers.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.util.parsing.combinator +package scala +package util.parsing.combinator import scala.util.parsing.input._ import scala.collection.mutable.ListBuffer @@ -157,12 +158,6 @@ trait Parsers { private lazy val lastNoSuccessVar = new DynamicVariable[Option[NoSuccess]](None) - @deprecated("lastNoSuccess was not thread-safe and will be removed in 2.11.0", "2.10.0") - def lastNoSuccess: NoSuccess = lastNoSuccessVar.value.orNull - - @deprecated("lastNoSuccess was not thread-safe and will be removed in 2.11.0", "2.10.0") - def lastNoSuccess_=(x: NoSuccess): Unit = lastNoSuccessVar.value = Option(x) - /** A common super-class for unsuccessful parse results. */ sealed abstract class NoSuccess(val msg: String, override val next: Input) extends ParseResult[Nothing] { // when we don't care about the difference between Failure and Error val successful = false diff --git a/src/library/scala/util/parsing/combinator/RegexParsers.scala b/src/library/scala/util/parsing/combinator/RegexParsers.scala index d17d0cac8d..8ebbc573ad 100644 --- a/src/library/scala/util/parsing/combinator/RegexParsers.scala +++ b/src/library/scala/util/parsing/combinator/RegexParsers.scala @@ -7,7 +7,8 @@ \* */ -package scala.util.parsing.combinator +package scala +package util.parsing.combinator import java.util.regex.Pattern import scala.util.matching.Regex diff --git a/src/library/scala/util/parsing/combinator/lexical/Lexical.scala b/src/library/scala/util/parsing/combinator/lexical/Lexical.scala index c25c97278f..d8029d068f 100644 --- a/src/library/scala/util/parsing/combinator/lexical/Lexical.scala +++ b/src/library/scala/util/parsing/combinator/lexical/Lexical.scala @@ -8,7 +8,8 @@ -package scala.util.parsing +package scala +package util.parsing package combinator package lexical diff --git a/src/library/scala/util/parsing/combinator/lexical/Scanners.scala b/src/library/scala/util/parsing/combinator/lexical/Scanners.scala index f6a8daabd9..2e12915bb8 100644 --- a/src/library/scala/util/parsing/combinator/lexical/Scanners.scala +++ b/src/library/scala/util/parsing/combinator/lexical/Scanners.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.util.parsing +package scala +package util.parsing package combinator package lexical diff --git a/src/library/scala/util/parsing/combinator/lexical/StdLexical.scala b/src/library/scala/util/parsing/combinator/lexical/StdLexical.scala index 2fbc1ec136..32d7502cda 100644 --- a/src/library/scala/util/parsing/combinator/lexical/StdLexical.scala +++ b/src/library/scala/util/parsing/combinator/lexical/StdLexical.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.util.parsing +package scala +package util.parsing package combinator package lexical diff --git a/src/library/scala/util/parsing/combinator/syntactical/StandardTokenParsers.scala b/src/library/scala/util/parsing/combinator/syntactical/StandardTokenParsers.scala index d3ae0ea54a..5b9d14c9a7 100644 --- a/src/library/scala/util/parsing/combinator/syntactical/StandardTokenParsers.scala +++ b/src/library/scala/util/parsing/combinator/syntactical/StandardTokenParsers.scala @@ -7,7 +7,8 @@ \* */ -package scala.util.parsing +package scala +package util.parsing package combinator package syntactical diff --git a/src/library/scala/util/parsing/combinator/syntactical/StdTokenParsers.scala b/src/library/scala/util/parsing/combinator/syntactical/StdTokenParsers.scala index 7283b01da4..adcf85da7a 100644 --- a/src/library/scala/util/parsing/combinator/syntactical/StdTokenParsers.scala +++ b/src/library/scala/util/parsing/combinator/syntactical/StdTokenParsers.scala @@ -8,7 +8,8 @@ -package scala.util.parsing +package scala +package util.parsing package combinator package syntactical diff --git a/src/library/scala/util/parsing/combinator/syntactical/TokenParsers.scala b/src/library/scala/util/parsing/combinator/syntactical/TokenParsers.scala index 1c4b25b999..b06babcd7e 100644 --- a/src/library/scala/util/parsing/combinator/syntactical/TokenParsers.scala +++ b/src/library/scala/util/parsing/combinator/syntactical/TokenParsers.scala @@ -7,7 +7,8 @@ \* */ -package scala.util.parsing +package scala +package util.parsing package combinator package syntactical diff --git a/src/library/scala/util/parsing/combinator/testing/RegexTest.scala b/src/library/scala/util/parsing/combinator/testing/RegexTest.scala deleted file mode 100644 index 80e9b0df39..0000000000 --- a/src/library/scala/util/parsing/combinator/testing/RegexTest.scala +++ /dev/null @@ -1,27 +0,0 @@ - -package scala.util.parsing.combinator.testing - -import scala.util.parsing.combinator._ -import scala.util.parsing.input._ -import scala.language.postfixOps - -@deprecated("This class will be removed", "2.10.0") -case class Ident(s: String) -@deprecated("This class will be removed", "2.10.0") -case class Number(n: Int) -@deprecated("This class will be removed", "2.10.0") -case class Str(s: String) - -@deprecated("This class will be removed", "2.10.0") -object RegexTest extends RegexParsers { - val ident: Parser[Any] = """[a-zA-Z_]\w*""".r ^^ (s => Ident(s)) - val number: Parser[Any] = """\d\d*""".r ^^ (s => Number(s.toInt)) - val string: Parser[Any] = "\".*\"".r ^^ (s => Str(s.substring(1, s.length - 1))) - val parser = (ident | number | string)* - - def main(args: Array[String]) = { - val in = args mkString " " - println("\nin : "+in) - println(phrase[Any](parser)(new CharSequenceReader(in))) - } -} diff --git a/src/library/scala/util/parsing/combinator/testing/Tester.scala b/src/library/scala/util/parsing/combinator/testing/Tester.scala deleted file mode 100644 index 3cdab2a885..0000000000 --- a/src/library/scala/util/parsing/combinator/testing/Tester.scala +++ /dev/null @@ -1,44 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2006-2013, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - -package scala.util.parsing.combinator.testing - -import scala.util.parsing.combinator.lexical.Lexical -import scala.util.parsing.combinator.syntactical.TokenParsers - -/** Facilitates testing a given parser on various input strings. - * - * Example use: - * {{{ - * val syntactic = new MyParsers - * }}} - * and - * {{{ - * val parser = syntactic.term - * }}} - * (If `MyParsers` extends [[scala.util.parsing.combinator.syntactical.TokenParsers]] - * with a parser called `term`.) - * - * @author Martin Odersky - * @author Adriaan Moors - */ -@deprecated("This class will be removed", "2.10.0") -abstract class Tester { - - val syntactic: TokenParsers { val lexical: Lexical } - val parser: syntactic.Parser[Any] - - /** Scans a String (using a `syntactic.lexical.Scanner`), parses it using - * `phrase(parser)`, and prints the input and the parsed result to the - * console. - */ - def test(in: String) { - Console.println("\nin : "+in) - Console.println(syntactic.phrase[Any](parser)(new syntactic.lexical.Scanner(in))) - } -} diff --git a/src/library/scala/util/parsing/combinator/token/StdTokens.scala b/src/library/scala/util/parsing/combinator/token/StdTokens.scala index 605f53bf1d..a102d1541e 100644 --- a/src/library/scala/util/parsing/combinator/token/StdTokens.scala +++ b/src/library/scala/util/parsing/combinator/token/StdTokens.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.util.parsing +package scala +package util.parsing package combinator package token diff --git a/src/library/scala/util/parsing/combinator/token/Tokens.scala b/src/library/scala/util/parsing/combinator/token/Tokens.scala index ff92802d77..5c3f1f95b5 100644 --- a/src/library/scala/util/parsing/combinator/token/Tokens.scala +++ b/src/library/scala/util/parsing/combinator/token/Tokens.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.util.parsing +package scala +package util.parsing package combinator package token diff --git a/src/library/scala/util/parsing/input/CharArrayReader.scala b/src/library/scala/util/parsing/input/CharArrayReader.scala index 3ba69b229b..22530cb9aa 100644 --- a/src/library/scala/util/parsing/input/CharArrayReader.scala +++ b/src/library/scala/util/parsing/input/CharArrayReader.scala @@ -7,7 +7,8 @@ \* */ -package scala.util.parsing.input +package scala +package util.parsing.input /** An object encapsulating basic character constants. * diff --git a/src/library/scala/util/parsing/input/CharSequenceReader.scala b/src/library/scala/util/parsing/input/CharSequenceReader.scala index 02aa2ab7b8..8e7751cc82 100644 --- a/src/library/scala/util/parsing/input/CharSequenceReader.scala +++ b/src/library/scala/util/parsing/input/CharSequenceReader.scala @@ -7,7 +7,8 @@ \* */ -package scala.util.parsing.input +package scala +package util.parsing.input /** An object encapsulating basic character constants. * diff --git a/src/library/scala/util/parsing/input/NoPosition.scala b/src/library/scala/util/parsing/input/NoPosition.scala index 40584b3293..4a32264b79 100644 --- a/src/library/scala/util/parsing/input/NoPosition.scala +++ b/src/library/scala/util/parsing/input/NoPosition.scala @@ -8,7 +8,8 @@ -package scala.util.parsing.input +package scala +package util.parsing.input /** Undefined position. * diff --git a/src/library/scala/util/parsing/input/OffsetPosition.scala b/src/library/scala/util/parsing/input/OffsetPosition.scala index 6b00af4ce2..23f79c74d1 100644 --- a/src/library/scala/util/parsing/input/OffsetPosition.scala +++ b/src/library/scala/util/parsing/input/OffsetPosition.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.util.parsing.input +package scala +package util.parsing.input import scala.collection.mutable.ArrayBuffer diff --git a/src/library/scala/util/parsing/input/PagedSeqReader.scala b/src/library/scala/util/parsing/input/PagedSeqReader.scala index 9140bf2a4f..468f1f9a5f 100644 --- a/src/library/scala/util/parsing/input/PagedSeqReader.scala +++ b/src/library/scala/util/parsing/input/PagedSeqReader.scala @@ -7,7 +7,8 @@ \* */ -package scala.util.parsing.input +package scala +package util.parsing.input import scala.collection.immutable.PagedSeq diff --git a/src/library/scala/util/parsing/input/Position.scala b/src/library/scala/util/parsing/input/Position.scala index 5e0cbbff5e..b7995a6471 100644 --- a/src/library/scala/util/parsing/input/Position.scala +++ b/src/library/scala/util/parsing/input/Position.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.util.parsing.input +package scala +package util.parsing.input /** `Position` is the base trait for objects describing a position in a `document`. * diff --git a/src/library/scala/util/parsing/input/Positional.scala b/src/library/scala/util/parsing/input/Positional.scala index 87cb16eac5..cfde67cadd 100644 --- a/src/library/scala/util/parsing/input/Positional.scala +++ b/src/library/scala/util/parsing/input/Positional.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.util.parsing.input +package scala +package util.parsing.input /** A trait for objects that have a source position. * diff --git a/src/library/scala/util/parsing/input/Reader.scala b/src/library/scala/util/parsing/input/Reader.scala index bded57bee1..9dbf08a7ca 100644 --- a/src/library/scala/util/parsing/input/Reader.scala +++ b/src/library/scala/util/parsing/input/Reader.scala @@ -8,7 +8,8 @@ -package scala.util.parsing.input +package scala +package util.parsing.input /** An interface for streams of values that have positions. diff --git a/src/library/scala/util/parsing/input/StreamReader.scala b/src/library/scala/util/parsing/input/StreamReader.scala index ba7ab65845..30eb097fd7 100644 --- a/src/library/scala/util/parsing/input/StreamReader.scala +++ b/src/library/scala/util/parsing/input/StreamReader.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.util.parsing.input +package scala +package util.parsing.input import java.io.BufferedReader import scala.collection.immutable.PagedSeq @@ -22,7 +23,7 @@ object StreamReader { * * @param in the `java.io.Reader` that provides the underlying * stream of characters for this Reader. - */ + */ def apply(in: java.io.Reader): StreamReader = { new StreamReader(PagedSeq.fromReader(in), 0, 1) } diff --git a/src/library/scala/util/parsing/json/JSON.scala b/src/library/scala/util/parsing/json/JSON.scala index 8f951d519a..6eaa47473f 100644 --- a/src/library/scala/util/parsing/json/JSON.scala +++ b/src/library/scala/util/parsing/json/JSON.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.util.parsing.json +package scala +package util.parsing.json /** * This object provides a simple interface to the JSON parser class. diff --git a/src/library/scala/util/parsing/json/Lexer.scala b/src/library/scala/util/parsing/json/Lexer.scala index 762c1352a7..63df9c28eb 100644 --- a/src/library/scala/util/parsing/json/Lexer.scala +++ b/src/library/scala/util/parsing/json/Lexer.scala @@ -8,7 +8,8 @@ -package scala.util.parsing.json +package scala +package util.parsing.json import scala.util.parsing.combinator._ import scala.util.parsing.combinator.lexical._ diff --git a/src/library/scala/util/parsing/json/Parser.scala b/src/library/scala/util/parsing/json/Parser.scala index bf1162000b..c61e3df181 100644 --- a/src/library/scala/util/parsing/json/Parser.scala +++ b/src/library/scala/util/parsing/json/Parser.scala @@ -8,7 +8,8 @@ -package scala.util.parsing.json +package scala +package util.parsing.json import scala.util.parsing.combinator._ import scala.util.parsing.combinator.syntactical._ diff --git a/src/library/scala/xml/Atom.scala b/src/library/scala/xml/Atom.scala index cba0b96875..33e58ba7e7 100644 --- a/src/library/scala/xml/Atom.scala +++ b/src/library/scala/xml/Atom.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.xml +package scala +package xml /** The class `Atom` provides an XML node for text (`PCDATA`). * It is used in both non-bound and bound XML representations. diff --git a/src/library/scala/xml/Attribute.scala b/src/library/scala/xml/Attribute.scala index 234281163d..e4b2b69fc6 100644 --- a/src/library/scala/xml/Attribute.scala +++ b/src/library/scala/xml/Attribute.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.xml +package scala +package xml /** This singleton object contains the `apply` and `unapply` methods for * convenient construction and deconstruction. diff --git a/src/library/scala/xml/Comment.scala b/src/library/scala/xml/Comment.scala index ff4280d691..b8dccdcb16 100644 --- a/src/library/scala/xml/Comment.scala +++ b/src/library/scala/xml/Comment.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.xml +package scala +package xml /** The class `Comment` implements an XML node for comments. * diff --git a/src/library/scala/xml/Document.scala b/src/library/scala/xml/Document.scala index a064c4d8e8..9a725014fc 100644 --- a/src/library/scala/xml/Document.scala +++ b/src/library/scala/xml/Document.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.xml +package scala +package xml /** A document information item (according to InfoSet spec). The comments * are copied from the Infoset spec, only augmented with some information diff --git a/src/library/scala/xml/Elem.scala b/src/library/scala/xml/Elem.scala index fc32e45a5e..4200b7046a 100755 --- a/src/library/scala/xml/Elem.scala +++ b/src/library/scala/xml/Elem.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.xml +package scala +package xml /** This singleton object contains the `apply` and `unapplySeq` methods for * convenient construction and deconstruction. It is possible to deconstruct diff --git a/src/library/scala/xml/EntityRef.scala b/src/library/scala/xml/EntityRef.scala index a7b9835a7e..7a58831075 100644 --- a/src/library/scala/xml/EntityRef.scala +++ b/src/library/scala/xml/EntityRef.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.xml +package scala +package xml /** The class `EntityRef` implements an XML node for entity references. * diff --git a/src/library/scala/xml/Equality.scala b/src/library/scala/xml/Equality.scala index 20f2405967..021d185812 100644 --- a/src/library/scala/xml/Equality.scala +++ b/src/library/scala/xml/Equality.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.xml +package scala +package xml /** In an attempt to contain the damage being inflicted on consistency by the * ad hoc `equals` methods spread around `xml`, the logic is centralized and diff --git a/src/library/scala/xml/Group.scala b/src/library/scala/xml/Group.scala index 2ee3941aa1..e3af615008 100644 --- a/src/library/scala/xml/Group.scala +++ b/src/library/scala/xml/Group.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.xml +package scala +package xml /** A hack to group XML nodes in one node for output. * diff --git a/src/library/scala/xml/MalformedAttributeException.scala b/src/library/scala/xml/MalformedAttributeException.scala index 3431cb6765..d499ad3e10 100644 --- a/src/library/scala/xml/MalformedAttributeException.scala +++ b/src/library/scala/xml/MalformedAttributeException.scala @@ -8,7 +8,8 @@ -package scala.xml +package scala +package xml case class MalformedAttributeException(msg: String) extends RuntimeException(msg) diff --git a/src/library/scala/xml/MetaData.scala b/src/library/scala/xml/MetaData.scala index 3bf3ebb1c0..8b5ea187cb 100644 --- a/src/library/scala/xml/MetaData.scala +++ b/src/library/scala/xml/MetaData.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.xml +package scala +package xml import Utility.sbToString import scala.annotation.tailrec diff --git a/src/library/scala/xml/NamespaceBinding.scala b/src/library/scala/xml/NamespaceBinding.scala index 32c378f3ef..b320466976 100644 --- a/src/library/scala/xml/NamespaceBinding.scala +++ b/src/library/scala/xml/NamespaceBinding.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.xml +package scala +package xml import Utility.sbToString diff --git a/src/library/scala/xml/Node.scala b/src/library/scala/xml/Node.scala index 7b1a97e8f2..e121284252 100755 --- a/src/library/scala/xml/Node.scala +++ b/src/library/scala/xml/Node.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.xml +package scala +package xml /** This singleton object contains the `unapplySeq` method for * convenient deconstruction. diff --git a/src/library/scala/xml/NodeBuffer.scala b/src/library/scala/xml/NodeBuffer.scala index 2db4338fb2..ae7c7b2bf8 100644 --- a/src/library/scala/xml/NodeBuffer.scala +++ b/src/library/scala/xml/NodeBuffer.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.xml +package scala +package xml /** * This class acts as a Buffer for nodes. If it is used as a sequence of diff --git a/src/library/scala/xml/NodeSeq.scala b/src/library/scala/xml/NodeSeq.scala index d2efc947b1..b8022472fb 100644 --- a/src/library/scala/xml/NodeSeq.scala +++ b/src/library/scala/xml/NodeSeq.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.xml +package scala +package xml import scala.collection.{ mutable, immutable, generic, SeqLike, AbstractSeq } import mutable.{ Builder, ListBuffer } diff --git a/src/library/scala/xml/Null.scala b/src/library/scala/xml/Null.scala index b39ef5dc67..f763c023c4 100644 --- a/src/library/scala/xml/Null.scala +++ b/src/library/scala/xml/Null.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.xml +package scala +package xml import Utility.isNameStart import scala.collection.Iterator diff --git a/src/library/scala/xml/PCData.scala b/src/library/scala/xml/PCData.scala index 64818a9c00..31eea2b6d7 100644 --- a/src/library/scala/xml/PCData.scala +++ b/src/library/scala/xml/PCData.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.xml +package scala +package xml /** This class (which is not used by all XML parsers, but always used by the * XHTML one) represents parseable character data, which appeared as CDATA diff --git a/src/library/scala/xml/PrefixedAttribute.scala b/src/library/scala/xml/PrefixedAttribute.scala index 429cd682d6..4ab79c8677 100644 --- a/src/library/scala/xml/PrefixedAttribute.scala +++ b/src/library/scala/xml/PrefixedAttribute.scala @@ -7,7 +7,8 @@ \* */ -package scala.xml +package scala +package xml /** prefixed attributes always have a non-null namespace. * diff --git a/src/library/scala/xml/PrettyPrinter.scala b/src/library/scala/xml/PrettyPrinter.scala index 720fe79b1d..9e01905357 100755 --- a/src/library/scala/xml/PrettyPrinter.scala +++ b/src/library/scala/xml/PrettyPrinter.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.xml +package scala +package xml import Utility.sbToString diff --git a/src/library/scala/xml/ProcInstr.scala b/src/library/scala/xml/ProcInstr.scala index 64a9dd5ca3..189c1c6878 100644 --- a/src/library/scala/xml/ProcInstr.scala +++ b/src/library/scala/xml/ProcInstr.scala @@ -7,7 +7,8 @@ \* */ -package scala.xml +package scala +package xml /** an XML node for processing instructions (PI) * diff --git a/src/library/scala/xml/QNode.scala b/src/library/scala/xml/QNode.scala index d4d3872181..f9e3f1854b 100644 --- a/src/library/scala/xml/QNode.scala +++ b/src/library/scala/xml/QNode.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.xml +package scala +package xml /** This object provides an extractor method to match a qualified node with * its namespace URI diff --git a/src/library/scala/xml/SpecialNode.scala b/src/library/scala/xml/SpecialNode.scala index 4c1b81c7ff..5fef8ef66c 100644 --- a/src/library/scala/xml/SpecialNode.scala +++ b/src/library/scala/xml/SpecialNode.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.xml +package scala +package xml /** `SpecialNode` is a special XML node which represents either text * `(PCDATA)`, a comment, a `PI`, or an entity ref. diff --git a/src/library/scala/xml/Text.scala b/src/library/scala/xml/Text.scala index 782c80f100..debea0c025 100644 --- a/src/library/scala/xml/Text.scala +++ b/src/library/scala/xml/Text.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.xml +package scala +package xml /** The class `Text` implements an XML node for text (PCDATA). * It is used in both non-bound and bound XML representations. diff --git a/src/library/scala/xml/TextBuffer.scala b/src/library/scala/xml/TextBuffer.scala index 0b96379d85..514b1701af 100644 --- a/src/library/scala/xml/TextBuffer.scala +++ b/src/library/scala/xml/TextBuffer.scala @@ -7,7 +7,8 @@ \* */ -package scala.xml +package scala +package xml import Utility.isSpace diff --git a/src/library/scala/xml/TopScope.scala b/src/library/scala/xml/TopScope.scala index 1ed1d50e10..474fbbbdb5 100644 --- a/src/library/scala/xml/TopScope.scala +++ b/src/library/scala/xml/TopScope.scala @@ -7,7 +7,8 @@ \* */ -package scala.xml +package scala +package xml /** top level namespace scope. only contains the predefined binding * for the "xml" prefix which is bound to diff --git a/src/library/scala/xml/TypeSymbol.scala b/src/library/scala/xml/TypeSymbol.scala index f02c0263c0..fb371ee340 100644 --- a/src/library/scala/xml/TypeSymbol.scala +++ b/src/library/scala/xml/TypeSymbol.scala @@ -8,7 +8,8 @@ -package scala.xml +package scala +package xml abstract class TypeSymbol diff --git a/src/library/scala/xml/Unparsed.scala b/src/library/scala/xml/Unparsed.scala index ef80823611..bc190eb724 100644 --- a/src/library/scala/xml/Unparsed.scala +++ b/src/library/scala/xml/Unparsed.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.xml +package scala +package xml /** An XML node for unparsed content. It will be output verbatim, all bets * are off regarding wellformedness etc. diff --git a/src/library/scala/xml/UnprefixedAttribute.scala b/src/library/scala/xml/UnprefixedAttribute.scala index 2985591c95..6fa827da5f 100644 --- a/src/library/scala/xml/UnprefixedAttribute.scala +++ b/src/library/scala/xml/UnprefixedAttribute.scala @@ -7,7 +7,8 @@ \* */ -package scala.xml +package scala +package xml /** Unprefixed attributes have the null namespace, and no prefix field * diff --git a/src/library/scala/xml/Utility.scala b/src/library/scala/xml/Utility.scala index fff27c6e30..9134476401 100755 --- a/src/library/scala/xml/Utility.scala +++ b/src/library/scala/xml/Utility.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.xml +package scala +package xml import scala.collection.mutable import parsing.XhtmlEntities diff --git a/src/library/scala/xml/XML.scala b/src/library/scala/xml/XML.scala index ec5e5e9e1c..020264e509 100755 --- a/src/library/scala/xml/XML.scala +++ b/src/library/scala/xml/XML.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.xml +package scala +package xml import parsing.NoBindingFactoryAdapter import factory.XMLLoader diff --git a/src/library/scala/xml/Xhtml.scala b/src/library/scala/xml/Xhtml.scala index 6730548b73..6a12c1a89a 100644 --- a/src/library/scala/xml/Xhtml.scala +++ b/src/library/scala/xml/Xhtml.scala @@ -1,5 +1,6 @@ -package scala.xml +package scala +package xml import parsing.XhtmlEntities import Utility.{ sbToString, isAtomAndNotText } diff --git a/src/library/scala/xml/dtd/ContentModel.scala b/src/library/scala/xml/dtd/ContentModel.scala index debdf37975..4007985dce 100644 --- a/src/library/scala/xml/dtd/ContentModel.scala +++ b/src/library/scala/xml/dtd/ContentModel.scala @@ -6,9 +6,8 @@ ** |/ ** \* */ - - -package scala.xml +package scala +package xml package dtd import scala.xml.dtd.impl._ diff --git a/src/library/scala/xml/dtd/ContentModelParser.scala b/src/library/scala/xml/dtd/ContentModelParser.scala index ca84bcad70..71b391c422 100644 --- a/src/library/scala/xml/dtd/ContentModelParser.scala +++ b/src/library/scala/xml/dtd/ContentModelParser.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.xml +package scala +package xml package dtd /** Parser for regexps (content models in DTD element declarations) */ diff --git a/src/library/scala/xml/dtd/DTD.scala b/src/library/scala/xml/dtd/DTD.scala index 1f8af3b59e..16a824fe2c 100644 --- a/src/library/scala/xml/dtd/DTD.scala +++ b/src/library/scala/xml/dtd/DTD.scala @@ -7,7 +7,8 @@ \* */ -package scala.xml +package scala +package xml package dtd import scala.collection.mutable diff --git a/src/library/scala/xml/dtd/Decl.scala b/src/library/scala/xml/dtd/Decl.scala index fd2eaa30ba..e6804478bd 100644 --- a/src/library/scala/xml/dtd/Decl.scala +++ b/src/library/scala/xml/dtd/Decl.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.xml +package scala +package xml package dtd import Utility.sbToString diff --git a/src/library/scala/xml/dtd/DocType.scala b/src/library/scala/xml/dtd/DocType.scala index af7e77e76f..849d560cc9 100644 --- a/src/library/scala/xml/dtd/DocType.scala +++ b/src/library/scala/xml/dtd/DocType.scala @@ -7,7 +7,8 @@ \* */ -package scala.xml +package scala +package xml package dtd /** An XML node for document type declaration. diff --git a/src/library/scala/xml/dtd/ElementValidator.scala b/src/library/scala/xml/dtd/ElementValidator.scala index ad74acb77e..4830769a7d 100644 --- a/src/library/scala/xml/dtd/ElementValidator.scala +++ b/src/library/scala/xml/dtd/ElementValidator.scala @@ -8,7 +8,8 @@ -package scala.xml +package scala +package xml package dtd import PartialFunction._ diff --git a/src/library/scala/xml/dtd/ExternalID.scala b/src/library/scala/xml/dtd/ExternalID.scala index 80ada0caaa..5a1b5d1a19 100644 --- a/src/library/scala/xml/dtd/ExternalID.scala +++ b/src/library/scala/xml/dtd/ExternalID.scala @@ -7,7 +7,8 @@ \* */ -package scala.xml +package scala +package xml package dtd /** an ExternalIDs - either PublicID or SystemID diff --git a/src/library/scala/xml/dtd/Scanner.scala b/src/library/scala/xml/dtd/Scanner.scala index 53404e34a7..5f9d1ccaed 100644 --- a/src/library/scala/xml/dtd/Scanner.scala +++ b/src/library/scala/xml/dtd/Scanner.scala @@ -7,7 +7,8 @@ \* */ -package scala.xml +package scala +package xml package dtd /** Scanner for regexps (content models in DTD element declarations) diff --git a/src/library/scala/xml/dtd/Tokens.scala b/src/library/scala/xml/dtd/Tokens.scala index eaffba99a4..07e888e77a 100644 --- a/src/library/scala/xml/dtd/Tokens.scala +++ b/src/library/scala/xml/dtd/Tokens.scala @@ -8,7 +8,8 @@ -package scala.xml +package scala +package xml package dtd diff --git a/src/library/scala/xml/dtd/ValidationException.scala b/src/library/scala/xml/dtd/ValidationException.scala index 15640e2da7..1bfae55286 100644 --- a/src/library/scala/xml/dtd/ValidationException.scala +++ b/src/library/scala/xml/dtd/ValidationException.scala @@ -8,7 +8,8 @@ -package scala.xml +package scala +package xml package dtd diff --git a/src/library/scala/xml/dtd/impl/Base.scala b/src/library/scala/xml/dtd/impl/Base.scala index dd277779f6..91ff03a93a 100644 --- a/src/library/scala/xml/dtd/impl/Base.scala +++ b/src/library/scala/xml/dtd/impl/Base.scala @@ -8,7 +8,8 @@ -package scala.xml.dtd.impl +package scala +package xml.dtd.impl /** Basic regular expressions. * diff --git a/src/library/scala/xml/dtd/impl/BaseBerrySethi.scala b/src/library/scala/xml/dtd/impl/BaseBerrySethi.scala index 99d5ab62e1..f30309b037 100644 --- a/src/library/scala/xml/dtd/impl/BaseBerrySethi.scala +++ b/src/library/scala/xml/dtd/impl/BaseBerrySethi.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.xml.dtd.impl +package scala +package xml.dtd.impl import scala.collection.{ mutable, immutable } diff --git a/src/library/scala/xml/dtd/impl/DetWordAutom.scala b/src/library/scala/xml/dtd/impl/DetWordAutom.scala index 5c1dcb7ff8..6f8ba4de72 100644 --- a/src/library/scala/xml/dtd/impl/DetWordAutom.scala +++ b/src/library/scala/xml/dtd/impl/DetWordAutom.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.xml.dtd.impl +package scala +package xml.dtd.impl import scala.collection.{ mutable, immutable } diff --git a/src/library/scala/xml/dtd/impl/Inclusion.scala b/src/library/scala/xml/dtd/impl/Inclusion.scala index 0ae78519ca..07b6afaeba 100644 --- a/src/library/scala/xml/dtd/impl/Inclusion.scala +++ b/src/library/scala/xml/dtd/impl/Inclusion.scala @@ -8,7 +8,8 @@ -package scala.xml.dtd.impl +package scala +package xml.dtd.impl /** A fast test of language inclusion between minimal automata. diff --git a/src/library/scala/xml/dtd/impl/NondetWordAutom.scala b/src/library/scala/xml/dtd/impl/NondetWordAutom.scala index 8e0b5a3a4c..0bb19a7e3e 100644 --- a/src/library/scala/xml/dtd/impl/NondetWordAutom.scala +++ b/src/library/scala/xml/dtd/impl/NondetWordAutom.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.xml.dtd.impl +package scala +package xml.dtd.impl import scala.collection.{ immutable, mutable } @@ -51,7 +52,7 @@ private[dtd] abstract class NondetWordAutom[T <: AnyRef] { override def toString = { val finalString = Map(finalStates map (j => j -> finals(j)) : _*).toString - val deltaString = (0 until nstates) + val deltaString = (0 until nstates) .map(i => " %d->%s\n _>%s\n".format(i, delta(i), default(i))).mkString "[NondetWordAutom nstates=%d finals=%s delta=\n%s".format(nstates, finalString, deltaString) diff --git a/src/library/scala/xml/dtd/impl/PointedHedgeExp.scala b/src/library/scala/xml/dtd/impl/PointedHedgeExp.scala index 0b5297510d..1720604132 100644 --- a/src/library/scala/xml/dtd/impl/PointedHedgeExp.scala +++ b/src/library/scala/xml/dtd/impl/PointedHedgeExp.scala @@ -8,7 +8,8 @@ -package scala.xml.dtd.impl +package scala +package xml.dtd.impl /** Pointed regular hedge expressions, a useful subclass of regular hedge expressions. * diff --git a/src/library/scala/xml/dtd/impl/SubsetConstruction.scala b/src/library/scala/xml/dtd/impl/SubsetConstruction.scala index d1ea4b6e9e..632ca1eb18 100644 --- a/src/library/scala/xml/dtd/impl/SubsetConstruction.scala +++ b/src/library/scala/xml/dtd/impl/SubsetConstruction.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.xml.dtd.impl +package scala +package xml.dtd.impl import scala.collection.{ mutable, immutable } diff --git a/src/library/scala/xml/dtd/impl/SyntaxError.scala b/src/library/scala/xml/dtd/impl/SyntaxError.scala index b0e0b8b6cd..a5b8a5aba0 100644 --- a/src/library/scala/xml/dtd/impl/SyntaxError.scala +++ b/src/library/scala/xml/dtd/impl/SyntaxError.scala @@ -8,7 +8,8 @@ -package scala.xml.dtd.impl +package scala +package xml.dtd.impl /** This runtime exception is thrown if an attempt to instantiate a * syntactically incorrect expression is detected. diff --git a/src/library/scala/xml/dtd/impl/WordBerrySethi.scala b/src/library/scala/xml/dtd/impl/WordBerrySethi.scala index 90d7fe760a..9bf3fa518b 100644 --- a/src/library/scala/xml/dtd/impl/WordBerrySethi.scala +++ b/src/library/scala/xml/dtd/impl/WordBerrySethi.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.xml.dtd.impl +package scala +package xml.dtd.impl import scala.collection.{ immutable, mutable } diff --git a/src/library/scala/xml/dtd/impl/WordExp.scala b/src/library/scala/xml/dtd/impl/WordExp.scala index 38f8aea697..a4bb54c1ea 100644 --- a/src/library/scala/xml/dtd/impl/WordExp.scala +++ b/src/library/scala/xml/dtd/impl/WordExp.scala @@ -8,7 +8,8 @@ -package scala.xml.dtd.impl +package scala +package xml.dtd.impl /** * The class `WordExp` provides regular word expressions. diff --git a/src/library/scala/xml/factory/Binder.scala b/src/library/scala/xml/factory/Binder.scala index b463fda5ba..947f99e6a4 100755 --- a/src/library/scala/xml/factory/Binder.scala +++ b/src/library/scala/xml/factory/Binder.scala @@ -8,7 +8,8 @@ -package scala.xml +package scala +package xml package factory import parsing.ValidatingMarkupHandler diff --git a/src/library/scala/xml/factory/LoggedNodeFactory.scala b/src/library/scala/xml/factory/LoggedNodeFactory.scala index 49a6d622a7..bc074bfc83 100644 --- a/src/library/scala/xml/factory/LoggedNodeFactory.scala +++ b/src/library/scala/xml/factory/LoggedNodeFactory.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.xml +package scala +package xml package factory /** This class logs what the nodefactory is actually doing. @@ -14,8 +15,9 @@ package factory {{{ object testLogged extends App { val x = new scala.xml.parsing.NoBindingFactoryAdapter - with scala.xml.factory.LoggedNodeFactory[scala.xml.Elem] - with scala.util.logging.ConsoleLogger + with scala.xml.factory.LoggedNodeFactory[scala.xml.Elem] { + override def log(s: String) = println(s) + } Console.println("Start") val doc = x.load(new java.net.URL("http://example.com/file.xml")) @@ -27,7 +29,8 @@ object testLogged extends App { * @author Burak Emir * @version 1.0 */ -trait LoggedNodeFactory[A <: Node] extends NodeFactory[A] with scala.util.logging.Logged { +@deprecated("This trait will be removed.", "2.11") +trait LoggedNodeFactory[A <: Node] extends NodeFactory[A] { // configuration values val logNode = true val logText = false @@ -82,4 +85,6 @@ trait LoggedNodeFactory[A <: Node] extends NodeFactory[A] with scala.util.loggin super.makeProcInstr(t, s) } + @deprecated("This method and its usages will be removed. Use a debugger to debug code.", "2.11") + def log(msg: String): Unit = {} } diff --git a/src/library/scala/xml/factory/NodeFactory.scala b/src/library/scala/xml/factory/NodeFactory.scala index 28a1b6fff4..94801bb554 100644 --- a/src/library/scala/xml/factory/NodeFactory.scala +++ b/src/library/scala/xml/factory/NodeFactory.scala @@ -7,7 +7,8 @@ \* */ -package scala.xml +package scala +package xml package factory import parsing.{ FactoryAdapter, NoBindingFactoryAdapter } diff --git a/src/library/scala/xml/factory/XMLLoader.scala b/src/library/scala/xml/factory/XMLLoader.scala index bd18f2a699..b69f187039 100644 --- a/src/library/scala/xml/factory/XMLLoader.scala +++ b/src/library/scala/xml/factory/XMLLoader.scala @@ -7,7 +7,8 @@ \* */ -package scala.xml +package scala +package xml package factory import javax.xml.parsers.SAXParserFactory diff --git a/src/library/scala/xml/include/CircularIncludeException.scala b/src/library/scala/xml/include/CircularIncludeException.scala index 5e74967d54..351f403008 100644 --- a/src/library/scala/xml/include/CircularIncludeException.scala +++ b/src/library/scala/xml/include/CircularIncludeException.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.xml +package scala +package xml package include /** diff --git a/src/library/scala/xml/include/UnavailableResourceException.scala b/src/library/scala/xml/include/UnavailableResourceException.scala index f00cc58699..47b176e0f3 100644 --- a/src/library/scala/xml/include/UnavailableResourceException.scala +++ b/src/library/scala/xml/include/UnavailableResourceException.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.xml +package scala +package xml package include /** diff --git a/src/library/scala/xml/include/XIncludeException.scala b/src/library/scala/xml/include/XIncludeException.scala index 84033f853f..11e1644d83 100644 --- a/src/library/scala/xml/include/XIncludeException.scala +++ b/src/library/scala/xml/include/XIncludeException.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.xml +package scala +package xml package include /** diff --git a/src/library/scala/xml/include/sax/EncodingHeuristics.scala b/src/library/scala/xml/include/sax/EncodingHeuristics.scala index 8d8ce5b290..57ab5ed91c 100644 --- a/src/library/scala/xml/include/sax/EncodingHeuristics.scala +++ b/src/library/scala/xml/include/sax/EncodingHeuristics.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.xml +package scala +package xml package include.sax import java.io.InputStream diff --git a/src/library/scala/xml/include/sax/XIncludeFilter.scala b/src/library/scala/xml/include/sax/XIncludeFilter.scala index 9079b5f9c7..3fa3beefb0 100644 --- a/src/library/scala/xml/include/sax/XIncludeFilter.scala +++ b/src/library/scala/xml/include/sax/XIncludeFilter.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.xml +package scala +package xml package include.sax import scala.xml.include._ diff --git a/src/library/scala/xml/include/sax/XIncluder.scala b/src/library/scala/xml/include/sax/XIncluder.scala index 8fcd66d4c0..531b7196f2 100644 --- a/src/library/scala/xml/include/sax/XIncluder.scala +++ b/src/library/scala/xml/include/sax/XIncluder.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.xml +package scala +package xml package include.sax import scala.collection.mutable diff --git a/src/library/scala/xml/parsing/ConstructingHandler.scala b/src/library/scala/xml/parsing/ConstructingHandler.scala index 6fda4dabfb..ba416e4301 100755 --- a/src/library/scala/xml/parsing/ConstructingHandler.scala +++ b/src/library/scala/xml/parsing/ConstructingHandler.scala @@ -8,7 +8,8 @@ -package scala.xml +package scala +package xml package parsing /** Implementation of MarkupHandler that constructs nodes. diff --git a/src/library/scala/xml/parsing/ConstructingParser.scala b/src/library/scala/xml/parsing/ConstructingParser.scala index 404411812e..3caeddabf4 100644 --- a/src/library/scala/xml/parsing/ConstructingParser.scala +++ b/src/library/scala/xml/parsing/ConstructingParser.scala @@ -8,7 +8,8 @@ -package scala.xml +package scala +package xml package parsing import java.io.File diff --git a/src/library/scala/xml/parsing/DefaultMarkupHandler.scala b/src/library/scala/xml/parsing/DefaultMarkupHandler.scala index 0152e44cda..6ec7474843 100755 --- a/src/library/scala/xml/parsing/DefaultMarkupHandler.scala +++ b/src/library/scala/xml/parsing/DefaultMarkupHandler.scala @@ -8,7 +8,8 @@ -package scala.xml +package scala +package xml package parsing diff --git a/src/library/scala/xml/parsing/ExternalSources.scala b/src/library/scala/xml/parsing/ExternalSources.scala index aaac588092..bb939bca95 100644 --- a/src/library/scala/xml/parsing/ExternalSources.scala +++ b/src/library/scala/xml/parsing/ExternalSources.scala @@ -8,7 +8,8 @@ -package scala.xml +package scala +package xml package parsing import java.net.URL diff --git a/src/library/scala/xml/parsing/FactoryAdapter.scala b/src/library/scala/xml/parsing/FactoryAdapter.scala index 8659d3f0c4..2154bdf5ba 100644 --- a/src/library/scala/xml/parsing/FactoryAdapter.scala +++ b/src/library/scala/xml/parsing/FactoryAdapter.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.xml +package scala +package xml package parsing import java.io.{ InputStream, Reader, File, FileDescriptor, FileInputStream } diff --git a/src/library/scala/xml/parsing/FatalError.scala b/src/library/scala/xml/parsing/FatalError.scala index a8b4f8f8cf..ab3cb2a74d 100644 --- a/src/library/scala/xml/parsing/FatalError.scala +++ b/src/library/scala/xml/parsing/FatalError.scala @@ -8,7 +8,8 @@ -package scala.xml +package scala +package xml package parsing /** !!! This is poorly named, but I guess it's in the API. diff --git a/src/library/scala/xml/parsing/MarkupHandler.scala b/src/library/scala/xml/parsing/MarkupHandler.scala index 7028161821..1ebffb9c90 100755 --- a/src/library/scala/xml/parsing/MarkupHandler.scala +++ b/src/library/scala/xml/parsing/MarkupHandler.scala @@ -8,12 +8,12 @@ -package scala.xml +package scala +package xml package parsing import scala.collection.mutable import scala.io.Source -import scala.util.logging.Logged import scala.xml.dtd._ /** class that handles markup - provides callback methods to MarkupParser. @@ -25,8 +25,8 @@ import scala.xml.dtd._ * @todo can we ignore more entity declarations (i.e. those with extIDs)? * @todo expanding entity references */ -abstract class MarkupHandler extends Logged -{ +abstract class MarkupHandler { + /** returns true is this markup handler is validating */ val isValidating: Boolean = false @@ -121,4 +121,7 @@ abstract class MarkupHandler extends Logged def unparsedEntityDecl(name: String, extID: ExternalID, notat: String): Unit = () def notationDecl(notat: String, extID: ExternalID): Unit = () def reportSyntaxError(pos: Int, str: String): Unit + + @deprecated("This method and its usages will be removed. Use a debugger to debug code.", "2.11") + def log(msg: String): Unit = {} } diff --git a/src/library/scala/xml/parsing/MarkupParser.scala b/src/library/scala/xml/parsing/MarkupParser.scala index 9c7bb60475..3bbd136b67 100755 --- a/src/library/scala/xml/parsing/MarkupParser.scala +++ b/src/library/scala/xml/parsing/MarkupParser.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.xml +package scala +package xml package parsing import scala.io.Source diff --git a/src/library/scala/xml/parsing/MarkupParserCommon.scala b/src/library/scala/xml/parsing/MarkupParserCommon.scala index 7bfbcc7fff..57c1651558 100644 --- a/src/library/scala/xml/parsing/MarkupParserCommon.scala +++ b/src/library/scala/xml/parsing/MarkupParserCommon.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.xml +package scala +package xml package parsing import scala.io.Source diff --git a/src/library/scala/xml/parsing/NoBindingFactoryAdapter.scala b/src/library/scala/xml/parsing/NoBindingFactoryAdapter.scala index 22dd450072..56ac185f47 100644 --- a/src/library/scala/xml/parsing/NoBindingFactoryAdapter.scala +++ b/src/library/scala/xml/parsing/NoBindingFactoryAdapter.scala @@ -7,7 +7,8 @@ \* */ -package scala.xml +package scala +package xml package parsing import factory.NodeFactory diff --git a/src/library/scala/xml/parsing/TokenTests.scala b/src/library/scala/xml/parsing/TokenTests.scala index c9cafaeea1..8dd9cdfaa3 100644 --- a/src/library/scala/xml/parsing/TokenTests.scala +++ b/src/library/scala/xml/parsing/TokenTests.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.xml +package scala +package xml package parsing /** diff --git a/src/library/scala/xml/parsing/ValidatingMarkupHandler.scala b/src/library/scala/xml/parsing/ValidatingMarkupHandler.scala index 018ae4d2cd..1b20901249 100644 --- a/src/library/scala/xml/parsing/ValidatingMarkupHandler.scala +++ b/src/library/scala/xml/parsing/ValidatingMarkupHandler.scala @@ -8,13 +8,13 @@ -package scala.xml +package scala +package xml package parsing import scala.xml.dtd._ -import scala.util.logging.Logged -abstract class ValidatingMarkupHandler extends MarkupHandler with Logged { +abstract class ValidatingMarkupHandler extends MarkupHandler { var rootLabel:String = _ var qStack: List[Int] = Nil @@ -25,20 +25,6 @@ abstract class ValidatingMarkupHandler extends MarkupHandler with Logged { final override val isValidating = true - override def log(msg: String) {} - - /* - override def checkChildren(pos: Int, pre: String, label:String,ns:NodeSeq): Unit = { - Console.println("checkChildren()"); - val decl = lookupElemDecl(label); - // @todo: nice error message - val res = decl.contentModel.validate(ns); - Console.println("res = "+res); - if(!res) - //sys.error("invalid!"); - } - */ - override def endDTD(n:String) = { rootLabel = n } @@ -115,5 +101,4 @@ abstract class ValidatingMarkupHandler extends MarkupHandler with Logged { /** report a syntax error */ def reportValidationError(pos: Int, str: String): Unit - } diff --git a/src/library/scala/xml/parsing/XhtmlEntities.scala b/src/library/scala/xml/parsing/XhtmlEntities.scala index 1bb843818a..3683af202c 100644 --- a/src/library/scala/xml/parsing/XhtmlEntities.scala +++ b/src/library/scala/xml/parsing/XhtmlEntities.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.xml +package scala +package xml package parsing import scala.xml.dtd.{ IntDef, ParsedEntityDecl } diff --git a/src/library/scala/xml/parsing/XhtmlParser.scala b/src/library/scala/xml/parsing/XhtmlParser.scala index 33b94c9bd7..6ce5bec8d0 100644 --- a/src/library/scala/xml/parsing/XhtmlParser.scala +++ b/src/library/scala/xml/parsing/XhtmlParser.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.xml +package scala +package xml package parsing import scala.io.Source diff --git a/src/library/scala/xml/persistent/CachedFileStorage.scala b/src/library/scala/xml/persistent/CachedFileStorage.scala index fc510b5f18..57d512a041 100644 --- a/src/library/scala/xml/persistent/CachedFileStorage.scala +++ b/src/library/scala/xml/persistent/CachedFileStorage.scala @@ -6,14 +6,15 @@ ** |/ ** \* */ -package scala.xml +package scala +package xml package persistent import java.io.{ File, FileOutputStream } import java.nio.ByteBuffer import java.nio.channels.Channels import java.lang.Thread -import scala.util.logging.Logged + import scala.collection.Iterator /** Mutable storage of immutable xml trees. Everything is kept in memory, @@ -25,7 +26,7 @@ import scala.collection.Iterator * * @author Burak Emir */ -abstract class CachedFileStorage(private val file1: File) extends Thread with Logged { +abstract class CachedFileStorage(private val file1: File) extends Thread { private val file2 = new File(file1.getParent, file1.getName+"$") @@ -122,4 +123,7 @@ abstract class CachedFileStorage(private val file1: File) extends Thread with Lo this.dirty = true save() } + + @deprecated("This method and its usages will be removed. Use a debugger to debug code.", "2.11") + def log(msg: String): Unit = {} } diff --git a/src/library/scala/xml/persistent/Index.scala b/src/library/scala/xml/persistent/Index.scala index defaf67d52..9ee45e7086 100644 --- a/src/library/scala/xml/persistent/Index.scala +++ b/src/library/scala/xml/persistent/Index.scala @@ -8,7 +8,8 @@ -package scala.xml +package scala +package xml package persistent /** an Index returns some unique key that is part of a node diff --git a/src/library/scala/xml/persistent/SetStorage.scala b/src/library/scala/xml/persistent/SetStorage.scala index d16c71c9f7..8db56a2e71 100644 --- a/src/library/scala/xml/persistent/SetStorage.scala +++ b/src/library/scala/xml/persistent/SetStorage.scala @@ -7,7 +7,8 @@ \* */ -package scala.xml +package scala +package xml package persistent import scala.collection.mutable diff --git a/src/library/scala/xml/pull/XMLEvent.scala b/src/library/scala/xml/pull/XMLEvent.scala index a266380f87..3beb3648e7 100644 --- a/src/library/scala/xml/pull/XMLEvent.scala +++ b/src/library/scala/xml/pull/XMLEvent.scala @@ -8,7 +8,8 @@ -package scala.xml +package scala +package xml package pull /** An XML event for pull parsing. All events received during diff --git a/src/library/scala/xml/pull/XMLEventReader.scala b/src/library/scala/xml/pull/XMLEventReader.scala index 3f9584fd04..76e51e17fd 100755 --- a/src/library/scala/xml/pull/XMLEventReader.scala +++ b/src/library/scala/xml/pull/XMLEventReader.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.xml +package scala +package xml package pull import scala.io.Source diff --git a/src/library/scala/xml/pull/package.scala b/src/library/scala/xml/pull/package.scala index 3742c55513..0e3019446b 100644 --- a/src/library/scala/xml/pull/package.scala +++ b/src/library/scala/xml/pull/package.scala @@ -1,4 +1,5 @@ -package scala.xml +package scala +package xml /** * Classes needed to view an XML document as a series of events. The document diff --git a/src/library/scala/xml/transform/BasicTransformer.scala b/src/library/scala/xml/transform/BasicTransformer.scala index e427071177..c98339fd67 100644 --- a/src/library/scala/xml/transform/BasicTransformer.scala +++ b/src/library/scala/xml/transform/BasicTransformer.scala @@ -8,7 +8,8 @@ -package scala.xml +package scala +package xml package transform /** A class for XML transformations. diff --git a/src/library/scala/xml/transform/RewriteRule.scala b/src/library/scala/xml/transform/RewriteRule.scala index 13210a6fd2..1399ee538d 100644 --- a/src/library/scala/xml/transform/RewriteRule.scala +++ b/src/library/scala/xml/transform/RewriteRule.scala @@ -8,7 +8,8 @@ -package scala.xml +package scala +package xml package transform /** A RewriteRule, when applied to a term, yields either diff --git a/src/library/scala/xml/transform/RuleTransformer.scala b/src/library/scala/xml/transform/RuleTransformer.scala index 85e92e5773..3a222ba759 100644 --- a/src/library/scala/xml/transform/RuleTransformer.scala +++ b/src/library/scala/xml/transform/RuleTransformer.scala @@ -6,9 +6,8 @@ ** |/ ** \* */ - - -package scala.xml +package scala +package xml package transform class RuleTransformer(rules: RewriteRule*) extends BasicTransformer { diff --git a/src/partest/scala/tools/partest/PartestDefaults.scala b/src/partest/scala/tools/partest/PartestDefaults.scala index 16f1a6933f..8478edeb4d 100644 --- a/src/partest/scala/tools/partest/PartestDefaults.scala +++ b/src/partest/scala/tools/partest/PartestDefaults.scala @@ -1,6 +1,7 @@ package scala.tools package partest +import scala.concurrent.duration.Duration import scala.tools.nsc.Properties.{ propOrElse, propOrNone, propOrEmpty } import java.lang.Runtime.{ getRuntime => runtime } @@ -21,6 +22,7 @@ object PartestDefaults { def testBuild = propOrNone("partest.build") def errorCount = propOrElse("partest.errors", "0").toInt def numThreads = propOrNone("partest.threads") map (_.toInt) getOrElse runtime.availableProcessors + def waitTime = propOrNone("partest.timeout") map (Duration.apply) getOrElse Duration("4 hours") - def timeout = "1200000" + //def timeout = "1200000" // per-test timeout } diff --git a/src/partest/scala/tools/partest/TestState.scala b/src/partest/scala/tools/partest/TestState.scala index ce8e72f616..dbe8a222a5 100644 --- a/src/partest/scala/tools/partest/TestState.scala +++ b/src/partest/scala/tools/partest/TestState.scala @@ -12,13 +12,15 @@ sealed abstract class TestState { def isOk = false def isSkipped = false def testIdent = testFile.testIdent - def transcriptString = transcript.mkString("\n") + def transcriptString = transcript mkString EOL def identAndReason = testIdent + reasonString def status = s"$what - $identAndReason" def longStatus = status + transcriptString def reasonString = if (reason == "") "" else s" [$reason]" + def shortStatus = if (isOk) "ok" else "!!" + override def toString = status } @@ -27,18 +29,27 @@ object TestState { def what = "uninitialized" def reason = what def transcript = Nil + override def shortStatus = "??" } case class Pass(testFile: File) extends TestState { - final override def isOk = true def what = "pass" + override def isOk = true def transcript: List[String] = Nil def reason = "" } - case class Skip(testFile: File, reason: String) extends TestState { + case class Updated(testFile: File) extends TestState { + def what = "updated" override def isOk = true - final override def isSkipped = true def transcript: List[String] = Nil + def reason = "updated check file" + override def shortStatus = "++" + } + case class Skip(testFile: File, reason: String) extends TestState { def what = "skip" + override def isOk = true + override def isSkipped = true + def transcript: List[String] = Nil + override def shortStatus = "--" } case class Fail(testFile: File, reason: String, transcript: List[String]) extends TestState { def what = "fail" diff --git a/src/partest/scala/tools/partest/nest/ConsoleRunner.scala b/src/partest/scala/tools/partest/nest/ConsoleRunner.scala index ddd42f5601..5717aabb6a 100644 --- a/src/partest/scala/tools/partest/nest/ConsoleRunner.scala +++ b/src/partest/scala/tools/partest/nest/ConsoleRunner.scala @@ -86,7 +86,7 @@ class ConsoleRunner extends DirectRunner { ) ::: standardArgs private val binaryArgs = List( - "--grep", "--srcpath", "--buildpath", "--classpath" + "--grep", "--srcpath", "--buildpath", "--classpath", "--timeout" ) def main(argstr: String) { @@ -95,6 +95,7 @@ class ConsoleRunner extends DirectRunner { if (parsed isSet "--debug") NestUI.setDebug() if (parsed isSet "--verbose") NestUI.setVerbose() if (parsed isSet "--terse") NestUI.setTerse() + if (parsed isSet "--show-diff") NestUI.setDiffOnFail() // Early return on no args, version, or invalid args if (parsed isSet "--version") return echo(versionMsg) @@ -109,6 +110,7 @@ class ConsoleRunner extends DirectRunner { } parsed get "--srcpath" foreach (x => setProp("partest.srcdir", x)) + parsed get "--timeout" foreach (x => setProp("partest.timeout", x)) fileManager = if (parsed isSet "--buildpath") new ConsoleFileManager(parsed("--buildpath")) diff --git a/src/partest/scala/tools/partest/nest/DirectCompiler.scala b/src/partest/scala/tools/partest/nest/DirectCompiler.scala index 650b6c35c8..8e5ff2abc4 100644 --- a/src/partest/scala/tools/partest/nest/DirectCompiler.scala +++ b/src/partest/scala/tools/partest/nest/DirectCompiler.scala @@ -48,7 +48,7 @@ class DirectCompiler(val fileManager: FileManager) { } def compile(runner: Runner, opts0: List[String], sources: List[File]): TestState = { - import runner._ + import runner.{ sources => _, _ } val testSettings = new TestSettings(ClassPath.join(fileManager.LATEST_LIB, outDir.getPath)) val logWriter = new FileWriter(logFile) diff --git a/src/partest/scala/tools/partest/nest/DirectRunner.scala b/src/partest/scala/tools/partest/nest/DirectRunner.scala deleted file mode 100644 index 49dd39c344..0000000000 --- a/src/partest/scala/tools/partest/nest/DirectRunner.scala +++ /dev/null @@ -1,52 +0,0 @@ -/* NEST (New Scala Test) - * Copyright 2007-2013 LAMP/EPFL - * @author Philipp Haller - */ - -package scala.tools.partest -package nest - -import java.io.File -import scala.util.Properties.setProp -import scala.tools.nsc.util.{ ScalaClassLoader, Exceptional } -import scala.tools.nsc.io.Path -import scala.collection.{ mutable, immutable } -import java.util.concurrent._ - -case class TestRunParams(val scalaCheckParentClassLoader: ScalaClassLoader) - -trait DirectRunner { - def fileManager: FileManager - - import PartestDefaults.numThreads - - Thread.setDefaultUncaughtExceptionHandler( - new Thread.UncaughtExceptionHandler { - def uncaughtException(thread: Thread, t: Throwable) { - val t1 = Exceptional unwrap t - System.err.println(s"Uncaught exception on thread $thread: $t1") - t1.printStackTrace() - } - } - ) - def runTestsForFiles(kindFiles: List[File], kind: String): List[TestState] = { - - NestUI.resetTestNumber() - - val allUrls = PathSettings.scalaCheck.toURL :: fileManager.latestUrls - val parentClassLoader = ScalaClassLoader fromURLs allUrls - val pool = Executors newFixedThreadPool numThreads - val manager = new RunnerManager(kind, fileManager, TestRunParams(parentClassLoader)) - val futures = kindFiles map (f => pool submit callable(manager runTest f)) - - pool.shutdown() - try if (!pool.awaitTermination(4, TimeUnit.HOURS)) - NestUI warning "Thread pool timeout elapsed before all tests were complete!" - catch { case t: InterruptedException => - NestUI warning "Thread pool was interrupted" - t.printStackTrace() - } - - futures map (_.get) - } -} diff --git a/src/partest/scala/tools/partest/nest/FileManager.scala b/src/partest/scala/tools/partest/nest/FileManager.scala index 25371b7d54..230ada4803 100644 --- a/src/partest/scala/tools/partest/nest/FileManager.scala +++ b/src/partest/scala/tools/partest/nest/FileManager.scala @@ -85,7 +85,6 @@ trait FileManager extends FileUtil { var SCALAC_OPTS = PartestDefaults.scalacOpts.split(' ').toSeq var JAVA_OPTS = PartestDefaults.javaOpts - var timeout = PartestDefaults.timeout /** Only when --debug is given. */ lazy val testTimings = new mutable.HashMap[String, Long] diff --git a/src/partest/scala/tools/partest/nest/NestUI.scala b/src/partest/scala/tools/partest/nest/NestUI.scala index 2e203bfd91..564270e531 100644 --- a/src/partest/scala/tools/partest/nest/NestUI.scala +++ b/src/partest/scala/tools/partest/nest/NestUI.scala @@ -27,9 +27,14 @@ class Colors(enabled: => Boolean) { object NestUI { private val testNum = new java.util.concurrent.atomic.AtomicInteger(1) + @volatile private var testNumberFmt = "%3d" // @volatile private var testNumber = 1 - private def testNumber = "%3d" format testNum.getAndIncrement() - def resetTestNumber() = testNum set 1 + private def testNumber = testNumberFmt format testNum.getAndIncrement() + def resetTestNumber(max: Int = -1) { + testNum set 1 + val width = if (max > 0) max.toString.length else 3 + testNumberFmt = s"%${width}d" + } var colorEnabled = sys.props contains "partest.colors" val color = new Colors(colorEnabled) @@ -57,12 +62,15 @@ object NestUI { def statusLine(state: TestState) = { import state._ - val word = bold( - if (isSkipped) yellow("--") - else if (isOk) green("ok") - else red("!!") - ) - word + f" $testNumber%3s - $testIdent%-40s$reasonString" + import TestState._ + val colorizer = state match { + case _: Skip => yellow + case _: Updated => cyan + case s if s.isOk => green + case _ => red + } + val word = bold(colorizer(state.shortStatus)) + f"$word $testNumber - $testIdent%-40s$reasonString" } def reportTest(state: TestState) = { @@ -76,7 +84,13 @@ object NestUI { dotCount += 1 } } - else echo(statusLine(state)) + else { + echo(statusLine(state)) + if (!state.isOk && isDiffy) { + val differ = bold(red("% ")) + "diff " + state.transcript find (_ startsWith differ) foreach (echo(_)) + } + } } def echo(message: String): Unit = synchronized { @@ -164,10 +178,12 @@ object NestUI { var _verbose = false var _debug = false var _terse = false + var _diff = false def isVerbose = _verbose def isDebug = _debug def isTerse = _terse + def isDiffy = _diff def setVerbose() { _verbose = true @@ -178,6 +194,9 @@ object NestUI { def setTerse() { _terse = true } + def setDiffOnFail() { + _diff = true + } def verbose(msg: String) { if (isVerbose) System.err.println(msg) diff --git a/src/partest/scala/tools/partest/nest/PathSettings.scala b/src/partest/scala/tools/partest/nest/PathSettings.scala index bae6bf819d..8e454d8de8 100644 --- a/src/partest/scala/tools/partest/nest/PathSettings.scala +++ b/src/partest/scala/tools/partest/nest/PathSettings.scala @@ -7,9 +7,9 @@ package nest import scala.tools.nsc.Properties.{ setProp, propOrEmpty, propOrNone, propOrElse } import scala.tools.nsc.util.ClassPath -import scala.tools.nsc.io +import scala.tools.nsc.io.{ Path, File, Directory } import scala.util.Properties.{ envOrElse, envOrNone, javaHome, jdkHome } -import io.{ Path, File, Directory } +import Path._ object PathSettings { import PartestDefaults.{ testRootDir, srcDirName } @@ -19,6 +19,8 @@ object PathSettings { private def findJar(d: Directory, name: String): Option[File] = findJar(d.files, name) private def findJar(files: Iterator[File], name: String): Option[File] = files filter (_ hasExtension "jar") find { _.name startsWith name } + private def findJarOrFail(name: String, ds: Directory*): File = findJar(ds flatMap (_.files) iterator, name) getOrElse + sys.error(s"'${name}.jar' not found in '${ds map (_.path) mkString ", "}'.") // Directory <root>/test lazy val testRoot: Directory = testRootDir getOrElse { @@ -73,6 +75,8 @@ object PathSettings { sys.error("No scalacheck jar found in '%s' or '%s'".format(buildPackLibDir, srcLibDir)) } + lazy val testInterface: File = findJarOrFail("test-interface", buildPackLibDir, srcLibDir) + lazy val diffUtils: File = findJar(buildPackLibDir.files, "diffutils") getOrElse sys.error(s"No diffutils.jar found in '$buildPackLibDir'.") diff --git a/src/partest/scala/tools/partest/nest/ReflectiveRunner.scala b/src/partest/scala/tools/partest/nest/ReflectiveRunner.scala index 9780e82cd9..734affa153 100644 --- a/src/partest/scala/tools/partest/nest/ReflectiveRunner.scala +++ b/src/partest/scala/tools/partest/nest/ReflectiveRunner.scala @@ -55,7 +55,7 @@ class ReflectiveRunner { // we hack into the classloader that will become parent classloader for scalac // this way we ensure that reflective macro lookup will pick correct Code.lift // it's also used to inject diffutils into the classpath when running partest from the test/partest script - val srcCodeLibAndDiff = List(PathSettings.srcCodeLib, PathSettings.diffUtils) + val srcCodeLibAndDiff = List(PathSettings.srcCodeLib, PathSettings.diffUtils, PathSettings.testInterface) val sepUrls = srcCodeLibAndDiff.map(_.toURI.toURL) ::: fileManager.latestUrls // this seems to be the core classloader that determines which classes can be found when running partest from the test/partest script val sepLoader = new URLClassLoader(sepUrls.toArray, null) diff --git a/src/partest/scala/tools/partest/nest/Runner.scala b/src/partest/scala/tools/partest/nest/Runner.scala index fc56818bfc..85679ad0b8 100644 --- a/src/partest/scala/tools/partest/nest/Runner.scala +++ b/src/partest/scala/tools/partest/nest/Runner.scala @@ -7,19 +7,24 @@ package nest import java.io.{ Console => _, _ } import java.net.URL -import scala.tools.nsc.Properties.{ jdkHome, javaHome, propOrElse, propOrEmpty } -import scala.util.Properties.{ envOrElse, isWin } +import java.nio.charset.{ Charset, CharsetDecoder, CharsetEncoder, CharacterCodingException, CodingErrorAction => Action } +import java.util.concurrent.Executors +import java.util.concurrent.TimeUnit.NANOSECONDS +import scala.collection.mutable.ListBuffer +import scala.concurrent.duration.Duration +import scala.io.Codec +import scala.sys.process.Process +import scala.tools.nsc.Properties.{ envOrElse, isWin, jdkHome, javaHome, propOrElse, propOrEmpty, setProp } import scala.tools.nsc.{ Settings, CompilerCommand, Global } -import scala.tools.nsc.io.{ AbstractFile, PlainFile, Path, Directory, File => SFile } +import scala.tools.nsc.io.{ AbstractFile, PlainFile } import scala.tools.nsc.reporters.ConsoleReporter -import scala.tools.nsc.util.{ ClassPath, FakePos, ScalaClassLoader, stackTraceString } -import ClassPath.{ join, split } +import scala.tools.nsc.util.{ Exceptional, ScalaClassLoader, stackTraceString } +import scala.tools.scalap.Main.decompileScala import scala.tools.scalap.scalax.rules.scalasig.ByteCode -import scala.collection.{ mutable, immutable } -import scala.sys.process.Process -import java.util.concurrent.{ Executors, TimeUnit, TimeoutException } +import scala.util.{ Try, Success, Failure } +import ClassPath.{ join, split } import PartestDefaults.{ javaCmd, javacCmd } -import scala.tools.scalap.Main.decompileScala +import TestState.{ Pass, Fail, Crash, Uninitialized, Updated } trait PartestRunSettings { def gitPath: Path @@ -35,7 +40,7 @@ trait PartestRunSettings { class TestTranscript { import NestUI.color._ - private val buf = mutable.ListBuffer[String]() + private val buf = ListBuffer[String]() private def pass(s: String) = bold(green("% ")) + s private def fail(s: String) = bold(red("% ")) + s @@ -49,7 +54,8 @@ class TestTranscript { } } -class Runner(val testFile: File, fileManager: FileManager) { +/** Run a single test. Rubber meets road. */ +class Runner(val testFile: File, fileManager: FileManager, val testRunParams: TestRunParams) { import fileManager._ // Override to true to have the outcome of this test displayed @@ -57,12 +63,10 @@ class Runner(val testFile: File, fileManager: FileManager) { // except for a . per passing test to show progress. def isEnumeratedTest = false - def testRunParams: TestRunParams = ??? - private var _lastState: TestState = null private var _transcript = new TestTranscript - def lastState = if (_lastState == null) TestState.Uninitialized(testFile) else _lastState + def lastState = if (_lastState == null) Uninitialized(testFile) else _lastState def setLastState(s: TestState) = _lastState = s def transcript: List[String] = _transcript.fail ++ logFile.fileLines def pushTranscript(msg: String) = _transcript add msg @@ -94,10 +98,11 @@ class Runner(val testFile: File, fileManager: FileManager) { genCrash(t) } - def genPass() = TestState.Pass(testFile) - def genFail(reason: String) = TestState.Fail(testFile, reason, _transcript.fail) - def genTimeout() = TestState.Fail(testFile, "timed out", _transcript.fail) - def genCrash(caught: Throwable) = TestState.Crash(testFile, caught, _transcript.fail) + def genPass() = Pass(testFile) + def genFail(reason: String) = Fail(testFile, reason, _transcript.fail) + def genTimeout() = Fail(testFile, "timed out", _transcript.fail) + def genCrash(caught: Throwable) = Crash(testFile, caught, _transcript.fail) + def genUpdated() = Updated(testFile) def speclib = PathSettings.srcSpecLib.toString // specialization lib def codelib = PathSettings.srcCodeLib.toString // reify lib @@ -151,14 +156,18 @@ class Runner(val testFile: File, fileManager: FileManager) { case _ => "% " } + /** Evaluate an action body and update the test state. + * @param failFn optionally map a result to a test state. + */ def nextTestAction[T](body: => T)(failFn: PartialFunction[T, TestState]): T = { val result = body setLastState( if (failFn isDefinedAt result) failFn(result) else genPass() ) result } - def nextTestActionExpectTrue[T](reason: String, body: => Boolean): Boolean = { + def nextTestActionExpectTrue(reason: String, body: => Boolean): Boolean = ( nextTestAction(body) { case false => genFail(reason) } - } + ) + def nextTestActionFailing(reason: String): Boolean = nextTestActionExpectTrue(reason, false) private def assembleTestCommand(outDir: File, logFile: File): List[String] = { // check whether there is a ".javaopts" file @@ -218,15 +227,17 @@ class Runner(val testFile: File, fileManager: FileManager) { private def execTest(outDir: File, logFile: File): Boolean = { val cmd = assembleTestCommand(outDir, logFile) - pushTranscript(cmd.mkString(" \\\n ") + " > " + logFile.getName) - nextTestActionExpectTrue("non-zero exit code", runCommand(cmd, logFile)) || { - _transcript append logFile.fileContents - false + pushTranscript((cmd mkString s" \\$EOL ") + " > " + logFile.getName) + nextTestAction(runCommand(cmd, logFile)) { + case false => + _transcript append EOL + logFile.fileContents + genFail("non-zero exit code") } } override def toString = s"""Test($testIdent, lastState = $lastState)""" + // result is unused def newTestWriters() = { val swr = new StringWriter val wr = new PrintWriter(swr, true) @@ -320,18 +331,20 @@ class Runner(val testFile: File, fileManager: FileManager) { def diffIsOk: Boolean = { val diff = currentDiff - val ok: Boolean = (diff == "") || { - fileManager.updateCheck && { + // if diff is not empty, is update needed? + val updating: Option[Boolean] = ( + if (diff == "") None + else Some(fileManager.updateCheck) + ) + pushTranscript(s"diff $logFile $checkFile") + nextTestAction(updating) { + case Some(true) => NestUI.verbose("Updating checkfile " + checkFile) checkFile writeAll file2String(logFile) - true - } - } - pushTranscript(s"diff $logFile $checkFile") - nextTestAction(ok) { - case false => + genUpdated() + case Some(false) => // Get a word-highlighted diff from git if we can find it - val bestDiff = if (ok) "" else { + val bestDiff = if (updating.isEmpty) "" else { if (checkFile.canRead) gitDiff(logFile, checkFile) getOrElse { s"diff $logFile $checkFile\n$diff" @@ -343,11 +356,13 @@ class Runner(val testFile: File, fileManager: FileManager) { // TestState.fail("output differs", "output differs", // genFail("output differs") // TestState.Fail("output differs", bestDiff) - } + case None => genPass() // redundant default case + } getOrElse true } /** 1. Creates log file and output directory. * 2. Runs script function, providing log file and output directory as arguments. + * 2b. or, just run the script without context and return a new context */ def runInContext(body: => Boolean): (Boolean, LogContext) = { val (swr, wr) = newTestWriters() @@ -356,11 +371,16 @@ class Runner(val testFile: File, fileManager: FileManager) { } /** Grouped files in group order, and lex order within each group. */ - def groupedFiles(dir: File): List[List[File]] = { - val testFiles = dir.listFiles.toList filter (_.isJavaOrScala) - val grouped = testFiles groupBy (_.group) - grouped.keys.toList.sorted map (k => grouped(k) sortBy (_.getName)) - } + def groupedFiles(files: List[File]): List[List[File]] = ( + if (files.tail.nonEmpty) { + val grouped = files filter (_.isJavaOrScala) groupBy (_.group) + grouped.keys.toList.sorted map (k => grouped(k) sortBy (_.getName)) + } + else List(files) + ) + + /** Source files for the given test file. */ + def sources(file: File): List[File] = if (file.isDirectory) file.listFiles.toList else List(file) def newCompiler = new DirectCompiler(fileManager) @@ -411,11 +431,9 @@ class Runner(val testFile: File, fileManager: FileManager) { lazy val result = { pushTranscript(description) ; attemptCompile(fs) } } - def compilationRounds(file: File): List[CompileRound] = { - val grouped = if (file.isDirectory) groupedFiles(file) else List(List(file)) - - (grouped map mixedCompileGroup).flatten - } + def compilationRounds(file: File): List[CompileRound] = ( + (groupedFiles(sources(file)) map mixedCompileGroup).flatten + ) def mixedCompileGroup(allFiles: List[File]): List[CompileRound] = { val (scalaFiles, javaFiles) = allFiles partition (_.isScala) val isMixed = javaFiles.nonEmpty && scalaFiles.nonEmpty @@ -429,12 +447,16 @@ class Runner(val testFile: File, fileManager: FileManager) { def runNegTest() = runInContext { val rounds = compilationRounds(testFile) - if (rounds forall (x => nextTestActionExpectTrue("compilation failed", x.isOk))) - nextTestActionExpectTrue("expected compilation failure", false) - else { - normalizeLog // put errors in a normal form - diffIsOk + // failing means Does Not Compile + val failing = rounds find (x => nextTestActionExpectTrue("compilation failed", x.isOk) == false) + + // which means passing if it checks and didn't crash the compiler + def checked(r: CompileRound) = r.result match { + case f: Crash => false + case f => normalizeLog(); diffIsOk } + + failing map (checked) getOrElse nextTestActionFailing("expected compilation failure") } def runTestCommon(andAlso: => Boolean): (Boolean, LogContext) = runInContext { @@ -495,24 +517,68 @@ class Runner(val testFile: File, fileManager: FileManager) { } def runScalacheckTest() = runTestCommon { - NestUI.verbose("compilation of "+testFile+" succeeded\n") + NestUI verbose f"compilation of $testFile succeeded%n" - val outURL = outDir.getAbsoluteFile.toURI.toURL + // this classloader is test specific: its parent contains library classes and others + val loader = { + import PathSettings.scalaCheck + val locations = List(outDir, scalaCheck.jfile) map (_.getAbsoluteFile.toURI.toURL) + ScalaClassLoader.fromURLs(locations, getClass.getClassLoader) + } val logWriter = new PrintStream(new FileOutputStream(logFile), true) - Output.withRedirected(logWriter) { - // this classloader is test specific: its parent contains library classes and others - ScalaClassLoader.fromURLs(List(outURL), testRunParams.scalaCheckParentClassLoader).run("Test", Nil) + def toolArgs(tool: String): List[String] = { + def argsplitter(s: String) = words(s) filter (_.nonEmpty) + def argsFor(f: File): List[String] = { + import scala.util.matching.Regex + val p = new Regex(s"(?:.*\\s)?${tool}:(.*)?", "args") + val max = 10 + val src = Path(f).toFile.chars(codec) + val args = try { + src.getLines take max collectFirst { + case s if (p findFirstIn s).nonEmpty => for (m <- p findFirstMatchIn s) yield m group "args" + } + } finally src.close() + args.flatten map argsplitter getOrElse Nil + } + sources(testFile) flatMap argsFor } - - NestUI.verbose(file2String(logFile)) - // obviously this must be improved upon - val lines = SFile(logFile).lines map (_.trim) filterNot (_ == "") toBuffer; - lines.forall(x => !x.startsWith("!")) || { - NestUI.normal("ScalaCheck test failed. Output:\n") - lines foreach (x => NestUI.normal(x + "\n")) - false + def runInFramework(): Boolean = { + import org.scalatools.testing._ + val f: Framework = loader.instantiate[Framework]("org.scalacheck.ScalaCheckFramework") + val logger = new Logger { + def ansiCodesSupported = false //params.env.isSet("colors") + def error(msg: String) = logWriter println msg + def warn(msg: String) = logWriter println msg + def info(msg: String) = logWriter println msg + def debug(msg: String) = logWriter println msg + def trace(t: Throwable) = t printStackTrace logWriter + } + var bad = 0 + val handler = new EventHandler { + // testName, description, result, error + // Result = Success, Failure, Error, Skipped + def handle(event: Event): Unit = event.result match { + case Result.Success => + //case Result.Skipped => // an exhausted test is skipped, therefore bad + case _ => bad += 1 + } + } + val loggers = Array(logger) + val r = f.testRunner(loader, loggers).asInstanceOf[Runner2] // why? + val claas = "Test" + val fingerprint = f.tests collectFirst { case x: SubclassFingerprint if x.isModule => x } + val args = toolArgs("scalacheck") + vlog(s"Run $testFile with args $args") + // set the context class loader for scaladoc/scalacheck tests (FIX ME) + ScalaClassLoader(testRunParams.scalaCheckParentClassLoader).asContext { + r.run(claas, fingerprint.get, handler, args.toArray) // synchronous? + } + val ok = (bad == 0) + if (!ok) _transcript append logFile.fileContents + ok } + try nextTestActionExpectTrue("ScalaCheck test failed", runInFramework()) finally logWriter.close() } def runResidentTest() = { @@ -626,3 +692,139 @@ class Runner(val testFile: File, fileManager: FileManager) { Directory(outDir).deleteRecursively() } } + +case class TestRunParams(val scalaCheckParentClassLoader: ScalaClassLoader) + +/** Extended by Ant- and ConsoleRunner for running a set of tests. */ +trait DirectRunner { + def fileManager: FileManager + + import PartestDefaults.{ numThreads, waitTime } + + Thread.setDefaultUncaughtExceptionHandler( + new Thread.UncaughtExceptionHandler { + def uncaughtException(thread: Thread, t: Throwable) { + val t1 = Exceptional unwrap t + System.err.println(s"Uncaught exception on thread $thread: $t1") + t1.printStackTrace() + } + } + ) + def runTestsForFiles(kindFiles: List[File], kind: String): List[TestState] = { + + NestUI.resetTestNumber(kindFiles.size) + + // this special class loader is for the benefit of scaladoc tests, which need a class path + import PathSettings.{ testInterface, scalaCheck } + val allUrls = scalaCheck.toURL :: testInterface.toURL :: fileManager.latestUrls + val parentClassLoader = ScalaClassLoader fromURLs allUrls + // add scalacheck.jar to a special classloader, but use our loader as parent with test-interface + //val parentClassLoader = ScalaClassLoader fromURLs (List(scalaCheck.toURL), getClass().getClassLoader) + val pool = Executors newFixedThreadPool numThreads + val manager = new RunnerManager(kind, fileManager, TestRunParams(parentClassLoader)) + val futures = kindFiles map (f => pool submit callable(manager runTest f)) + + pool.shutdown() + Try (pool.awaitTermination(waitTime) { + throw TimeoutException(waitTime) + }) match { + case Success(_) => futures map (_.get) + case Failure(e) => + e match { + case TimeoutException(d) => + NestUI warning "Thread pool timeout elapsed before all tests were complete!" + case ie: InterruptedException => + NestUI warning "Thread pool was interrupted" + ie.printStackTrace() + } + pool.shutdownNow() // little point in continuing + // try to get as many completions as possible, in case someone cares + val results = for (f <- futures) yield { + try { + Some(f.get(0, NANOSECONDS)) + } catch { + case _: Throwable => None + } + } + results.flatten + } + } +} + +case class TimeoutException(duration: Duration) extends RuntimeException + +class LogContext(val file: File, val writers: Option[(StringWriter, PrintWriter)]) + +object LogContext { + def apply(file: File, swr: StringWriter, wr: PrintWriter): LogContext = { + require (file != null) + new LogContext(file, Some((swr, wr))) + } + def apply(file: File): LogContext = new LogContext(file, None) +} + +object Output { + object outRedirect extends Redirecter(out) + object errRedirect extends Redirecter(err) + + System.setOut(outRedirect) + System.setErr(errRedirect) + + import scala.util.DynamicVariable + private def out = java.lang.System.out + private def err = java.lang.System.err + private val redirVar = new DynamicVariable[Option[PrintStream]](None) + + class Redirecter(stream: PrintStream) extends PrintStream(new OutputStream { + def write(b: Int) = withStream(_ write b) + + private def withStream(f: PrintStream => Unit) = f(redirVar.value getOrElse stream) + + override def write(b: Array[Byte]) = withStream(_ write b) + override def write(b: Array[Byte], off: Int, len: Int) = withStream(_.write(b, off, len)) + override def flush = withStream(_.flush) + override def close = withStream(_.close) + }) + + // this supports thread-safe nested output redirects + def withRedirected[T](newstream: PrintStream)(func: => T): T = { + // note down old redirect destination + // this may be None in which case outRedirect and errRedirect print to stdout and stderr + val saved = redirVar.value + // set new redirecter + // this one will redirect both out and err to newstream + redirVar.value = Some(newstream) + + try func + finally { + newstream.flush() + redirVar.value = saved + } + } +} + +/** Use a Runner to run a test. */ +class RunnerManager(kind: String, fileManager: FileManager, params: TestRunParams) { + import fileManager._ + fileManager.CLASSPATH += File.pathSeparator + PathSettings.scalaCheck + fileManager.CLASSPATH += File.pathSeparator + PathSettings.diffUtils // needed to put diffutils on test/partest's classpath + + def runTest(testFile: File): TestState = { + val runner = new Runner(testFile, fileManager, params) + + // when option "--failed" is provided execute test only if log + // is present (which means it failed before) + if (fileManager.failed && !runner.logFile.canRead) + runner.genPass() + else { + val (state, elapsed) = + try timed(runner.run()) + catch { + case t: Throwable => throw new RuntimeException(s"Error running $testFile", t) + } + NestUI.reportTest(state) + runner.cleanup() + state + } + } +} diff --git a/src/partest/scala/tools/partest/nest/RunnerManager.scala b/src/partest/scala/tools/partest/nest/RunnerManager.scala deleted file mode 100644 index fa2b5ea74b..0000000000 --- a/src/partest/scala/tools/partest/nest/RunnerManager.scala +++ /dev/null @@ -1,97 +0,0 @@ -/* NEST (New Scala Test) - * Copyright 2007-2013 LAMP/EPFL - * @author Philipp Haller - */ - -package scala.tools.partest -package nest - -import java.io._ -import java.net.URL -import scala.tools.nsc.Properties.{ jdkHome, javaHome, propOrElse } -import scala.util.Properties.{ envOrElse, isWin } -import scala.tools.nsc.{ Settings, CompilerCommand, Global } -import scala.tools.nsc.io.{ AbstractFile, PlainFile, Path, Directory, File => SFile } -import scala.tools.nsc.reporters.ConsoleReporter -import scala.tools.nsc.util.{ ClassPath, FakePos, ScalaClassLoader, stackTraceString } -import ClassPath.{ join, split } -import scala.tools.scalap.scalax.rules.scalasig.ByteCode -import scala.collection.{ mutable, immutable } -import scala.sys.process._ -import java.util.concurrent.{ Executors, TimeUnit, TimeoutException } -import PartestDefaults.{ javaCmd, javacCmd } -import scala.tools.scalap.Main.decompileScala - -class LogContext(val file: File, val writers: Option[(StringWriter, PrintWriter)]) - -object LogContext { - def apply(file: File, swr: StringWriter, wr: PrintWriter): LogContext = { - require (file != null) - new LogContext(file, Some((swr, wr))) - } - def apply(file: File): LogContext = new LogContext(file, None) -} - -object Output { - object outRedirect extends Redirecter(out) - object errRedirect extends Redirecter(err) - - System.setOut(outRedirect) - System.setErr(errRedirect) - - import scala.util.DynamicVariable - private def out = java.lang.System.out - private def err = java.lang.System.err - private val redirVar = new DynamicVariable[Option[PrintStream]](None) - - class Redirecter(stream: PrintStream) extends PrintStream(new OutputStream { - def write(b: Int) = withStream(_ write b) - - private def withStream(f: PrintStream => Unit) = f(redirVar.value getOrElse stream) - - override def write(b: Array[Byte]) = withStream(_ write b) - override def write(b: Array[Byte], off: Int, len: Int) = withStream(_.write(b, off, len)) - override def flush = withStream(_.flush) - override def close = withStream(_.close) - }) - - // this supports thread-safe nested output redirects - def withRedirected[T](newstream: PrintStream)(func: => T): T = { - // note down old redirect destination - // this may be None in which case outRedirect and errRedirect print to stdout and stderr - val saved = redirVar.value - // set new redirecter - // this one will redirect both out and err to newstream - redirVar.value = Some(newstream) - - try func - finally { - newstream.flush() - redirVar.value = saved - } - } -} - -class RunnerManager(kind: String, val fileManager: FileManager, params: TestRunParams) { - import fileManager._ - - fileManager.CLASSPATH += File.pathSeparator + PathSettings.scalaCheck - fileManager.CLASSPATH += File.pathSeparator + PathSettings.diffUtils // needed to put diffutils on test/partest's classpath - PathSettings.platformTools foreach (fileManager.CLASSPATH += File.pathSeparator + _) - - def runTest(testFile: File): TestState = { - val runner = new Runner(testFile, fileManager) { - override def testRunParams = params - } - // when option "--failed" is provided execute test only if log - // is present (which means it failed before) - if (fileManager.failed && !runner.logFile.canRead) - runner.genPass() - else { - val (state, elapsed) = timed(runner.run()) - NestUI.reportTest(state) - runner.cleanup() - state - } - } -} diff --git a/src/partest/scala/tools/partest/package.scala b/src/partest/scala/tools/partest/package.scala index 9e21b0f6ba..4a516d620b 100644 --- a/src/partest/scala/tools/partest/package.scala +++ b/src/partest/scala/tools/partest/package.scala @@ -4,8 +4,9 @@ package scala.tools +import java.util.concurrent.{ Callable, ExecutorService } +import scala.concurrent.duration.Duration import scala.sys.process.javaVmArguments -import java.util.concurrent.Callable import scala.tools.partest.nest.NestUI import scala.tools.nsc.util.{ ScalaClassLoader, Exceptional } @@ -31,6 +32,8 @@ package object partest { def ojoin(xs: String*): String = oempty(xs: _*) mkString space def nljoin(xs: String*): String = oempty(xs: _*) mkString EOL + implicit val codec = scala.io.Codec.UTF8 + def setUncaughtHandler() = { Thread.setDefaultUncaughtExceptionHandler( new Thread.UncaughtExceptionHandler { @@ -85,6 +88,25 @@ package object partest { def copyTo(dest: Path): Unit = dest.toFile writeAll f.slurp(scala.io.Codec.UTF8) } + implicit class LoaderOps(val loader: ClassLoader) extends AnyVal { + import scala.util.control.Exception.catching + /** Like ScalaClassLoader.create for the case where the result type is + * available to the current class loader, implying that the current + * loader is a parent of `loader`. + */ + def instantiate[A >: Null](name: String): A = ( + catching(classOf[ClassNotFoundException], classOf[SecurityException]) opt + (loader loadClass name).newInstance.asInstanceOf[A] orNull + ) + } + + implicit class ExecutorOps(val executor: ExecutorService) { + def awaitTermination[A](wait: Duration)(failing: => A = ()): Option[A] = ( + if (executor awaitTermination (wait.length, wait.unit)) None + else Some(failing) + ) + } + implicit def temporaryPath2File(x: Path): File = x.jfile implicit def stringPathToJavaFile(path: String): File = new File(path) diff --git a/src/reflect/scala/reflect/api/Annotations.scala b/src/reflect/scala/reflect/api/Annotations.scala index f87e10c792..e19e0cefad 100644 --- a/src/reflect/scala/reflect/api/Annotations.scala +++ b/src/reflect/scala/reflect/api/Annotations.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package api import scala.collection.immutable.ListMap diff --git a/src/reflect/scala/reflect/api/BuildUtils.scala b/src/reflect/scala/reflect/api/BuildUtils.scala index 8f256aa1f5..2e95a01176 100644 --- a/src/reflect/scala/reflect/api/BuildUtils.scala +++ b/src/reflect/scala/reflect/api/BuildUtils.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package api /** diff --git a/src/reflect/scala/reflect/api/Constants.scala b/src/reflect/scala/reflect/api/Constants.scala index 0b7dd5582a..c654961f4a 100644 --- a/src/reflect/scala/reflect/api/Constants.scala +++ b/src/reflect/scala/reflect/api/Constants.scala @@ -3,7 +3,8 @@ * @author Martin Odersky */ -package scala.reflect +package scala +package reflect package api /** diff --git a/src/reflect/scala/reflect/api/Exprs.scala b/src/reflect/scala/reflect/api/Exprs.scala index 2ba18a8207..009d9dbfdb 100644 --- a/src/reflect/scala/reflect/api/Exprs.scala +++ b/src/reflect/scala/reflect/api/Exprs.scala @@ -3,7 +3,8 @@ * @author Martin Odersky */ -package scala.reflect +package scala +package reflect package api import scala.reflect.runtime.{universe => ru} @@ -174,4 +175,4 @@ private[scala] class SerializedExpr(var treec: TreeCreator, var tag: ru.WeakType import ru._ Expr(rootMirror, treec)(tag) } -}
\ No newline at end of file +} diff --git a/src/reflect/scala/reflect/api/FlagSets.scala b/src/reflect/scala/reflect/api/FlagSets.scala index 712236cce1..8a1d2f7f1d 100644 --- a/src/reflect/scala/reflect/api/FlagSets.scala +++ b/src/reflect/scala/reflect/api/FlagSets.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package api import scala.language.implicitConversions diff --git a/src/reflect/scala/reflect/api/ImplicitTags.scala b/src/reflect/scala/reflect/api/ImplicitTags.scala index fdc1d9017b..1b654a4a8d 100644 --- a/src/reflect/scala/reflect/api/ImplicitTags.scala +++ b/src/reflect/scala/reflect/api/ImplicitTags.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package api /** Tags which preserve the identity of abstract types in the face of erasure. diff --git a/src/reflect/scala/reflect/api/Importers.scala b/src/reflect/scala/reflect/api/Importers.scala index afc4f2f25d..e6f314b712 100644 --- a/src/reflect/scala/reflect/api/Importers.scala +++ b/src/reflect/scala/reflect/api/Importers.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package api /** diff --git a/src/reflect/scala/reflect/api/JavaMirrors.scala b/src/reflect/scala/reflect/api/JavaMirrors.scala index b678033e1a..23abc23eb9 100644 --- a/src/reflect/scala/reflect/api/JavaMirrors.scala +++ b/src/reflect/scala/reflect/api/JavaMirrors.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package api /** diff --git a/src/reflect/scala/reflect/api/JavaUniverse.scala b/src/reflect/scala/reflect/api/JavaUniverse.scala index 04d091ee9d..6fc76c9693 100644 --- a/src/reflect/scala/reflect/api/JavaUniverse.scala +++ b/src/reflect/scala/reflect/api/JavaUniverse.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package api /** diff --git a/src/reflect/scala/reflect/api/Mirror.scala b/src/reflect/scala/reflect/api/Mirror.scala index 1223326d7c..e0219c9074 100644 --- a/src/reflect/scala/reflect/api/Mirror.scala +++ b/src/reflect/scala/reflect/api/Mirror.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package api /** @@ -49,16 +50,16 @@ abstract class Mirror[U <: Universe with Singleton] { * If you need a symbol that corresponds to the type alias itself, load it directly from the package class: * * scala> cm.staticClass("scala.List") - * res0: reflect.runtime.universe.ClassSymbol = class List + * res0: scala.reflect.runtime.universe.ClassSymbol = class List * * scala> res0.fullName * res1: String = scala.collection.immutable.List * * scala> cm.staticPackage("scala") - * res2: reflect.runtime.universe.ModuleSymbol = package scala + * res2: scala.reflect.runtime.universe.ModuleSymbol = package scala * * scala> res2.moduleClass.typeSignature member newTypeName("List") - * res3: reflect.runtime.universe.Symbol = type List + * res3: scala.reflect.runtime.universe.Symbol = type List * * scala> res3.fullName * res4: String = scala.List diff --git a/src/reflect/scala/reflect/api/Mirrors.scala b/src/reflect/scala/reflect/api/Mirrors.scala index d30563c706..4fd9943379 100644 --- a/src/reflect/scala/reflect/api/Mirrors.scala +++ b/src/reflect/scala/reflect/api/Mirrors.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package api /** diff --git a/src/reflect/scala/reflect/api/Names.scala b/src/reflect/scala/reflect/api/Names.scala index 0a85237a4e..f74e0ce014 100644 --- a/src/reflect/scala/reflect/api/Names.scala +++ b/src/reflect/scala/reflect/api/Names.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package api import scala.language.implicitConversions diff --git a/src/reflect/scala/reflect/api/Position.scala b/src/reflect/scala/reflect/api/Position.scala index 63c67627a3..4d5f1f6e67 100644 --- a/src/reflect/scala/reflect/api/Position.scala +++ b/src/reflect/scala/reflect/api/Position.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package api import scala.reflect.macros.Attachments diff --git a/src/reflect/scala/reflect/api/Positions.scala b/src/reflect/scala/reflect/api/Positions.scala index 6edf8e13e4..8ad46418f8 100644 --- a/src/reflect/scala/reflect/api/Positions.scala +++ b/src/reflect/scala/reflect/api/Positions.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package api /** diff --git a/src/reflect/scala/reflect/api/Printers.scala b/src/reflect/scala/reflect/api/Printers.scala index 162fe1296b..81d30dec1e 100644 --- a/src/reflect/scala/reflect/api/Printers.scala +++ b/src/reflect/scala/reflect/api/Printers.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package api import java.io.{ PrintWriter, StringWriter } diff --git a/src/reflect/scala/reflect/api/Scopes.scala b/src/reflect/scala/reflect/api/Scopes.scala index 4bab6b6a04..2eb477f652 100644 --- a/src/reflect/scala/reflect/api/Scopes.scala +++ b/src/reflect/scala/reflect/api/Scopes.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package api /** diff --git a/src/reflect/scala/reflect/api/StandardDefinitions.scala b/src/reflect/scala/reflect/api/StandardDefinitions.scala index 721b0bc7f2..bbfebcb434 100644 --- a/src/reflect/scala/reflect/api/StandardDefinitions.scala +++ b/src/reflect/scala/reflect/api/StandardDefinitions.scala @@ -2,7 +2,8 @@ * Copyright 2005-2013 LAMP/EPFL * @author Martin Odersky */ -package scala.reflect +package scala +package reflect package api /** diff --git a/src/reflect/scala/reflect/api/StandardNames.scala b/src/reflect/scala/reflect/api/StandardNames.scala index 6c78f18716..aec5f19fa0 100644 --- a/src/reflect/scala/reflect/api/StandardNames.scala +++ b/src/reflect/scala/reflect/api/StandardNames.scala @@ -2,7 +2,8 @@ * Copyright 2005-2013 LAMP/EPFL * @author Martin Odersky */ -package scala.reflect +package scala +package reflect package api // Q: I have a pretty name. Can I put it here? diff --git a/src/reflect/scala/reflect/api/Symbols.scala b/src/reflect/scala/reflect/api/Symbols.scala index 7225919de5..1250545497 100644 --- a/src/reflect/scala/reflect/api/Symbols.scala +++ b/src/reflect/scala/reflect/api/Symbols.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package api /** diff --git a/src/reflect/scala/reflect/api/TagInterop.scala b/src/reflect/scala/reflect/api/TagInterop.scala index 5de811578e..51b7c519c5 100644 --- a/src/reflect/scala/reflect/api/TagInterop.scala +++ b/src/reflect/scala/reflect/api/TagInterop.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package api /** diff --git a/src/reflect/scala/reflect/api/TreeCreator.scala b/src/reflect/scala/reflect/api/TreeCreator.scala index 6969418470..027c840955 100644 --- a/src/reflect/scala/reflect/api/TreeCreator.scala +++ b/src/reflect/scala/reflect/api/TreeCreator.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package api /** This is an internal implementation class. diff --git a/src/reflect/scala/reflect/api/Trees.scala b/src/reflect/scala/reflect/api/Trees.scala index 99b5ef87f8..f4ada814af 100644 --- a/src/reflect/scala/reflect/api/Trees.scala +++ b/src/reflect/scala/reflect/api/Trees.scala @@ -2,7 +2,8 @@ * Copyright 2005-2013 LAMP/EPFL * @author Martin Odersky */ -package scala.reflect +package scala +package reflect package api /** diff --git a/src/reflect/scala/reflect/api/TypeCreator.scala b/src/reflect/scala/reflect/api/TypeCreator.scala index 24271cb48d..37fff90b43 100644 --- a/src/reflect/scala/reflect/api/TypeCreator.scala +++ b/src/reflect/scala/reflect/api/TypeCreator.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package api /** A mirror-aware factory for types. diff --git a/src/reflect/scala/reflect/api/Types.scala b/src/reflect/scala/reflect/api/Types.scala index 0291d5d26f..9d2d06da69 100644 --- a/src/reflect/scala/reflect/api/Types.scala +++ b/src/reflect/scala/reflect/api/Types.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package api /** diff --git a/src/reflect/scala/reflect/api/Universe.scala b/src/reflect/scala/reflect/api/Universe.scala index 16e533cf7b..799fbd0dfb 100644 --- a/src/reflect/scala/reflect/api/Universe.scala +++ b/src/reflect/scala/reflect/api/Universe.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package api /** diff --git a/src/reflect/scala/reflect/api/package.scala b/src/reflect/scala/reflect/api/package.scala index dbda84dd0e..14dcc9247f 100644 --- a/src/reflect/scala/reflect/api/package.scala +++ b/src/reflect/scala/reflect/api/package.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect import scala.reflect.api.{Universe => ApiUniverse} diff --git a/src/reflect/scala/reflect/internal/AnnotationCheckers.scala b/src/reflect/scala/reflect/internal/AnnotationCheckers.scala index 73cc7fbbd6..74310e1c34 100644 --- a/src/reflect/scala/reflect/internal/AnnotationCheckers.scala +++ b/src/reflect/scala/reflect/internal/AnnotationCheckers.scala @@ -3,7 +3,8 @@ * @author Martin Odersky */ -package scala.reflect +package scala +package reflect package internal /** Additions to the type checker that can be added at diff --git a/src/reflect/scala/reflect/internal/AnnotationInfos.scala b/src/reflect/scala/reflect/internal/AnnotationInfos.scala index f9a026744c..90534a9865 100644 --- a/src/reflect/scala/reflect/internal/AnnotationInfos.scala +++ b/src/reflect/scala/reflect/internal/AnnotationInfos.scala @@ -3,7 +3,8 @@ * @author Martin Odersky */ -package scala.reflect +package scala +package reflect package internal import pickling.ByteCodecs @@ -121,25 +122,32 @@ trait AnnotationInfos extends api.Annotations { self: SymbolTable => * must be `String`. This specialised class is used to encode Scala * signatures for reasons of efficiency, both in term of class-file size * and in term of compiler performance. + * Details about the storage format of pickles at the bytecode level (classfile annotations) can be found in SIP-10. */ case class ScalaSigBytes(bytes: Array[Byte]) extends ClassfileAnnotArg { override def toString = (bytes map { byte => (byte & 0xff).toHexString }).mkString("[ ", " ", " ]") - lazy val encodedBytes = ByteCodecs.encode(bytes) // TODO remove after migration to ASM-based GenJVM complete - def isLong: Boolean = (encodedBytes.length > 65535) // TODO remove after migration to ASM-based GenJVM complete lazy val sevenBitsMayBeZero: Array[Byte] = { mapToNextModSevenBits(scala.reflect.internal.pickling.ByteCodecs.encode8to7(bytes)) } + + /* In order to store a byte array (the pickle) using a bytecode-level annotation, + * the most compact representation is used (which happens to be string-constant and not byte array as one would expect). + * However, a String constant in a classfile annotation is limited to a maximum of 65535 characters. + * Method `fitsInOneString` tells us whether the pickle can be held by a single classfile-annotation of string-type. + * Otherwise an array of strings will be used. + */ def fitsInOneString: Boolean = { + // due to escaping, a zero byte in a classfile-annotation of string-type takes actually two characters. val numZeros = (sevenBitsMayBeZero count { b => b == 0 }) - val res = (sevenBitsMayBeZero.length + numZeros) <= 65535 - assert(this.isLong == !res, "As things stand, can't just swap in `fitsInOneString()` for `isLong()`") - res + + (sevenBitsMayBeZero.length + numZeros) <= 65535 } + def sigAnnot: Type = - if (this.isLong) - definitions.ScalaLongSignatureAnnotation.tpe - else + if (fitsInOneString) definitions.ScalaSignatureAnnotation.tpe + else + definitions.ScalaLongSignatureAnnotation.tpe private def mapToNextModSevenBits(src: Array[Byte]): Array[Byte] = { var i = 0 diff --git a/src/reflect/scala/reflect/internal/BaseTypeSeqs.scala b/src/reflect/scala/reflect/internal/BaseTypeSeqs.scala index 9daf9504f1..66eddd7ec0 100644 --- a/src/reflect/scala/reflect/internal/BaseTypeSeqs.scala +++ b/src/reflect/scala/reflect/internal/BaseTypeSeqs.scala @@ -2,7 +2,8 @@ * Copyright 2005-2013 LAMP/EPFL * @author Martin Odersky */ -package scala.reflect +package scala +package reflect package internal // todo implement in terms of BitSet diff --git a/src/reflect/scala/reflect/internal/BuildUtils.scala b/src/reflect/scala/reflect/internal/BuildUtils.scala index 175943d264..ece2d28be3 100644 --- a/src/reflect/scala/reflect/internal/BuildUtils.scala +++ b/src/reflect/scala/reflect/internal/BuildUtils.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package internal trait BuildUtils { self: SymbolTable => diff --git a/src/reflect/scala/reflect/internal/CapturedVariables.scala b/src/reflect/scala/reflect/internal/CapturedVariables.scala index c262c8474a..2c5e87b95d 100644 --- a/src/reflect/scala/reflect/internal/CapturedVariables.scala +++ b/src/reflect/scala/reflect/internal/CapturedVariables.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package internal import Flags._ diff --git a/src/reflect/scala/reflect/internal/Chars.scala b/src/reflect/scala/reflect/internal/Chars.scala index 2d07092862..74413fdaba 100644 --- a/src/reflect/scala/reflect/internal/Chars.scala +++ b/src/reflect/scala/reflect/internal/Chars.scala @@ -2,7 +2,8 @@ * Copyright 2006-2013 LAMP/EPFL * @author Martin Odersky */ -package scala.reflect +package scala +package reflect package internal import scala.annotation.{ tailrec, switch } diff --git a/src/reflect/scala/reflect/internal/ClassfileConstants.scala b/src/reflect/scala/reflect/internal/ClassfileConstants.scala index b682b7d0ca..a7ce044780 100644 --- a/src/reflect/scala/reflect/internal/ClassfileConstants.scala +++ b/src/reflect/scala/reflect/internal/ClassfileConstants.scala @@ -3,7 +3,8 @@ * @author Martin Odersky */ -package scala.reflect +package scala +package reflect package internal import scala.annotation.switch diff --git a/src/reflect/scala/reflect/internal/Constants.scala b/src/reflect/scala/reflect/internal/Constants.scala index 5ed2f675b2..905c7caa52 100644 --- a/src/reflect/scala/reflect/internal/Constants.scala +++ b/src/reflect/scala/reflect/internal/Constants.scala @@ -3,7 +3,8 @@ * @author Martin Odersky */ -package scala.reflect +package scala +package reflect package internal import java.lang.Integer.toOctalString diff --git a/src/reflect/scala/reflect/internal/Definitions.scala b/src/reflect/scala/reflect/internal/Definitions.scala index dafaf03eaf..a0ddc1e1b2 100644 --- a/src/reflect/scala/reflect/internal/Definitions.scala +++ b/src/reflect/scala/reflect/internal/Definitions.scala @@ -3,7 +3,8 @@ * @author Martin Odersky */ -package scala.reflect +package scala +package reflect package internal import scala.language.postfixOps @@ -323,7 +324,9 @@ trait Definitions extends api.StandardDefinitions { lazy val ThrowableClass = getClassByName(sn.Throwable) lazy val UninitializedErrorClass = requiredClass[UninitializedFieldError] + @deprecated("Same effect but more compact: `throw null`. Details in JVM spec, `athrow` instruction.", "2.11.0") lazy val NPEConstructor = getMemberMethod(NullPointerExceptionClass, nme.CONSTRUCTOR) suchThat (_.paramss.flatten.isEmpty) + lazy val UninitializedFieldConstructor = UninitializedErrorClass.primaryConstructor // fundamental reference classes @@ -404,6 +407,10 @@ trait Definitions extends api.StandardDefinitions { lazy val JavaRepeatedParamClass = specialPolyClass(tpnme.JAVA_REPEATED_PARAM_CLASS_NAME, COVARIANT)(tparam => arrayType(tparam.tpe)) lazy val RepeatedParamClass = specialPolyClass(tpnme.REPEATED_PARAM_CLASS_NAME, COVARIANT)(tparam => seqType(tparam.tpe)) + def dropByName(tp: Type): Type = tp match { + case TypeRef(_, ByNameParamClass, arg :: Nil) => arg + case _ => tp + } def isByNameParamType(tp: Type) = tp.typeSymbol == ByNameParamClass def isScalaRepeatedParamType(tp: Type) = tp.typeSymbol == RepeatedParamClass def isJavaRepeatedParamType(tp: Type) = tp.typeSymbol == JavaRepeatedParamClass diff --git a/src/reflect/scala/reflect/internal/ExistentialsAndSkolems.scala b/src/reflect/scala/reflect/internal/ExistentialsAndSkolems.scala index 34bd400186..6251849182 100644 --- a/src/reflect/scala/reflect/internal/ExistentialsAndSkolems.scala +++ b/src/reflect/scala/reflect/internal/ExistentialsAndSkolems.scala @@ -3,7 +3,8 @@ * @author Martin Odersky */ -package scala.reflect +package scala +package reflect package internal import scala.collection.{ mutable, immutable } diff --git a/src/reflect/scala/reflect/internal/FatalError.scala b/src/reflect/scala/reflect/internal/FatalError.scala index a084fc24f3..08a9a635af 100644 --- a/src/reflect/scala/reflect/internal/FatalError.scala +++ b/src/reflect/scala/reflect/internal/FatalError.scala @@ -2,5 +2,6 @@ * Copyright 2005-2013 LAMP/EPFL * @author Martin Odersky */ -package scala.reflect.internal +package scala +package reflect.internal case class FatalError(msg: String) extends Exception(msg) diff --git a/src/reflect/scala/reflect/internal/FlagSets.scala b/src/reflect/scala/reflect/internal/FlagSets.scala index 6a3b6870a0..961adb2c57 100644 --- a/src/reflect/scala/reflect/internal/FlagSets.scala +++ b/src/reflect/scala/reflect/internal/FlagSets.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package internal import scala.language.implicitConversions diff --git a/src/reflect/scala/reflect/internal/Flags.scala b/src/reflect/scala/reflect/internal/Flags.scala index fe46a0471e..1d5fe3685c 100644 --- a/src/reflect/scala/reflect/internal/Flags.scala +++ b/src/reflect/scala/reflect/internal/Flags.scala @@ -3,7 +3,8 @@ * @author Martin Odersky */ -package scala.reflect +package scala +package reflect package internal import scala.collection.{ mutable, immutable } diff --git a/src/reflect/scala/reflect/internal/HasFlags.scala b/src/reflect/scala/reflect/internal/HasFlags.scala index 6f8befd23e..420b5fef81 100644 --- a/src/reflect/scala/reflect/internal/HasFlags.scala +++ b/src/reflect/scala/reflect/internal/HasFlags.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package internal import Flags._ diff --git a/src/reflect/scala/reflect/internal/Importers.scala b/src/reflect/scala/reflect/internal/Importers.scala index f736202e13..b0d3cda629 100644 --- a/src/reflect/scala/reflect/internal/Importers.scala +++ b/src/reflect/scala/reflect/internal/Importers.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package internal import scala.collection.mutable.WeakHashMap diff --git a/src/reflect/scala/reflect/internal/InfoTransformers.scala b/src/reflect/scala/reflect/internal/InfoTransformers.scala index 4e84a29fd0..3814259e22 100644 --- a/src/reflect/scala/reflect/internal/InfoTransformers.scala +++ b/src/reflect/scala/reflect/internal/InfoTransformers.scala @@ -3,7 +3,8 @@ * @author Martin Odersky */ -package scala.reflect +package scala +package reflect package internal trait InfoTransformers { diff --git a/src/reflect/scala/reflect/internal/JMethodOrConstructor.scala b/src/reflect/scala/reflect/internal/JMethodOrConstructor.scala index d17e2488af..fb1cdb34e1 100644 --- a/src/reflect/scala/reflect/internal/JMethodOrConstructor.scala +++ b/src/reflect/scala/reflect/internal/JMethodOrConstructor.scala @@ -2,7 +2,8 @@ * Copyright 2005-2013 LAMP/EPFL * @author Paul Phillips */ -package scala.reflect +package scala +package reflect package internal import scala.language.implicitConversions diff --git a/src/reflect/scala/reflect/internal/JavaAccFlags.scala b/src/reflect/scala/reflect/internal/JavaAccFlags.scala index 4be1f828d3..0a33b8cf0d 100644 --- a/src/reflect/scala/reflect/internal/JavaAccFlags.scala +++ b/src/reflect/scala/reflect/internal/JavaAccFlags.scala @@ -2,7 +2,8 @@ * Copyright 2005-2013 LAMP/EPFL * @author Paul Phillips */ -package scala.reflect +package scala +package reflect package internal import java.lang.{ Class => jClass } diff --git a/src/reflect/scala/reflect/internal/Kinds.scala b/src/reflect/scala/reflect/internal/Kinds.scala index 3c49aef05a..4612e65e7a 100644 --- a/src/reflect/scala/reflect/internal/Kinds.scala +++ b/src/reflect/scala/reflect/internal/Kinds.scala @@ -3,7 +3,8 @@ * @author Martin Odersky */ -package scala.reflect +package scala +package reflect package internal import scala.collection.{ mutable, immutable } diff --git a/src/reflect/scala/reflect/internal/Mirrors.scala b/src/reflect/scala/reflect/internal/Mirrors.scala index 81d7619f22..bf38c3bf1e 100644 --- a/src/reflect/scala/reflect/internal/Mirrors.scala +++ b/src/reflect/scala/reflect/internal/Mirrors.scala @@ -3,7 +3,8 @@ * @author Martin Odersky */ -package scala.reflect +package scala +package reflect package internal import Flags._ @@ -35,7 +36,7 @@ trait Mirrors extends api.Mirrors { else definitions.findNamedMember(segs.tail, RootClass.info member segs.head) } - /** Todo: organize similar to mkStatic in reflect.Base */ + /** Todo: organize similar to mkStatic in scala.reflect.Base */ private def getModuleOrClass(path: Name, len: Int): Symbol = { val point = path lastPos('.', len - 1) val owner = diff --git a/src/reflect/scala/reflect/internal/MissingRequirementError.scala b/src/reflect/scala/reflect/internal/MissingRequirementError.scala index 48203caa83..66dbf535d7 100644 --- a/src/reflect/scala/reflect/internal/MissingRequirementError.scala +++ b/src/reflect/scala/reflect/internal/MissingRequirementError.scala @@ -3,7 +3,8 @@ * @author Martin Odersky */ -package scala.reflect +package scala +package reflect package internal class MissingRequirementError private (msg: String) extends FatalError(msg) { diff --git a/src/reflect/scala/reflect/internal/Mode.scala b/src/reflect/scala/reflect/internal/Mode.scala index 7ed410bbd2..516e96cbb3 100644 --- a/src/reflect/scala/reflect/internal/Mode.scala +++ b/src/reflect/scala/reflect/internal/Mode.scala @@ -3,7 +3,8 @@ * @author Martin Odersky */ -package scala.reflect +package scala +package reflect package internal import scala.language.implicitConversions diff --git a/src/reflect/scala/reflect/internal/Names.scala b/src/reflect/scala/reflect/internal/Names.scala index b8141d25f5..ed5b92565d 100644 --- a/src/reflect/scala/reflect/internal/Names.scala +++ b/src/reflect/scala/reflect/internal/Names.scala @@ -3,7 +3,8 @@ * @author Martin Odersky */ -package scala.reflect +package scala +package reflect package internal import scala.io.Codec diff --git a/src/reflect/scala/reflect/internal/Phase.scala b/src/reflect/scala/reflect/internal/Phase.scala index c0f4232724..450c90ed56 100644 --- a/src/reflect/scala/reflect/internal/Phase.scala +++ b/src/reflect/scala/reflect/internal/Phase.scala @@ -3,7 +3,8 @@ * @author Martin Odersky */ -package scala.reflect +package scala +package reflect package internal abstract class Phase(val prev: Phase) { diff --git a/src/reflect/scala/reflect/internal/Positions.scala b/src/reflect/scala/reflect/internal/Positions.scala index 3cf4f4a1df..eef8159ad4 100644 --- a/src/reflect/scala/reflect/internal/Positions.scala +++ b/src/reflect/scala/reflect/internal/Positions.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package internal import util._ diff --git a/src/reflect/scala/reflect/internal/Printers.scala b/src/reflect/scala/reflect/internal/Printers.scala index b8e73e51f3..1603029340 100644 --- a/src/reflect/scala/reflect/internal/Printers.scala +++ b/src/reflect/scala/reflect/internal/Printers.scala @@ -5,7 +5,8 @@ // todo. we need to unify this prettyprinter with NodePrinters -package scala.reflect +package scala +package reflect package internal import java.io.{ OutputStream, PrintWriter, StringWriter, Writer } @@ -434,7 +435,7 @@ trait Printers extends api.Printers { self: SymbolTable => print(tpt) printColumn(whereClauses, " forSome { ", ";", "}") -// SelectFromArray is no longer visible in reflect.internal. +// SelectFromArray is no longer visible in scala.reflect.internal. // eliminated until we figure out what we will do with both Printers and // SelectFromArray. // case SelectFromArray(qualifier, name, _) => diff --git a/src/reflect/scala/reflect/internal/PrivateWithin.scala b/src/reflect/scala/reflect/internal/PrivateWithin.scala index 5646ac82ae..996f9c13bb 100644 --- a/src/reflect/scala/reflect/internal/PrivateWithin.scala +++ b/src/reflect/scala/reflect/internal/PrivateWithin.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package internal import java.lang.{ Class => jClass } diff --git a/src/reflect/scala/reflect/internal/Required.scala b/src/reflect/scala/reflect/internal/Required.scala index 93383f5376..14db252a16 100644 --- a/src/reflect/scala/reflect/internal/Required.scala +++ b/src/reflect/scala/reflect/internal/Required.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package internal import settings.MutableSettings diff --git a/src/reflect/scala/reflect/internal/Scopes.scala b/src/reflect/scala/reflect/internal/Scopes.scala index 371eddbc4f..8d20c8e546 100644 --- a/src/reflect/scala/reflect/internal/Scopes.scala +++ b/src/reflect/scala/reflect/internal/Scopes.scala @@ -3,7 +3,8 @@ * @author Martin Odersky */ -package scala.reflect +package scala +package reflect package internal import scala.annotation.tailrec diff --git a/src/reflect/scala/reflect/internal/StdAttachments.scala b/src/reflect/scala/reflect/internal/StdAttachments.scala index 6c5bbc9774..9eb66db01e 100644 --- a/src/reflect/scala/reflect/internal/StdAttachments.scala +++ b/src/reflect/scala/reflect/internal/StdAttachments.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package internal trait StdAttachments { diff --git a/src/reflect/scala/reflect/internal/StdCreators.scala b/src/reflect/scala/reflect/internal/StdCreators.scala index 5e5e4f9043..a0084dc95c 100644 --- a/src/reflect/scala/reflect/internal/StdCreators.scala +++ b/src/reflect/scala/reflect/internal/StdCreators.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package internal import scala.reflect.api.{TreeCreator, TypeCreator} diff --git a/src/reflect/scala/reflect/internal/StdNames.scala b/src/reflect/scala/reflect/internal/StdNames.scala index ae2cf09c2e..a20307882d 100644 --- a/src/reflect/scala/reflect/internal/StdNames.scala +++ b/src/reflect/scala/reflect/internal/StdNames.scala @@ -3,7 +3,8 @@ * @author Martin Odersky */ -package scala.reflect +package scala +package reflect package internal import java.security.MessageDigest @@ -589,6 +590,7 @@ trait StdNames { val clone_ : NameType = "clone" val conforms: NameType = "conforms" val copy: NameType = "copy" + val create: NameType = "create" val currentMirror: NameType = "currentMirror" val delayedInit: NameType = "delayedInit" val delayedInitArg: NameType = "delayedInit$body" @@ -697,6 +699,7 @@ trait StdNames { val view_ : NameType = "view" val wait_ : NameType = "wait" val withFilter: NameType = "withFilter" + val zero: NameType = "zero" // unencoded operators object raw { diff --git a/src/reflect/scala/reflect/internal/SymbolTable.scala b/src/reflect/scala/reflect/internal/SymbolTable.scala index 336c2748c6..7f9811220f 100644 --- a/src/reflect/scala/reflect/internal/SymbolTable.scala +++ b/src/reflect/scala/reflect/internal/SymbolTable.scala @@ -3,7 +3,8 @@ * @author Martin Odersky */ -package scala.reflect +package scala +package reflect package internal import scala.annotation.elidable @@ -47,6 +48,7 @@ abstract class SymbolTable extends macros.Universe def log(msg: => AnyRef): Unit def warning(msg: String): Unit = Console.err.println(msg) + def inform(msg: String): Unit = Console.err.println(msg) def globalError(msg: String): Unit = abort(msg) def abort(msg: String): Nothing = throw new FatalError(supplementErrorMessage(msg)) @@ -124,6 +126,8 @@ abstract class SymbolTable extends macros.Universe val global: SymbolTable.this.type = SymbolTable.this } with util.TraceSymbolActivity + val treeInfo: TreeInfo { val global: SymbolTable.this.type } + /** Check that the executing thread is the compiler thread. No-op here, * overridden in interactive.Global. */ @elidable(elidable.WARNING) diff --git a/src/reflect/scala/reflect/internal/Symbols.scala b/src/reflect/scala/reflect/internal/Symbols.scala index a87d002f25..cf4e210ccf 100644 --- a/src/reflect/scala/reflect/internal/Symbols.scala +++ b/src/reflect/scala/reflect/internal/Symbols.scala @@ -3,7 +3,8 @@ * @author Martin Odersky */ -package scala.reflect +package scala +package reflect package internal import scala.collection.{ mutable, immutable } @@ -91,6 +92,8 @@ trait Symbols extends api.Symbols { self: SymbolTable => def isExistential: Boolean = this.isExistentiallyBound def isParamWithDefault: Boolean = this.hasDefault + // `isByNameParam` is only true for a call-by-name parameter of a *method*, + // an argument of the primary constructor seen in the class body is excluded by `isValueParameter` def isByNameParam: Boolean = this.isValueParameter && (this hasFlag BYNAMEPARAM) def isImplementationArtifact: Boolean = (this hasFlag BRIDGE) || (this hasFlag VBRIDGE) || (this hasFlag ARTIFACT) def isJava: Boolean = isJavaDefined @@ -659,8 +662,29 @@ trait Symbols extends api.Symbols { self: SymbolTable => final def hasGetter = isTerm && nme.isLocalName(name) + /** A little explanation for this confusing situation. + * Nested modules which have no static owner when ModuleDefs + * are eliminated (refchecks) are given the lateMETHOD flag, + * which makes them appear as methods after refchecks. + * Here's an example where one can see all four of FF FT TF TT + * for (isStatic, isMethod) at various phases. + * + * trait A1 { case class Quux() } + * object A2 extends A1 { object Flax } + * // -- namer object Quux in trait A1 + * // -M flatten object Quux in trait A1 + * // S- flatten object Flax in object A2 + * // -M posterasure object Quux in trait A1 + * // -M jvm object Quux in trait A1 + * // SM jvm object Quux in object A2 + * + * So "isModuleNotMethod" exists not for its achievement in + * brevity, but to encapsulate the relevant condition. + */ + def isModuleNotMethod = isModule && !isMethod + def isStaticModule = isModuleNotMethod && isStatic + final def isInitializedToDefault = !isType && hasAllFlags(DEFAULTINIT | ACCESSOR) - final def isStaticModule = isModule && isStatic && !isMethod final def isThisSym = isTerm && owner.thisSym == this final def isError = hasFlag(IS_ERROR) final def isErroneous = isError || isInitialized && tpe_*.isErroneous @@ -766,8 +790,12 @@ trait Symbols extends api.Symbols { self: SymbolTable => /** Is this symbol an accessor method for outer? */ final def isOuterField = isArtifact && (unexpandedName == nme.OUTER_LOCAL) - /** Does this symbol denote a stable value? */ - def isStable = false + /** Does this symbol denote a stable value, ignoring volatility? + * + * Stability and volatility are checked separately to allow volatile paths in patterns that amount to equality checks. SI-6815 + */ + final def isStable = isTerm && !isMutable && !(hasFlag(BYNAMEPARAM)) && (!isMethod || hasStableFlag) + final def hasVolatileType = tpe.isVolatile && !hasAnnotation(uncheckedStableClass) /** Does this symbol denote the primary constructor of its enclosing class? */ final def isPrimaryConstructor = @@ -1110,12 +1138,13 @@ trait Symbols extends api.Symbols { self: SymbolTable => new TermSymbol(this, pos, name) initFlags newFlags final def newTermSymbol(name: TermName, pos: Position = NoPosition, newFlags: Long = 0L): TermSymbol = { - if ((newFlags & METHOD) != 0) - createMethodSymbol(name, pos, newFlags) - else if ((newFlags & PACKAGE) != 0) + // Package before Module, Module before Method, or we might grab the wrong guy. + if ((newFlags & PACKAGE) != 0) createPackageSymbol(name, pos, newFlags | PackageFlags) else if ((newFlags & MODULE) != 0) createModuleSymbol(name, pos, newFlags) + else if ((newFlags & METHOD) != 0) + createMethodSymbol(name, pos, newFlags) else if ((newFlags & PARAM) != 0) createValueParameterSymbol(name, pos, newFlags) else @@ -2564,13 +2593,7 @@ trait Symbols extends api.Symbols { self: SymbolTable => override def isMixinConstructor = name == nme.MIXIN_CONSTRUCTOR override def isConstructor = nme.isConstructorName(name) - override def isPackageObject = isModule && (name == nme.PACKAGE) - override def isStable = !isUnstable - private def isUnstable = ( - isMutable - || (hasFlag(METHOD | BYNAMEPARAM) && !hasFlag(STABLE)) - || (tpe.isVolatile && !hasAnnotation(uncheckedStableClass)) - ) + override def isPackageObject = isModule && (name == nme.PACKAGE) // The name in comments is what it is being disambiguated from. // TODO - rescue CAPTURED from BYNAMEPARAM so we can see all the names. @@ -3027,8 +3050,7 @@ trait Symbols extends api.Symbols { self: SymbolTable => * returned, otherwise, `NoSymbol` is returned. */ protected final def companionModule0: Symbol = - flatOwnerInfo.decl(name.toTermName).suchThat( - sym => sym.isModule && (sym isCoDefinedWith this) && !sym.isMethod) + flatOwnerInfo.decl(name.toTermName).suchThat(sym => sym.isModuleNotMethod && (sym isCoDefinedWith this)) override def companionModule = companionModule0 override def companionSymbol = companionModule0 diff --git a/src/reflect/scala/reflect/internal/TreeGen.scala b/src/reflect/scala/reflect/internal/TreeGen.scala index 11574ad8ac..44c66b2bbf 100644 --- a/src/reflect/scala/reflect/internal/TreeGen.scala +++ b/src/reflect/scala/reflect/internal/TreeGen.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package internal abstract class TreeGen extends macros.TreeBuilder { @@ -141,17 +142,15 @@ abstract class TreeGen extends macros.TreeBuilder { } /** Computes stable type for a tree if possible */ - def stableTypeFor(tree: Tree): Option[Type] = tree match { - case This(_) if tree.symbol != null && !tree.symbol.isError => - Some(ThisType(tree.symbol)) - case Ident(_) if tree.symbol.isStable => - Some(singleType(tree.symbol.owner.thisType, tree.symbol)) - case Select(qual, _) if ((tree.symbol ne null) && (qual.tpe ne null)) && // turned assert into guard for #4064 - tree.symbol.isStable && qual.tpe.isStable => - Some(singleType(qual.tpe, tree.symbol)) - case _ => - None - } + def stableTypeFor(tree: Tree): Option[Type] = + if (treeInfo.admitsTypeSelection(tree)) + tree match { + case This(_) => Some(ThisType(tree.symbol)) + case Ident(_) => Some(singleType(tree.symbol.owner.thisType, tree.symbol)) + case Select(qual, _) => Some(singleType(qual.tpe, tree.symbol)) + case _ => None + } + else None /** Builds a reference with stable type to given symbol */ def mkAttributedStableRef(pre: Type, sym: Symbol): Tree = diff --git a/src/reflect/scala/reflect/internal/TreeInfo.scala b/src/reflect/scala/reflect/internal/TreeInfo.scala index bf3857ea4e..4c0f0695b3 100644 --- a/src/reflect/scala/reflect/internal/TreeInfo.scala +++ b/src/reflect/scala/reflect/internal/TreeInfo.scala @@ -3,7 +3,8 @@ * @author Martin Odersky */ -package scala.reflect +package scala +package reflect package internal import Flags._ @@ -17,7 +18,7 @@ abstract class TreeInfo { val global: SymbolTable import global._ - import definitions.{ isVarArgsList, isCastSymbol, ThrowableClass, TupleClass, MacroContextClass, MacroContextPrefixType } + import definitions.{ isTupleSymbol, isVarArgsList, isCastSymbol, ThrowableClass, TupleClass, MacroContextClass, MacroContextPrefixType, uncheckedStableClass } /* Does not seem to be used. Not sure what it does anyway. def isOwnerDefinition(tree: Tree): Boolean = tree match { @@ -65,6 +66,80 @@ abstract class TreeInfo { false } + /** Is `tree` a path, defined as follows? (Spec: 3.1 Paths) + * + * - The empty path ε (which cannot be written explicitly in user programs). + * - C.this, where C references a class. + * - p.x where p is a path and x is a stable member of p. + * - C.super.x or C.super[M].x where C references a class + * and x references a stable member of the super class or designated parent class M of C. + * + * NOTE: Trees with errors are (mostly) excluded. + * + * Path ::= StableId | [id ‘.’] this + * + */ + def isPath(tree: Tree, allowVolatile: Boolean): Boolean = + tree match { + // Super is not technically a path. + // However, syntactically, it can only occur nested in a Select. + // This gives a nicer definition of isStableIdentifier that's equivalent to the spec's. + // must consider Literal(_) a path for typedSingletonTypeTree + case EmptyTree | Literal(_) => true + case This(_) | Super(_, _) => symOk(tree.symbol) + case _ => isStableIdentifier(tree, allowVolatile) + } + + /** Is `tree` a stable identifier, a path which ends in an identifier? + * + * StableId ::= id + * | Path ‘.’ id + * | [id ’.’] ‘super’ [‘[’ id ‘]’] ‘.’ id + */ + def isStableIdentifier(tree: Tree, allowVolatile: Boolean): Boolean = + tree match { + case Ident(_) => symOk(tree.symbol) && tree.symbol.isStable && !tree.symbol.hasVolatileType // TODO SPEC: not required by spec + case Select(qual, _) => isStableMemberOf(tree.symbol, qual, allowVolatile) && isPath(qual, allowVolatile) + case Apply(Select(free @ Ident(_), nme.apply), _) if free.symbol.name endsWith nme.REIFY_FREE_VALUE_SUFFIX => + // see a detailed explanation of this trick in `GenSymbols.reifyFreeTerm` + free.symbol.hasStableFlag && isPath(free, allowVolatile) + case _ => false + } + + private def symOk(sym: Symbol) = sym != null && !sym.isError && sym != NoSymbol + private def typeOk(tp: Type) = tp != null && ! tp.isError + + /** Assuming `sym` is a member of `tree`, is it a "stable member"? + * + * Stable members are packages or members introduced + * by object definitions or by value definitions of non-volatile types (§3.6). + */ + def isStableMemberOf(sym: Symbol, tree: Tree, allowVolatile: Boolean): Boolean = ( + symOk(sym) && (!sym.isTerm || (sym.isStable && (allowVolatile || !sym.hasVolatileType))) && + typeOk(tree.tpe) && (allowVolatile || !hasVolatileType(tree)) && !definitions.isByNameParamType(tree.tpe) + ) + + /** Is `tree`'s type volatile? (Ignored if its symbol has the @uncheckedStable annotation.) + */ + def hasVolatileType(tree: Tree): Boolean = + symOk(tree.symbol) && tree.tpe.isVolatile && !tree.symbol.hasAnnotation(uncheckedStableClass) + + /** Is `tree` either a non-volatile type, + * or a path that does not include any of: + * - a reference to a mutable variable/field + * - a reference to a by-name parameter + * - a member selection on a volatile type (Spec: 3.6 Volatile Types)? + * + * Such a tree is a suitable target for type selection. + */ + def admitsTypeSelection(tree: Tree): Boolean = isPath(tree, allowVolatile = false) + + /** Is `tree` admissible as a stable identifier pattern (8.1.5 Stable Identifier Patterns)? + * + * We disregard volatility, as it's irrelevant in patterns (SI-6815) + */ + def isStableIdentifierPattern(tree: Tree): Boolean = isStableIdentifier(tree, allowVolatile = true) + // TODO SI-5304 tighten this up so we don't elide side effect in module loads def isQualifierSafeToElide(tree: Tree): Boolean = isExprSafeToInline(tree) @@ -472,9 +547,9 @@ abstract class TreeInfo { /** Does this CaseDef catch Throwable? */ def catchesThrowable(cdef: CaseDef) = ( cdef.guard.isEmpty && (unbind(cdef.pat) match { - case Ident(nme.WILDCARD) => true - case i@Ident(name) => hasNoSymbol(i) - case _ => false + case Ident(nme.WILDCARD) => true + case i@Ident(name) => hasNoSymbol(i) + case _ => false }) ) @@ -531,6 +606,20 @@ abstract class TreeInfo { case _ => false } + /** + * {{{ + * //------------------------ => effectivePatternArity(args) + * case Extractor(a) => 1 + * case Extractor(a, b) => 2 + * case Extractor((a, b)) => 2 + * case Extractor(a @ (b, c)) => 2 + * }}} + */ + def effectivePatternArity(args: List[Tree]): Int = (args.map(unbind) match { + case Apply(fun, xs) :: Nil if isTupleSymbol(fun.symbol) => xs + case xs => xs + }).length + // used in the symbols for labeldefs and valdefs emitted by the pattern matcher // tailcalls, cps,... use this flag combination to detect translated matches diff --git a/src/reflect/scala/reflect/internal/Trees.scala b/src/reflect/scala/reflect/internal/Trees.scala index 7467ccc6b9..de0b4e8247 100644 --- a/src/reflect/scala/reflect/internal/Trees.scala +++ b/src/reflect/scala/reflect/internal/Trees.scala @@ -3,7 +3,8 @@ * @author Martin Odersky */ -package scala.reflect +package scala +package reflect package internal import Flags._ @@ -1649,6 +1650,21 @@ trait Trees extends api.Trees { self: SymbolTable => sys.error("Not a ClassDef: " + t + "/" + t.getClass) } + def copyModuleDef(tree: Tree)( + mods: Modifiers = null, + name: Name = null, + impl: Template = null + ): ModuleDef = tree match { + case ModuleDef(mods0, name0, impl0) => + treeCopy.ModuleDef(tree, + if (mods eq null) mods0 else mods, + if (name eq null) name0 else name, + if (impl eq null) impl0 else impl + ) + case t => + sys.error("Not a ModuleDef: " + t + "/" + t.getClass) + } + def deriveDefDef(ddef: Tree)(applyToRhs: Tree => Tree): DefDef = ddef match { case DefDef(mods0, name0, tparams0, vparamss0, tpt0, rhs0) => treeCopy.DefDef(ddef, mods0, name0, tparams0, vparamss0, tpt0, applyToRhs(rhs0)) diff --git a/src/reflect/scala/reflect/internal/TypeDebugging.scala b/src/reflect/scala/reflect/internal/TypeDebugging.scala index d437b1b058..71f84ab557 100644 --- a/src/reflect/scala/reflect/internal/TypeDebugging.scala +++ b/src/reflect/scala/reflect/internal/TypeDebugging.scala @@ -3,7 +3,8 @@ * @author Paul Phillips */ -package scala.reflect +package scala +package reflect package internal trait TypeDebugging { diff --git a/src/reflect/scala/reflect/internal/Types.scala b/src/reflect/scala/reflect/internal/Types.scala index 75b4e9c100..00fd20a46b 100644 --- a/src/reflect/scala/reflect/internal/Types.scala +++ b/src/reflect/scala/reflect/internal/Types.scala @@ -3,7 +3,8 @@ * @author Martin Odersky */ -package scala.reflect +package scala +package reflect package internal import scala.collection.{ mutable, immutable, generic } @@ -1078,7 +1079,7 @@ trait Types (bcs eq bcs0) || (flags & PrivateLocal) != PrivateLocal || (bcs0.head.hasTransOwner(bcs.head)))) { - if (name.isTypeName || stableOnly && sym.isStable) { + if (name.isTypeName || (stableOnly && sym.isStable && !sym.hasVolatileType)) { if (Statistics.canEnable) Statistics.popTimer(typeOpsStack, start) return sym } else if (member eq NoSymbol) { @@ -1355,7 +1356,7 @@ trait Types // more precise conceptually, but causes cyclic errors: (paramss exists (_ contains sym)) override def isImmediatelyDependent = (sym ne NoSymbol) && (sym.owner.isMethod && sym.isValueParameter) - override def isVolatile : Boolean = underlying.isVolatile && !sym.isStable + override def isVolatile : Boolean = underlying.isVolatile && (sym.hasVolatileType || !sym.isStable) /* override def narrow: Type = { if (phase.erasedTypes) this @@ -3399,7 +3400,7 @@ trait Types /** Rebind symbol `sym` to an overriding member in type `pre`. */ private def rebind(pre: Type, sym: Symbol): Symbol = { if (!sym.isOverridableMember || sym.owner == pre.typeSymbol) sym - else pre.nonPrivateMember(sym.name).suchThat(sym => sym.isType || sym.isStable) orElse sym + else pre.nonPrivateMember(sym.name).suchThat(sym => sym.isType || (sym.isStable && !sym.hasVolatileType)) orElse sym } /** Convert a `super` prefix to a this-type if `sym` is abstract or final. */ @@ -4095,7 +4096,7 @@ trait Types val info1 = tp1.memberInfo(sym1) val info2 = tp2.memberInfo(sym2).substThis(tp2.typeSymbol, tp1) //System.out.println("specializes "+tp1+"."+sym1+":"+info1+sym1.locationString+" AND "+tp2+"."+sym2+":"+info2)//DEBUG - ( sym2.isTerm && isSubType(info1, info2, depth) && (!sym2.isStable || sym1.isStable) + ( sym2.isTerm && isSubType(info1, info2, depth) && (!sym2.isStable || sym1.isStable) && (!sym1.hasVolatileType || sym2.hasVolatileType) || sym2.isAbstractType && { val memberTp1 = tp1.memberType(sym1) // println("kinds conform? "+(memberTp1, tp1, sym2, kindsConform(List(sym2), List(memberTp1), tp2, sym2.owner))) @@ -4434,11 +4435,11 @@ trait Types /** Perform operation `p` on arguments `tp1`, `arg2` and print trace of computation. */ protected def explain[T](op: String, p: (Type, T) => Boolean, tp1: Type, arg2: T): Boolean = { - Console.println(indent + tp1 + " " + op + " " + arg2 + "?" /* + "("+tp1.getClass+","+arg2.getClass+")"*/) + inform(indent + tp1 + " " + op + " " + arg2 + "?" /* + "("+tp1.getClass+","+arg2.getClass+")"*/) indent = indent + " " val result = p(tp1, arg2) indent = indent stripSuffix " " - Console.println(indent + result) + inform(indent + result) result } diff --git a/src/reflect/scala/reflect/internal/Variance.scala b/src/reflect/scala/reflect/internal/Variance.scala index 007d56eb35..3480161567 100644 --- a/src/reflect/scala/reflect/internal/Variance.scala +++ b/src/reflect/scala/reflect/internal/Variance.scala @@ -3,7 +3,8 @@ * @author Paul Phillips */ -package scala.reflect +package scala +package reflect package internal import Variance._ diff --git a/src/reflect/scala/reflect/internal/Variances.scala b/src/reflect/scala/reflect/internal/Variances.scala index 716e49b303..78df3c9617 100644 --- a/src/reflect/scala/reflect/internal/Variances.scala +++ b/src/reflect/scala/reflect/internal/Variances.scala @@ -3,7 +3,8 @@ * @author Martin Odersky */ -package scala.reflect +package scala +package reflect package internal import Variance._ diff --git a/src/reflect/scala/reflect/internal/annotations/compileTimeOnly.scala b/src/reflect/scala/reflect/internal/annotations/compileTimeOnly.scala index 058ff61fbf..2c9f909629 100644 --- a/src/reflect/scala/reflect/internal/annotations/compileTimeOnly.scala +++ b/src/reflect/scala/reflect/internal/annotations/compileTimeOnly.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package internal package annotations diff --git a/src/reflect/scala/reflect/internal/pickling/ByteCodecs.scala b/src/reflect/scala/reflect/internal/pickling/ByteCodecs.scala index 367a3b8b19..18d7e05c4c 100644 --- a/src/reflect/scala/reflect/internal/pickling/ByteCodecs.scala +++ b/src/reflect/scala/reflect/internal/pickling/ByteCodecs.scala @@ -5,7 +5,8 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ -package scala.reflect.internal.pickling +package scala +package reflect.internal.pickling object ByteCodecs { @@ -195,10 +196,10 @@ object ByteCodecs { * * Sometimes returns (length+1) of the decoded array. Example: * - * scala> val enc = reflect.generic.ByteCodecs.encode(Array(1,2,3)) + * scala> val enc = scala.reflect.generic.ByteCodecs.encode(Array(1,2,3)) * enc: Array[Byte] = Array(2, 5, 13, 1) * - * scala> reflect.generic.ByteCodecs.decode(enc) + * scala> scala.reflect.generic.ByteCodecs.decode(enc) * res43: Int = 4 * * scala> enc diff --git a/src/reflect/scala/reflect/internal/pickling/PickleBuffer.scala b/src/reflect/scala/reflect/internal/pickling/PickleBuffer.scala index c9dfb7fe71..c953b5df22 100644 --- a/src/reflect/scala/reflect/internal/pickling/PickleBuffer.scala +++ b/src/reflect/scala/reflect/internal/pickling/PickleBuffer.scala @@ -3,7 +3,8 @@ * @author Martin Odersky */ -package scala.reflect +package scala +package reflect package internal package pickling diff --git a/src/reflect/scala/reflect/internal/pickling/PickleFormat.scala b/src/reflect/scala/reflect/internal/pickling/PickleFormat.scala index 3722c77aa2..ce0ceec688 100644 --- a/src/reflect/scala/reflect/internal/pickling/PickleFormat.scala +++ b/src/reflect/scala/reflect/internal/pickling/PickleFormat.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package internal package pickling diff --git a/src/reflect/scala/reflect/internal/pickling/UnPickler.scala b/src/reflect/scala/reflect/internal/pickling/UnPickler.scala index c940d863f7..6cffdbc193 100644 --- a/src/reflect/scala/reflect/internal/pickling/UnPickler.scala +++ b/src/reflect/scala/reflect/internal/pickling/UnPickler.scala @@ -3,7 +3,8 @@ * @author Martin Odersky */ -package scala.reflect +package scala +package reflect package internal package pickling @@ -851,7 +852,8 @@ abstract class UnPickler { private val p = phase override def complete(sym: Symbol) : Unit = try { val tp = at(i, () => readType(sym.isTerm)) // after NMT_TRANSITION, revert `() => readType(sym.isTerm)` to `readType` - enteringPhase(p) (sym setInfo tp) + if (p ne null) + enteringPhase(p) (sym setInfo tp) if (currentRunId != definedAtRunId) sym.setInfo(adaptToNewRunMap(tp)) } diff --git a/src/reflect/scala/reflect/internal/settings/AbsSettings.scala b/src/reflect/scala/reflect/internal/settings/AbsSettings.scala index a6fb4187ca..859f703d97 100644 --- a/src/reflect/scala/reflect/internal/settings/AbsSettings.scala +++ b/src/reflect/scala/reflect/internal/settings/AbsSettings.scala @@ -3,7 +3,8 @@ * @author Paul Phillips */ -package scala.reflect.internal +package scala +package reflect.internal package settings /** A Settings abstraction boiled out of the original highly mutable Settings diff --git a/src/reflect/scala/reflect/internal/settings/MutableSettings.scala b/src/reflect/scala/reflect/internal/settings/MutableSettings.scala index 68f9fc8e83..e21e95903b 100644 --- a/src/reflect/scala/reflect/internal/settings/MutableSettings.scala +++ b/src/reflect/scala/reflect/internal/settings/MutableSettings.scala @@ -4,7 +4,8 @@ */ // $Id$ -package scala.reflect.internal +package scala +package reflect.internal package settings /** A mutable Settings object. diff --git a/src/reflect/scala/reflect/internal/tpe/CommonOwners.scala b/src/reflect/scala/reflect/internal/tpe/CommonOwners.scala index e5ddd8f359..f879960407 100644 --- a/src/reflect/scala/reflect/internal/tpe/CommonOwners.scala +++ b/src/reflect/scala/reflect/internal/tpe/CommonOwners.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package internal package tpe diff --git a/src/reflect/scala/reflect/internal/tpe/GlbLubs.scala b/src/reflect/scala/reflect/internal/tpe/GlbLubs.scala index cb1ec67d23..2da9960c81 100644 --- a/src/reflect/scala/reflect/internal/tpe/GlbLubs.scala +++ b/src/reflect/scala/reflect/internal/tpe/GlbLubs.scala @@ -1,8 +1,10 @@ -package scala.reflect +package scala +package reflect package internal package tpe -import scala.collection.{ mutable } +import scala.collection.mutable +import scala.annotation.tailrec import util.Statistics import Variance._ @@ -11,7 +13,7 @@ private[internal] trait GlbLubs { import definitions._ import TypesStats._ - private final val printLubs = sys.props contains "scalac.debug.lub" + private final val printLubs = scala.sys.props contains "scalac.debug.lub" /** In case anyone wants to turn off lub verification without reverting anything. */ private final val verifyLubs = true @@ -86,7 +88,7 @@ private[internal] trait GlbLubs { case _ => tp } // pretypes is a tail-recursion-preserving accumulator. - @annotation.tailrec def loop(pretypes: List[Type], tsBts: List[List[Type]]): List[Type] = { + @tailrec def loop(pretypes: List[Type], tsBts: List[List[Type]]): List[Type] = { lubListDepth += 1 if (tsBts.isEmpty || (tsBts exists typeListIsEmpty)) pretypes.reverse diff --git a/src/reflect/scala/reflect/internal/tpe/TypeComparers.scala b/src/reflect/scala/reflect/internal/tpe/TypeComparers.scala index e18b21aa76..711a94d7bd 100644 --- a/src/reflect/scala/reflect/internal/tpe/TypeComparers.scala +++ b/src/reflect/scala/reflect/internal/tpe/TypeComparers.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package internal package tpe diff --git a/src/reflect/scala/reflect/internal/tpe/TypeConstraints.scala b/src/reflect/scala/reflect/internal/tpe/TypeConstraints.scala index b0feb0a7fb..39e427f588 100644 --- a/src/reflect/scala/reflect/internal/tpe/TypeConstraints.scala +++ b/src/reflect/scala/reflect/internal/tpe/TypeConstraints.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package internal package tpe diff --git a/src/reflect/scala/reflect/internal/tpe/TypeMaps.scala b/src/reflect/scala/reflect/internal/tpe/TypeMaps.scala index 4227699da2..7665e7c0f4 100644 --- a/src/reflect/scala/reflect/internal/tpe/TypeMaps.scala +++ b/src/reflect/scala/reflect/internal/tpe/TypeMaps.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package internal package tpe diff --git a/src/reflect/scala/reflect/internal/tpe/TypeToStrings.scala b/src/reflect/scala/reflect/internal/tpe/TypeToStrings.scala index c86383e9e3..16929cca0f 100644 --- a/src/reflect/scala/reflect/internal/tpe/TypeToStrings.scala +++ b/src/reflect/scala/reflect/internal/tpe/TypeToStrings.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package internal package tpe diff --git a/src/reflect/scala/reflect/internal/transform/Erasure.scala b/src/reflect/scala/reflect/internal/transform/Erasure.scala index b8a8e4d0c0..24da8d20cc 100644 --- a/src/reflect/scala/reflect/internal/transform/Erasure.scala +++ b/src/reflect/scala/reflect/internal/transform/Erasure.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package internal package transform diff --git a/src/reflect/scala/reflect/internal/transform/RefChecks.scala b/src/reflect/scala/reflect/internal/transform/RefChecks.scala index d6108ab665..4ca114e781 100644 --- a/src/reflect/scala/reflect/internal/transform/RefChecks.scala +++ b/src/reflect/scala/reflect/internal/transform/RefChecks.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package internal package transform @@ -10,4 +11,4 @@ trait RefChecks { def transformInfo(sym: Symbol, tp: Type): Type = if (sym.isModule && !sym.isStatic) NullaryMethodType(tp) else tp -}
\ No newline at end of file +} diff --git a/src/reflect/scala/reflect/internal/transform/Transforms.scala b/src/reflect/scala/reflect/internal/transform/Transforms.scala index 71cc80895d..fa185db22f 100644 --- a/src/reflect/scala/reflect/internal/transform/Transforms.scala +++ b/src/reflect/scala/reflect/internal/transform/Transforms.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package internal package transform diff --git a/src/reflect/scala/reflect/internal/transform/UnCurry.scala b/src/reflect/scala/reflect/internal/transform/UnCurry.scala index 1f7638a621..c525e794a9 100644 --- a/src/reflect/scala/reflect/internal/transform/UnCurry.scala +++ b/src/reflect/scala/reflect/internal/transform/UnCurry.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package internal package transform diff --git a/src/reflect/scala/reflect/internal/util/Collections.scala b/src/reflect/scala/reflect/internal/util/Collections.scala index d6fca9d186..51b2f9f4e4 100644 --- a/src/reflect/scala/reflect/internal/util/Collections.scala +++ b/src/reflect/scala/reflect/internal/util/Collections.scala @@ -3,7 +3,8 @@ * @author Paul Phillips */ -package scala.reflect.internal.util +package scala +package reflect.internal.util import scala.collection.{ mutable, immutable } import scala.annotation.tailrec diff --git a/src/reflect/scala/reflect/internal/util/HashSet.scala b/src/reflect/scala/reflect/internal/util/HashSet.scala index 74b6a54c6e..b4178e055d 100644 --- a/src/reflect/scala/reflect/internal/util/HashSet.scala +++ b/src/reflect/scala/reflect/internal/util/HashSet.scala @@ -3,7 +3,9 @@ * @author Martin Odersky */ -package scala.reflect.internal.util +package scala +package reflect +package internal.util object HashSet { def apply[T >: Null <: AnyRef](initialCapacity: Int): HashSet[T] = this("No Label", initialCapacity) diff --git a/src/reflect/scala/reflect/internal/util/Origins.scala b/src/reflect/scala/reflect/internal/util/Origins.scala index a2b9e24ebc..2eb4fa29d5 100644 --- a/src/reflect/scala/reflect/internal/util/Origins.scala +++ b/src/reflect/scala/reflect/internal/util/Origins.scala @@ -3,7 +3,8 @@ * @author Paul Phillips */ -package scala.reflect +package scala +package reflect package internal.util import scala.collection.{ mutable, immutable } diff --git a/src/reflect/scala/reflect/internal/util/Position.scala b/src/reflect/scala/reflect/internal/util/Position.scala index fe6c7db989..ddd0a64675 100644 --- a/src/reflect/scala/reflect/internal/util/Position.scala +++ b/src/reflect/scala/reflect/internal/util/Position.scala @@ -4,7 +4,8 @@ * */ -package scala.reflect.internal.util +package scala +package reflect.internal.util import scala.reflect.ClassTag import scala.reflect.internal.FatalError @@ -210,7 +211,7 @@ abstract class Position extends scala.reflect.api.Position { self => */ def lineWithCarat(maxWidth: Int): (String, String) = { val radius = maxWidth / 2 - var start = math.max(column - radius, 0) + var start = scala.math.max(column - radius, 0) var result = lineContent drop start take maxWidth if (result.length < maxWidth) { diff --git a/src/reflect/scala/reflect/internal/util/RangePosition.scala b/src/reflect/scala/reflect/internal/util/RangePosition.scala index 3712aa0a52..0d09a53cd9 100644 --- a/src/reflect/scala/reflect/internal/util/RangePosition.scala +++ b/src/reflect/scala/reflect/internal/util/RangePosition.scala @@ -3,12 +3,13 @@ * @author Paul Phillips */ -package scala.reflect.internal.util +package scala +package reflect.internal.util /** new for position ranges */ class RangePosition(source: SourceFile, override val start: Int, point: Int, override val end: Int) extends OffsetPosition(source, point) { - if (start > end) sys.error("bad position: "+show) + if (start > end) scala.sys.error("bad position: "+show) override def isRange: Boolean = true override def isOpaqueRange: Boolean = true override def startOrPoint: Int = start diff --git a/src/reflect/scala/reflect/internal/util/Set.scala b/src/reflect/scala/reflect/internal/util/Set.scala index 57e5e0c0b9..75dcfaa59b 100644 --- a/src/reflect/scala/reflect/internal/util/Set.scala +++ b/src/reflect/scala/reflect/internal/util/Set.scala @@ -2,7 +2,8 @@ * Copyright 2005-2013 LAMP/EPFL * @author Martin Odersky */ -package scala.reflect.internal.util +package scala +package reflect.internal.util /** A common class for lightweight sets. */ diff --git a/src/reflect/scala/reflect/internal/util/SourceFile.scala b/src/reflect/scala/reflect/internal/util/SourceFile.scala index dd2a6e21f1..ea4c9a9b68 100644 --- a/src/reflect/scala/reflect/internal/util/SourceFile.scala +++ b/src/reflect/scala/reflect/internal/util/SourceFile.scala @@ -4,7 +4,8 @@ */ -package scala.reflect.internal.util +package scala +package reflect.internal.util import scala.reflect.io.{ AbstractFile, VirtualFile } import scala.collection.mutable.ArrayBuffer diff --git a/src/reflect/scala/reflect/internal/util/Statistics.scala b/src/reflect/scala/reflect/internal/util/Statistics.scala index 0fa798058d..5b1e8ffdf8 100644 --- a/src/reflect/scala/reflect/internal/util/Statistics.scala +++ b/src/reflect/scala/reflect/internal/util/Statistics.scala @@ -1,4 +1,5 @@ -package scala.reflect.internal.util +package scala +package reflect.internal.util import scala.collection.mutable diff --git a/src/reflect/scala/reflect/internal/util/StringOps.scala b/src/reflect/scala/reflect/internal/util/StringOps.scala index 93bbfdd273..4d98a344d8 100644 --- a/src/reflect/scala/reflect/internal/util/StringOps.scala +++ b/src/reflect/scala/reflect/internal/util/StringOps.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.reflect.internal.util +package scala +package reflect.internal.util /** This object provides utility methods to extract elements * from Strings. diff --git a/src/reflect/scala/reflect/internal/util/StripMarginInterpolator.scala b/src/reflect/scala/reflect/internal/util/StripMarginInterpolator.scala index 9259c5abf1..e622e78d57 100644 --- a/src/reflect/scala/reflect/internal/util/StripMarginInterpolator.scala +++ b/src/reflect/scala/reflect/internal/util/StripMarginInterpolator.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package internal package util diff --git a/src/reflect/scala/reflect/internal/util/TableDef.scala b/src/reflect/scala/reflect/internal/util/TableDef.scala index d57c59757d..1626da2c93 100644 --- a/src/reflect/scala/reflect/internal/util/TableDef.scala +++ b/src/reflect/scala/reflect/internal/util/TableDef.scala @@ -1,4 +1,5 @@ -package scala.reflect.internal.util +package scala +package reflect.internal.util import TableDef._ import scala.language.postfixOps diff --git a/src/reflect/scala/reflect/internal/util/ThreeValues.scala b/src/reflect/scala/reflect/internal/util/ThreeValues.scala index f89bd9e199..18410510cb 100644 --- a/src/reflect/scala/reflect/internal/util/ThreeValues.scala +++ b/src/reflect/scala/reflect/internal/util/ThreeValues.scala @@ -1,4 +1,5 @@ -package scala.reflect.internal.util +package scala +package reflect.internal.util /** A simple three value type for booleans with an unknown value */ object ThreeValues { diff --git a/src/reflect/scala/reflect/internal/util/TraceSymbolActivity.scala b/src/reflect/scala/reflect/internal/util/TraceSymbolActivity.scala index 632890d600..97cc19952c 100644 --- a/src/reflect/scala/reflect/internal/util/TraceSymbolActivity.scala +++ b/src/reflect/scala/reflect/internal/util/TraceSymbolActivity.scala @@ -1,4 +1,5 @@ -package scala.reflect.internal +package scala +package reflect.internal package util import scala.collection.{ mutable, immutable } diff --git a/src/reflect/scala/reflect/internal/util/WeakHashSet.scala b/src/reflect/scala/reflect/internal/util/WeakHashSet.scala index 41e74f80e9..ef62fa481b 100644 --- a/src/reflect/scala/reflect/internal/util/WeakHashSet.scala +++ b/src/reflect/scala/reflect/internal/util/WeakHashSet.scala @@ -1,4 +1,5 @@ -package scala.reflect.internal.util +package scala +package reflect.internal.util import scala.collection.mutable import scala.collection.generic.Clearable diff --git a/src/reflect/scala/reflect/io/AbstractFile.scala b/src/reflect/scala/reflect/io/AbstractFile.scala index 4ac56da628..ac1159b2ac 100644 --- a/src/reflect/scala/reflect/io/AbstractFile.scala +++ b/src/reflect/scala/reflect/io/AbstractFile.scala @@ -4,7 +4,8 @@ */ -package scala.reflect +package scala +package reflect package io import java.io.{ FileOutputStream, IOException, InputStream, OutputStream, BufferedOutputStream, ByteArrayOutputStream } diff --git a/src/reflect/scala/reflect/io/Directory.scala b/src/reflect/scala/reflect/io/Directory.scala index c11119286f..2b965e6d69 100644 --- a/src/reflect/scala/reflect/io/Directory.scala +++ b/src/reflect/scala/reflect/io/Directory.scala @@ -6,7 +6,8 @@ ** |/ ** \* */ -package scala.reflect +package scala +package reflect package io import java.io.{ File => JFile } diff --git a/src/reflect/scala/reflect/io/File.scala b/src/reflect/scala/reflect/io/File.scala index 64651dcfbd..a9c6807e88 100644 --- a/src/reflect/scala/reflect/io/File.scala +++ b/src/reflect/scala/reflect/io/File.scala @@ -7,13 +7,16 @@ \* */ -package scala.reflect +package scala +package reflect package io import java.io.{ FileInputStream, FileOutputStream, BufferedReader, BufferedWriter, InputStreamReader, OutputStreamWriter, - BufferedInputStream, BufferedOutputStream, IOException, PrintStream, PrintWriter, Closeable => JCloseable } -import java.io.{ File => JFile } + BufferedInputStream, BufferedOutputStream, IOException, PrintStream, PrintWriter, Closeable => JCloseable, + File => JFile +} + import java.nio.channels.{ Channel, FileChannel } import scala.io.Codec import scala.language.{reflectiveCalls, implicitConversions} diff --git a/src/reflect/scala/reflect/io/FileOperationException.scala b/src/reflect/scala/reflect/io/FileOperationException.scala index 13a1322798..fdfe0234e0 100644 --- a/src/reflect/scala/reflect/io/FileOperationException.scala +++ b/src/reflect/scala/reflect/io/FileOperationException.scala @@ -7,7 +7,8 @@ \* */ -package scala.reflect +package scala +package reflect package io /** ''Note: This library is considered experimental and should not be used unless you know what you are doing.'' */ case class FileOperationException(msg: String) extends RuntimeException(msg) diff --git a/src/reflect/scala/reflect/io/IOStats.scala b/src/reflect/scala/reflect/io/IOStats.scala index 64e1e952cd..71f8be330d 100644 --- a/src/reflect/scala/reflect/io/IOStats.scala +++ b/src/reflect/scala/reflect/io/IOStats.scala @@ -1,4 +1,5 @@ -package scala.reflect.io +package scala +package reflect.io import scala.reflect.internal.util.Statistics diff --git a/src/reflect/scala/reflect/io/NoAbstractFile.scala b/src/reflect/scala/reflect/io/NoAbstractFile.scala index 2c59fd8aae..a4e869ed41 100644 --- a/src/reflect/scala/reflect/io/NoAbstractFile.scala +++ b/src/reflect/scala/reflect/io/NoAbstractFile.scala @@ -3,15 +3,15 @@ * @author Paul Phillips */ -package scala.reflect +package scala +package reflect package io import java.io.InputStream -import java.io.{ File => JFile } /** A distinguished object so you can avoid both null * and Option. - * + * * ''Note: This library is considered experimental and should not be used unless you know what you are doing.'' */ object NoAbstractFile extends AbstractFile { @@ -19,7 +19,7 @@ object NoAbstractFile extends AbstractFile { def container: AbstractFile = this def create(): Unit = ??? def delete(): Unit = ??? - def file: JFile = null + def file: java.io.File = null def input: InputStream = null def isDirectory: Boolean = false override def isVirtual: Boolean = true diff --git a/src/reflect/scala/reflect/io/Path.scala b/src/reflect/scala/reflect/io/Path.scala index 56d4faed99..15fce953f2 100644 --- a/src/reflect/scala/reflect/io/Path.scala +++ b/src/reflect/scala/reflect/io/Path.scala @@ -3,13 +3,13 @@ * @author Paul Phillips */ -package scala.reflect +package scala +package reflect package io import java.io.{ FileInputStream, FileOutputStream, BufferedReader, BufferedWriter, InputStreamReader, OutputStreamWriter, - BufferedInputStream, BufferedOutputStream, RandomAccessFile } -import java.io.{ File => JFile } + BufferedInputStream, BufferedOutputStream, RandomAccessFile, File => JFile } import java.net.{ URI, URL } import scala.util.Random.alphanumeric import scala.language.implicitConversions @@ -209,7 +209,7 @@ class Path private[io] (val jfile: JFile) { } def isDirectory = { if (Statistics.canEnable) Statistics.incCounter(IOStats.fileIsDirectoryCount) - try jfile.isDirectory() catch { case ex: SecurityException => false } + try jfile.isDirectory() catch { case ex: SecurityException => jfile.getPath == "." } } def isAbsolute = jfile.isAbsolute() def isEmpty = path.length == 0 diff --git a/src/reflect/scala/reflect/io/PlainFile.scala b/src/reflect/scala/reflect/io/PlainFile.scala index b892fe7cef..8f24d84488 100644 --- a/src/reflect/scala/reflect/io/PlainFile.scala +++ b/src/reflect/scala/reflect/io/PlainFile.scala @@ -3,7 +3,8 @@ * @author Martin Odersky */ -package scala.reflect +package scala +package reflect package io import java.io.{ FileInputStream, FileOutputStream, IOException } diff --git a/src/reflect/scala/reflect/io/Streamable.scala b/src/reflect/scala/reflect/io/Streamable.scala index 1d51ad7f54..aa47947672 100644 --- a/src/reflect/scala/reflect/io/Streamable.scala +++ b/src/reflect/scala/reflect/io/Streamable.scala @@ -3,7 +3,8 @@ * @author Paul Phillips */ -package scala.reflect +package scala +package reflect package io import java.net.{ URI, URL } diff --git a/src/reflect/scala/reflect/io/VirtualDirectory.scala b/src/reflect/scala/reflect/io/VirtualDirectory.scala index 210167e5c6..aa6ceaa09f 100644 --- a/src/reflect/scala/reflect/io/VirtualDirectory.scala +++ b/src/reflect/scala/reflect/io/VirtualDirectory.scala @@ -2,7 +2,8 @@ * Copyright 2005-2013 LAMP/EPFL */ -package scala.reflect +package scala +package reflect package io import scala.collection.mutable diff --git a/src/reflect/scala/reflect/io/VirtualFile.scala b/src/reflect/scala/reflect/io/VirtualFile.scala index d34eece3f0..45f38db745 100644 --- a/src/reflect/scala/reflect/io/VirtualFile.scala +++ b/src/reflect/scala/reflect/io/VirtualFile.scala @@ -3,11 +3,11 @@ * @author Martin Odersky */ -package scala.reflect +package scala +package reflect package io -import java.io.{ ByteArrayInputStream, ByteArrayOutputStream, InputStream, OutputStream } -import java.io.{ File => JFile } +import java.io.{ ByteArrayInputStream, ByteArrayOutputStream, InputStream, OutputStream, File => JFile } /** This class implements an in-memory file. * diff --git a/src/reflect/scala/reflect/io/ZipArchive.scala b/src/reflect/scala/reflect/io/ZipArchive.scala index 11d04538e9..eabf1dcbab 100644 --- a/src/reflect/scala/reflect/io/ZipArchive.scala +++ b/src/reflect/scala/reflect/io/ZipArchive.scala @@ -3,7 +3,8 @@ * @author Paul Phillips */ -package scala.reflect +package scala +package reflect package io import java.net.URL @@ -267,8 +268,8 @@ final class ManifestResources(val url: URL) extends ZipArchive(null) { def input = url.openStream() def lastModified = try url.openConnection().getLastModified() - catch { case _: IOException => 0 } - + catch { case _: IOException => 0 } + override def canEqual(other: Any) = other.isInstanceOf[ManifestResources] override def hashCode() = url.hashCode override def equals(that: Any) = that match { diff --git a/src/reflect/scala/reflect/macros/Aliases.scala b/src/reflect/scala/reflect/macros/Aliases.scala index 92d76f4370..9e05f343e6 100644 --- a/src/reflect/scala/reflect/macros/Aliases.scala +++ b/src/reflect/scala/reflect/macros/Aliases.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package macros /** diff --git a/src/reflect/scala/reflect/macros/Attachments.scala b/src/reflect/scala/reflect/macros/Attachments.scala index eeb87fafcc..c1ab269268 100644 --- a/src/reflect/scala/reflect/macros/Attachments.scala +++ b/src/reflect/scala/reflect/macros/Attachments.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package macros /** diff --git a/src/reflect/scala/reflect/macros/Context.scala b/src/reflect/scala/reflect/macros/Context.scala index f4a4631e53..434b7c1b9c 100644 --- a/src/reflect/scala/reflect/macros/Context.scala +++ b/src/reflect/scala/reflect/macros/Context.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package macros // todo. introduce context hierarchy diff --git a/src/reflect/scala/reflect/macros/Enclosures.scala b/src/reflect/scala/reflect/macros/Enclosures.scala index a3baec9042..d6ba5f39cd 100644 --- a/src/reflect/scala/reflect/macros/Enclosures.scala +++ b/src/reflect/scala/reflect/macros/Enclosures.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package macros import scala.language.existentials // SI-6541 @@ -44,13 +45,17 @@ trait Enclosures { */ def enclosingMacros: List[Context] - /** Types along with corresponding trees for which implicit arguments are currently searched. + /** Information about one of the currently considered implicit candidates. + * Candidates are used in plural form, because implicit parameters may themselves have implicit parameters, + * hence implicit searches can recursively trigger other implicit searches. + * * Can be useful to get information about an application with an implicit parameter that is materialized during current macro expansion. + * If we're in an implicit macro being expanded, it's included in this list. * * Unlike `openImplicits`, this is a val, which means that it gets initialized when the context is created * and always stays the same regardless of whatever happens during macro expansion. */ - def enclosingImplicits: List[(Type, Tree)] + def enclosingImplicits: List[ImplicitCandidate] /** Tries to guess a position for the enclosing application. * But that is simple, right? Just dereference `pos` of `macroApplication`? Not really. diff --git a/src/reflect/scala/reflect/macros/Evals.scala b/src/reflect/scala/reflect/macros/Evals.scala index 37680c219b..70b2ab58d4 100644 --- a/src/reflect/scala/reflect/macros/Evals.scala +++ b/src/reflect/scala/reflect/macros/Evals.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package macros /** @@ -54,4 +55,4 @@ trait Evals { * refers to a runtime value `x`, which is unknown at compile time. */ def eval[T](expr: Expr[T]): T -}
\ No newline at end of file +} diff --git a/src/reflect/scala/reflect/macros/ExprUtils.scala b/src/reflect/scala/reflect/macros/ExprUtils.scala index 458cde9692..af11bd6efc 100644 --- a/src/reflect/scala/reflect/macros/ExprUtils.scala +++ b/src/reflect/scala/reflect/macros/ExprUtils.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package macros /** diff --git a/src/reflect/scala/reflect/macros/FrontEnds.scala b/src/reflect/scala/reflect/macros/FrontEnds.scala index 67b24088b5..6abd8c335b 100644 --- a/src/reflect/scala/reflect/macros/FrontEnds.scala +++ b/src/reflect/scala/reflect/macros/FrontEnds.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package macros /** @@ -44,4 +45,4 @@ trait FrontEnds { * Use `enclosingPosition` if you're in doubt what position to pass to `pos`. */ def abort(pos: Position, msg: String): Nothing -}
\ No newline at end of file +} diff --git a/src/reflect/scala/reflect/macros/Infrastructure.scala b/src/reflect/scala/reflect/macros/Infrastructure.scala index 99706e84fe..eb63fb7b7f 100644 --- a/src/reflect/scala/reflect/macros/Infrastructure.scala +++ b/src/reflect/scala/reflect/macros/Infrastructure.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package macros /** @@ -22,4 +23,4 @@ trait Infrastructure { /** Exposes current classpath. */ def classPath: List[java.net.URL] -}
\ No newline at end of file +} diff --git a/src/reflect/scala/reflect/macros/Names.scala b/src/reflect/scala/reflect/macros/Names.scala index 7e2ac5e02d..8773175561 100644 --- a/src/reflect/scala/reflect/macros/Names.scala +++ b/src/reflect/scala/reflect/macros/Names.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package macros /** diff --git a/src/reflect/scala/reflect/macros/Parsers.scala b/src/reflect/scala/reflect/macros/Parsers.scala index b4b93da3fa..3b25309614 100644 --- a/src/reflect/scala/reflect/macros/Parsers.scala +++ b/src/reflect/scala/reflect/macros/Parsers.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package macros /** diff --git a/src/reflect/scala/reflect/macros/Reifiers.scala b/src/reflect/scala/reflect/macros/Reifiers.scala index 1eae3e3fce..6ebd2db730 100644 --- a/src/reflect/scala/reflect/macros/Reifiers.scala +++ b/src/reflect/scala/reflect/macros/Reifiers.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package macros /** diff --git a/src/reflect/scala/reflect/macros/Synthetics.scala b/src/reflect/scala/reflect/macros/Synthetics.scala index 14c6c930b3..5e422ee89f 100644 --- a/src/reflect/scala/reflect/macros/Synthetics.scala +++ b/src/reflect/scala/reflect/macros/Synthetics.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package macros /** diff --git a/src/reflect/scala/reflect/macros/TreeBuilder.scala b/src/reflect/scala/reflect/macros/TreeBuilder.scala index 19230010e6..427b4f70d1 100644 --- a/src/reflect/scala/reflect/macros/TreeBuilder.scala +++ b/src/reflect/scala/reflect/macros/TreeBuilder.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package macros /** diff --git a/src/reflect/scala/reflect/macros/Typers.scala b/src/reflect/scala/reflect/macros/Typers.scala index 09a2373205..d7aec9b3ef 100644 --- a/src/reflect/scala/reflect/macros/Typers.scala +++ b/src/reflect/scala/reflect/macros/Typers.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package macros /** @@ -10,8 +11,6 @@ package macros trait Typers { self: Context => - import universe._ - /** Contexts that represent macros in-flight, including the current one. Very much like a stack trace, but for macros only. * Can be useful for interoperating with other macros and for imposing compiler-friendly limits on macro expansion. * @@ -24,13 +23,26 @@ trait Typers { */ def openMacros: List[Context] - /** Types along with corresponding trees for which implicit arguments are currently searched. + /** Information about one of the currently considered implicit candidates. + * Candidates are used in plural form, because implicit parameters may themselves have implicit parameters, + * hence implicit searches can recursively trigger other implicit searches. + * + * `pre` and `sym` provide information about the candidate itself. + * `pt` and `tree` store the parameters of the implicit search the candidate is participating in. + */ + case class ImplicitCandidate(pre: Type, sym: Symbol, pt: Type, tree: Tree) + + /** Information about one of the currently considered implicit candidates. + * Candidates are used in plural form, because implicit parameters may themselves have implicit parameters, + * hence implicit searches can recursively trigger other implicit searches. + * * Can be useful to get information about an application with an implicit parameter that is materialized during current macro expansion. + * If we're in an implicit macro being expanded, it's included in this list. * * Unlike `enclosingImplicits`, this is a def, which means that it gets recalculated on every invocation, * so it might change depending on what is going on during macro expansion. */ - def openImplicits: List[(Type, Tree)] + def openImplicits: List[ImplicitCandidate] /** Typechecks the provided tree against the expected type `pt` in the macro callsite context. * @@ -45,7 +57,7 @@ trait Typers { * * @throws [[scala.reflect.macros.TypecheckException]] */ - def typeCheck(tree: Tree, pt: Type = WildcardType, silent: Boolean = false, withImplicitViewsDisabled: Boolean = false, withMacrosDisabled: Boolean = false): Tree + def typeCheck(tree: Tree, pt: Type = universe.WildcardType, silent: Boolean = false, withImplicitViewsDisabled: Boolean = false, withMacrosDisabled: Boolean = false): Tree /** Infers an implicit value of the expected type `pt` in the macro callsite context. * Optional `pos` parameter provides a position that will be associated with the implicit search. diff --git a/src/reflect/scala/reflect/macros/Universe.scala b/src/reflect/scala/reflect/macros/Universe.scala index 31f3192a85..d1d90f53c9 100644 --- a/src/reflect/scala/reflect/macros/Universe.scala +++ b/src/reflect/scala/reflect/macros/Universe.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package macros /** diff --git a/src/reflect/scala/reflect/macros/package.scala b/src/reflect/scala/reflect/macros/package.scala index 21d189bb25..2e2e8e79f8 100644 --- a/src/reflect/scala/reflect/macros/package.scala +++ b/src/reflect/scala/reflect/macros/package.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect /** * <span class="badge badge-red" style="float: right;">EXPERIMENTAL</span> diff --git a/src/reflect/scala/reflect/runtime/JavaMirrors.scala b/src/reflect/scala/reflect/runtime/JavaMirrors.scala index d67687368c..c46ec691ae 100644 --- a/src/reflect/scala/reflect/runtime/JavaMirrors.scala +++ b/src/reflect/scala/reflect/runtime/JavaMirrors.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package runtime import scala.ref.WeakReference diff --git a/src/reflect/scala/reflect/runtime/JavaUniverse.scala b/src/reflect/scala/reflect/runtime/JavaUniverse.scala index 4d90afcdc3..06a7db6289 100644 --- a/src/reflect/scala/reflect/runtime/JavaUniverse.scala +++ b/src/reflect/scala/reflect/runtime/JavaUniverse.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package runtime /** An implementation of [[scala.reflect.api.Universe]] for runtime reflection using JVM classloaders. @@ -9,16 +10,21 @@ package runtime */ class JavaUniverse extends internal.SymbolTable with ReflectSetup with runtime.SymbolTable { self => - def inform(msg: String): Unit = log(msg) + override def inform(msg: String): Unit = log(msg) def picklerPhase = internal.SomePhase lazy val settings = new Settings private val isLogging = sys.props contains "scala.debug.reflect" - def log(msg: => AnyRef): Unit = if (isLogging) Console.err.println("[reflect] " + msg) + def log(msg: => AnyRef): Unit = if (isLogging) Console.err.println("[reflect] " + msg) type TreeCopier = InternalTreeCopierOps def newStrictTreeCopier: TreeCopier = new StrictTreeCopier def newLazyTreeCopier: TreeCopier = new LazyTreeCopier + // can't put this in runtime.Trees since that's mixed with Global in ReflectGlobal, which has the definition from internal.Trees + object treeInfo extends { + val global: JavaUniverse.this.type = JavaUniverse.this + } with internal.TreeInfo + init() } diff --git a/src/reflect/scala/reflect/runtime/ReflectSetup.scala b/src/reflect/scala/reflect/runtime/ReflectSetup.scala index 6e28fc8520..84f159be00 100644 --- a/src/reflect/scala/reflect/runtime/ReflectSetup.scala +++ b/src/reflect/scala/reflect/runtime/ReflectSetup.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package runtime import internal.{SomePhase, NoPhase, Phase, TreeGen} diff --git a/src/reflect/scala/reflect/runtime/ReflectionUtils.scala b/src/reflect/scala/reflect/runtime/ReflectionUtils.scala index aebaea40af..536bdc815d 100644 --- a/src/reflect/scala/reflect/runtime/ReflectionUtils.scala +++ b/src/reflect/scala/reflect/runtime/ReflectionUtils.scala @@ -3,7 +3,8 @@ * @author Paul Phillips */ -package scala.reflect.runtime +package scala +package reflect.runtime import java.lang.{Class => jClass} import java.lang.reflect.{ Method, InvocationTargetException, UndeclaredThrowableException } diff --git a/src/reflect/scala/reflect/runtime/Settings.scala b/src/reflect/scala/reflect/runtime/Settings.scala index 6714bae1e0..a14eafff24 100644 --- a/src/reflect/scala/reflect/runtime/Settings.scala +++ b/src/reflect/scala/reflect/runtime/Settings.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package runtime import scala.reflect.internal.settings.MutableSettings diff --git a/src/reflect/scala/reflect/runtime/SymbolLoaders.scala b/src/reflect/scala/reflect/runtime/SymbolLoaders.scala index ea14e8ad43..815cc0c885 100644 --- a/src/reflect/scala/reflect/runtime/SymbolLoaders.scala +++ b/src/reflect/scala/reflect/runtime/SymbolLoaders.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package runtime import internal.Flags diff --git a/src/reflect/scala/reflect/runtime/SymbolTable.scala b/src/reflect/scala/reflect/runtime/SymbolTable.scala index ade7a4a21a..bcd4d16cde 100644 --- a/src/reflect/scala/reflect/runtime/SymbolTable.scala +++ b/src/reflect/scala/reflect/runtime/SymbolTable.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package runtime import scala.reflect.internal.Flags._ diff --git a/src/reflect/scala/reflect/runtime/SynchronizedOps.scala b/src/reflect/scala/reflect/runtime/SynchronizedOps.scala index 7b280e59b9..132470b2e7 100644 --- a/src/reflect/scala/reflect/runtime/SynchronizedOps.scala +++ b/src/reflect/scala/reflect/runtime/SynchronizedOps.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package runtime // SI-6240: test thread-safety, make trees synchronized as well diff --git a/src/reflect/scala/reflect/runtime/SynchronizedSymbols.scala b/src/reflect/scala/reflect/runtime/SynchronizedSymbols.scala index 1154927279..98cad45db1 100644 --- a/src/reflect/scala/reflect/runtime/SynchronizedSymbols.scala +++ b/src/reflect/scala/reflect/runtime/SynchronizedSymbols.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package runtime import scala.reflect.io.AbstractFile diff --git a/src/reflect/scala/reflect/runtime/SynchronizedTypes.scala b/src/reflect/scala/reflect/runtime/SynchronizedTypes.scala index a3e7c28ca4..f4b02c5bcd 100644 --- a/src/reflect/scala/reflect/runtime/SynchronizedTypes.scala +++ b/src/reflect/scala/reflect/runtime/SynchronizedTypes.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package runtime import scala.collection.mutable.WeakHashMap diff --git a/src/reflect/scala/reflect/runtime/TwoWayCache.scala b/src/reflect/scala/reflect/runtime/TwoWayCache.scala index 05debcba65..181ca6014a 100644 --- a/src/reflect/scala/reflect/runtime/TwoWayCache.scala +++ b/src/reflect/scala/reflect/runtime/TwoWayCache.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect package runtime import scala.collection.mutable.WeakHashMap diff --git a/src/reflect/scala/reflect/runtime/package.scala b/src/reflect/scala/reflect/runtime/package.scala index eadbc0c52e..0354b424d2 100644 --- a/src/reflect/scala/reflect/runtime/package.scala +++ b/src/reflect/scala/reflect/runtime/package.scala @@ -1,4 +1,5 @@ -package scala.reflect +package scala +package reflect /** Entry points into runtime reflection. * See [[scala.reflect.api.package the overview page]] for details on how to use them. diff --git a/src/repl/scala/tools/nsc/MainGenericRunner.scala b/src/repl/scala/tools/nsc/MainGenericRunner.scala index 9e87b6ba55..43f0ea1256 100644 --- a/src/repl/scala/tools/nsc/MainGenericRunner.scala +++ b/src/repl/scala/tools/nsc/MainGenericRunner.scala @@ -3,7 +3,8 @@ * @author Lex Spoon */ -package scala.tools.nsc +package scala +package tools.nsc import io.{ File } import util.{ ClassPath, ScalaClassLoader } diff --git a/src/repl/scala/tools/nsc/interpreter/ILoop.scala b/src/repl/scala/tools/nsc/interpreter/ILoop.scala index df28e428ce..197e76d990 100644 --- a/src/repl/scala/tools/nsc/interpreter/ILoop.scala +++ b/src/repl/scala/tools/nsc/interpreter/ILoop.scala @@ -3,7 +3,8 @@ * @author Alexander Spoon */ -package scala.tools.nsc +package scala +package tools.nsc package interpreter import Predef.{ println => _, _ } diff --git a/src/repl/scala/tools/nsc/interpreter/IMain.scala b/src/repl/scala/tools/nsc/interpreter/IMain.scala index dda26aa6b7..66129e0be8 100644 --- a/src/repl/scala/tools/nsc/interpreter/IMain.scala +++ b/src/repl/scala/tools/nsc/interpreter/IMain.scala @@ -3,7 +3,8 @@ * @author Martin Odersky */ -package scala.tools.nsc +package scala +package tools.nsc package interpreter import Predef.{ println => _, _ } diff --git a/src/repl/scala/tools/nsc/interpreter/JavapClass.scala b/src/repl/scala/tools/nsc/interpreter/JavapClass.scala index 2eaf8595b0..ef6f4c2920 100644 --- a/src/repl/scala/tools/nsc/interpreter/JavapClass.scala +++ b/src/repl/scala/tools/nsc/interpreter/JavapClass.scala @@ -3,7 +3,8 @@ * @author Paul Phillips */ -package scala.tools.nsc +package scala +package tools.nsc package interpreter import java.lang.{ ClassLoader => JavaClassLoader, Iterable => JIterable } diff --git a/src/repl/scala/tools/nsc/interpreter/LoopCommands.scala b/src/repl/scala/tools/nsc/interpreter/LoopCommands.scala index 4bba27b714..12d6ee5112 100644 --- a/src/repl/scala/tools/nsc/interpreter/LoopCommands.scala +++ b/src/repl/scala/tools/nsc/interpreter/LoopCommands.scala @@ -3,7 +3,9 @@ * @author Paul Phillips */ -package scala.tools.nsc +package scala +package tools +package nsc package interpreter import scala.collection.{ mutable, immutable } diff --git a/src/repl/scala/tools/nsc/interpreter/Naming.scala b/src/repl/scala/tools/nsc/interpreter/Naming.scala index 57f3675ada..7f577b3a8b 100644 --- a/src/repl/scala/tools/nsc/interpreter/Naming.scala +++ b/src/repl/scala/tools/nsc/interpreter/Naming.scala @@ -3,7 +3,8 @@ * @author Paul Phillips */ -package scala.tools.nsc +package scala +package tools.nsc package interpreter import scala.util.Properties.lineSeparator diff --git a/src/repl/scala/tools/nsc/interpreter/SimpleReader.scala b/src/repl/scala/tools/nsc/interpreter/SimpleReader.scala index 2d0917d91f..6634dc6944 100644 --- a/src/repl/scala/tools/nsc/interpreter/SimpleReader.scala +++ b/src/repl/scala/tools/nsc/interpreter/SimpleReader.scala @@ -3,7 +3,8 @@ * @author Stepan Koltsov */ -package scala.tools.nsc +package scala +package tools.nsc package interpreter import java.io.{ BufferedReader } diff --git a/src/scalacheck/org/scalacheck/Arbitrary.scala b/src/scalacheck/org/scalacheck/Arbitrary.scala index 8c43cdaafe..db4163c8af 100644 --- a/src/scalacheck/org/scalacheck/Arbitrary.scala +++ b/src/scalacheck/org/scalacheck/Arbitrary.scala @@ -1,6 +1,6 @@ /*-------------------------------------------------------------------------*\ ** ScalaCheck ** -** Copyright (c) 2007-2011 Rickard Nilsson. All rights reserved. ** +** Copyright (c) 2007-2013 Rickard Nilsson. All rights reserved. ** ** http://www.scalacheck.org ** ** ** ** This software is released under the terms of the Revised BSD License. ** @@ -10,49 +10,44 @@ package org.scalacheck import util.{FreqMap,Buildable} -import scala.reflect.ClassTag sealed abstract class Arbitrary[T] { val arbitrary: Gen[T] } -/** Defines implicit <code>Arbitrary</code> instances for common types. +/** Defines implicit [[org.scalacheck.Arbitrary]] instances for common types. * <p> * ScalaCheck - * uses implicit <code>Arbitrary</code> instances when creating properties - * out of functions with the <code>Prop.property</code> method, and when - * the <code>Arbitrary.arbitrary</code> method is used. For example, the + * uses implicit [[org.scalacheck.Arbitrary]] instances when creating properties + * out of functions with the `Prop.property` method, and when + * the `Arbitrary.arbitrary` method is used. For example, the * following code requires that there exists an implicit - * <code>Arbitrary[MyClass]</code> instance: + * `Arbitrary[MyClass]` instance: * </p> * - * <p> - * <code> - * val myProp = Prop.forAll { myClass: MyClass =><br /> - * ...<br /> - * }<br /> + * {{{ + * val myProp = Prop.forAll { myClass: MyClass => + * ... + * } * * val myGen = Arbitrary.arbitrary[MyClass] - * </code> - * </p> + * }}} * * <p> * The required implicit definition could look like this: * </p> * - * <p> - * <code> + * {{{ * implicit val arbMyClass: Arbitrary[MyClass] = Arbitrary(...) - * </code> - * </p> + * }}} * * <p> - * The factory method <code>Arbitrary(...)</code> takes a generator of type - * <code>Gen[T]</code> and returns an instance of <code>Arbitrary[T]</code>. + * The factory method `Arbitrary(...)` takes a generator of type + * `Gen[T]` and returns an instance of `Arbitrary[T]`. * </p> * * <p> - * The <code>Arbitrary</code> module defines implicit <code>Arbitrary</code> + * The `Arbitrary` module defines implicit [[org.scalacheck.Arbitrary]] * instances for common types, for convenient use in your properties and * generators. * </p> @@ -93,7 +88,7 @@ object Arbitrary { /** Arbitrary instance of Long */ implicit lazy val arbLong: Arbitrary[Long] = Arbitrary( - Gen.chooseNum(Long.MinValue / 2, Long.MaxValue / 2) + Gen.chooseNum(Long.MinValue, Long.MaxValue) ) /** Arbitrary instance of Float */ @@ -182,7 +177,13 @@ object Arbitrary { mc <- mcGen limit <- value(if(mc == UNLIMITED) 0 else math.max(x.abs.toString.length - mc.getPrecision, 0)) scale <- Gen.chooseNum(Int.MinValue + limit , Int.MaxValue) - } yield BigDecimal(x, scale, mc) + } yield { + try { + BigDecimal(x, scale, mc) + } catch { + case ae: java.lang.ArithmeticException => BigDecimal(x, scale, UNLIMITED) // Handle the case where scale/precision conflict + } + } Arbitrary(bdGen) } @@ -213,23 +214,43 @@ object Arbitrary { )) } - /** Arbitrary instance of test params */ + /** Arbitrary instance of test params + * @deprecated (in 1.10.0) Use `arbTestParameters` instead. + */ + @deprecated("Use 'arbTestParameters' instead", "1.10.0") implicit lazy val arbTestParams: Arbitrary[Test.Params] = Arbitrary(for { minSuccTests <- choose(10,200) - maxDiscardRatio <- choose(0.2f,10f) - minSize <- choose(0,500) + maxDiscTests <- choose(100,500) + mnSize <- choose(0,500) sizeDiff <- choose(0,500) - maxSize <- choose(minSize, minSize + sizeDiff) + mxSize <- choose(mnSize, mnSize + sizeDiff) ws <- choose(1,4) } yield Test.Params( minSuccessfulTests = minSuccTests, - maxDiscardRatio = maxDiscardRatio, - minSize = minSize, - maxSize = maxSize, + maxDiscardedTests = maxDiscTests, + minSize = mnSize, + maxSize = mxSize, workers = ws )) + /** Arbitrary instance of test parameters */ + implicit lazy val arbTestParameters: Arbitrary[Test.Parameters] = + Arbitrary(for { + _minSuccTests <- choose(10,200) + _maxDiscardRatio <- choose(0.2f,10f) + _minSize <- choose(0,500) + sizeDiff <- choose(0,500) + _maxSize <- choose(_minSize, _minSize + sizeDiff) + _workers <- choose(1,4) + } yield new Test.Parameters.Default { + override val minSuccessfulTests = _minSuccTests + override val maxDiscardRatio = _maxDiscardRatio + override val minSize = _minSize + override val maxSize = _maxSize + override val workers = _workers + }) + /** Arbitrary instance of gen params */ implicit lazy val arbGenParams: Arbitrary[Gen.Params] = Arbitrary(for { @@ -278,7 +299,7 @@ object Arbitrary { ): Arbitrary[C[T]] = Arbitrary(containerOf[C,T](arbitrary[T])) /** Arbitrary instance of any array. */ - implicit def arbArray[T](implicit a: Arbitrary[T], c: ClassTag[T] + implicit def arbArray[T](implicit a: Arbitrary[T], c: ClassManifest[T] ): Arbitrary[Array[T]] = Arbitrary(containerOf[Array,T](arbitrary[T])) diff --git a/src/scalacheck/org/scalacheck/Arg.scala b/src/scalacheck/org/scalacheck/Arg.scala index 8959211f09..4961c78a26 100644 --- a/src/scalacheck/org/scalacheck/Arg.scala +++ b/src/scalacheck/org/scalacheck/Arg.scala @@ -1,6 +1,6 @@ /*-------------------------------------------------------------------------*\ ** ScalaCheck ** -** Copyright (c) 2007-2011 Rickard Nilsson. All rights reserved. ** +** Copyright (c) 2007-2013 Rickard Nilsson. All rights reserved. ** ** http://www.scalacheck.org ** ** ** ** This software is released under the terms of the Revised BSD License. ** diff --git a/src/scalacheck/org/scalacheck/Commands.scala b/src/scalacheck/org/scalacheck/Commands.scala index 2acc460b5e..604b68cb36 100644 --- a/src/scalacheck/org/scalacheck/Commands.scala +++ b/src/scalacheck/org/scalacheck/Commands.scala @@ -1,6 +1,6 @@ /*-------------------------------------------------------------------------*\ ** ScalaCheck ** -** Copyright (c) 2007-2011 Rickard Nilsson. All rights reserved. ** +** Copyright (c) 2007-2013 Rickard Nilsson. All rights reserved. ** ** http://www.scalacheck.org ** ** ** ** This software is released under the terms of the Revised BSD License. ** @@ -53,7 +53,7 @@ trait Commands extends Prop { * takes the current abstract state as parameter and returns a boolean * that says if the precondition is fulfilled or not. You can add several * conditions to the precondition list */ - val preConditions = new scala.collection.mutable.ListBuffer[State => Boolean] + val preConditions = new collection.mutable.ListBuffer[State => Boolean] /** Returns all postconditions merged into a single function */ def postCondition: (State,State,Any) => Prop = (s0,s1,r) => all(postConditions.map(_.apply(s0,s1,r)): _*) @@ -65,7 +65,7 @@ trait Commands extends Prop { * method. The postcondition function should return a Boolean (or * a Prop instance) that says if the condition holds or not. You can add several * conditions to the postConditions list. */ - val postConditions = new scala.collection.mutable.ListBuffer[(State,State,Any) => Prop] + val postConditions = new collection.mutable.ListBuffer[(State,State,Any) => Prop] } /** A command that binds its result for later use */ @@ -87,6 +87,11 @@ trait Commands extends Prop { private val bindings = new scala.collection.mutable.ListBuffer[(State,Any)] + private def initState() = { + bindings.clear() + initialState() + } + private def genCmds: Gen[Cmds] = { def sizedCmds(s: State)(sz: Int): Gen[Cmds] = if(sz <= 0) value(Cmds(Nil, Nil)) else for { diff --git a/src/scalacheck/org/scalacheck/ConsoleReporter.scala b/src/scalacheck/org/scalacheck/ConsoleReporter.scala index 93f1dc222e..d565322d99 100644 --- a/src/scalacheck/org/scalacheck/ConsoleReporter.scala +++ b/src/scalacheck/org/scalacheck/ConsoleReporter.scala @@ -1,6 +1,6 @@ /*-------------------------------------------------------------------------*\ ** ScalaCheck ** -** Copyright (c) 2007-2011 Rickard Nilsson. All rights reserved. ** +** Copyright (c) 2007-2013 Rickard Nilsson. All rights reserved. ** ** http://www.scalacheck.org ** ** ** ** This software is released under the terms of the Revised BSD License. ** diff --git a/src/scalacheck/org/scalacheck/Gen.scala b/src/scalacheck/org/scalacheck/Gen.scala index 64bb61c2d3..aec67159f1 100644 --- a/src/scalacheck/org/scalacheck/Gen.scala +++ b/src/scalacheck/org/scalacheck/Gen.scala @@ -1,6 +1,6 @@ /*-------------------------------------------------------------------------*\ ** ScalaCheck ** -** Copyright (c) 2007-2011 Rickard Nilsson. All rights reserved. ** +** Copyright (c) 2007-2013 Rickard Nilsson. All rights reserved. ** ** http://www.scalacheck.org ** ** ** ** This software is released under the terms of the Revised BSD License. ** @@ -23,7 +23,7 @@ object Choose { implicit val chooseLong: Choose[Long] = new Choose[Long] { def choose(low: Long, high: Long) = - if(low > high || (high-low < 0)) fail + if (low > high) fail else parameterized(prms => value(prms.choose(low,high))) } @@ -204,9 +204,17 @@ object Gen { /** @throws IllegalArgumentException if l is greater than h, or if * the range between l and h doesn't fit in a Long. */ def choose(l: Long, h: Long): Long = { - val d = h-l - if (d < 0) throw new IllegalArgumentException("Invalid range") - else l + math.abs(rng.nextLong % (d+1)) + if (h < l) throw new IllegalArgumentException("Invalid range") + val d = h - l + 1 + if (d <= 0) { + var n = rng.nextLong + while (n < l || n > h) { + n = rng.nextLong + } + n + } else { + l + math.abs(rng.nextLong % d) + } } /** @throws IllegalArgumentException if l is greater than h, or if @@ -225,8 +233,11 @@ object Gen { def apply(p: Gen.Params) = g(p) } - /* Convenience method for using the <code>frequency</code> method like this: - * <code>frequency((1, "foo"), (3, "bar"))</code> */ + /* Convenience method for using the `frequency` method like this: + * {{{ + * frequency((1, "foo"), (3, "bar")) + * }}} + */ implicit def freqTuple[T](t: (Int, T)): (Int, Gen[T]) = (t._1, value(t._2)) @@ -308,9 +319,9 @@ object Gen { //// List Generators //// /** Generates a container of any type for which there exists an implicit - * <code>Buildable</code> instance. The elements in the container will + * [[org.scalacheck.util.Buildable]] instance. The elements in the container will * be generated by the given generator. The size of the generated container - * is given by <code>n</code>. */ + * is given by `n`. */ def containerOfN[C[_],T](n: Int, g: Gen[T])(implicit b: Buildable[T,C] ): Gen[C[T]] = sequence[C,T](new Iterable[Gen[T]] { def iterator = new Iterator[Gen[T]] { @@ -321,14 +332,14 @@ object Gen { }) /** Generates a container of any type for which there exists an implicit - * <code>Buildable</code> instance. The elements in the container will - * be generated by the given generator. The size of the container is + * [[org.scalacheck.util.Buildable]] instance. The elements in the container + * will be generated by the given generator. The size of the container is * bounded by the size parameter used when generating values. */ def containerOf[C[_],T](g: Gen[T])(implicit b: Buildable[T,C]): Gen[C[T]] = sized(size => for(n <- choose(0,size); c <- containerOfN[C,T](n,g)) yield c) /** Generates a non-empty container of any type for which there exists an - * implicit <code>Buildable</code> instance. The elements in the container + * implicit [[org.scalacheck.util.Buildable]] instance. The elements in the container * will be generated by the given generator. The size of the container is * bounded by the size parameter used when generating values. */ def containerOf1[C[_],T](g: Gen[T])(implicit b: Buildable[T,C]): Gen[C[T]] = @@ -336,16 +347,16 @@ object Gen { /** Generates a list of random length. The maximum length depends on the * size parameter. This method is equal to calling - * <code>containerOf[List,T](g)</code>. */ + * `containerOf[List,T](g)`. */ def listOf[T](g: => Gen[T]) = containerOf[List,T](g) /** Generates a non-empty list of random length. The maximum length depends * on the size parameter. This method is equal to calling - * <code>containerOf1[List,T](g)</code>. */ + * `containerOf1[List,T](g)`. */ def listOf1[T](g: => Gen[T]) = containerOf1[List,T](g) /** Generates a list of the given length. This method is equal to calling - * <code>containerOfN[List,T](n,g)</code>. */ + * `containerOfN[List,T](n,g)`. */ def listOfN[T](n: Int, g: Gen[T]) = containerOfN[List,T](n,g) /** A generator that picks a random number of elements from a list */ diff --git a/src/scalacheck/org/scalacheck/Pretty.scala b/src/scalacheck/org/scalacheck/Pretty.scala index eeb5936086..3e8f6de5f6 100644 --- a/src/scalacheck/org/scalacheck/Pretty.scala +++ b/src/scalacheck/org/scalacheck/Pretty.scala @@ -1,6 +1,6 @@ /*-------------------------------------------------------------------------*\ ** ScalaCheck ** -** Copyright (c) 2007-2011 Rickard Nilsson. All rights reserved. ** +** Copyright (c) 2007-2013 Rickard Nilsson. All rights reserved. ** ** http://www.scalacheck.org ** ** ** ** This software is released under the terms of the Revised BSD License. ** @@ -96,7 +96,7 @@ object Pretty { } implicit def prettyTestRes(res: Test.Result) = Pretty { prms => - def labels(ls: scala.collection.immutable.Set[String]) = + def labels(ls: collection.immutable.Set[String]) = if(ls.isEmpty) "" else "> Labels of failing property: " / ls.mkString("\n") val s = res.status match { diff --git a/src/scalacheck/org/scalacheck/Prop.scala b/src/scalacheck/org/scalacheck/Prop.scala index dfd85a832a..38e00f260f 100644 --- a/src/scalacheck/org/scalacheck/Prop.scala +++ b/src/scalacheck/org/scalacheck/Prop.scala @@ -1,6 +1,6 @@ /*-------------------------------------------------------------------------*\ ** ScalaCheck ** -** Copyright (c) 2007-2011 Rickard Nilsson. All rights reserved. ** +** Copyright (c) 2007-2013 Rickard Nilsson. All rights reserved. ** ** http://www.scalacheck.org ** ** ** ** This software is released under the terms of the Revised BSD License. ** @@ -31,16 +31,27 @@ trait Prop { /** Convenience method that checks this property with the given parameters * and reports the result on the console. If you need to get the results - * from the test use the <code>check</code> methods in <code>Test</code> - * instead. */ + * from the test use the `check` methods in [[org.scalacheck.Test]] + * instead. + * @deprecated (in 1.10.0) Use `check(Test.Parameters)` instead. + */ + @deprecated("Use 'check(Test.Parameters)' instead", "1.10.0") def check(prms: Test.Params): Unit = Test.check( prms copy (testCallback = ConsoleReporter(1) chain prms.testCallback), this ) + /** Convenience method that checks this property with the given parameters + * and reports the result on the console. If you need to get the results + * from the test use the `check` methods in [[org.scalacheck.Test]] + * instead. */ + def check(prms: Test.Parameters): Unit = Test.check( + prms copy (_testCallback = ConsoleReporter(1) chain prms.testCallback), this + ) + /** Convenience method that checks this property and reports the * result on the console. If you need to get the results from the test use - * the <code>check</code> methods in <code>Test</code> instead. */ - def check: Unit = check(Test.Params()) + * the `check` methods in [[org.scalacheck.Test]] instead. */ + def check: Unit = check(Test.Parameters.default) /** The logic for main, separated out to make it easier to * avoid System.exit calls. Returns exit code. @@ -60,7 +71,7 @@ trait Prop { /** Whether main should call System.exit with an exit code. * Defaults to true; override to change. */ - def mainCallsExit = false + def mainCallsExit = true /** Convenience method that makes it possible to use this property * as an application that checks itself on execution */ @@ -274,20 +285,51 @@ object Prop { def apply(r: Result): Prop = Prop(prms => r) + def apply(b: Boolean): Prop = if(b) proved else falsified - // Implicit defs + // Implicits + + /** A collection of property operators on [[Any]] values. + * Import [[Prop.AnyOperators]] to make the operators available. */ class ExtendedAny[T <% Pretty](x: => T) { + /** See [[Prop.imply]] */ def imply(f: PartialFunction[T,Prop]) = Prop.imply(x,f) + /** See [[Prop.iff]] */ def iff(f: PartialFunction[T,Prop]) = Prop.iff(x,f) - def throws[U <: Throwable](c: Class[U]) = Prop.throws(x, c) + @deprecated("Use 'Prop.throws' instead", "1.10.1") + def throws[U <: Throwable](c: Class[U]): Prop = Prop.throws(c)(x) + /** See [[Prop.?=]] */ def ?=(y: T) = Prop.?=(x, y) + /** See [[Prop.=?]] */ def =?(y: T) = Prop.=?(x, y) } + /** A collection of property operators on [[Boolean]] values. + * Import [[Prop.BooleanOperators]] to make the operators available. */ + class ExtendedBoolean(b: => Boolean) { + /** See [[Prop.==>]] */ + def ==>(p: => Prop) = Prop(b) ==> p + } + + /** Implicit method that makes a number of property operators on values of + * type [[Any]] available in the current scope. See [[Prop.ExtendedAny]] for + * documentation on the operators. */ + @deprecated("Use 'Prop.AnyOperators' instead", "1.10.1") implicit def extendedAny[T <% Pretty](x: => T) = new ExtendedAny[T](x) - implicit def propBoolean(b: Boolean): Prop = if(b) proved else falsified + /** Implicit method that makes a number of property operators on values of + * type [[Any]] available in the current scope. See [[Prop.ExtendedAny]] for + * documentation on the operators. */ + implicit def AnyOperators[T <% Pretty](x: => T) = new ExtendedAny[T](x) + + /** Implicit method that makes a number of property operators on boolean + * values available in the current scope. See [[Prop.ExtendedBoolean]] for + * documentation on the operators. */ + implicit def BooleanOperators(b: => Boolean) = new ExtendedBoolean(b) + + /** Implicit conversion of Boolean values to Prop values. */ + implicit def propBoolean(b: Boolean): Prop = Prop(b) // Private support functions @@ -318,6 +360,9 @@ object Prop { /** A property that denotes an exception */ lazy val exception: Prop = exception(null) + /** Create a property that compares to values. If the values aren't equal, + * the property will fail and report that first value doesn't match the + * expected (second) value. */ def ?=[T](x: T, y: T)(implicit pp: T => Pretty): Prop = if(x == y) proved else falsified :| { val exp = Pretty.pretty[T](y, Pretty.Params(0)) @@ -325,6 +370,9 @@ object Prop { "Expected "+exp+" but got "+act } + /** Create a property that compares to values. If the values aren't equal, + * the property will fail and report that second value doesn't match the + * expected (first) value. */ def =?[T](x: T, y: T)(implicit pp: T => Pretty): Prop = ?=(y, x) /** A property that depends on the generator size */ @@ -340,7 +388,7 @@ object Prop { secure(if(f.isDefinedAt(x)) f(x) else undecided) /** Property holds only if the given partial function is defined at - * <code>x</code>, and returns a property that holds */ + * `x`, and returns a property that holds */ def iff[T](x: T, f: PartialFunction[T,Prop]): Prop = secure(if(f.isDefinedAt(x)) f(x) else falsified) @@ -365,9 +413,16 @@ object Prop { def noneFailing[T](gs: Seq[Gen[T]]) = all(gs.map(_ !== fail):_*) /** A property that holds if the given statement throws an exception + * of the specified type + * @deprecated (in 1.10.1) Use `throws(...): Boolean` instead. + */ + @deprecated("Use 'throws(...): Boolean' instead", "1.10.1") + def throws[T <: Throwable](x: => Any, c: Class[T]): Prop = throws(c)(x) + + /** Returns true if the given statement throws an exception * of the specified type */ - def throws[T <: Throwable](x: => Any, c: Class[T]) = - try { x; falsified } catch { case e if c.isInstance(e) => proved } + def throws[T <: Throwable](c: Class[T])(x: => Any): Boolean = + try { x; false } catch { case e if c.isInstance(e) => true } /** Collect data for presentation in test report */ def collect[T, P <% Prop](f: T => P): T => Prop = t => Prop { prms => @@ -390,7 +445,7 @@ object Prop { /** Wraps and protects a property */ def secure[P <% Prop](p: => P): Prop = - try { p: Prop } catch { case e => exception(e) } + try { p: Prop } catch { case e: Throwable => exception(e) } /** Existential quantifier for an explicit generator. */ def exists[A,P](f: A => P)(implicit diff --git a/src/scalacheck/org/scalacheck/Properties.scala b/src/scalacheck/org/scalacheck/Properties.scala index 26059231d6..d4836d7420 100644 --- a/src/scalacheck/org/scalacheck/Properties.scala +++ b/src/scalacheck/org/scalacheck/Properties.scala @@ -1,6 +1,6 @@ /*-------------------------------------------------------------------------*\ ** ScalaCheck ** -** Copyright (c) 2007-2011 Rickard Nilsson. All rights reserved. ** +** Copyright (c) 2007-2013 Rickard Nilsson. All rights reserved. ** ** http://www.scalacheck.org ** ** ** ** This software is released under the terms of the Revised BSD License. ** @@ -14,15 +14,15 @@ package org.scalacheck * holds if and only if all of the contained properties hold. * <p>Properties are added in the following way:</p> * - * <p> - * <code> + * {{{ * object MyProps extends Properties("MyProps") { - * property("myProp1") = forAll { (n:Int, m:Int) => + * property("myProp1") = forAll { (n:Int, m:Int) => * n+m == m+n * } * * property("myProp2") = ((0/1) throws classOf[ArithmeticException]) * } + * }}} */ class Properties(val name: String) extends Prop { @@ -42,16 +42,27 @@ class Properties(val name: String) extends Prop { /** Convenience method that checks the properties with the given parameters * and reports the result on the console. If you need to get the results - * from the test use the <code>check</code> methods in <code>Test</code> + * from the test use the `check` methods in [[org.scalacheck.Test]] * instead. */ + override def check(prms: Test.Parameters): Unit = Test.checkProperties( + prms copy (_testCallback = ConsoleReporter(1) chain prms.testCallback), this + ) + + /** Convenience method that checks the properties with the given parameters + * and reports the result on the console. If you need to get the results + * from the test use the `check` methods in [[org.scalacheck.Test]] + * instead. + * @deprecated (in 1.10.0) Use `check(Test.Parameters)` instead. + */ + @deprecated("Use 'check(Test.Parameters)' instead", "1.10.0") override def check(prms: Test.Params): Unit = Test.checkProperties( prms copy (testCallback = ConsoleReporter(1) chain prms.testCallback), this ) /** Convenience method that checks the properties and reports the * result on the console. If you need to get the results from the test use - * the <code>check</code> methods in <code>Test</code> instead. */ - override def check: Unit = check(Test.Params()) + * the `check` methods in [[org.scalacheck.Test]] instead. */ + override def check: Unit = check(Test.Parameters.default) /** The logic for main, separated out to make it easier to * avoid System.exit calls. Returns exit code. @@ -73,7 +84,10 @@ class Properties(val name: String) extends Prop { def include(ps: Properties) = for((n,p) <- ps.properties) property(n) = p /** Used for specifying properties. Usage: - * <code>property("myProp") = ...</code> */ + * {{{ + * property("myProp") = ... + * }}} + */ class PropertySpecifier() { def update(propName: String, p: Prop) = props += ((name+"."+propName, p)) } diff --git a/src/scalacheck/org/scalacheck/ScalaCheckFramework.scala b/src/scalacheck/org/scalacheck/ScalaCheckFramework.scala new file mode 100644 index 0000000000..7764101844 --- /dev/null +++ b/src/scalacheck/org/scalacheck/ScalaCheckFramework.scala @@ -0,0 +1,92 @@ +/*-------------------------------------------------------------------------*\ +** ScalaCheck ** +** Copyright (c) 2007-2013 Rickard Nilsson. All rights reserved. ** +** http://www.scalacheck.org ** +** ** +** This software is released under the terms of the Revised BSD License. ** +** There is NO WARRANTY. See the file LICENSE for the full text. ** +\*------------------------------------------------------------------------ */ + +// vim: set ts=2 sw=2 et: + +package org.scalacheck + +import org.scalatools.testing._ + +class ScalaCheckFramework extends Framework { + + private case object PropFingerprint extends TestFingerprint { + val superClassName = "org.scalacheck.Prop" + val isModule = false + } + + private case object PropsFingerprint extends TestFingerprint { + val superClassName = "org.scalacheck.Properties" + val isModule = true + } + + val name = "ScalaCheck" + + val tests = Array[Fingerprint](PropsFingerprint, PropsFingerprint) + + def testRunner(loader: ClassLoader, loggers: Array[Logger]) = new Runner2 { + + private def asEvent(nr: (String, Test.Result)) = nr match { + case (n: String, r: Test.Result) => new Event { + val testName = n + val description = n + val result = r.status match { + case Test.Passed => Result.Success + case _:Test.Proved => Result.Success + case _:Test.Failed => Result.Failure + case Test.Exhausted => Result.Skipped + case _:Test.PropException | _:Test.GenException => Result.Error + } + val error = r.status match { + case Test.PropException(_, e, _) => e + case _:Test.Failed => new Exception(Pretty.pretty(r,Pretty.Params(0))) + case _ => null + } + } + } + + def run(testClassName: String, fingerprint: Fingerprint, handler: EventHandler, args: Array[String]) { + + val testCallback = new Test.TestCallback { + override def onPropEval(n: String, w: Int, s: Int, d: Int) = {} + + override def onTestResult(n: String, r: Test.Result) = { + for (l <- loggers) { + import Pretty._ + l.info( + (if (r.passed) "+ " else "! ") + n + ": " + pretty(r, Params(0)) + ) + } + handler.handle(asEvent((n,r))) + } + } + + import Test.cmdLineParser.{Success, NoSuccess} + val prms = Test.cmdLineParser.parseParams(args) match { + case Success(params, _) => + params.copy(_testCallback = testCallback, _customClassLoader = Some(loader)) + // TODO: Maybe handle this a bit better than throwing exception? + case e: NoSuccess => throw new Exception(e.toString) + } + + fingerprint match { + case fp: SubclassFingerprint => + if(fp.isModule) { + val obj = Class.forName(testClassName + "$", true, loader) + val ps = obj.getField("MODULE$").get(null).asInstanceOf[Properties] + Test.checkProperties(prms, ps) + } else { + val p = Class.forName(testClassName, true, loader).newInstance.asInstanceOf[Prop] + handler.handle(asEvent((testClassName, Test.check(prms, p)))) + } + } + } + + } + +} diff --git a/src/scalacheck/org/scalacheck/Shrink.scala b/src/scalacheck/org/scalacheck/Shrink.scala index ae15bd9616..4895171a35 100644 --- a/src/scalacheck/org/scalacheck/Shrink.scala +++ b/src/scalacheck/org/scalacheck/Shrink.scala @@ -1,6 +1,6 @@ /*-------------------------------------------------------------------------*\ ** ScalaCheck ** -** Copyright (c) 2007-2011 Rickard Nilsson. All rights reserved. ** +** Copyright (c) 2007-2013 Rickard Nilsson. All rights reserved. ** ** http://www.scalacheck.org ** ** ** ** This software is released under the terms of the Revised BSD License. ** diff --git a/src/scalacheck/org/scalacheck/Test.scala b/src/scalacheck/org/scalacheck/Test.scala index 4368184823..6e9b6b88fd 100644 --- a/src/scalacheck/org/scalacheck/Test.scala +++ b/src/scalacheck/org/scalacheck/Test.scala @@ -1,6 +1,6 @@ /*-------------------------------------------------------------------------*\ ** ScalaCheck ** -** Copyright (c) 2007-2011 Rickard Nilsson. All rights reserved. ** +** Copyright (c) 2007-2013 Rickard Nilsson. All rights reserved. ** ** http://www.scalacheck.org ** ** ** ** This software is released under the terms of the Revised BSD License. ** @@ -16,23 +16,120 @@ object Test { import Prop.FM import util.CmdLineParser - /** Test parameters */ + /** Test parameters used by the `Test.check` method. + */ + trait Parameters { + /** The minimum number of tests that must succeed for ScalaCheck to + * consider a property passed. */ + def minSuccessfulTests: Int + + /** The starting size given as parameter to the generators. */ + def minSize: Int + + /** The maximum size given as parameter to the generators. */ + def maxSize: Int + + /** The random numbe generator used. */ + def rng: java.util.Random + + /** The number of tests run in parallell. */ + def workers: Int + + /** A callback that ScalaCheck calls each time a test is executed. */ + def testCallback: TestCallback + + /** The maximum ratio between discarded and passed tests allowed before + * ScalaCheck gives up and discards the property. At least + * `minSuccesfulTests` will always be run, though. */ + def maxDiscardRatio: Float + + /** A custom class loader that should be used during test execution. */ + def customClassLoader: Option[ClassLoader] + + // private since we can't guarantee binary compatibility for this one + private[scalacheck] def copy( + _minSuccessfulTests: Int = Parameters.this.minSuccessfulTests, + _minSize: Int = Parameters.this.minSize, + _maxSize: Int = Parameters.this.maxSize, + _rng: java.util.Random = Parameters.this.rng, + _workers: Int = Parameters.this.workers, + _testCallback: TestCallback = Parameters.this.testCallback, + _maxDiscardRatio: Float = Parameters.this.maxDiscardRatio, + _customClassLoader: Option[ClassLoader] = Parameters.this.customClassLoader + ): Parameters = new Parameters { + val minSuccessfulTests: Int = _minSuccessfulTests + val minSize: Int = _minSize + val maxSize: Int = _maxSize + val rng: java.util.Random = _rng + val workers: Int = _workers + val testCallback: TestCallback = _testCallback + val maxDiscardRatio: Float = _maxDiscardRatio + val customClassLoader: Option[ClassLoader] = _customClassLoader + } + } + + /** Test parameters used by the `Test.check` method. + * + * To override default values, extend the + * [[org.scalacheck.Test.Parameters.Default]] trait: + * + * {{{ + * val myParams = new Parameters.Default { + * override val minSuccesfulTests = 600 + * override val maxDiscardRatio = 8 + * } + * }}} + */ + object Parameters { + /** Default test parameters trait. This can be overriden if you need to + * tweak the parameters. */ + trait Default extends Parameters { + val minSuccessfulTests: Int = 100 + val minSize: Int = 0 + val maxSize: Int = Gen.Params().size + val rng: java.util.Random = Gen.Params().rng + val workers: Int = 1 + val testCallback: TestCallback = new TestCallback {} + val maxDiscardRatio: Float = 5 + val customClassLoader: Option[ClassLoader] = None + } + + /** Default test parameters instance. */ + val default: Parameters = new Default {} + } + + /** Test parameters + * @deprecated (in 1.10.0) Use [[org.scalacheck.Test.Parameters]] instead. + */ + @deprecated("Use [[org.scalacheck.Test.Parameters]] instead", "1.10.0") case class Params( minSuccessfulTests: Int = 100, - - /** @deprecated Use maxDiscardRatio instead. */ - @deprecated("Use maxDiscardRatio instead.", "1.10") maxDiscardedTests: Int = -1, - minSize: Int = 0, maxSize: Int = Gen.Params().size, rng: java.util.Random = Gen.Params().rng, workers: Int = 1, - testCallback: TestCallback = new TestCallback {}, - maxDiscardRatio: Float = 5, - customClassLoader: Option[ClassLoader] = None + testCallback: TestCallback = new TestCallback {} ) + @deprecated("Use [[org.scalacheck.Test.Parameters]] instead", "1.10.0") + private def paramsToParameters(params: Params) = new Parameters { + val minSuccessfulTests = params.minSuccessfulTests + val minSize = params.minSize + val maxSize = params.maxSize + val rng = params.rng + val workers = params.workers + val testCallback = params.testCallback + + // maxDiscardedTests is deprecated, but if someone + // uses it let it override maxDiscardRatio + val maxDiscardRatio = + if(params.maxDiscardedTests < 0) Parameters.default.maxDiscardRatio + else (params.maxDiscardedTests: Float)/(params.minSuccessfulTests: Float) + + val customClassLoader = Parameters.default.customClassLoader + } + /** Test statistics */ case class Result(status: Status, succeeded: Int, discarded: Int, freqMap: FM, time: Long = 0) { def passed = status match { @@ -92,7 +189,7 @@ object Test { } } - private def assertParams(prms: Params) = { + private def assertParams(prms: Parameters) = { import prms._ if( minSuccessfulTests <= 0 || @@ -104,16 +201,24 @@ object Test { } private def secure[T](x: => T): Either[T,Throwable] = - try { Left(x) } catch { case e => Right(e) } + try { Left(x) } catch { case e: Throwable => Right(e) } private[scalacheck] lazy val cmdLineParser = new CmdLineParser { object OptMinSuccess extends IntOpt { - val default = Test.Params().minSuccessfulTests + val default = Parameters.default.minSuccessfulTests val names = Set("minSuccessfulTests", "s") val help = "Number of tests that must succeed in order to pass a property" } + object OptMaxDiscarded extends IntOpt { + val default = -1 + val names = Set("maxDiscardedTests", "d") + val help = + "Number of tests that can be discarded before ScalaCheck stops " + + "testing a property. NOTE: this option is deprecated, please use " + + "the option maxDiscardRatio (-r) instead." + } object OptMaxDiscardRatio extends FloatOpt { - val default = Test.Params().maxDiscardRatio + val default = Parameters.default.maxDiscardRatio val names = Set("maxDiscardRatio", "r") val help = "The maximum ratio between discarded and succeeded tests " + @@ -121,17 +226,17 @@ object Test { "least minSuccessfulTests will always be tested, though." } object OptMinSize extends IntOpt { - val default = Test.Params().minSize + val default = Parameters.default.minSize val names = Set("minSize", "n") val help = "Minimum data generation size" } object OptMaxSize extends IntOpt { - val default = Test.Params().maxSize + val default = Parameters.default.maxSize val names = Set("maxSize", "x") val help = "Maximum data generation size" } object OptWorkers extends IntOpt { - val default = Test.Params().workers + val default = Parameters.default.workers val names = Set("workers", "w") val help = "Number of threads to execute in parallel for testing" } @@ -142,54 +247,63 @@ object Test { } val opts = Set[Opt[_]]( - OptMinSuccess, OptMaxDiscardRatio, OptMinSize, + OptMinSuccess, OptMaxDiscarded, OptMaxDiscardRatio, OptMinSize, OptMaxSize, OptWorkers, OptVerbosity ) def parseParams(args: Array[String]) = parseArgs(args) { - optMap => Test.Params( - minSuccessfulTests = optMap(OptMinSuccess), - maxDiscardRatio = optMap(OptMaxDiscardRatio), - minSize = optMap(OptMinSize), - maxSize = optMap(OptMaxSize), - rng = Test.Params().rng, - workers = optMap(OptWorkers), - testCallback = ConsoleReporter(optMap(OptVerbosity)) + optMap => Parameters.default.copy( + _minSuccessfulTests = optMap(OptMinSuccess), + _maxDiscardRatio = + if (optMap(OptMaxDiscarded) < 0) optMap(OptMaxDiscardRatio) + else optMap(OptMaxDiscarded).toFloat / optMap(OptMinSuccess), + _minSize = optMap(OptMinSize), + _maxSize = optMap(OptMaxSize), + _workers = optMap(OptWorkers), + _testCallback = ConsoleReporter(optMap(OptVerbosity)) ) } } /** Tests a property with the given testing parameters, and returns - * the test results. */ + * the test results. + * @deprecated (in 1.10.0) Use + * `check(Parameters, Properties)` instead. + */ + @deprecated("Use 'checkProperties(Parameters, Properties)' instead", "1.10.0") def check(params: Params, p: Prop): Result = { + check(paramsToParameters(params), p) + } - // maxDiscardedTests is deprecated, but if someone - // uses it let it override maxDiscardRatio - val mdr = - if(params.maxDiscardedTests < 0) params.maxDiscardRatio - else (params.maxDiscardedTests: Float)/(params.minSuccessfulTests: Float) - val prms = params.copy( maxDiscardRatio = mdr) - - import prms._ - import scala.actors.Futures.future + /** Tests a property with the given testing parameters, and returns + * the test results. */ + def check(params: Parameters, p: Prop): Result = { + import params._ - assertParams(prms) - if(workers > 1) + assertParams(params) + if(workers > 1) { assert(!p.isInstanceOf[Commands], "Commands cannot be checked multi-threaded") + } val iterations = math.ceil(minSuccessfulTests / (workers: Double)) val sizeStep = (maxSize-minSize) / (iterations*workers) var stop = false - def worker(workerIdx: Int) = future { - params.customClassLoader.map(Thread.currentThread.setContextClassLoader(_)) + def worker(workerIdx: Int) = + if (workers < 2) () => workerFun(workerIdx) + else actors.Futures.future { + params.customClassLoader.map(Thread.currentThread.setContextClassLoader(_)) + workerFun(workerIdx) + } + + def workerFun(workerIdx: Int) = { var n = 0 // passed tests var d = 0 // discarded tests var res: Result = null var fm = FreqMap.empty[immutable.Set[Any]] while(!stop && res == null && n < iterations) { val size = (minSize: Double) + (sizeStep * (workerIdx + (workers*(n+d)))) - val propPrms = Prop.Params(Gen.Params(size.round.toInt, prms.rng), fm) + val propPrms = Prop.Params(Gen.Params(size.round.toInt, params.rng), fm) secure(p(propPrms)) match { case Right(e) => res = Result(GenException(e), n, d, FreqMap.empty[immutable.Set[Any]]) @@ -250,11 +364,20 @@ object Test { stop = true results foreach (_.apply()) val timedRes = r.copy(time = System.currentTimeMillis-start) - prms.testCallback.onTestResult("", timedRes) + params.testCallback.onTestResult("", timedRes) timedRes } + /** Check a set of properties. + * @deprecated (in 1.10.0) Use + * `checkProperties(Parameters, Properties)` instead. + */ + @deprecated("Use 'checkProperties(Parameters, Properties)' instead", "1.10.0") def checkProperties(prms: Params, ps: Properties): Seq[(String,Result)] = + checkProperties(paramsToParameters(prms), ps) + + /** Check a set of properties. */ + def checkProperties(prms: Parameters, ps: Properties): Seq[(String,Result)] = ps.properties.map { case (name,p) => val testCallback = new TestCallback { override def onPropEval(n: String, t: Int, s: Int, d: Int) = @@ -262,7 +385,7 @@ object Test { override def onTestResult(n: String, r: Result) = prms.testCallback.onTestResult(name,r) } - val res = check(prms copy (testCallback = testCallback), p) + val res = check(prms copy (_testCallback = testCallback), p) (name,res) } diff --git a/src/scalacheck/org/scalacheck/util/Buildable.scala b/src/scalacheck/org/scalacheck/util/Buildable.scala index 221b8a61c3..140c541a95 100644 --- a/src/scalacheck/org/scalacheck/util/Buildable.scala +++ b/src/scalacheck/org/scalacheck/util/Buildable.scala @@ -1,6 +1,6 @@ /*-------------------------------------------------------------------------*\ ** ScalaCheck ** -** Copyright (c) 2007-2011 Rickard Nilsson. All rights reserved. ** +** Copyright (c) 2007-2013 Rickard Nilsson. All rights reserved. ** ** http://www.scalacheck.org ** ** ** ** This software is released under the terms of the Revised BSD License. ** @@ -10,7 +10,6 @@ package org.scalacheck.util import scala.collection._ -import scala.reflect.ClassTag trait Buildable[T,C[_]] { def builder: mutable.Builder[T,C[T]] @@ -31,7 +30,7 @@ object Buildable { def builder = (new mutable.ListBuffer[T]).mapResult(_.toStream) } - implicit def buildableArray[T](implicit cm: ClassTag[T]) = + implicit def buildableArray[T](implicit cm: ClassManifest[T]) = new Buildable[T,Array] { def builder = mutable.ArrayBuilder.make[T] } diff --git a/src/scalacheck/org/scalacheck/util/CmdLineParser.scala b/src/scalacheck/org/scalacheck/util/CmdLineParser.scala index 4683c34a65..eb3a91fe59 100644 --- a/src/scalacheck/org/scalacheck/util/CmdLineParser.scala +++ b/src/scalacheck/org/scalacheck/util/CmdLineParser.scala @@ -1,6 +1,6 @@ /*-------------------------------------------------------------------------*\ ** ScalaCheck ** -** Copyright (c) 2007-2011 Rickard Nilsson. All rights reserved. ** +** Copyright (c) 2007-2013 Rickard Nilsson. All rights reserved. ** ** http://www.scalacheck.org ** ** ** ** This software is released under the terms of the Revised BSD License. ** @@ -30,7 +30,7 @@ trait CmdLineParser extends Parsers { trait StrOpt extends Opt[String] class OptMap { - private val opts = new scala.collection.mutable.HashMap[Opt[_], Any] + private val opts = new collection.mutable.HashMap[Opt[_], Any] def apply(flag: Flag): Boolean = opts.contains(flag) def apply[T](opt: Opt[T]): T = opts.get(opt) match { case None => opt.default diff --git a/src/scalacheck/org/scalacheck/util/FreqMap.scala b/src/scalacheck/org/scalacheck/util/FreqMap.scala index c7474d3b87..d0686aec72 100644 --- a/src/scalacheck/org/scalacheck/util/FreqMap.scala +++ b/src/scalacheck/org/scalacheck/util/FreqMap.scala @@ -1,6 +1,6 @@ /*-------------------------------------------------------------------------*\ ** ScalaCheck ** -** Copyright (c) 2007-2011 Rickard Nilsson. All rights reserved. ** +** Copyright (c) 2007-2013 Rickard Nilsson. All rights reserved. ** ** http://www.scalacheck.org ** ** ** ** This software is released under the terms of the Revised BSD License. ** diff --git a/src/scalacheck/org/scalacheck/util/StdRand.scala b/src/scalacheck/org/scalacheck/util/StdRand.scala index 317b0ccd10..7c1dc8dcc4 100644 --- a/src/scalacheck/org/scalacheck/util/StdRand.scala +++ b/src/scalacheck/org/scalacheck/util/StdRand.scala @@ -1,6 +1,6 @@ /*-------------------------------------------------------------------------*\ ** ScalaCheck ** -** Copyright (c) 2007-2011 Rickard Nilsson. All rights reserved. ** +** Copyright (c) 2007-2013 Rickard Nilsson. All rights reserved. ** ** http://www.scalacheck.org ** ** ** ** This software is released under the terms of the Revised BSD License. ** diff --git a/src/scaladoc/scala/tools/nsc/doc/html/HtmlPage.scala b/src/scaladoc/scala/tools/nsc/doc/html/HtmlPage.scala index 9edd5afa13..159e16375c 100644 --- a/src/scaladoc/scala/tools/nsc/doc/html/HtmlPage.scala +++ b/src/scaladoc/scala/tools/nsc/doc/html/HtmlPage.scala @@ -3,7 +3,9 @@ * @author David Bernard, Manohar Jonnalagedda */ -package scala.tools.nsc +package scala +package tools +package nsc package doc package html diff --git a/src/scaladoc/scala/tools/nsc/doc/html/Page.scala b/src/scaladoc/scala/tools/nsc/doc/html/Page.scala index 91939cf3de..93950fd0a7 100644 --- a/src/scaladoc/scala/tools/nsc/doc/html/Page.scala +++ b/src/scaladoc/scala/tools/nsc/doc/html/Page.scala @@ -3,7 +3,8 @@ * @author David Bernard, Manohar Jonnalagedda */ -package scala.tools.nsc.doc.html +package scala +package tools.nsc.doc.html import scala.tools.nsc.doc.model._ import java.io.{FileOutputStream, File} diff --git a/src/scaladoc/scala/tools/nsc/doc/html/SyntaxHigh.scala b/src/scaladoc/scala/tools/nsc/doc/html/SyntaxHigh.scala index 348ea97c5b..fe0fc64033 100644 --- a/src/scaladoc/scala/tools/nsc/doc/html/SyntaxHigh.scala +++ b/src/scaladoc/scala/tools/nsc/doc/html/SyntaxHigh.scala @@ -3,7 +3,8 @@ * @author Stephane Micheloud */ -package scala.tools.nsc.doc.html +package scala +package tools.nsc.doc.html import scala.xml.NodeSeq import scala.annotation.tailrec diff --git a/src/scaladoc/scala/tools/nsc/doc/html/page/ReferenceIndex.scala b/src/scaladoc/scala/tools/nsc/doc/html/page/ReferenceIndex.scala index a74c2eedbd..84ee82f994 100755 --- a/src/scaladoc/scala/tools/nsc/doc/html/page/ReferenceIndex.scala +++ b/src/scaladoc/scala/tools/nsc/doc/html/page/ReferenceIndex.scala @@ -3,10 +3,13 @@ * @author Pedro Furlanetto */ -package scala.tools.nsc +package scala +package tools +package nsc package doc package html package page + import doc.model._ class ReferenceIndex(letter: Char, index: doc.Index, universe: Universe) extends HtmlPage { diff --git a/src/scaladoc/scala/tools/nsc/doc/html/page/Template.scala b/src/scaladoc/scala/tools/nsc/doc/html/page/Template.scala index c5ccc06cf9..119d4e0143 100644 --- a/src/scaladoc/scala/tools/nsc/doc/html/page/Template.scala +++ b/src/scaladoc/scala/tools/nsc/doc/html/page/Template.scala @@ -3,7 +3,9 @@ * @author David Bernard, Manohar Jonnalagedda */ -package scala.tools.nsc +package scala +package tools +package nsc package doc package html package page diff --git a/src/scaladoc/scala/tools/nsc/doc/html/page/diagram/DotDiagramGenerator.scala b/src/scaladoc/scala/tools/nsc/doc/html/page/diagram/DotDiagramGenerator.scala index 7d146b4a5f..4ff436bdc6 100644 --- a/src/scaladoc/scala/tools/nsc/doc/html/page/diagram/DotDiagramGenerator.scala +++ b/src/scaladoc/scala/tools/nsc/doc/html/page/diagram/DotDiagramGenerator.scala @@ -2,7 +2,9 @@ * @author Damien Obrist * @author Vlad Ureche */ -package scala.tools.nsc +package scala +package tools +package nsc package doc package html package page diff --git a/src/scaladoc/scala/tools/nsc/doc/model/IndexModelFactory.scala b/src/scaladoc/scala/tools/nsc/doc/model/IndexModelFactory.scala index 1272906df5..53410fd4ad 100755 --- a/src/scaladoc/scala/tools/nsc/doc/model/IndexModelFactory.scala +++ b/src/scaladoc/scala/tools/nsc/doc/model/IndexModelFactory.scala @@ -3,7 +3,8 @@ * @author Pedro Furlanetto */ -package scala.tools.nsc +package scala +package tools.nsc package doc package model diff --git a/src/scaladoc/scala/tools/nsc/doc/model/ModelFactory.scala b/src/scaladoc/scala/tools/nsc/doc/model/ModelFactory.scala index 5b91ef2ba5..c4e3c115be 100644 --- a/src/scaladoc/scala/tools/nsc/doc/model/ModelFactory.scala +++ b/src/scaladoc/scala/tools/nsc/doc/model/ModelFactory.scala @@ -1,6 +1,7 @@ /* NSC -- new Scala compiler -- Copyright 2007-2013 LAMP/EPFL */ -package scala.tools.nsc +package scala +package tools.nsc package doc package model @@ -9,11 +10,9 @@ import diagram._ import scala.collection._ import scala.util.matching.Regex - import symtab.Flags import io._ - import model.{ RootPackage => RootPackageEntity } /** This trait extracts all required information for documentation from compilation units */ @@ -819,36 +818,36 @@ class ModelFactory(val global: Global, val settings: doc.Settings) { } } - /** */ def makeAnnotation(annot: AnnotationInfo): scala.tools.nsc.doc.model.Annotation = { val aSym = annot.symbol new EntityImpl(aSym, makeTemplate(aSym.owner)) with scala.tools.nsc.doc.model.Annotation { lazy val annotationClass = makeTemplate(annot.symbol) - val arguments = { // lazy - def annotArgs = annot.args match { - case Nil => annot.assocs collect { case (_, LiteralAnnotArg(const)) => Literal(const) } - case xs => xs - } - def noParams = annotArgs map (_ => None) - - val params: List[Option[ValueParam]] = annotationClass match { + val arguments = { + val paramsOpt: Option[List[ValueParam]] = annotationClass match { case aClass: DocTemplateEntity with Class => - (aClass.primaryConstructor map { _.valueParams.head }) match { - case Some(vps) => vps map { Some(_) } - case _ => noParams + val constr = aClass.constructors collectFirst { + case c: MemberImpl if c.sym == annot.original.symbol => c } - case _ => noParams + constr flatMap (_.valueParams.headOption) + case _ => None } - assert(params.length == annotArgs.length, (params, annotArgs)) - - params zip annotArgs flatMap { case (param, arg) => - makeTree(arg) map { tree => - new ValueArgument { - def parameter = param - def value = tree + val argTrees = annot.args map makeTree + paramsOpt match { + case Some (params) => + params zip argTrees map { case (param, tree) => + new ValueArgument { + def parameter = Some(param) + def value = tree + } + } + case None => + argTrees map { tree => + new ValueArgument { + def parameter = None + def value = tree + } } - } } } } @@ -888,9 +887,8 @@ class ModelFactory(val global: Global, val settings: doc.Settings) { sym.name == aSym.name && sym.isParamWithDefault ) - (unit.body find (t => isCorrespondingParam(t.symbol))) match { - case Some(ValDef(_,_,_,rhs)) => makeTree(rhs) - case _ => None + unit.body find (t => isCorrespondingParam(t.symbol)) collect { + case ValDef(_,_,_,rhs) if rhs ne EmptyTree => makeTree(rhs) } case _ => None } diff --git a/src/scaladoc/scala/tools/nsc/doc/model/TreeFactory.scala b/src/scaladoc/scala/tools/nsc/doc/model/TreeFactory.scala index b972649194..b381176b17 100755 --- a/src/scaladoc/scala/tools/nsc/doc/model/TreeFactory.scala +++ b/src/scaladoc/scala/tools/nsc/doc/model/TreeFactory.scala @@ -19,7 +19,7 @@ trait TreeFactory { thisTreeFactory: ModelFactory with TreeFactory => val global: Global import global._ - def makeTree(rhs: Tree): Option[TreeEntity] = { + def makeTree(rhs: Tree): TreeEntity = { val expr = new StringBuilder var refs = new immutable.TreeMap[Int, (Entity, Int)] // start, (Entity to be linked to , end) @@ -80,17 +80,16 @@ trait TreeFactory { thisTreeFactory: ModelFactory with TreeFactory => traverser.traverse(rhs) - Some(new TreeEntity { + new TreeEntity { val expression = expr.toString val refEntity = refs - }) + } } - case pos: OffsetPosition => - Some(new TreeEntity { + case _ => + new TreeEntity { val expression = rhs.toString val refEntity = new immutable.TreeMap[Int, (Entity, Int)] - }) - case _ => None + } } } } diff --git a/src/scalap/scala/tools/scalap/ByteArrayReader.scala b/src/scalap/scala/tools/scalap/ByteArrayReader.scala index bb001623a8..9c72bdbf1e 100644 --- a/src/scalap/scala/tools/scalap/ByteArrayReader.scala +++ b/src/scalap/scala/tools/scalap/ByteArrayReader.scala @@ -6,7 +6,8 @@ */ -package scala.tools.scalap +package scala +package tools.scalap class ByteArrayReader(content: Array[Byte]) { diff --git a/src/scalap/scala/tools/scalap/CodeWriter.scala b/src/scalap/scala/tools/scalap/CodeWriter.scala index 8254c2dfce..fe594c14cf 100644 --- a/src/scalap/scala/tools/scalap/CodeWriter.scala +++ b/src/scalap/scala/tools/scalap/CodeWriter.scala @@ -6,7 +6,8 @@ */ -package scala.tools.scalap +package scala +package tools.scalap import java.io._ diff --git a/src/scalap/scala/tools/scalap/Main.scala b/src/scalap/scala/tools/scalap/Main.scala index 90f8cb8d71..5da4227e53 100644 --- a/src/scalap/scala/tools/scalap/Main.scala +++ b/src/scalap/scala/tools/scalap/Main.scala @@ -5,7 +5,8 @@ ** */ -package scala.tools.scalap +package scala +package tools.scalap import java.io.{ PrintStream, OutputStreamWriter, ByteArrayOutputStream } import scala.reflect.NameTransformer diff --git a/src/scalap/scala/tools/scalap/MetaParser.scala b/src/scalap/scala/tools/scalap/MetaParser.scala index 00678ab504..8b4ffb3efd 100644 --- a/src/scalap/scala/tools/scalap/MetaParser.scala +++ b/src/scalap/scala/tools/scalap/MetaParser.scala @@ -6,7 +6,8 @@ */ -package scala.tools.scalap +package scala +package tools.scalap import java.io._ import java.util._ diff --git a/src/swing/scala/swing/Action.scala b/src/swing/scala/swing/Action.scala index 8740f63e98..98b9fee2ee 100644 --- a/src/swing/scala/swing/Action.scala +++ b/src/swing/scala/swing/Action.scala @@ -35,7 +35,12 @@ object Action { // TODO: we need an action cache private var _action: Action = Action.NoAction def action: Action = _action - def action_=(a: Action) { _action = a; peer.setAction(a.peer) } + def action_=(a: Action) { + _action = a; + + import scala.language.reflectiveCalls + peer.setAction(a.peer) + } //1.6: def hideActionText: Boolean = peer.getHideActionText //def hideActionText_=(b: Boolean) = peer.setHideActionText(b) diff --git a/src/swing/scala/swing/ComboBox.scala b/src/swing/scala/swing/ComboBox.scala index ce2b3ba6fb..a075d22a7e 100644 --- a/src/swing/scala/swing/ComboBox.scala +++ b/src/swing/scala/swing/ComboBox.scala @@ -11,6 +11,7 @@ package scala.swing import event._ import javax.swing.{JList, JComponent, JComboBox, JTextField, ComboBoxModel, AbstractListModel, ListCellRenderer} import java.awt.event.ActionListener +import scala.language.implicitConversions object ComboBox { /** diff --git a/src/swing/scala/swing/GridBagPanel.scala b/src/swing/scala/swing/GridBagPanel.scala index 7d181af4d8..c58d398737 100644 --- a/src/swing/scala/swing/GridBagPanel.scala +++ b/src/swing/scala/swing/GridBagPanel.scala @@ -9,6 +9,7 @@ package scala.swing import java.awt.{GridBagConstraints, GridBagLayout} +import scala.language.implicitConversions object GridBagPanel { object Fill extends Enumeration { diff --git a/src/swing/scala/swing/Orientable.scala b/src/swing/scala/swing/Orientable.scala index a73bafb9d3..db7cf09f27 100644 --- a/src/swing/scala/swing/Orientable.scala +++ b/src/swing/scala/swing/Orientable.scala @@ -12,7 +12,10 @@ package scala.swing object Orientable { trait Wrapper extends Oriented.Wrapper with Orientable { - def orientation_=(o: Orientation.Value) { peer.setOrientation(o.id) } + def orientation_=(o: Orientation.Value) { + import scala.language.reflectiveCalls + peer.setOrientation(o.id) + } } } diff --git a/src/swing/scala/swing/Oriented.scala b/src/swing/scala/swing/Oriented.scala index 7996d21898..72d7d574e2 100644 --- a/src/swing/scala/swing/Oriented.scala +++ b/src/swing/scala/swing/Oriented.scala @@ -22,6 +22,7 @@ object Oriented { def getOrientation(): Int def setOrientation(n: Int) } + import scala.language.reflectiveCalls def orientation: Orientation.Value = Orientation(peer.getOrientation) } } diff --git a/src/swing/scala/swing/Slider.scala b/src/swing/scala/swing/Slider.scala index e329c31a01..241876587b 100644 --- a/src/swing/scala/swing/Slider.scala +++ b/src/swing/scala/swing/Slider.scala @@ -53,7 +53,7 @@ class Slider extends Component with Orientable.Wrapper with Publisher { def labels: scala.collection.Map[Int, Label] = { val labelTable = peer.getLabelTable.asInstanceOf[java.util.Hashtable[Int, JLabel]] - new scala.collection.JavaConversions.JMapWrapper(labelTable) + new scala.collection.convert.Wrappers.JMapWrapper(labelTable) .mapValues(v => UIElement.cachedWrapper[Label](v)) } def labels_=(l: scala.collection.Map[Int, Label]) { diff --git a/src/swing/scala/swing/Swing.scala b/src/swing/scala/swing/Swing.scala index cd5bbf2c4f..e2c8479354 100644 --- a/src/swing/scala/swing/Swing.scala +++ b/src/swing/scala/swing/Swing.scala @@ -14,6 +14,7 @@ import java.awt.event._ import javax.swing.event._ import javax.swing.border._ import javax.swing.{JComponent, Icon, BorderFactory, SwingUtilities} +import scala.language.implicitConversions /** diff --git a/src/swing/scala/swing/package.scala b/src/swing/scala/swing/package.scala index 45497665d7..d5095f021b 100644 --- a/src/swing/scala/swing/package.scala +++ b/src/swing/scala/swing/package.scala @@ -14,9 +14,6 @@ package object swing { type Image = java.awt.Image type Font = java.awt.Font - implicit lazy val reflectiveCalls = scala.language.reflectiveCalls - implicit lazy val implicitConversions = scala.language.implicitConversions - private[swing] def ifNull[A](o: Object, a: A): A = if(o eq null) a else o.asInstanceOf[A] private[swing] def toOption[A](o: Object): Option[A] = if(o eq null) None else Some(o.asInstanceOf[A]) private[swing] def toAnyRef(x: Any): AnyRef = x.asInstanceOf[AnyRef] diff --git a/test/files/jvm/xml01.scala b/test/files/jvm/xml01.scala index 2fab650637..75777a5b94 100644 --- a/test/files/jvm/xml01.scala +++ b/test/files/jvm/xml01.scala @@ -1,7 +1,6 @@ import java.io.StringReader import org.xml.sax.InputSource -import scala.util.logging._ import scala.xml._ object Test extends App { diff --git a/test/files/neg/abstract-explaintypes.check b/test/files/neg/abstract-explaintypes.check index 59c1ad2378..e303b45a32 100644 --- a/test/files/neg/abstract-explaintypes.check +++ b/test/files/neg/abstract-explaintypes.check @@ -3,9 +3,13 @@ abstract-explaintypes.scala:6: error: type mismatch; required: A.this.T def foo2: T = bar().baz(); ^ +A <: A.this.T? +false abstract-explaintypes.scala:9: error: type mismatch; found : A required: A.this.T def foo5: T = baz().baz(); ^ +A <: A.this.T? +false two errors found diff --git a/test/files/neg/delayed-init-ref.check b/test/files/neg/delayed-init-ref.check new file mode 100644 index 0000000000..ce5b205832 --- /dev/null +++ b/test/files/neg/delayed-init-ref.check @@ -0,0 +1,12 @@ +delayed-init-ref.scala:17: warning: Selecting value vall from object O, which extends scala.DelayedInit, is likely to yield an uninitialized value + println(O.vall) // warn + ^ +delayed-init-ref.scala:19: warning: Selecting value vall from object O, which extends scala.DelayedInit, is likely to yield an uninitialized value + println(vall) // warn + ^ +delayed-init-ref.scala:40: warning: Selecting value foo from trait UserContext, which extends scala.DelayedInit, is likely to yield an uninitialized value + println({locally(()); this}.foo) // warn (spurious, but we can't discriminate) + ^ +error: No warnings can be incurred under -Xfatal-warnings. +three warnings found +one error found diff --git a/test/files/neg/delayed-init-ref.flags b/test/files/neg/delayed-init-ref.flags new file mode 100644 index 0000000000..7949c2afa2 --- /dev/null +++ b/test/files/neg/delayed-init-ref.flags @@ -0,0 +1 @@ +-Xlint -Xfatal-warnings diff --git a/test/files/neg/delayed-init-ref.scala b/test/files/neg/delayed-init-ref.scala new file mode 100644 index 0000000000..f2aa804e28 --- /dev/null +++ b/test/files/neg/delayed-init-ref.scala @@ -0,0 +1,42 @@ +trait T { + val traitVal = "" +} + +object O extends App with T { + val vall = "" + lazy val lazyy = "" + def deff = "" + + println(vall) // no warn + new { + println(vall) // no warn + } +} + +object Client { + println(O.vall) // warn + import O.vall + println(vall) // warn + + println(O.lazyy) // no warn + println(O.deff) // no warn + println(O.traitVal) // no warn +} + +// Delayed init usage pattern from Specs2 +// See: https://groups.google.com/d/msg/scala-sips/wP6dL8nIAQs/ogjoPE-MSVAJ +trait Before extends DelayedInit { + def before() + override def delayedInit(x: => Unit): Unit = { before; x } +} +object Spec { + trait UserContext extends Before { + def before() = () + val foo = "foo" + } + new UserContext { + println(foo) // no warn + println(this.foo) // no warn + println({locally(()); this}.foo) // warn (spurious, but we can't discriminate) + } +} diff --git a/test/files/neg/macro-divergence-controlled.check b/test/files/neg/macro-divergence-controlled.check new file mode 100644 index 0000000000..4876f7cf96 --- /dev/null +++ b/test/files/neg/macro-divergence-controlled.check @@ -0,0 +1,4 @@ +Test_2.scala:2: error: could not find implicit value for parameter e: Complex[Foo] + println(implicitly[Complex[Foo]]) + ^ +one error found diff --git a/test/files/neg/macro-divergence-controlled/Impls_Macros_1.scala b/test/files/neg/macro-divergence-controlled/Impls_Macros_1.scala new file mode 100644 index 0000000000..59acaede65 --- /dev/null +++ b/test/files/neg/macro-divergence-controlled/Impls_Macros_1.scala @@ -0,0 +1,23 @@ +import scala.reflect.macros.Context +import language.experimental.macros + +trait Complex[T] + +class Foo(val foo: Foo) + +object Complex { + def impl[T: c.WeakTypeTag](c: Context): c.Expr[Complex[T]] = { + import c.universe._ + val tpe = weakTypeOf[T] + for (f <- tpe.declarations.collect{case f: TermSymbol if f.isParamAccessor && !f.isMethod => f}) { + val trecur = appliedType(typeOf[Complex[_]], List(f.typeSignature)) + if (c.openImplicits.tail.exists(ic => ic.pt =:= trecur)) c.abort(c.enclosingPosition, "diverging implicit expansion. reported by a macro!") + val recur = c.inferImplicitValue(trecur, silent = true) + if (recur == EmptyTree) c.abort(c.enclosingPosition, s"couldn't synthesize $trecur") + } + c.literalNull + } + + implicit object ComplexString extends Complex[String] + implicit def genComplex[T]: Complex[T] = macro impl[T] +} diff --git a/test/files/neg/macro-divergence-controlled/Test_2.scala b/test/files/neg/macro-divergence-controlled/Test_2.scala new file mode 100644 index 0000000000..dcc4593335 --- /dev/null +++ b/test/files/neg/macro-divergence-controlled/Test_2.scala @@ -0,0 +1,3 @@ +object Test extends App { + println(implicitly[Complex[Foo]]) +}
\ No newline at end of file diff --git a/test/files/neg/t414.check b/test/files/neg/t414.check index e15dbaea71..30211eef8e 100644 --- a/test/files/neg/t414.check +++ b/test/files/neg/t414.check @@ -1,7 +1,7 @@ t414.scala:5: error: pattern type is incompatible with expected type; found : Empty.type required: IntMap[a] -Note: if you intended to match against the class, try `case _: Empty[_]` or `case Empty()` +Note: if you intended to match against the class, try `case Empty()` case Empty => ^ t414.scala:7: error: type mismatch; diff --git a/test/files/neg/t4879.check b/test/files/neg/t4879.check index 21cd329640..c7edd583c8 100644 --- a/test/files/neg/t4879.check +++ b/test/files/neg/t4879.check @@ -1,13 +1,13 @@ t4879.scala:6: error: pattern type is incompatible with expected type; found : C.type required: C -Note: if you intended to match against the class, try `case _: C` or `case C(_)` +Note: if you intended to match against the class, try `case C(_)` case C => true ^ t4879.scala:10: error: pattern type is incompatible with expected type; found : D.type required: D[T,U,V] -Note: if you intended to match against the class, try `case _: D[_,_,_]` or `case D(_,_,_)` +Note: if you intended to match against the class, try `case D(_,_,_)` case D => true ^ two errors found diff --git a/test/files/neg/t5663-badwarneq.check b/test/files/neg/t5663-badwarneq.check index 12e93ff373..732e4f44d0 100644 --- a/test/files/neg/t5663-badwarneq.check +++ b/test/files/neg/t5663-badwarneq.check @@ -1,24 +1,42 @@ -t5663-badwarneq.scala:42: warning: comparing case class values of types Some[Int] and None.type using `==' will always yield false +t5663-badwarneq.scala:47: warning: comparing case class values of types Some[Int] and None.type using `==' will always yield false println(new Some(1) == None) // Should complain on type, was: spuriously complains on fresh object ^ -t5663-badwarneq.scala:43: warning: comparing case class values of types Some[Int] and Thing using `==' will always yield false +t5663-badwarneq.scala:48: warning: comparing case class values of types Some[Int] and Thing using `==' will always yield false println(Some(1) == new Thing(1)) // Should complain on type, was: spuriously complains on fresh object ^ -t5663-badwarneq.scala:51: warning: ThingOne and Thingy are unrelated: they will most likely never compare equal +t5663-badwarneq.scala:56: warning: ThingOne and Thingy are unrelated: they will most likely never compare equal println(t1 == t2) // true, but apparently unrelated, a compromise warning ^ -t5663-badwarneq.scala:52: warning: ThingThree and Thingy are unrelated: they will most likely never compare equal +t5663-badwarneq.scala:57: warning: ThingThree and Thingy are unrelated: they will most likely never compare equal println(t4 == t2) // true, complains because ThingThree is final and Thingy not a subclass, stronger claim than unrelated ^ -t5663-badwarneq.scala:55: warning: comparing case class values of types ThingTwo and Some[Int] using `==' will always yield false +t5663-badwarneq.scala:60: warning: comparing case class values of types ThingTwo and Some[Int] using `==' will always yield false println(t3 == Some(1)) // false, warn on different cases ^ -t5663-badwarneq.scala:56: warning: comparing values of types ThingOne and Cousin using `==' will always yield false +t5663-badwarneq.scala:61: warning: comparing values of types ThingOne and Cousin using `==' will always yield false println(t1 == c) // should warn ^ -t5663-badwarneq.scala:64: warning: comparing case class values of types Simple and SimpleSibling.type using `==' will always yield false +t5663-badwarneq.scala:69: warning: comparing case class values of types Simple and SimpleSibling.type using `==' will always yield false println(new Simple() == SimpleSibling) // like Some(1) == None, but needn't be final case ^ +t5663-badwarneq.scala:72: warning: ValueClass1 and Int are unrelated: they will never compare equal + println(new ValueClass1(5) == 5) // bad + ^ +t5663-badwarneq.scala:74: warning: comparing values of types Int and ValueClass1 using `==' will always yield false + println(5 == new ValueClass1(5)) // bad + ^ +t5663-badwarneq.scala:78: warning: ValueClass2[String] and String are unrelated: they will never compare equal + println(new ValueClass2("abc") == "abc") // bad + ^ +t5663-badwarneq.scala:79: warning: ValueClass2[Int] and ValueClass1 are unrelated: they will never compare equal + println(new ValueClass2(5) == new ValueClass1(5)) // bad - different value classes + ^ +t5663-badwarneq.scala:81: warning: comparing values of types ValueClass3 and ValueClass2[Int] using `==' will always yield false + println(ValueClass3(5) == new ValueClass2(5)) // bad + ^ +t5663-badwarneq.scala:82: warning: comparing values of types ValueClass3 and Int using `==' will always yield false + println(ValueClass3(5) == 5) // bad + ^ error: No warnings can be incurred under -Xfatal-warnings. -7 warnings found +13 warnings found one error found diff --git a/test/files/neg/t5663-badwarneq.scala b/test/files/neg/t5663-badwarneq.scala index 56ec389c03..3c0376914e 100644 --- a/test/files/neg/t5663-badwarneq.scala +++ b/test/files/neg/t5663-badwarneq.scala @@ -17,6 +17,11 @@ class SimpleParent case class Simple() extends SimpleParent case object SimpleSibling extends SimpleParent +// value classes +final class ValueClass1(val value: Int) extends AnyVal +final class ValueClass2[T](val value: T) extends AnyVal +final case class ValueClass3(val value: Int) extends AnyVal + /* It's not possible to run partest without -deprecation. * Since detecting the warnings requires a neg test with * -Xfatal-warnings, and deprecation terminates the compile, @@ -63,6 +68,19 @@ object Test { println(new Simple() == SimpleSibling) // like Some(1) == None, but needn't be final case + println(new ValueClass1(5) == new ValueClass1(5)) // ok + println(new ValueClass1(5) == 5) // bad + println(new ValueClass1(5) == (5: Any)) // ok, have to let it through + println(5 == new ValueClass1(5)) // bad + println((5: Any) == new ValueClass1(5) == (5: Any)) // ok + + println(new ValueClass2("abc") == new ValueClass2("abc")) // ok + println(new ValueClass2("abc") == "abc") // bad + println(new ValueClass2(5) == new ValueClass1(5)) // bad - different value classes + println(ValueClass3(5) == new ValueClass3(5)) // ok + println(ValueClass3(5) == new ValueClass2(5)) // bad + println(ValueClass3(5) == 5) // bad + /* val mine = new MyThing val some = new SomeThing diff --git a/test/files/neg/t6406-regextract.check b/test/files/neg/t6406-regextract.check index 4fea66f760..19425a68b0 100644 --- a/test/files/neg/t6406-regextract.check +++ b/test/files/neg/t6406-regextract.check @@ -1,7 +1,6 @@ -t6406-regextract.scala:4: error: cannot resolve overloaded unapply +t6406-regextract.scala:4: warning: method unapplySeq in class Regex is deprecated: Extracting a match result from anything but a CharSequence or Match is deprecated List(1) collect { case r(i) => i } ^ -t6406-regextract.scala:4: error: not found: value i - List(1) collect { case r(i) => i } - ^ -two errors found +error: No warnings can be incurred under -Xfatal-warnings. +one warning found +one error found diff --git a/test/files/neg/t6815.check b/test/files/neg/t6815.check new file mode 100644 index 0000000000..fae3819be1 --- /dev/null +++ b/test/files/neg/t6815.check @@ -0,0 +1,5 @@ +t6815.scala:15: error: stable identifier required, but Test.this.u.emptyValDef found. + Note that value emptyValDef is not stable because its type, Test.u.ValDef, is volatile. + case _: u.emptyValDef.T => // and, unlike in pos/t6185.scala, we shouldn't allow this. + ^ +one error found diff --git a/test/files/neg/t6815.scala b/test/files/neg/t6815.scala new file mode 100644 index 0000000000..ff973a7437 --- /dev/null +++ b/test/files/neg/t6815.scala @@ -0,0 +1,17 @@ +trait U { + trait ValOrDefDefApi { + def name: Any + } + type ValOrDefDef <: ValOrDefDefApi + type ValDef <: ValOrDefDef with ValDefApi { type T } + trait ValDefApi extends ValOrDefDefApi { this: ValDef => } + val emptyValDef: ValDef // the result type is volatile +} + +object Test { + val u: U = ??? + + (null: Any) match { + case _: u.emptyValDef.T => // and, unlike in pos/t6185.scala, we shouldn't allow this. + } +} diff --git a/test/files/neg/t696.check b/test/files/neg/t696.check index ac26a864a5..b7bc5cdf98 100644 --- a/test/files/neg/t696.check +++ b/test/files/neg/t696.check @@ -1,5 +1,9 @@ -t696.scala:4: error: diverging implicit expansion for type TypeUtil0.Type[Any] +t696.scala:5: error: diverging implicit expansion for type TypeUtil0.Type[Any] starting with method WithType in object TypeUtil0 - as[Any](null); + as[Any](null) ^ -one error found +t696.scala:6: error: diverging implicit expansion for type TypeUtil0.Type[X] +starting with method WithType in object TypeUtil0 + def foo[X]() = as[X](null) + ^ +two errors found diff --git a/test/files/neg/t696.scala b/test/files/neg/t696.scala index a06a32141a..ca76f7ef6c 100644 --- a/test/files/neg/t696.scala +++ b/test/files/neg/t696.scala @@ -1,6 +1,7 @@ object TypeUtil0 { - trait Type[+T]; + trait Type[+T] implicit def WithType[S,T](implicit tpeS : Type[S], tpeT : Type[T]) : Type[S with T] = null - as[Any](null); - def as[T](x : Any)(implicit tpe : Type[T]) = null; + def as[T](x : Any)(implicit tpe : Type[T]) = null + as[Any](null) + def foo[X]() = as[X](null) } diff --git a/test/files/neg/t7330.check b/test/files/neg/t7330.check new file mode 100644 index 0000000000..b96d656d2b --- /dev/null +++ b/test/files/neg/t7330.check @@ -0,0 +1,5 @@ +t7330.scala:4: error: pattern must be a value: Y[_] +Note: if you intended to match against the class, try `case _: Y[_]` + 0 match { case Y[_] => } + ^ +one error found diff --git a/test/files/neg/t7330.scala b/test/files/neg/t7330.scala new file mode 100644 index 0000000000..13a943a02b --- /dev/null +++ b/test/files/neg/t7330.scala @@ -0,0 +1,5 @@ +class Y[T] +class Test { + // TypeTree is not a valid tree for a pattern + 0 match { case Y[_] => } +}
\ No newline at end of file diff --git a/test/files/neg/t7369.check b/test/files/neg/t7369.check new file mode 100644 index 0000000000..a4e99f496e --- /dev/null +++ b/test/files/neg/t7369.check @@ -0,0 +1,15 @@ +t7369.scala:6: warning: unreachable code + case Tuple1(X) => // unreachable + ^ +t7369.scala:13: warning: unreachable code + case Tuple1(true) => // unreachable + ^ +t7369.scala:31: warning: unreachable code + case Tuple1(X) => // unreachable + ^ +t7369.scala:40: warning: unreachable code + case Tuple1(null) => // unreachable + ^ +error: No warnings can be incurred under -Xfatal-warnings. +four warnings found +one error found diff --git a/test/files/neg/t7369.flags b/test/files/neg/t7369.flags new file mode 100644 index 0000000000..e8fb65d50c --- /dev/null +++ b/test/files/neg/t7369.flags @@ -0,0 +1 @@ +-Xfatal-warnings
\ No newline at end of file diff --git a/test/files/neg/t7369.scala b/test/files/neg/t7369.scala new file mode 100644 index 0000000000..87ddfe98b7 --- /dev/null +++ b/test/files/neg/t7369.scala @@ -0,0 +1,43 @@ +object Test { + val X, Y = true + (null: Tuple1[Boolean]) match { + case Tuple1(X) => + case Tuple1(Y) => + case Tuple1(X) => // unreachable + case _ => + } + + (null: Tuple1[Boolean]) match { + case Tuple1(true) => + case Tuple1(false) => + case Tuple1(true) => // unreachable + case _ => + } +} + + +sealed abstract class B; +case object True extends B; +case object False extends B; + +object Test2 { + + val X: B = True + val Y: B = False + + (null: Tuple1[B]) match { + case Tuple1(X) => + case Tuple1(Y) => + case Tuple1(X) => // unreachable + case _ => + } +} + +object Test3 { + (null: Tuple1[B]) match { + case Tuple1(null) => + case Tuple1(True) => + case Tuple1(null) => // unreachable + case _ => + } +} diff --git a/test/files/neg/tailrec-2.check b/test/files/neg/tailrec-2.check index d3432a7e76..1daad6922e 100644 --- a/test/files/neg/tailrec-2.check +++ b/test/files/neg/tailrec-2.check @@ -1,4 +1,4 @@ -tailrec-2.scala:8: error: could not optimize @tailrec annotated method f: it contains a recursive call targeting supertype Super[A] +tailrec-2.scala:8: error: could not optimize @tailrec annotated method f: it contains a recursive call targeting a supertype @annotation.tailrec final def f[B >: A](mem: List[B]): List[B] = (null: Super[A]).f(mem) ^ tailrec-2.scala:9: error: @tailrec annotated method contains no recursive calls diff --git a/test/files/neg/volatile_no_override.check b/test/files/neg/volatile_no_override.check new file mode 100644 index 0000000000..a9a60ab697 --- /dev/null +++ b/test/files/neg/volatile_no_override.check @@ -0,0 +1,5 @@ +volatile_no_override.scala:13: error: overriding value x in class A of type Volatile.this.D; + value x has a volatile type; cannot override a member with non-volatile type + val x: A with D = null + ^ +one error found diff --git a/test/files/neg/volatile_no_override.scala b/test/files/neg/volatile_no_override.scala new file mode 100644 index 0000000000..9fad082a90 --- /dev/null +++ b/test/files/neg/volatile_no_override.scala @@ -0,0 +1,14 @@ +class B +class C(x: String) extends B + +abstract class A { + class D { type T >: C <: B } + val x: D + var y: x.T = new C("abc") +} + +class Volatile extends A { + type A >: Null + // test (1.4), pt 2 in RefChecks + val x: A with D = null +} diff --git a/test/files/pos/t1648.scala b/test/files/pos/t1648.scala deleted file mode 100644 index 6d53ce11ee..0000000000 --- a/test/files/pos/t1648.scala +++ /dev/null @@ -1,4 +0,0 @@ -object Test { - class MyClass extends scala.util.logging.Logged { } - val x = new MyClass with scala.util.logging.ConsoleLogger -} diff --git a/test/files/pos/t3943/Client_2.scala b/test/files/pos/t3943/Client_2.scala new file mode 100644 index 0000000000..650ac9b7a9 --- /dev/null +++ b/test/files/pos/t3943/Client_2.scala @@ -0,0 +1,7 @@ +object Test { + val x: Child = new Child + x.getInner.foo("meh") +// error: type mismatch; +// found : java.lang.String("meh") +// required: E +} diff --git a/test/files/pos/t3943/Outer_1.java b/test/files/pos/t3943/Outer_1.java new file mode 100644 index 0000000000..1d38c5e76b --- /dev/null +++ b/test/files/pos/t3943/Outer_1.java @@ -0,0 +1,14 @@ +class Outer<E> { + abstract class Inner { + abstract public void foo(E e); + } +} + +class Child extends Outer<String> { + // the implicit prefix for Inner is Outer<E> instead of Outer<String> + public Inner getInner() { + return new Inner() { + public void foo(String e) { System.out.println("meh "+e); } + }; + } +} diff --git a/test/files/pos/t5692c.check b/test/files/pos/t5692c.check new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/test/files/pos/t5692c.check diff --git a/test/files/pos/t5692c.scala b/test/files/pos/t5692c.scala new file mode 100644 index 0000000000..fa5f0b2dcd --- /dev/null +++ b/test/files/pos/t5692c.scala @@ -0,0 +1,4 @@ +class C { + def foo[T: scala.reflect.ClassTag](xs: T*): Array[T] = ??? + foo() +}
\ No newline at end of file diff --git a/test/files/pos/t6675.flags b/test/files/pos/t6675.flags new file mode 100644 index 0000000000..e8fb65d50c --- /dev/null +++ b/test/files/pos/t6675.flags @@ -0,0 +1 @@ +-Xfatal-warnings
\ No newline at end of file diff --git a/test/files/pos/t6675.scala b/test/files/pos/t6675.scala new file mode 100644 index 0000000000..f3bebea5be --- /dev/null +++ b/test/files/pos/t6675.scala @@ -0,0 +1,20 @@ +object LeftOrRight { + def unapply[A](value: Either[A, A]): Option[A] = value match { + case scala.Left(x) => Some(x) + case scala.Right(x) => Some(x) + } +} + +object Test { + (Left((0, 0)): Either[(Int, Int), (Int, Int)]) match { + case LeftOrRight(pair @ (a, b)) => a // false -Xlint warning: "extractor pattern binds a single value to a Product2 of type (Int, Int)" + } + + (Left((0, 0)): Either[(Int, Int), (Int, Int)]) match { + case LeftOrRight((a, b)) => a // false -Xlint warning: "extractor pattern binds a single value to a Product2 of type (Int, Int)" + } + + (Left((0, 0)): Either[(Int, Int), (Int, Int)]) match { + case LeftOrRight(a, b) => a // false -Xlint warning: "extractor pattern binds a single value to a Product2 of type (Int, Int)" + } +} diff --git a/test/files/pos/t6815.scala b/test/files/pos/t6815.scala new file mode 100644 index 0000000000..9244b3d353 --- /dev/null +++ b/test/files/pos/t6815.scala @@ -0,0 +1,17 @@ +trait U { + trait ValOrDefDefApi { + def name: Any + } + type ValOrDefDef <: ValOrDefDefApi + type ValDef <: ValOrDefDef with ValDefApi + trait ValDefApi extends ValOrDefDefApi { this: ValDef => } + val emptyValDef: ValDef // the result type is volatile +} + +object Test { + val u: U = ??? + + u.emptyValDef match { + case u.emptyValDef => // but we shouldn't let that stop us from treating it as a stable identifier pattern. + } +} diff --git a/test/files/pos/t6815_import.scala b/test/files/pos/t6815_import.scala new file mode 100644 index 0000000000..56f4358d59 --- /dev/null +++ b/test/files/pos/t6815_import.scala @@ -0,0 +1,16 @@ +trait U { + trait ValOrDefDefApi { + def name: Any + } + type ValOrDefDef <: ValOrDefDefApi + type ValDef <: ValOrDefDef with ValDefApi + trait ValDefApi extends ValOrDefDefApi { this: ValDef => } + val emptyValDef: ValDef // the result type is volatile +} + +object Test { + val u: U = ??? + + // but we shouldn't let that stop us from treating it as a stable identifier for import + import u.emptyValDef.name +} diff --git a/test/files/pos/t7200b.scala b/test/files/pos/t7200b.scala new file mode 100644 index 0000000000..9d579c6ef9 --- /dev/null +++ b/test/files/pos/t7200b.scala @@ -0,0 +1,50 @@ +import language.higherKinds + +trait T { + def t = 0 +} +trait Foo { + def coflatMap[A <: T](f: A): A +} + +object O extends Foo { + def coflatMap[A <: T](f: A) = { + val f2 = coflatMap(f) // inferred in 2.9.2 / 2.10.0 as [Nothing] + f2.t // so this does't type check. + f2 + } +} + +// Why? When a return type is inherited, the derived method +// symbol first gets a preliminary type assigned, based on the +// 1) method type of a unique matching super member +// 2) viewed as a member type of the inheritor (to substitute, +// e.g. class type parameters) +// 3) substituted to replace the super-method's type parameters +// with those of the inheritor +// 4) dissected to take just the return type wrapped in thisMethodType(). +// +// In Scala 2.10.0 and earlier, this preliminary method type +// +// 1) [A#11329 <: <empty>#3.this.T#7068](<param> f#11333: A#11329)A#11329 +// 2) [A#11329 <: <empty>#3.this.T#7068](<param> f#11333: A#11329)A#11329 +// 3) (<param> f#12556: A#11336)A#11336 +// 4) [A#11336 <: <empty>#3.this.T#7068](<param> f#12552: A#11337&0)A#11336 +// +// The type #4 from the old version is problematic: the parameter is typed with +// a skolem for the type parameter `A`. It won't be considered to match the +// method it overrides, instead they are seen as being overloaded, and type inference +// goes awry (Nothing is inferred as the type argument for the recursive call +// to coflatMap. +// +// The Namers patch adds one step here: it subsitutes the type parameter symbols +// for the skolems: +// +// https://github.com/scala/scala/commit/b74c33eb#L2R1014 +// +// So we end up with a method symbol info: +// +// 5) [A#11336 <: <empty>#3.this.T#7068](<param> f#12505: A#11336)A#11336 +// +// This *does* match the method in the super class, and type inference +// chooses the correct type argument.
\ No newline at end of file diff --git a/test/files/pos/t7369.flags b/test/files/pos/t7369.flags new file mode 100644 index 0000000000..85d8eb2ba2 --- /dev/null +++ b/test/files/pos/t7369.flags @@ -0,0 +1 @@ +-Xfatal-warnings diff --git a/test/files/pos/t7369.scala b/test/files/pos/t7369.scala new file mode 100644 index 0000000000..2f31c93d29 --- /dev/null +++ b/test/files/pos/t7369.scala @@ -0,0 +1,37 @@ +object Test { + val X, Y = true + (null: Tuple1[Boolean]) match { + case Tuple1(X) => + case Tuple1(Y) => // unreachable + case _ => + } +} + + +sealed abstract class B; +case object True extends B; +case object False extends B; + +object Test2 { + + val X: B = True + val Y: B = False + + (null: Tuple1[B]) match { + case Tuple1(X) => + case Tuple1(Y) => // no warning + case _ => + } +} + +object Test3 { + val X, O = true + def classify(neighbourhood: (Boolean, Boolean, Boolean)): String = { + neighbourhood match { + case (X, X, X) => "middle" + case (X, X, O) => "right" + case (O, X, X) => "left" + case _ => throw new IllegalArgumentException("Invalid") + } + } +}
\ No newline at end of file diff --git a/test/files/pos/xlint1.flags b/test/files/pos/xlint1.flags new file mode 100644 index 0000000000..7949c2afa2 --- /dev/null +++ b/test/files/pos/xlint1.flags @@ -0,0 +1 @@ +-Xlint -Xfatal-warnings diff --git a/test/files/pos/xlint1.scala b/test/files/pos/xlint1.scala new file mode 100644 index 0000000000..27936d8b14 --- /dev/null +++ b/test/files/pos/xlint1.scala @@ -0,0 +1,13 @@ +package object foo { + implicit class Bar[T](val x: T) extends AnyVal { + def bippy = 1 + } +} + +package foo { + object Baz { + def main(args: Array[String]): Unit = { + "abc".bippy + } + } +} diff --git a/test/files/presentation/callcc-interpreter.check b/test/files/presentation/callcc-interpreter.check index 804b365101..59c841a255 100644 --- a/test/files/presentation/callcc-interpreter.check +++ b/test/files/presentation/callcc-interpreter.check @@ -2,91 +2,91 @@ reload: CallccInterpreter.scala askTypeCompletion at CallccInterpreter.scala(51,38) ================================================================================ -[response] aksTypeCompletion at (51,38) +[response] askCompletionAt (51,38) retrieved 63 members -[accessible: true] `class AddcallccInterpreter.Add` -[accessible: true] `class AppcallccInterpreter.App` -[accessible: true] `class CcccallccInterpreter.Ccc` -[accessible: true] `class ConcallccInterpreter.Con` -[accessible: true] `class FuncallccInterpreter.Fun` -[accessible: true] `class LamcallccInterpreter.Lam` -[accessible: true] `class McallccInterpreter.M` -[accessible: true] `class NumcallccInterpreter.Num` -[accessible: true] `class VarcallccInterpreter.Var` -[accessible: true] `method !=(x$1: Any)Boolean` -[accessible: true] `method !=(x$1: AnyRef)Boolean` -[accessible: true] `method ##()Int` -[accessible: true] `method +(other: String)String` -[accessible: true] `method ->[B](y: B)(callccInterpreter.type, B)` -[accessible: true] `method ==(x$1: Any)Boolean` -[accessible: true] `method ==(x$1: AnyRef)Boolean` -[accessible: true] `method add(a: callccInterpreter.Value, b: callccInterpreter.Value)callccInterpreter.M[_ >: callccInterpreter.Num with callccInterpreter.Wrong.type <: Product with Serializable with callccInterpreter.Value]` -[accessible: true] `method apply(a: callccInterpreter.Value, b: callccInterpreter.Value)callccInterpreter.M[callccInterpreter.Value]` -[accessible: true] `method asInstanceOf[T0]=> T0` -[accessible: true] `method callCC[A](h: (A => callccInterpreter.M[A]) => callccInterpreter.M[A])callccInterpreter.M[A]` -[accessible: true] `method clone()Object` -[accessible: true] `method ensuring(cond: Boolean)callccInterpreter.type` -[accessible: true] `method ensuring(cond: Boolean, msg: => Any)callccInterpreter.type` -[accessible: true] `method ensuring(cond: callccInterpreter.type => Boolean)callccInterpreter.type` -[accessible: true] `method ensuring(cond: callccInterpreter.type => Boolean, msg: => Any)callccInterpreter.type` -[accessible: true] `method eq(x$1: AnyRef)Boolean` -[accessible: true] `method equals(x$1: Any)Boolean` -[accessible: true] `method finalize()Unit` -[accessible: true] `method formatted(fmtstr: String)String` -[accessible: true] `method hashCode()Int` -[accessible: true] `method id[A]=> A => A` -[accessible: true] `method interp(t: callccInterpreter.Term, e: callccInterpreter.Environment)callccInterpreter.M[callccInterpreter.Value]` -[accessible: true] `method isInstanceOf[T0]=> Boolean` -[accessible: true] `method lookup(x: callccInterpreter.Name, e: callccInterpreter.Environment)callccInterpreter.M[callccInterpreter.Value]` -[accessible: true] `method main(args: Array[String])Unit` -[accessible: true] `method ne(x$1: AnyRef)Boolean` -[accessible: true] `method notify()Unit` -[accessible: true] `method notifyAll()Unit` -[accessible: true] `method showM(m: callccInterpreter.M[callccInterpreter.Value])String` -[accessible: true] `method synchronized[T0](x$1: T0)T0` -[accessible: true] `method test(t: callccInterpreter.Term)String` -[accessible: true] `method toString()String` -[accessible: true] `method unitM[A](a: A)callccInterpreter.M[A]` -[accessible: true] `method wait()Unit` -[accessible: true] `method wait(x$1: Long)Unit` -[accessible: true] `method wait(x$1: Long, x$2: Int)Unit` -[accessible: true] `method →[B](y: B)(callccInterpreter.type, B)` -[accessible: true] `object WrongcallccInterpreter.Wrong.type` -[accessible: true] `trait TermcallccInterpreter.Term` -[accessible: true] `trait ValuecallccInterpreter.Value` -[accessible: true] `type AnswercallccInterpreter.Answer` -[accessible: true] `type EnvironmentcallccInterpreter.Environment` -[accessible: true] `type NamecallccInterpreter.Name` -[accessible: true] `value __leftOfArrowcallccInterpreter.type` -[accessible: true] `value __resultOfEnsuringcallccInterpreter.type` -[accessible: true] `value __stringToFormatcallccInterpreter.type` -[accessible: true] `value __thingToAddcallccInterpreter.type` -[accessible: true] `value term0callccInterpreter.App` -[accessible: true] `value term1callccInterpreter.App` -[accessible: true] `value term2callccInterpreter.Add` +abstract trait Term extends AnyRef +abstract trait Value extends AnyRef +case class Add extends callccInterpreter.Term with Product with Serializable +case class App extends callccInterpreter.Term with Product with Serializable +case class Ccc extends callccInterpreter.Term with Product with Serializable +case class Con extends callccInterpreter.Term with Product with Serializable +case class Fun extends callccInterpreter.Value with Product with Serializable +case class Lam extends callccInterpreter.Term with Product with Serializable +case class M[A] extends Product with Serializable +case class Num extends callccInterpreter.Value with Product with Serializable +case class Var extends callccInterpreter.Term with Product with Serializable +case object Wrong +def +(other: String): String +def ->[B](y: B): (callccInterpreter.type, B) +def add(a: callccInterpreter.Value,b: callccInterpreter.Value): callccInterpreter.M[_ >: callccInterpreter.Num with callccInterpreter.Wrong.type <: Product with Serializable with callccInterpreter.Value] +def apply(a: callccInterpreter.Value,b: callccInterpreter.Value): callccInterpreter.M[callccInterpreter.Value] +def callCC[A](h: (A => callccInterpreter.M[A]) => callccInterpreter.M[A]): callccInterpreter.M[A] +def ensuring(cond: Boolean): callccInterpreter.type +def ensuring(cond: Boolean,msg: => Any): callccInterpreter.type +def ensuring(cond: callccInterpreter.type => Boolean): callccInterpreter.type +def ensuring(cond: callccInterpreter.type => Boolean,msg: => Any): callccInterpreter.type +def equals(x$1: Any): Boolean +def formatted(fmtstr: String): String +def hashCode(): Int +def id[A]: A => A +def interp(t: callccInterpreter.Term,e: callccInterpreter.Environment): callccInterpreter.M[callccInterpreter.Value] +def lookup(x: callccInterpreter.Name,e: callccInterpreter.Environment): callccInterpreter.M[callccInterpreter.Value] +def main(args: Array[String]): Unit +def showM(m: callccInterpreter.M[callccInterpreter.Value]): String +def test(t: callccInterpreter.Term): String +def toString(): String +def unitM[A](a: A): callccInterpreter.M[A] +def →[B](y: B): (callccInterpreter.type, B) +final def !=(x$1: Any): Boolean +final def !=(x$1: AnyRef): Boolean +final def ##(): Int +final def ==(x$1: Any): Boolean +final def ==(x$1: AnyRef): Boolean +final def asInstanceOf[T0]: T0 +final def eq(x$1: AnyRef): Boolean +final def isInstanceOf[T0]: Boolean +final def ne(x$1: AnyRef): Boolean +final def notify(): Unit +final def notifyAll(): Unit +final def synchronized[T0](x$1: T0): T0 +final def wait(): Unit +final def wait(x$1: Long): Unit +final def wait(x$1: Long,x$2: Int): Unit +private[this] val __leftOfArrow: callccInterpreter.type +private[this] val __resultOfEnsuring: callccInterpreter.type +private[this] val __stringToFormat: callccInterpreter.type +private[this] val __thingToAdd: callccInterpreter.type +private[this] val term0: callccInterpreter.App +private[this] val term1: callccInterpreter.App +private[this] val term2: callccInterpreter.Add +protected[package lang] def clone(): Object +protected[package lang] def finalize(): Unit +type Answer = callccInterpreter.Answer +type Environment = callccInterpreter.Environment +type Name = callccInterpreter.Name ================================================================================ askType at CallccInterpreter.scala(14,21) ================================================================================ -[response] askTypeAt at (14,21) +[response] askTypeAt (14,21) def unitM[A](a: A): callccInterpreter.M[A] = callccInterpreter.this.M.apply[A](((c: A => callccInterpreter.Answer) => c.apply(a))) ================================================================================ askType at CallccInterpreter.scala(16,12) ================================================================================ -[response] askTypeAt at (16,12) +[response] askTypeAt (16,12) def id[A]: A => A = ((x: A) => x) ================================================================================ askType at CallccInterpreter.scala(17,25) ================================================================================ -[response] askTypeAt at (17,25) +[response] askTypeAt (17,25) def showM(m: callccInterpreter.M[callccInterpreter.Value]): String = m.in.apply(callccInterpreter.this.id[callccInterpreter.Value]).toString() ================================================================================ askType at CallccInterpreter.scala(50,30) ================================================================================ -[response] askTypeAt at (50,30) +[response] askTypeAt (50,30) def add(a: callccInterpreter.Value, b: callccInterpreter.Value): callccInterpreter.M[_ >: callccInterpreter.Num with callccInterpreter.Wrong.type <: Product with Serializable with callccInterpreter.Value] = scala.this.Predef.Pair.apply[callccInterpreter.Value, callccInterpreter.Value](a, b) match { case scala.this.Predef.Pair.unapply[callccInterpreter.Value, callccInterpreter.Value](<unapply-selector>) <unapply> ((n: Int)callccInterpreter.Num((m @ _)), (n: Int)callccInterpreter.Num((n @ _))) => this.unitM[callccInterpreter.Num](callccInterpreter.this.Num.apply(m.+(n))) case _ => callccInterpreter.this.unitM[callccInterpreter.Wrong.type](callccInterpreter.this.Wrong) diff --git a/test/files/presentation/ide-bug-1000349.check b/test/files/presentation/ide-bug-1000349.check index 0040300083..b15486f4ac 100644 --- a/test/files/presentation/ide-bug-1000349.check +++ b/test/files/presentation/ide-bug-1000349.check @@ -2,39 +2,39 @@ reload: CompletionOnEmptyArgMethod.scala askTypeCompletion at CompletionOnEmptyArgMethod.scala(2,17) ================================================================================ -[response] aksTypeCompletion at (2,17) +[response] askCompletionAt (2,17) retrieved 36 members -[accessible: true] `method !=(x$1: Any)Boolean` -[accessible: true] `method !=(x$1: AnyRef)Boolean` -[accessible: true] `method ##()Int` -[accessible: true] `method +(other: String)String` -[accessible: true] `method ->[B](y: B)(Foo, B)` -[accessible: true] `method ==(x$1: Any)Boolean` -[accessible: true] `method ==(x$1: AnyRef)Boolean` -[accessible: true] `method asInstanceOf[T0]=> T0` -[accessible: true] `method clone()Object` -[accessible: true] `method ensuring(cond: Boolean)Foo` -[accessible: true] `method ensuring(cond: Boolean, msg: => Any)Foo` -[accessible: true] `method ensuring(cond: Foo => Boolean)Foo` -[accessible: true] `method ensuring(cond: Foo => Boolean, msg: => Any)Foo` -[accessible: true] `method eq(x$1: AnyRef)Boolean` -[accessible: true] `method equals(x$1: Any)Boolean` -[accessible: true] `method finalize()Unit` -[accessible: true] `method foo=> Foo` -[accessible: true] `method formatted(fmtstr: String)String` -[accessible: true] `method hashCode()Int` -[accessible: true] `method isInstanceOf[T0]=> Boolean` -[accessible: true] `method ne(x$1: AnyRef)Boolean` -[accessible: true] `method notify()Unit` -[accessible: true] `method notifyAll()Unit` -[accessible: true] `method synchronized[T0](x$1: T0)T0` -[accessible: true] `method toString()String` -[accessible: true] `method wait()Unit` -[accessible: true] `method wait(x$1: Long)Unit` -[accessible: true] `method wait(x$1: Long, x$2: Int)Unit` -[accessible: true] `method →[B](y: B)(Foo, B)` -[accessible: true] `value __leftOfArrowFoo` -[accessible: true] `value __resultOfEnsuringFoo` -[accessible: true] `value __stringToFormatFoo` -[accessible: true] `value __thingToAddFoo` +def +(other: String): String +def ->[B](y: B): (Foo, B) +def ensuring(cond: Boolean): Foo +def ensuring(cond: Boolean,msg: => Any): Foo +def ensuring(cond: Foo => Boolean): Foo +def ensuring(cond: Foo => Boolean,msg: => Any): Foo +def equals(x$1: Any): Boolean +def foo: Foo +def formatted(fmtstr: String): String +def hashCode(): Int +def toString(): String +def →[B](y: B): (Foo, B) +final def !=(x$1: Any): Boolean +final def !=(x$1: AnyRef): Boolean +final def ##(): Int +final def ==(x$1: Any): Boolean +final def ==(x$1: AnyRef): Boolean +final def asInstanceOf[T0]: T0 +final def eq(x$1: AnyRef): Boolean +final def isInstanceOf[T0]: Boolean +final def ne(x$1: AnyRef): Boolean +final def notify(): Unit +final def notifyAll(): Unit +final def synchronized[T0](x$1: T0): T0 +final def wait(): Unit +final def wait(x$1: Long): Unit +final def wait(x$1: Long,x$2: Int): Unit +private[this] val __leftOfArrow: Foo +private[this] val __resultOfEnsuring: Foo +private[this] val __stringToFormat: Foo +private[this] val __thingToAdd: Foo +protected[package lang] def clone(): Object +protected[package lang] def finalize(): Unit ================================================================================ diff --git a/test/files/presentation/ide-bug-1000475.check b/test/files/presentation/ide-bug-1000475.check index 7866e4af15..e4b8508846 100644 --- a/test/files/presentation/ide-bug-1000475.check +++ b/test/files/presentation/ide-bug-1000475.check @@ -2,114 +2,114 @@ reload: Foo.scala askTypeCompletion at Foo.scala(3,7) ================================================================================ -[response] aksTypeCompletion at (3,7) +[response] askCompletionAt (3,7) retrieved 35 members -[accessible: true] `method !=(x$1: Any)Boolean` -[accessible: true] `method !=(x$1: AnyRef)Boolean` -[accessible: true] `method ##()Int` -[accessible: true] `method +(other: String)String` -[accessible: true] `method ->[B](y: B)(Object, B)` -[accessible: true] `method ==(x$1: Any)Boolean` -[accessible: true] `method ==(x$1: AnyRef)Boolean` -[accessible: true] `method asInstanceOf[T0]=> T0` -[accessible: true] `method ensuring(cond: Boolean)Object` -[accessible: true] `method ensuring(cond: Boolean, msg: => Any)Object` -[accessible: true] `method ensuring(cond: Object => Boolean)Object` -[accessible: true] `method ensuring(cond: Object => Boolean, msg: => Any)Object` -[accessible: true] `method eq(x$1: AnyRef)Boolean` -[accessible: true] `method equals(x$1: Any)Boolean` -[accessible: true] `method formatted(fmtstr: String)String` -[accessible: true] `method hashCode()Int` -[accessible: true] `method isInstanceOf[T0]=> Boolean` -[accessible: true] `method ne(x$1: AnyRef)Boolean` -[accessible: true] `method notify()Unit` -[accessible: true] `method notifyAll()Unit` -[accessible: true] `method synchronized[T0](x$1: T0)T0` -[accessible: true] `method toString()String` -[accessible: true] `method wait()Unit` -[accessible: true] `method wait(x$1: Long)Unit` -[accessible: true] `method wait(x$1: Long, x$2: Int)Unit` -[accessible: true] `method →[B](y: B)(Object, B)` -[accessible: true] `value __leftOfArrowObject` -[accessible: true] `value __resultOfEnsuringObject` -[accessible: true] `value __stringToFormatObject` -[accessible: true] `value __thingToAddObject` -[accessible: false] `method clone()Object` -[accessible: false] `method finalize()Unit` +[inaccessible] protected[package lang] def clone(): Object +[inaccessible] protected[package lang] def finalize(): Unit +def +(other: String): String +def ->[B](y: B): (Object, B) +def ensuring(cond: Boolean): Object +def ensuring(cond: Boolean,msg: => Any): Object +def ensuring(cond: Object => Boolean): Object +def ensuring(cond: Object => Boolean,msg: => Any): Object +def equals(x$1: Any): Boolean +def formatted(fmtstr: String): String +def hashCode(): Int +def toString(): String +def →[B](y: B): (Object, B) +final def !=(x$1: Any): Boolean +final def !=(x$1: AnyRef): Boolean +final def ##(): Int +final def ==(x$1: Any): Boolean +final def ==(x$1: AnyRef): Boolean +final def asInstanceOf[T0]: T0 +final def eq(x$1: AnyRef): Boolean +final def isInstanceOf[T0]: Boolean +final def ne(x$1: AnyRef): Boolean +final def notify(): Unit +final def notifyAll(): Unit +final def synchronized[T0](x$1: T0): T0 +final def wait(): Unit +final def wait(x$1: Long): Unit +final def wait(x$1: Long,x$2: Int): Unit +private[this] val __leftOfArrow: Object +private[this] val __resultOfEnsuring: Object +private[this] val __stringToFormat: Object +private[this] val __thingToAdd: Object ================================================================================ askTypeCompletion at Foo.scala(6,10) ================================================================================ -[response] aksTypeCompletion at (6,10) +[response] askCompletionAt (6,10) retrieved 35 members -[accessible: true] `method !=(x$1: Any)Boolean` -[accessible: true] `method !=(x$1: AnyRef)Boolean` -[accessible: true] `method ##()Int` -[accessible: true] `method +(other: String)String` -[accessible: true] `method ->[B](y: B)(Object, B)` -[accessible: true] `method ==(x$1: Any)Boolean` -[accessible: true] `method ==(x$1: AnyRef)Boolean` -[accessible: true] `method asInstanceOf[T0]=> T0` -[accessible: true] `method ensuring(cond: Boolean)Object` -[accessible: true] `method ensuring(cond: Boolean, msg: => Any)Object` -[accessible: true] `method ensuring(cond: Object => Boolean)Object` -[accessible: true] `method ensuring(cond: Object => Boolean, msg: => Any)Object` -[accessible: true] `method eq(x$1: AnyRef)Boolean` -[accessible: true] `method equals(x$1: Any)Boolean` -[accessible: true] `method formatted(fmtstr: String)String` -[accessible: true] `method hashCode()Int` -[accessible: true] `method isInstanceOf[T0]=> Boolean` -[accessible: true] `method ne(x$1: AnyRef)Boolean` -[accessible: true] `method notify()Unit` -[accessible: true] `method notifyAll()Unit` -[accessible: true] `method synchronized[T0](x$1: T0)T0` -[accessible: true] `method toString()String` -[accessible: true] `method wait()Unit` -[accessible: true] `method wait(x$1: Long)Unit` -[accessible: true] `method wait(x$1: Long, x$2: Int)Unit` -[accessible: true] `method →[B](y: B)(Object, B)` -[accessible: true] `value __leftOfArrowObject` -[accessible: true] `value __resultOfEnsuringObject` -[accessible: true] `value __stringToFormatObject` -[accessible: true] `value __thingToAddObject` -[accessible: false] `method clone()Object` -[accessible: false] `method finalize()Unit` +[inaccessible] protected[package lang] def clone(): Object +[inaccessible] protected[package lang] def finalize(): Unit +def +(other: String): String +def ->[B](y: B): (Object, B) +def ensuring(cond: Boolean): Object +def ensuring(cond: Boolean,msg: => Any): Object +def ensuring(cond: Object => Boolean): Object +def ensuring(cond: Object => Boolean,msg: => Any): Object +def equals(x$1: Any): Boolean +def formatted(fmtstr: String): String +def hashCode(): Int +def toString(): String +def →[B](y: B): (Object, B) +final def !=(x$1: Any): Boolean +final def !=(x$1: AnyRef): Boolean +final def ##(): Int +final def ==(x$1: Any): Boolean +final def ==(x$1: AnyRef): Boolean +final def asInstanceOf[T0]: T0 +final def eq(x$1: AnyRef): Boolean +final def isInstanceOf[T0]: Boolean +final def ne(x$1: AnyRef): Boolean +final def notify(): Unit +final def notifyAll(): Unit +final def synchronized[T0](x$1: T0): T0 +final def wait(): Unit +final def wait(x$1: Long): Unit +final def wait(x$1: Long,x$2: Int): Unit +private[this] val __leftOfArrow: Object +private[this] val __resultOfEnsuring: Object +private[this] val __stringToFormat: Object +private[this] val __thingToAdd: Object ================================================================================ askTypeCompletion at Foo.scala(7,7) ================================================================================ -[response] aksTypeCompletion at (7,7) +[response] askCompletionAt (7,7) retrieved 35 members -[accessible: true] `method !=(x$1: Any)Boolean` -[accessible: true] `method !=(x$1: AnyRef)Boolean` -[accessible: true] `method ##()Int` -[accessible: true] `method +(other: String)String` -[accessible: true] `method ->[B](y: B)(Object, B)` -[accessible: true] `method ==(x$1: Any)Boolean` -[accessible: true] `method ==(x$1: AnyRef)Boolean` -[accessible: true] `method asInstanceOf[T0]=> T0` -[accessible: true] `method ensuring(cond: Boolean)Object` -[accessible: true] `method ensuring(cond: Boolean, msg: => Any)Object` -[accessible: true] `method ensuring(cond: Object => Boolean)Object` -[accessible: true] `method ensuring(cond: Object => Boolean, msg: => Any)Object` -[accessible: true] `method eq(x$1: AnyRef)Boolean` -[accessible: true] `method equals(x$1: Any)Boolean` -[accessible: true] `method formatted(fmtstr: String)String` -[accessible: true] `method hashCode()Int` -[accessible: true] `method isInstanceOf[T0]=> Boolean` -[accessible: true] `method ne(x$1: AnyRef)Boolean` -[accessible: true] `method notify()Unit` -[accessible: true] `method notifyAll()Unit` -[accessible: true] `method synchronized[T0](x$1: T0)T0` -[accessible: true] `method toString()String` -[accessible: true] `method wait()Unit` -[accessible: true] `method wait(x$1: Long)Unit` -[accessible: true] `method wait(x$1: Long, x$2: Int)Unit` -[accessible: true] `method →[B](y: B)(Object, B)` -[accessible: true] `value __leftOfArrowObject` -[accessible: true] `value __resultOfEnsuringObject` -[accessible: true] `value __stringToFormatObject` -[accessible: true] `value __thingToAddObject` -[accessible: false] `method clone()Object` -[accessible: false] `method finalize()Unit` +[inaccessible] protected[package lang] def clone(): Object +[inaccessible] protected[package lang] def finalize(): Unit +def +(other: String): String +def ->[B](y: B): (Object, B) +def ensuring(cond: Boolean): Object +def ensuring(cond: Boolean,msg: => Any): Object +def ensuring(cond: Object => Boolean): Object +def ensuring(cond: Object => Boolean,msg: => Any): Object +def equals(x$1: Any): Boolean +def formatted(fmtstr: String): String +def hashCode(): Int +def toString(): String +def →[B](y: B): (Object, B) +final def !=(x$1: Any): Boolean +final def !=(x$1: AnyRef): Boolean +final def ##(): Int +final def ==(x$1: Any): Boolean +final def ==(x$1: AnyRef): Boolean +final def asInstanceOf[T0]: T0 +final def eq(x$1: AnyRef): Boolean +final def isInstanceOf[T0]: Boolean +final def ne(x$1: AnyRef): Boolean +final def notify(): Unit +final def notifyAll(): Unit +final def synchronized[T0](x$1: T0): T0 +final def wait(): Unit +final def wait(x$1: Long): Unit +final def wait(x$1: Long,x$2: Int): Unit +private[this] val __leftOfArrow: Object +private[this] val __resultOfEnsuring: Object +private[this] val __stringToFormat: Object +private[this] val __thingToAdd: Object ================================================================================ diff --git a/test/files/presentation/ide-bug-1000531.check b/test/files/presentation/ide-bug-1000531.check index 18ecd4b536..980bb0a25d 100644 --- a/test/files/presentation/ide-bug-1000531.check +++ b/test/files/presentation/ide-bug-1000531.check @@ -2,127 +2,127 @@ reload: CrashOnLoad.scala askTypeCompletion at CrashOnLoad.scala(6,12) ================================================================================ -[response] aksTypeCompletion at (6,12) +[response] askCompletionAt (6,12) retrieved 124 members -[accessible: true] `class GroupedIteratorIterator[B]#GroupedIterator` -[accessible: true] `method !=(x$1: Any)Boolean` -[accessible: true] `method !=(x$1: AnyRef)Boolean` -[accessible: true] `method ##()Int` -[accessible: true] `method +(other: String)String` -[accessible: true] `method ++[B >: B](that: => scala.collection.GenTraversableOnce[B])Iterator[B]` -[accessible: true] `method ->[B](y: B)(java.util.Iterator[B], B)` -[accessible: true] `method /:[B](z: B)(op: (B, B) => B)B` -[accessible: true] `method :\[B](z: B)(op: (B, B) => B)B` -[accessible: true] `method ==(x$1: Any)Boolean` -[accessible: true] `method ==(x$1: AnyRef)Boolean` -[accessible: true] `method addString(b: StringBuilder)StringBuilder` -[accessible: true] `method addString(b: StringBuilder, sep: String)StringBuilder` -[accessible: true] `method addString(b: StringBuilder, start: String, sep: String, end: String)StringBuilder` -[accessible: true] `method aggregate[B](z: => B)(seqop: (B, B) => B, combop: (B, B) => B)B` -[accessible: true] `method asInstanceOf[T0]=> T0` -[accessible: true] `method buffered=> scala.collection.BufferedIterator[B]` -[accessible: true] `method collectFirst[B](pf: PartialFunction[B,B])Option[B]` -[accessible: true] `method collect[B](pf: PartialFunction[B,B])Iterator[B]` -[accessible: true] `method contains(elem: Any)Boolean` -[accessible: true] `method copyToArray[B >: B](xs: Array[B])Unit` -[accessible: true] `method copyToArray[B >: B](xs: Array[B], start: Int)Unit` -[accessible: true] `method copyToArray[B >: B](xs: Array[B], start: Int, len: Int)Unit` -[accessible: true] `method copyToBuffer[B >: B](dest: scala.collection.mutable.Buffer[B])Unit` -[accessible: true] `method corresponds[B](that: scala.collection.GenTraversableOnce[B])(p: (B, B) => Boolean)Boolean` -[accessible: true] `method count(p: B => Boolean)Int` -[accessible: true] `method drop(n: Int)Iterator[B]` -[accessible: true] `method dropWhile(p: B => Boolean)Iterator[B]` -[accessible: true] `method duplicate=> (Iterator[B], Iterator[B])` -[accessible: true] `method ensuring(cond: Boolean)java.util.Iterator[B]` -[accessible: true] `method ensuring(cond: Boolean, msg: => Any)java.util.Iterator[B]` -[accessible: true] `method ensuring(cond: java.util.Iterator[B] => Boolean)java.util.Iterator[B]` -[accessible: true] `method ensuring(cond: java.util.Iterator[B] => Boolean, msg: => Any)java.util.Iterator[B]` -[accessible: true] `method eq(x$1: AnyRef)Boolean` -[accessible: true] `method equals(x$1: Any)Boolean` -[accessible: true] `method exists(p: B => Boolean)Boolean` -[accessible: true] `method filter(p: B => Boolean)Iterator[B]` -[accessible: true] `method filterNot(p: B => Boolean)Iterator[B]` -[accessible: true] `method find(p: B => Boolean)Option[B]` -[accessible: true] `method flatMap[B](f: B => scala.collection.GenTraversableOnce[B])Iterator[B]` -[accessible: true] `method foldLeft[B](z: B)(op: (B, B) => B)B` -[accessible: true] `method foldRight[B](z: B)(op: (B, B) => B)B` -[accessible: true] `method fold[A1 >: B](z: A1)(op: (A1, A1) => A1)A1` -[accessible: true] `method forall(p: B => Boolean)Boolean` -[accessible: true] `method foreach[U](f: B => U)Unit` -[accessible: true] `method formatted(fmtstr: String)String` -[accessible: true] `method grouped[B >: B](size: Int)Iterator[B]#GroupedIterator[B]` -[accessible: true] `method hasDefiniteSize=> Boolean` -[accessible: true] `method hasNext()Boolean` -[accessible: true] `method hashCode()Int` -[accessible: true] `method indexOf[B >: B](elem: B)Int` -[accessible: true] `method indexWhere(p: B => Boolean)Int` -[accessible: true] `method isEmpty=> Boolean` -[accessible: true] `method isInstanceOf[T0]=> Boolean` -[accessible: true] `method isTraversableAgain=> Boolean` -[accessible: true] `method length=> Int` -[accessible: true] `method map[B](f: B => B)Iterator[B]` -[accessible: true] `method maxBy[B](f: B => B)(implicit cmp: Ordering[B])B` -[accessible: true] `method max[B >: B](implicit cmp: Ordering[B])B` -[accessible: true] `method minBy[B](f: B => B)(implicit cmp: Ordering[B])B` -[accessible: true] `method min[B >: B](implicit cmp: Ordering[B])B` -[accessible: true] `method mkString(sep: String)String` -[accessible: true] `method mkString(start: String, sep: String, end: String)String` -[accessible: true] `method mkString=> String` -[accessible: true] `method ne(x$1: AnyRef)Boolean` -[accessible: true] `method next()B` -[accessible: true] `method nonEmpty=> Boolean` -[accessible: true] `method notify()Unit` -[accessible: true] `method notifyAll()Unit` -[accessible: true] `method padTo[A1 >: B](len: Int, elem: A1)Iterator[A1]` -[accessible: true] `method partition(p: B => Boolean)(Iterator[B], Iterator[B])` -[accessible: true] `method patch[B >: B](from: Int, patchElems: Iterator[B], replaced: Int)Iterator[B]` -[accessible: true] `method product[B >: B](implicit num: Numeric[B])B` -[accessible: true] `method reduceLeftOption[B >: B](op: (B, B) => B)Option[B]` -[accessible: true] `method reduceLeft[B >: B](op: (B, B) => B)B` -[accessible: true] `method reduceOption[A1 >: B](op: (A1, A1) => A1)Option[A1]` -[accessible: true] `method reduceRightOption[B >: B](op: (B, B) => B)Option[B]` -[accessible: true] `method reduceRight[B >: B](op: (B, B) => B)B` -[accessible: true] `method reduce[A1 >: B](op: (A1, A1) => A1)A1` -[accessible: true] `method remove()Unit` -[accessible: true] `method sameElements(that: Iterator[_])Boolean` -[accessible: true] `method scanLeft[B](z: B)(op: (B, B) => B)Iterator[B]` -[accessible: true] `method scanRight[B](z: B)(op: (B, B) => B)Iterator[B]` -[accessible: true] `method seq=> Iterator[B]` -[accessible: true] `method size=> Int` -[accessible: true] `method slice(from: Int, until: Int)Iterator[B]` -[accessible: true] `method sliding[B >: B](size: Int, step: Int)Iterator[B]#GroupedIterator[B]` -[accessible: true] `method span(p: B => Boolean)(Iterator[B], Iterator[B])` -[accessible: true] `method sum[B >: B](implicit num: Numeric[B])B` -[accessible: true] `method synchronized[T0](x$1: T0)T0` -[accessible: true] `method take(n: Int)Iterator[B]` -[accessible: true] `method takeWhile(p: B => Boolean)Iterator[B]` -[accessible: true] `method toArray[B >: B](implicit evidence$1: scala.reflect.ClassTag[B])Array[B]` -[accessible: true] `method toBuffer[B >: B]=> scala.collection.mutable.Buffer[B]` -[accessible: true] `method toIndexedSeq=> scala.collection.immutable.IndexedSeq[B]` -[accessible: true] `method toIterable=> Iterable[B]` -[accessible: true] `method toIterator=> Iterator[B]` -[accessible: true] `method toList=> List[B]` -[accessible: true] `method toMap[T, U](implicit ev: <:<[B,(T, U)])scala.collection.immutable.Map[T,U]` -[accessible: true] `method toSeq=> Seq[B]` -[accessible: true] `method toSet[B >: B]=> scala.collection.immutable.Set[B]` -[accessible: true] `method toStream=> scala.collection.immutable.Stream[B]` -[accessible: true] `method toString()String` -[accessible: true] `method toTraversable=> Traversable[B]` -[accessible: true] `method toVector=> Vector[B]` -[accessible: true] `method to[Col[_]](implicit cbf: scala.collection.generic.CanBuildFrom[Nothing,B,Col[B]])Col[B]` -[accessible: true] `method wait()Unit` -[accessible: true] `method wait(x$1: Long)Unit` -[accessible: true] `method wait(x$1: Long, x$2: Int)Unit` -[accessible: true] `method withFilter(p: B => Boolean)Iterator[B]` -[accessible: true] `method zipAll[B, A1 >: B, B1 >: B](that: Iterator[B], thisElem: A1, thatElem: B1)Iterator[(A1, B1)]` -[accessible: true] `method zipWithIndex=> Iterator[(B, Int)]` -[accessible: true] `method zip[B](that: Iterator[B])Iterator[(B, B)]` -[accessible: true] `method →[B](y: B)(java.util.Iterator[B], B)` -[accessible: true] `value __leftOfArrowjava.util.Iterator[B]` -[accessible: true] `value __resultOfEnsuringjava.util.Iterator[B]` -[accessible: true] `value __stringToFormatjava.util.Iterator[B]` -[accessible: true] `value __thingToAddjava.util.Iterator[B]` -[accessible: false] `method clone()Object` -[accessible: false] `method finalize()Unit` -[accessible: false] `method reversed=> List[B]` +[inaccessible] protected[package lang] def clone(): Object +[inaccessible] protected[package lang] def finalize(): Unit +[inaccessible] protected[this] def reversed: List[B] +class GroupedIterator[B <: <?>] extends AbstractIterator[Seq[B]] with Iterator[Seq[B]] +def +(other: String): String +def ++[B >: B](that: => scala.collection.GenTraversableOnce[B]): Iterator[B] +def ->[B](y: B): (java.util.Iterator[B], B) +def /:[B](z: B)(op: (B, B) => B): B +def :\[B](z: B)(op: (B, B) => B): B +def addString(b: StringBuilder): StringBuilder +def addString(b: StringBuilder,sep: String): StringBuilder +def addString(b: StringBuilder,start: String,sep: String,end: String): StringBuilder +def aggregate[B](z: => B)(seqop: (B, B) => B,combop: (B, B) => B): B +def buffered: scala.collection.BufferedIterator[B] +def collectFirst[B](pf: PartialFunction[B,B]): Option[B] +def collect[B](pf: PartialFunction[B,B]): Iterator[B] +def contains(elem: Any): Boolean +def copyToArray[B >: B](xs: Array[B]): Unit +def copyToArray[B >: B](xs: Array[B],start: Int): Unit +def copyToArray[B >: B](xs: Array[B],start: Int,len: Int): Unit +def copyToBuffer[B >: B](dest: scala.collection.mutable.Buffer[B]): Unit +def corresponds[B](that: scala.collection.GenTraversableOnce[B])(p: (B, B) => Boolean): Boolean +def count(p: B => Boolean): Int +def drop(n: Int): Iterator[B] +def dropWhile(p: B => Boolean): Iterator[B] +def duplicate: (Iterator[B], Iterator[B]) +def ensuring(cond: Boolean): java.util.Iterator[B] +def ensuring(cond: Boolean,msg: => Any): java.util.Iterator[B] +def ensuring(cond: java.util.Iterator[B] => Boolean): java.util.Iterator[B] +def ensuring(cond: java.util.Iterator[B] => Boolean,msg: => Any): java.util.Iterator[B] +def equals(x$1: Any): Boolean +def exists(p: B => Boolean): Boolean +def filter(p: B => Boolean): Iterator[B] +def filterNot(p: B => Boolean): Iterator[B] +def find(p: B => Boolean): Option[B] +def flatMap[B](f: B => scala.collection.GenTraversableOnce[B]): Iterator[B] +def foldLeft[B](z: B)(op: (B, B) => B): B +def foldRight[B](z: B)(op: (B, B) => B): B +def fold[A1 >: B](z: A1)(op: (A1, A1) => A1): A1 +def forall(p: B => Boolean): Boolean +def foreach[U](f: B => U): Unit +def formatted(fmtstr: String): String +def grouped[B >: B](size: Int): Iterator[B]#GroupedIterator[B] +def hasDefiniteSize: Boolean +def hasNext(): Boolean +def hashCode(): Int +def indexOf[B >: B](elem: B): Int +def indexWhere(p: B => Boolean): Int +def isEmpty: Boolean +def isTraversableAgain: Boolean +def length: Int +def map[B](f: B => B): Iterator[B] +def maxBy[B](f: B => B)(implicit cmp: Ordering[B]): B +def max[B >: B](implicit cmp: Ordering[B]): B +def minBy[B](f: B => B)(implicit cmp: Ordering[B]): B +def min[B >: B](implicit cmp: Ordering[B]): B +def mkString(sep: String): String +def mkString(start: String,sep: String,end: String): String +def mkString: String +def next(): B +def nonEmpty: Boolean +def padTo[A1 >: B](len: Int,elem: A1): Iterator[A1] +def partition(p: B => Boolean): (Iterator[B], Iterator[B]) +def patch[B >: B](from: Int,patchElems: Iterator[B],replaced: Int): Iterator[B] +def product[B >: B](implicit num: Numeric[B]): B +def reduceLeftOption[B >: B](op: (B, B) => B): Option[B] +def reduceLeft[B >: B](op: (B, B) => B): B +def reduceOption[A1 >: B](op: (A1, A1) => A1): Option[A1] +def reduceRightOption[B >: B](op: (B, B) => B): Option[B] +def reduceRight[B >: B](op: (B, B) => B): B +def reduce[A1 >: B](op: (A1, A1) => A1): A1 +def remove(): Unit +def sameElements(that: Iterator[_]): Boolean +def scanLeft[B](z: B)(op: (B, B) => B): Iterator[B] +def scanRight[B](z: B)(op: (B, B) => B): Iterator[B] +def seq: Iterator[B] +def size: Int +def slice(from: Int,until: Int): Iterator[B] +def sliding[B >: B](size: Int,step: Int): Iterator[B]#GroupedIterator[B] +def span(p: B => Boolean): (Iterator[B], Iterator[B]) +def sum[B >: B](implicit num: Numeric[B]): B +def take(n: Int): Iterator[B] +def takeWhile(p: B => Boolean): Iterator[B] +def toArray[B >: B](implicit evidence$1: scala.reflect.ClassTag[B]): Array[B] +def toBuffer[B >: B]: scala.collection.mutable.Buffer[B] +def toIndexedSeq: scala.collection.immutable.IndexedSeq[B] +def toIterable: Iterable[B] +def toIterator: Iterator[B] +def toList: List[B] +def toMap[T, U](implicit ev: <:<[B,(T, U)]): scala.collection.immutable.Map[T,U] +def toSeq: Seq[B] +def toSet[B >: B]: scala.collection.immutable.Set[B] +def toStream: scala.collection.immutable.Stream[B] +def toString(): String +def toTraversable: Traversable[B] +def toVector: Vector[B] +def to[Col[_]](implicit cbf: scala.collection.generic.CanBuildFrom[Nothing,B,Col[B]]): Col[B] +def withFilter(p: B => Boolean): Iterator[B] +def zipAll[B, A1 >: B, B1 >: B](that: Iterator[B],thisElem: A1,thatElem: B1): Iterator[(A1, B1)] +def zipWithIndex: Iterator[(B, Int)] +def zip[B](that: Iterator[B]): Iterator[(B, B)] +def →[B](y: B): (java.util.Iterator[B], B) +final def !=(x$1: Any): Boolean +final def !=(x$1: AnyRef): Boolean +final def ##(): Int +final def ==(x$1: Any): Boolean +final def ==(x$1: AnyRef): Boolean +final def asInstanceOf[T0]: T0 +final def eq(x$1: AnyRef): Boolean +final def isInstanceOf[T0]: Boolean +final def ne(x$1: AnyRef): Boolean +final def notify(): Unit +final def notifyAll(): Unit +final def synchronized[T0](x$1: T0): T0 +final def wait(): Unit +final def wait(x$1: Long): Unit +final def wait(x$1: Long,x$2: Int): Unit +private[this] val __leftOfArrow: java.util.Iterator[B] +private[this] val __resultOfEnsuring: java.util.Iterator[B] +private[this] val __stringToFormat: java.util.Iterator[B] +private[this] val __thingToAdd: java.util.Iterator[B] ================================================================================ diff --git a/test/files/presentation/implicit-member.check b/test/files/presentation/implicit-member.check index 6a23facc78..92d8e38abe 100644 --- a/test/files/presentation/implicit-member.check +++ b/test/files/presentation/implicit-member.check @@ -2,41 +2,41 @@ reload: ImplicitMember.scala askTypeCompletion at ImplicitMember.scala(7,7) ================================================================================ -[response] aksTypeCompletion at (7,7) +[response] askCompletionAt (7,7) retrieved 38 members -[accessible: true] `class AppliedImplicitImplicit.AppliedImplicit` -[accessible: true] `method !=(x$1: Any)Boolean` -[accessible: true] `method !=(x$1: AnyRef)Boolean` -[accessible: true] `method ##()Int` -[accessible: true] `method +(other: String)String` -[accessible: true] `method ->[B](y: B)(Implicit.type, B)` -[accessible: true] `method ==(x$1: Any)Boolean` -[accessible: true] `method ==(x$1: AnyRef)Boolean` -[accessible: true] `method AppliedImplicit[A](x: A)Implicit.AppliedImplicit[A]` -[accessible: true] `method asInstanceOf[T0]=> T0` -[accessible: true] `method clone()Object` -[accessible: true] `method ensuring(cond: Boolean)Implicit.type` -[accessible: true] `method ensuring(cond: Boolean, msg: => Any)Implicit.type` -[accessible: true] `method ensuring(cond: Implicit.type => Boolean)Implicit.type` -[accessible: true] `method ensuring(cond: Implicit.type => Boolean, msg: => Any)Implicit.type` -[accessible: true] `method eq(x$1: AnyRef)Boolean` -[accessible: true] `method equals(x$1: Any)Boolean` -[accessible: true] `method finalize()Unit` -[accessible: true] `method formatted(fmtstr: String)String` -[accessible: true] `method hashCode()Int` -[accessible: true] `method isInstanceOf[T0]=> Boolean` -[accessible: true] `method ne(x$1: AnyRef)Boolean` -[accessible: true] `method notify()Unit` -[accessible: true] `method notifyAll()Unit` -[accessible: true] `method synchronized[T0](x$1: T0)T0` -[accessible: true] `method toString()String` -[accessible: true] `method wait()Unit` -[accessible: true] `method wait(x$1: Long)Unit` -[accessible: true] `method wait(x$1: Long, x$2: Int)Unit` -[accessible: true] `method →[B](y: B)(Implicit.type, B)` -[accessible: true] `value __leftOfArrowImplicit.type` -[accessible: true] `value __resultOfEnsuringImplicit.type` -[accessible: true] `value __stringToFormatImplicit.type` -[accessible: true] `value __thingToAddImplicit.type` -[accessible: true] `value xImplicit.type` +def +(other: String): String +def ->[B](y: B): (Implicit.type, B) +def ensuring(cond: Boolean): Implicit.type +def ensuring(cond: Boolean,msg: => Any): Implicit.type +def ensuring(cond: Implicit.type => Boolean): Implicit.type +def ensuring(cond: Implicit.type => Boolean,msg: => Any): Implicit.type +def equals(x$1: Any): Boolean +def formatted(fmtstr: String): String +def hashCode(): Int +def toString(): String +def →[B](y: B): (Implicit.type, B) +final class AppliedImplicit[A <: <?>] extends AnyRef +final def !=(x$1: Any): Boolean +final def !=(x$1: AnyRef): Boolean +final def ##(): Int +final def ==(x$1: Any): Boolean +final def ==(x$1: AnyRef): Boolean +final def asInstanceOf[T0]: T0 +final def eq(x$1: AnyRef): Boolean +final def isInstanceOf[T0]: Boolean +final def ne(x$1: AnyRef): Boolean +final def notify(): Unit +final def notifyAll(): Unit +final def synchronized[T0](x$1: T0): T0 +final def wait(): Unit +final def wait(x$1: Long): Unit +final def wait(x$1: Long,x$2: Int): Unit +implicit def AppliedImplicit[A](x: A): Implicit.AppliedImplicit[A] +private[this] val __leftOfArrow: Implicit.type +private[this] val __resultOfEnsuring: Implicit.type +private[this] val __stringToFormat: Implicit.type +private[this] val __thingToAdd: Implicit.type +private[this] val x: Implicit.type +protected[package lang] def clone(): Object +protected[package lang] def finalize(): Unit ================================================================================ diff --git a/test/files/presentation/ping-pong.check b/test/files/presentation/ping-pong.check index c7a5d0b5d1..be80601e11 100644 --- a/test/files/presentation/ping-pong.check +++ b/test/files/presentation/ping-pong.check @@ -2,101 +2,101 @@ reload: PingPong.scala askTypeCompletion at PingPong.scala(10,23) ================================================================================ -[response] aksTypeCompletion at (10,23) +[response] askCompletionAt (10,23) retrieved 39 members -[accessible: true] `method !=(x$1: Any)Boolean` -[accessible: true] `method !=(x$1: AnyRef)Boolean` -[accessible: true] `method ##()Int` -[accessible: true] `method +(other: String)String` -[accessible: true] `method ->[B](y: B)(Pong, B)` -[accessible: true] `method ==(x$1: Any)Boolean` -[accessible: true] `method ==(x$1: AnyRef)Boolean` -[accessible: true] `method asInstanceOf[T0]=> T0` -[accessible: true] `method ensuring(cond: Boolean)Pong` -[accessible: true] `method ensuring(cond: Boolean, msg: => Any)Pong` -[accessible: true] `method ensuring(cond: Pong => Boolean)Pong` -[accessible: true] `method ensuring(cond: Pong => Boolean, msg: => Any)Pong` -[accessible: true] `method eq(x$1: AnyRef)Boolean` -[accessible: true] `method equals(x$1: Any)Boolean` -[accessible: true] `method formatted(fmtstr: String)String` -[accessible: true] `method hashCode()Int` -[accessible: true] `method isInstanceOf[T0]=> Boolean` -[accessible: true] `method ne(x$1: AnyRef)Boolean` -[accessible: true] `method notify()Unit` -[accessible: true] `method notifyAll()Unit` -[accessible: true] `method poke()Unit` -[accessible: true] `method synchronized[T0](x$1: T0)T0` -[accessible: true] `method toString()String` -[accessible: true] `method wait()Unit` -[accessible: true] `method wait(x$1: Long)Unit` -[accessible: true] `method wait(x$1: Long, x$2: Int)Unit` -[accessible: true] `method →[B](y: B)(Pong, B)` -[accessible: true] `value __leftOfArrowPong` -[accessible: true] `value __resultOfEnsuringPong` -[accessible: true] `value __stringToFormatPong` -[accessible: true] `value __thingToAddPong` -[accessible: true] `value nameString` -[accessible: false] `method clone()Object` -[accessible: false] `method finalize()Unit` -[accessible: false] `value pingPing` +[inaccessible] private[this] val ping: Ping +[inaccessible] protected[package lang] def clone(): Object +[inaccessible] protected[package lang] def finalize(): Unit +def +(other: String): String +def ->[B](y: B): (Pong, B) +def ensuring(cond: Boolean): Pong +def ensuring(cond: Boolean,msg: => Any): Pong +def ensuring(cond: Pong => Boolean): Pong +def ensuring(cond: Pong => Boolean,msg: => Any): Pong +def equals(x$1: Any): Boolean +def formatted(fmtstr: String): String +def hashCode(): Int +def poke(): Unit +def →[B](y: B): (Pong, B) +final def !=(x$1: Any): Boolean +final def !=(x$1: AnyRef): Boolean +final def ##(): Int +final def ==(x$1: Any): Boolean +final def ==(x$1: AnyRef): Boolean +final def asInstanceOf[T0]: T0 +final def eq(x$1: AnyRef): Boolean +final def isInstanceOf[T0]: Boolean +final def ne(x$1: AnyRef): Boolean +final def notify(): Unit +final def notifyAll(): Unit +final def synchronized[T0](x$1: T0): T0 +final def wait(): Unit +final def wait(x$1: Long): Unit +final def wait(x$1: Long,x$2: Int): Unit +override def toString(): String +private[this] val __leftOfArrow: Pong +private[this] val __resultOfEnsuring: Pong +private[this] val __stringToFormat: Pong +private[this] val __thingToAdd: Pong +private[this] val name: String ================================================================================ askTypeCompletion at PingPong.scala(19,20) ================================================================================ -[response] aksTypeCompletion at (19,20) +[response] askCompletionAt (19,20) retrieved 39 members -[accessible: true] `method !=(x$1: Any)Boolean` -[accessible: true] `method !=(x$1: AnyRef)Boolean` -[accessible: true] `method ##()Int` -[accessible: true] `method +(other: String)String` -[accessible: true] `method ->[B](y: B)(Ping, B)` -[accessible: true] `method ==(x$1: Any)Boolean` -[accessible: true] `method ==(x$1: AnyRef)Boolean` -[accessible: true] `method asInstanceOf[T0]=> T0` -[accessible: true] `method ensuring(cond: Boolean)Ping` -[accessible: true] `method ensuring(cond: Boolean, msg: => Any)Ping` -[accessible: true] `method ensuring(cond: Ping => Boolean)Ping` -[accessible: true] `method ensuring(cond: Ping => Boolean, msg: => Any)Ping` -[accessible: true] `method eq(x$1: AnyRef)Boolean` -[accessible: true] `method equals(x$1: Any)Boolean` -[accessible: true] `method formatted(fmtstr: String)String` -[accessible: true] `method hashCode()Int` -[accessible: true] `method isInstanceOf[T0]=> Boolean` -[accessible: true] `method loop=> Unit` -[accessible: true] `method name=> String` -[accessible: true] `method ne(x$1: AnyRef)Boolean` -[accessible: true] `method notify()Unit` -[accessible: true] `method notifyAll()Unit` -[accessible: true] `method poke=> Unit` -[accessible: true] `method synchronized[T0](x$1: T0)T0` -[accessible: true] `method toString()String` -[accessible: true] `method wait()Unit` -[accessible: true] `method wait(x$1: Long)Unit` -[accessible: true] `method wait(x$1: Long, x$2: Int)Unit` -[accessible: true] `method →[B](y: B)(Ping, B)` -[accessible: true] `value __leftOfArrowPing` -[accessible: true] `value __resultOfEnsuringPing` -[accessible: true] `value __stringToFormatPing` -[accessible: true] `value __thingToAddPing` -[accessible: true] `value pongPong` -[accessible: false] `method clone()Object` -[accessible: false] `method finalize()Unit` +[inaccessible] protected[package lang] def clone(): Object +[inaccessible] protected[package lang] def finalize(): Unit +def +(other: String): String +def ->[B](y: B): (Ping, B) +def ensuring(cond: Boolean): Ping +def ensuring(cond: Boolean,msg: => Any): Ping +def ensuring(cond: Ping => Boolean): Ping +def ensuring(cond: Ping => Boolean,msg: => Any): Ping +def equals(x$1: Any): Boolean +def formatted(fmtstr: String): String +def hashCode(): Int +def loop: Unit +def name: String +def poke: Unit +def →[B](y: B): (Ping, B) +final def !=(x$1: Any): Boolean +final def !=(x$1: AnyRef): Boolean +final def ##(): Int +final def ==(x$1: Any): Boolean +final def ==(x$1: AnyRef): Boolean +final def asInstanceOf[T0]: T0 +final def eq(x$1: AnyRef): Boolean +final def isInstanceOf[T0]: Boolean +final def ne(x$1: AnyRef): Boolean +final def notify(): Unit +final def notifyAll(): Unit +final def synchronized[T0](x$1: T0): T0 +final def wait(): Unit +final def wait(x$1: Long): Unit +final def wait(x$1: Long,x$2: Int): Unit +override def toString(): String +private[this] val __leftOfArrow: Ping +private[this] val __resultOfEnsuring: Ping +private[this] val __stringToFormat: Ping +private[this] val __thingToAdd: Ping +private[this] val pong: Pong ================================================================================ askType at PingPong.scala(8,10) ================================================================================ -[response] askTypeAt at (8,10) +[response] askTypeAt (8,10) def loop: Unit = Ping.this.poke() ================================================================================ askType at PingPong.scala(10,10) ================================================================================ -[response] askTypeAt at (10,10) +[response] askTypeAt (10,10) def poke: Unit = Ping.this.pong.poke() ================================================================================ askType at PingPong.scala(17,10) ================================================================================ -[response] askTypeAt at (17,10) +[response] askTypeAt (17,10) private[this] val name: String = "pong" ================================================================================ diff --git a/test/files/presentation/random.check b/test/files/presentation/random.check index fce4b69fb3..fb3500aeea 100644 --- a/test/files/presentation/random.check +++ b/test/files/presentation/random.check @@ -2,7 +2,7 @@ reload: Random.scala askType at Random.scala(18,14) ================================================================================ -[response] askTypeAt at (18,14) +[response] askTypeAt (18,14) val filter: Int => Boolean = try { java.this.lang.Integer.parseInt(args.apply(0)) match { case 1 => ((x: Int) => x.%(2).!=(0)) @@ -16,12 +16,12 @@ val filter: Int => Boolean = try { askType at Random.scala(19,30) ================================================================================ -[response] askTypeAt at (19,30) +[response] askTypeAt (19,30) 0 ================================================================================ askType at Random.scala(26,12) ================================================================================ -[response] askTypeAt at (26,12) +[response] askTypeAt (26,12) _ ================================================================================ diff --git a/test/files/presentation/t1207.check b/test/files/presentation/t1207.check new file mode 100644 index 0000000000..84bfd79d75 --- /dev/null +++ b/test/files/presentation/t1207.check @@ -0,0 +1,53 @@ +reload: Completions.scala + +askTypeCompletion at Completions.scala(10,15) +================================================================================ +[response] askCompletionAt (10,15) +retrieved 3 members +final package bongo +final package lang +final package util +================================================================================ + +askTypeCompletion at Completions.scala(11,16) +================================================================================ +[response] askCompletionAt (11,16) +retrieved 3 members +final package bongo +final package lang +final package util +================================================================================ + +askTypeCompletion at Completions.scala(12,19) +================================================================================ +[response] askCompletionAt (12,19) +retrieved 3 members +final package bongo +final package lang +final package util +================================================================================ + +askTypeCompletion at Completions.scala(13,19) +================================================================================ +[response] askCompletionAt (13,19) +retrieved 3 members +final package bongo +final package lang +final package util +================================================================================ + +askTypeCompletion at Completions.scala(14,23) +================================================================================ +[response] askCompletionAt (14,23) +retrieved 3 members +final package bongo +final package lang +final package util +================================================================================ + +askTypeCompletion at Completions.scala(15,10) +================================================================================ +[response] askCompletionAt (15,10) +retrieved 0 members + +================================================================================ diff --git a/test/files/presentation/t1207/Test.scala b/test/files/presentation/t1207/Test.scala new file mode 100644 index 0000000000..bec1131c4c --- /dev/null +++ b/test/files/presentation/t1207/Test.scala @@ -0,0 +1,3 @@ +import scala.tools.nsc.interactive.tests.InteractiveTest + +object Test extends InteractiveTest
\ No newline at end of file diff --git a/test/files/presentation/t1207/src/Completions.scala b/test/files/presentation/t1207/src/Completions.scala new file mode 100644 index 0000000000..804d4fdc3d --- /dev/null +++ b/test/files/presentation/t1207/src/Completions.scala @@ -0,0 +1,20 @@ +package other { + package bongo { } + package lang { } + package util { + package boogly + } +} + +package ticket_1001207 { + import other./*!*/ + import other.u/*!*/ + import other.uti /*!*/ + import other.util/*!*/ + import other.{lang, u/*!*/} + import j/*!*/ + + class T1207 { + + } +} diff --git a/test/files/presentation/t5708.check b/test/files/presentation/t5708.check index 4fc7a56426..b2cedd689f 100644 --- a/test/files/presentation/t5708.check +++ b/test/files/presentation/t5708.check @@ -2,46 +2,46 @@ reload: Completions.scala askTypeCompletion at Completions.scala(17,9) ================================================================================ -[response] aksTypeCompletion at (17,9) +[response] askCompletionAt (17,9) retrieved 43 members -[accessible: true] `lazy value fooInt` -[accessible: true] `method !=(x$1: Any)Boolean` -[accessible: true] `method !=(x$1: AnyRef)Boolean` -[accessible: true] `method ##()Int` -[accessible: true] `method +(other: String)String` -[accessible: true] `method ->[B](y: B)(test.Compat.type, B)` -[accessible: true] `method ==(x$1: Any)Boolean` -[accessible: true] `method ==(x$1: AnyRef)Boolean` -[accessible: true] `method asInstanceOf[T0]=> T0` -[accessible: true] `method ensuring(cond: Boolean)test.Compat.type` -[accessible: true] `method ensuring(cond: Boolean, msg: => Any)test.Compat.type` -[accessible: true] `method ensuring(cond: test.Compat.type => Boolean)test.Compat.type` -[accessible: true] `method ensuring(cond: test.Compat.type => Boolean, msg: => Any)test.Compat.type` -[accessible: true] `method eq(x$1: AnyRef)Boolean` -[accessible: true] `method equals(x$1: Any)Boolean` -[accessible: true] `method formatted(fmtstr: String)String` -[accessible: true] `method hashCode()Int` -[accessible: true] `method isInstanceOf[T0]=> Boolean` -[accessible: true] `method ne(x$1: AnyRef)Boolean` -[accessible: true] `method notify()Unit` -[accessible: true] `method notifyAll()Unit` -[accessible: true] `method pkgPrivateM=> String` -[accessible: true] `method synchronized[T0](x$1: T0)T0` -[accessible: true] `method toString()String` -[accessible: true] `method wait()Unit` -[accessible: true] `method wait(x$1: Long)Unit` -[accessible: true] `method wait(x$1: Long, x$2: Int)Unit` -[accessible: true] `method →[B](y: B)(test.Compat.type, B)` -[accessible: true] `value CONST_STRINGString("constant")` -[accessible: true] `value __leftOfArrowtest.Compat.type` -[accessible: true] `value __resultOfEnsuringtest.Compat.type` -[accessible: true] `value __stringToFormattest.Compat.type` -[accessible: true] `value __thingToAddtest.Compat.type` -[accessible: true] `value pkgPrivateVString` -[accessible: false] `method clone()Object` -[accessible: false] `method finalize()Unit` -[accessible: false] `method privateM=> String` -[accessible: false] `method protectedValM=> String` -[accessible: false] `value privateVString` -[accessible: false] `value protectedVString` +[inaccessible] private def privateM: String +[inaccessible] private[this] val privateV: String +[inaccessible] private[this] val protectedV: String +[inaccessible] protected def protectedValM: String +[inaccessible] protected[package lang] def clone(): Object +[inaccessible] protected[package lang] def finalize(): Unit +def +(other: String): String +def ->[B](y: B): (test.Compat.type, B) +def ensuring(cond: Boolean): test.Compat.type +def ensuring(cond: Boolean,msg: => Any): test.Compat.type +def ensuring(cond: test.Compat.type => Boolean): test.Compat.type +def ensuring(cond: test.Compat.type => Boolean,msg: => Any): test.Compat.type +def equals(x$1: Any): Boolean +def formatted(fmtstr: String): String +def hashCode(): Int +def toString(): String +def →[B](y: B): (test.Compat.type, B) +final def !=(x$1: Any): Boolean +final def !=(x$1: AnyRef): Boolean +final def ##(): Int +final def ==(x$1: Any): Boolean +final def ==(x$1: AnyRef): Boolean +final def asInstanceOf[T0]: T0 +final def eq(x$1: AnyRef): Boolean +final def isInstanceOf[T0]: Boolean +final def ne(x$1: AnyRef): Boolean +final def notify(): Unit +final def notifyAll(): Unit +final def synchronized[T0](x$1: T0): T0 +final def wait(): Unit +final def wait(x$1: Long): Unit +final def wait(x$1: Long,x$2: Int): Unit +final private[this] val CONST_STRING: String("constant") +lazy private[this] var foo: Int +private[package test] def pkgPrivateM: String +private[this] val __leftOfArrow: test.Compat.type +private[this] val __resultOfEnsuring: test.Compat.type +private[this] val __stringToFormat: test.Compat.type +private[this] val __thingToAdd: test.Compat.type +private[this] val pkgPrivateV: String ================================================================================ diff --git a/test/files/presentation/visibility.check b/test/files/presentation/visibility.check index e9b349ac06..4ba7dbaad9 100644 --- a/test/files/presentation/visibility.check +++ b/test/files/presentation/visibility.check @@ -2,220 +2,220 @@ reload: Completions.scala askTypeCompletion at Completions.scala(14,12) ================================================================================ -[response] aksTypeCompletion at (14,12) +[response] askCompletionAt (14,12) retrieved 41 members -[accessible: true] `method !=(x$1: Any)Boolean` -[accessible: true] `method !=(x$1: AnyRef)Boolean` -[accessible: true] `method ##()Int` -[accessible: true] `method +(other: String)String` -[accessible: true] `method ->[B](y: B)(accessibility.Foo, B)` -[accessible: true] `method ==(x$1: Any)Boolean` -[accessible: true] `method ==(x$1: AnyRef)Boolean` -[accessible: true] `method asInstanceOf[T0]=> T0` -[accessible: true] `method clone()Object` -[accessible: true] `method ensuring(cond: Boolean)accessibility.Foo` -[accessible: true] `method ensuring(cond: Boolean, msg: => Any)accessibility.Foo` -[accessible: true] `method ensuring(cond: accessibility.Foo => Boolean)accessibility.Foo` -[accessible: true] `method ensuring(cond: accessibility.Foo => Boolean, msg: => Any)accessibility.Foo` -[accessible: true] `method eq(x$1: AnyRef)Boolean` -[accessible: true] `method equals(x$1: Any)Boolean` -[accessible: true] `method finalize()Unit` -[accessible: true] `method formatted(fmtstr: String)String` -[accessible: true] `method hashCode()Int` -[accessible: true] `method isInstanceOf[T0]=> Boolean` -[accessible: true] `method ne(x$1: AnyRef)Boolean` -[accessible: true] `method notify()Unit` -[accessible: true] `method notifyAll()Unit` -[accessible: true] `method secretPrivate()Unit` -[accessible: true] `method secretProtected()Unit` -[accessible: true] `method secretProtectedInPackage()Unit` -[accessible: true] `method secretPublic()Unit` -[accessible: true] `method someTests(other: accessibility.Foo)Unit` -[accessible: true] `method synchronized[T0](x$1: T0)T0` -[accessible: true] `method toString()String` -[accessible: true] `method wait()Unit` -[accessible: true] `method wait(x$1: Long)Unit` -[accessible: true] `method wait(x$1: Long, x$2: Int)Unit` -[accessible: true] `method →[B](y: B)(accessibility.Foo, B)` -[accessible: true] `value __leftOfArrowaccessibility.Foo` -[accessible: true] `value __resultOfEnsuringaccessibility.Foo` -[accessible: true] `value __stringToFormataccessibility.Foo` -[accessible: true] `value __thingToAddaccessibility.Foo` -[accessible: false] `method secretPrivateThis()Unit` +[inaccessible] private[this] def secretPrivateThis(): Unit +def +(other: String): String +def ->[B](y: B): (accessibility.Foo, B) +def ensuring(cond: Boolean): accessibility.Foo +def ensuring(cond: Boolean,msg: => Any): accessibility.Foo +def ensuring(cond: accessibility.Foo => Boolean): accessibility.Foo +def ensuring(cond: accessibility.Foo => Boolean,msg: => Any): accessibility.Foo +def equals(x$1: Any): Boolean +def formatted(fmtstr: String): String +def hashCode(): Int +def secretPublic(): Unit +def someTests(other: accessibility.Foo): Unit +def toString(): String +def →[B](y: B): (accessibility.Foo, B) +final def !=(x$1: Any): Boolean +final def !=(x$1: AnyRef): Boolean +final def ##(): Int +final def ==(x$1: Any): Boolean +final def ==(x$1: AnyRef): Boolean +final def asInstanceOf[T0]: T0 +final def eq(x$1: AnyRef): Boolean +final def isInstanceOf[T0]: Boolean +final def ne(x$1: AnyRef): Boolean +final def notify(): Unit +final def notifyAll(): Unit +final def synchronized[T0](x$1: T0): T0 +final def wait(): Unit +final def wait(x$1: Long): Unit +final def wait(x$1: Long,x$2: Int): Unit +private def secretPrivate(): Unit +private[this] val __leftOfArrow: accessibility.Foo +private[this] val __resultOfEnsuring: accessibility.Foo +private[this] val __stringToFormat: accessibility.Foo +private[this] val __thingToAdd: accessibility.Foo +protected def secretProtected(): Unit +protected[package accessibility] def secretProtectedInPackage(): Unit +protected[package lang] def clone(): Object +protected[package lang] def finalize(): Unit ================================================================================ askTypeCompletion at Completions.scala(16,11) ================================================================================ -[response] aksTypeCompletion at (16,11) +[response] askCompletionAt (16,11) retrieved 41 members -[accessible: true] `method !=(x$1: Any)Boolean` -[accessible: true] `method !=(x$1: AnyRef)Boolean` -[accessible: true] `method ##()Int` -[accessible: true] `method +(other: String)String` -[accessible: true] `method ->[B](y: B)(accessibility.Foo, B)` -[accessible: true] `method ==(x$1: Any)Boolean` -[accessible: true] `method ==(x$1: AnyRef)Boolean` -[accessible: true] `method asInstanceOf[T0]=> T0` -[accessible: true] `method clone()Object` -[accessible: true] `method ensuring(cond: Boolean)accessibility.Foo` -[accessible: true] `method ensuring(cond: Boolean, msg: => Any)accessibility.Foo` -[accessible: true] `method ensuring(cond: accessibility.Foo => Boolean)accessibility.Foo` -[accessible: true] `method ensuring(cond: accessibility.Foo => Boolean, msg: => Any)accessibility.Foo` -[accessible: true] `method eq(x$1: AnyRef)Boolean` -[accessible: true] `method equals(x$1: Any)Boolean` -[accessible: true] `method finalize()Unit` -[accessible: true] `method formatted(fmtstr: String)String` -[accessible: true] `method hashCode()Int` -[accessible: true] `method isInstanceOf[T0]=> Boolean` -[accessible: true] `method ne(x$1: AnyRef)Boolean` -[accessible: true] `method notify()Unit` -[accessible: true] `method notifyAll()Unit` -[accessible: true] `method secretPrivate()Unit` -[accessible: true] `method secretPrivateThis()Unit` -[accessible: true] `method secretProtected()Unit` -[accessible: true] `method secretProtectedInPackage()Unit` -[accessible: true] `method secretPublic()Unit` -[accessible: true] `method someTests(other: accessibility.Foo)Unit` -[accessible: true] `method synchronized[T0](x$1: T0)T0` -[accessible: true] `method toString()String` -[accessible: true] `method wait()Unit` -[accessible: true] `method wait(x$1: Long)Unit` -[accessible: true] `method wait(x$1: Long, x$2: Int)Unit` -[accessible: true] `method →[B](y: B)(accessibility.Foo, B)` -[accessible: true] `value __leftOfArrowaccessibility.Foo` -[accessible: true] `value __resultOfEnsuringaccessibility.Foo` -[accessible: true] `value __stringToFormataccessibility.Foo` -[accessible: true] `value __thingToAddaccessibility.Foo` +def +(other: String): String +def ->[B](y: B): (accessibility.Foo, B) +def ensuring(cond: Boolean): accessibility.Foo +def ensuring(cond: Boolean,msg: => Any): accessibility.Foo +def ensuring(cond: accessibility.Foo => Boolean): accessibility.Foo +def ensuring(cond: accessibility.Foo => Boolean,msg: => Any): accessibility.Foo +def equals(x$1: Any): Boolean +def formatted(fmtstr: String): String +def hashCode(): Int +def secretPublic(): Unit +def someTests(other: accessibility.Foo): Unit +def toString(): String +def →[B](y: B): (accessibility.Foo, B) +final def !=(x$1: Any): Boolean +final def !=(x$1: AnyRef): Boolean +final def ##(): Int +final def ==(x$1: Any): Boolean +final def ==(x$1: AnyRef): Boolean +final def asInstanceOf[T0]: T0 +final def eq(x$1: AnyRef): Boolean +final def isInstanceOf[T0]: Boolean +final def ne(x$1: AnyRef): Boolean +final def notify(): Unit +final def notifyAll(): Unit +final def synchronized[T0](x$1: T0): T0 +final def wait(): Unit +final def wait(x$1: Long): Unit +final def wait(x$1: Long,x$2: Int): Unit +private def secretPrivate(): Unit +private[this] def secretPrivateThis(): Unit +private[this] val __leftOfArrow: accessibility.Foo +private[this] val __resultOfEnsuring: accessibility.Foo +private[this] val __stringToFormat: accessibility.Foo +private[this] val __thingToAdd: accessibility.Foo +protected def secretProtected(): Unit +protected[package accessibility] def secretProtectedInPackage(): Unit +protected[package lang] def clone(): Object +protected[package lang] def finalize(): Unit ================================================================================ askTypeCompletion at Completions.scala(22,11) ================================================================================ -[response] aksTypeCompletion at (22,11) +[response] askCompletionAt (22,11) retrieved 41 members -[accessible: true] `method !=(x$1: Any)Boolean` -[accessible: true] `method !=(x$1: AnyRef)Boolean` -[accessible: true] `method ##()Int` -[accessible: true] `method +(other: String)String` -[accessible: true] `method ->[B](y: B)(accessibility.AccessibilityChecks, B)` -[accessible: true] `method ==(x$1: Any)Boolean` -[accessible: true] `method ==(x$1: AnyRef)Boolean` -[accessible: true] `method asInstanceOf[T0]=> T0` -[accessible: true] `method clone()Object` -[accessible: true] `method ensuring(cond: Boolean)accessibility.AccessibilityChecks` -[accessible: true] `method ensuring(cond: Boolean, msg: => Any)accessibility.AccessibilityChecks` -[accessible: true] `method ensuring(cond: accessibility.AccessibilityChecks => Boolean)accessibility.AccessibilityChecks` -[accessible: true] `method ensuring(cond: accessibility.AccessibilityChecks => Boolean, msg: => Any)accessibility.AccessibilityChecks` -[accessible: true] `method eq(x$1: AnyRef)Boolean` -[accessible: true] `method equals(x$1: Any)Boolean` -[accessible: true] `method finalize()Unit` -[accessible: true] `method formatted(fmtstr: String)String` -[accessible: true] `method hashCode()Int` -[accessible: true] `method isInstanceOf[T0]=> Boolean` -[accessible: true] `method ne(x$1: AnyRef)Boolean` -[accessible: true] `method notify()Unit` -[accessible: true] `method notifyAll()Unit` -[accessible: true] `method secretProtected()Unit` -[accessible: true] `method secretProtectedInPackage()Unit` -[accessible: true] `method secretPublic()Unit` -[accessible: true] `method someTests(other: accessibility.Foo)Unit` -[accessible: true] `method someTests=> Unit` -[accessible: true] `method synchronized[T0](x$1: T0)T0` -[accessible: true] `method toString()String` -[accessible: true] `method wait()Unit` -[accessible: true] `method wait(x$1: Long)Unit` -[accessible: true] `method wait(x$1: Long, x$2: Int)Unit` -[accessible: true] `method →[B](y: B)(accessibility.AccessibilityChecks, B)` -[accessible: true] `value __leftOfArrowaccessibility.AccessibilityChecks` -[accessible: true] `value __resultOfEnsuringaccessibility.AccessibilityChecks` -[accessible: true] `value __stringToFormataccessibility.AccessibilityChecks` -[accessible: true] `value __thingToAddaccessibility.AccessibilityChecks` -[accessible: false] `method secretPrivate()Unit` +[inaccessible] private def secretPrivate(): Unit +def +(other: String): String +def ->[B](y: B): (accessibility.AccessibilityChecks, B) +def ensuring(cond: Boolean): accessibility.AccessibilityChecks +def ensuring(cond: Boolean,msg: => Any): accessibility.AccessibilityChecks +def ensuring(cond: accessibility.AccessibilityChecks => Boolean): accessibility.AccessibilityChecks +def ensuring(cond: accessibility.AccessibilityChecks => Boolean,msg: => Any): accessibility.AccessibilityChecks +def equals(x$1: Any): Boolean +def formatted(fmtstr: String): String +def hashCode(): Int +def secretPublic(): Unit +def someTests(other: accessibility.Foo): Unit +def someTests: Unit +def toString(): String +def →[B](y: B): (accessibility.AccessibilityChecks, B) +final def !=(x$1: Any): Boolean +final def !=(x$1: AnyRef): Boolean +final def ##(): Int +final def ==(x$1: Any): Boolean +final def ==(x$1: AnyRef): Boolean +final def asInstanceOf[T0]: T0 +final def eq(x$1: AnyRef): Boolean +final def isInstanceOf[T0]: Boolean +final def ne(x$1: AnyRef): Boolean +final def notify(): Unit +final def notifyAll(): Unit +final def synchronized[T0](x$1: T0): T0 +final def wait(): Unit +final def wait(x$1: Long): Unit +final def wait(x$1: Long,x$2: Int): Unit +private[this] val __leftOfArrow: accessibility.AccessibilityChecks +private[this] val __resultOfEnsuring: accessibility.AccessibilityChecks +private[this] val __stringToFormat: accessibility.AccessibilityChecks +private[this] val __thingToAdd: accessibility.AccessibilityChecks +protected def secretProtected(): Unit +protected[package accessibility] def secretProtectedInPackage(): Unit +protected[package lang] def clone(): Object +protected[package lang] def finalize(): Unit ================================================================================ askTypeCompletion at Completions.scala(28,10) ================================================================================ -[response] aksTypeCompletion at (28,10) +[response] askCompletionAt (28,10) retrieved 41 members -[accessible: true] `method !=(x$1: Any)Boolean` -[accessible: true] `method !=(x$1: AnyRef)Boolean` -[accessible: true] `method ##()Int` -[accessible: true] `method +(other: String)String` -[accessible: true] `method ->[B](y: B)(accessibility.Foo, B)` -[accessible: true] `method ==(x$1: Any)Boolean` -[accessible: true] `method ==(x$1: AnyRef)Boolean` -[accessible: true] `method asInstanceOf[T0]=> T0` -[accessible: true] `method ensuring(cond: Boolean)accessibility.Foo` -[accessible: true] `method ensuring(cond: Boolean, msg: => Any)accessibility.Foo` -[accessible: true] `method ensuring(cond: accessibility.Foo => Boolean)accessibility.Foo` -[accessible: true] `method ensuring(cond: accessibility.Foo => Boolean, msg: => Any)accessibility.Foo` -[accessible: true] `method eq(x$1: AnyRef)Boolean` -[accessible: true] `method equals(x$1: Any)Boolean` -[accessible: true] `method formatted(fmtstr: String)String` -[accessible: true] `method hashCode()Int` -[accessible: true] `method isInstanceOf[T0]=> Boolean` -[accessible: true] `method ne(x$1: AnyRef)Boolean` -[accessible: true] `method notify()Unit` -[accessible: true] `method notifyAll()Unit` -[accessible: true] `method secretProtectedInPackage()Unit` -[accessible: true] `method secretPublic()Unit` -[accessible: true] `method someTests(other: accessibility.Foo)Unit` -[accessible: true] `method synchronized[T0](x$1: T0)T0` -[accessible: true] `method toString()String` -[accessible: true] `method wait()Unit` -[accessible: true] `method wait(x$1: Long)Unit` -[accessible: true] `method wait(x$1: Long, x$2: Int)Unit` -[accessible: true] `method →[B](y: B)(accessibility.Foo, B)` -[accessible: true] `value __leftOfArrowaccessibility.Foo` -[accessible: true] `value __resultOfEnsuringaccessibility.Foo` -[accessible: true] `value __stringToFormataccessibility.Foo` -[accessible: true] `value __thingToAddaccessibility.Foo` -[accessible: false] `method clone()Object` -[accessible: false] `method finalize()Unit` -[accessible: false] `method secretPrivate()Unit` -[accessible: false] `method secretPrivateThis()Unit` -[accessible: false] `method secretProtected()Unit` +[inaccessible] private def secretPrivate(): Unit +[inaccessible] private[this] def secretPrivateThis(): Unit +[inaccessible] protected def secretProtected(): Unit +[inaccessible] protected[package lang] def clone(): Object +[inaccessible] protected[package lang] def finalize(): Unit +def +(other: String): String +def ->[B](y: B): (accessibility.Foo, B) +def ensuring(cond: Boolean): accessibility.Foo +def ensuring(cond: Boolean,msg: => Any): accessibility.Foo +def ensuring(cond: accessibility.Foo => Boolean): accessibility.Foo +def ensuring(cond: accessibility.Foo => Boolean,msg: => Any): accessibility.Foo +def equals(x$1: Any): Boolean +def formatted(fmtstr: String): String +def hashCode(): Int +def secretPublic(): Unit +def someTests(other: accessibility.Foo): Unit +def toString(): String +def →[B](y: B): (accessibility.Foo, B) +final def !=(x$1: Any): Boolean +final def !=(x$1: AnyRef): Boolean +final def ##(): Int +final def ==(x$1: Any): Boolean +final def ==(x$1: AnyRef): Boolean +final def asInstanceOf[T0]: T0 +final def eq(x$1: AnyRef): Boolean +final def isInstanceOf[T0]: Boolean +final def ne(x$1: AnyRef): Boolean +final def notify(): Unit +final def notifyAll(): Unit +final def synchronized[T0](x$1: T0): T0 +final def wait(): Unit +final def wait(x$1: Long): Unit +final def wait(x$1: Long,x$2: Int): Unit +private[this] val __leftOfArrow: accessibility.Foo +private[this] val __resultOfEnsuring: accessibility.Foo +private[this] val __stringToFormat: accessibility.Foo +private[this] val __thingToAdd: accessibility.Foo +protected[package accessibility] def secretProtectedInPackage(): Unit ================================================================================ askTypeCompletion at Completions.scala(37,8) ================================================================================ -[response] aksTypeCompletion at (37,8) +[response] askCompletionAt (37,8) retrieved 41 members -[accessible: true] `method !=(x$1: Any)Boolean` -[accessible: true] `method !=(x$1: AnyRef)Boolean` -[accessible: true] `method ##()Int` -[accessible: true] `method +(other: String)String` -[accessible: true] `method ->[B](y: B)(accessibility.Foo, B)` -[accessible: true] `method ==(x$1: Any)Boolean` -[accessible: true] `method ==(x$1: AnyRef)Boolean` -[accessible: true] `method asInstanceOf[T0]=> T0` -[accessible: true] `method ensuring(cond: Boolean)accessibility.Foo` -[accessible: true] `method ensuring(cond: Boolean, msg: => Any)accessibility.Foo` -[accessible: true] `method ensuring(cond: accessibility.Foo => Boolean)accessibility.Foo` -[accessible: true] `method ensuring(cond: accessibility.Foo => Boolean, msg: => Any)accessibility.Foo` -[accessible: true] `method eq(x$1: AnyRef)Boolean` -[accessible: true] `method equals(x$1: Any)Boolean` -[accessible: true] `method formatted(fmtstr: String)String` -[accessible: true] `method hashCode()Int` -[accessible: true] `method isInstanceOf[T0]=> Boolean` -[accessible: true] `method ne(x$1: AnyRef)Boolean` -[accessible: true] `method notify()Unit` -[accessible: true] `method notifyAll()Unit` -[accessible: true] `method secretPublic()Unit` -[accessible: true] `method someTests(other: accessibility.Foo)Unit` -[accessible: true] `method synchronized[T0](x$1: T0)T0` -[accessible: true] `method toString()String` -[accessible: true] `method wait()Unit` -[accessible: true] `method wait(x$1: Long)Unit` -[accessible: true] `method wait(x$1: Long, x$2: Int)Unit` -[accessible: true] `method →[B](y: B)(accessibility.Foo, B)` -[accessible: true] `value __leftOfArrowaccessibility.Foo` -[accessible: true] `value __resultOfEnsuringaccessibility.Foo` -[accessible: true] `value __stringToFormataccessibility.Foo` -[accessible: true] `value __thingToAddaccessibility.Foo` -[accessible: false] `method clone()Object` -[accessible: false] `method finalize()Unit` -[accessible: false] `method secretPrivate()Unit` -[accessible: false] `method secretPrivateThis()Unit` -[accessible: false] `method secretProtected()Unit` -[accessible: false] `method secretProtectedInPackage()Unit` +[inaccessible] private def secretPrivate(): Unit +[inaccessible] private[this] def secretPrivateThis(): Unit +[inaccessible] protected def secretProtected(): Unit +[inaccessible] protected[package accessibility] def secretProtectedInPackage(): Unit +[inaccessible] protected[package lang] def clone(): Object +[inaccessible] protected[package lang] def finalize(): Unit +def +(other: String): String +def ->[B](y: B): (accessibility.Foo, B) +def ensuring(cond: Boolean): accessibility.Foo +def ensuring(cond: Boolean,msg: => Any): accessibility.Foo +def ensuring(cond: accessibility.Foo => Boolean): accessibility.Foo +def ensuring(cond: accessibility.Foo => Boolean,msg: => Any): accessibility.Foo +def equals(x$1: Any): Boolean +def formatted(fmtstr: String): String +def hashCode(): Int +def secretPublic(): Unit +def someTests(other: accessibility.Foo): Unit +def toString(): String +def →[B](y: B): (accessibility.Foo, B) +final def !=(x$1: Any): Boolean +final def !=(x$1: AnyRef): Boolean +final def ##(): Int +final def ==(x$1: Any): Boolean +final def ==(x$1: AnyRef): Boolean +final def asInstanceOf[T0]: T0 +final def eq(x$1: AnyRef): Boolean +final def isInstanceOf[T0]: Boolean +final def ne(x$1: AnyRef): Boolean +final def notify(): Unit +final def notifyAll(): Unit +final def synchronized[T0](x$1: T0): T0 +final def wait(): Unit +final def wait(x$1: Long): Unit +final def wait(x$1: Long,x$2: Int): Unit +private[this] val __leftOfArrow: accessibility.Foo +private[this] val __resultOfEnsuring: accessibility.Foo +private[this] val __stringToFormat: accessibility.Foo +private[this] val __thingToAdd: accessibility.Foo ================================================================================ diff --git a/test/files/run/macro-divergence-spurious.check b/test/files/run/macro-divergence-spurious.check new file mode 100644 index 0000000000..19765bd501 --- /dev/null +++ b/test/files/run/macro-divergence-spurious.check @@ -0,0 +1 @@ +null diff --git a/test/files/run/macro-divergence-spurious/Impls_Macros_1.scala b/test/files/run/macro-divergence-spurious/Impls_Macros_1.scala new file mode 100644 index 0000000000..bc4a9fded7 --- /dev/null +++ b/test/files/run/macro-divergence-spurious/Impls_Macros_1.scala @@ -0,0 +1,23 @@ +import scala.reflect.macros.Context +import language.experimental.macros + +trait Complex[T] + +class Foo(val bar: Bar) +class Bar(val s: String) + +object Complex { + def impl[T: c.WeakTypeTag](c: Context): c.Expr[Complex[T]] = { + import c.universe._ + val tpe = weakTypeOf[T] + for (f <- tpe.declarations.collect{case f: TermSymbol if f.isParamAccessor && !f.isMethod => f}) { + val trecur = appliedType(typeOf[Complex[_]], List(f.typeSignature)) + val recur = c.inferImplicitValue(trecur, silent = true) + if (recur == EmptyTree) c.abort(c.enclosingPosition, s"couldn't synthesize $trecur") + } + c.literalNull + } + + implicit object ComplexString extends Complex[String] + implicit def genComplex[T]: Complex[T] = macro impl[T] +} diff --git a/test/files/run/macro-divergence-spurious/Test_2.scala b/test/files/run/macro-divergence-spurious/Test_2.scala new file mode 100644 index 0000000000..dcc4593335 --- /dev/null +++ b/test/files/run/macro-divergence-spurious/Test_2.scala @@ -0,0 +1,3 @@ +object Test extends App { + println(implicitly[Complex[Foo]]) +}
\ No newline at end of file diff --git a/test/files/run/macro-sip19-revised/Impls_Macros_1.scala b/test/files/run/macro-sip19-revised/Impls_Macros_1.scala index 5f3f61ca3f..8d7d3b5d3d 100644 --- a/test/files/run/macro-sip19-revised/Impls_Macros_1.scala +++ b/test/files/run/macro-sip19-revised/Impls_Macros_1.scala @@ -7,7 +7,7 @@ object Macros { val inscope = c.inferImplicitValue(c.mirror.staticClass("SourceLocation").toType) val outer = c.Expr[SourceLocation](if (!inscope.isEmpty) inscope else Literal(Constant(null))) - val Apply(fun, args) = c.enclosingImplicits(0)._2 + val Apply(fun, args) = c.enclosingImplicits(0).tree val fileName = fun.pos.source.file.file.getName val line = fun.pos.line val charOffset = fun.pos.point diff --git a/test/files/run/macro-sip19/Impls_Macros_1.scala b/test/files/run/macro-sip19/Impls_Macros_1.scala index 535ec2ccf0..4c165ed1b8 100644 --- a/test/files/run/macro-sip19/Impls_Macros_1.scala +++ b/test/files/run/macro-sip19/Impls_Macros_1.scala @@ -3,7 +3,7 @@ import scala.reflect.macros.Context object Macros { def impl(c: Context) = { import c.universe._ - val Apply(fun, args) = c.enclosingImplicits(0)._2 + val Apply(fun, args) = c.enclosingImplicits(0).tree val fileName = fun.pos.source.file.file.getName val line = fun.pos.line val charOffset = fun.pos.point diff --git a/test/files/run/memberpos.check b/test/files/run/memberpos.check new file mode 100644 index 0000000000..e7d3534000 --- /dev/null +++ b/test/files/run/memberpos.check @@ -0,0 +1,11 @@ +newSource1 +2,4 class A +6,28 object A + 7,10 def bippy + 8 def hello + 11,27 class Dingo + 12,26 def foooooz + 22 val a +30 class B + 30 def f + diff --git a/test/files/run/memberpos.scala b/test/files/run/memberpos.scala new file mode 100644 index 0000000000..f2b79c0ec1 --- /dev/null +++ b/test/files/run/memberpos.scala @@ -0,0 +1,39 @@ +import scala.tools.partest._ + +// Simple sanity test for -Yshow-member-pos. +object Test extends DirectTest { + override def extraSettings: String = "-usejavacp -Ystop-after:parser -Yshow-member-pos \"\" -d " + testOutput.path + override def show() = compile() + override def code = """ +class A(val a: Int = 1) { + +} + +object A { + def bippy = { + def hello = 55 + "" + hello + } + class Dingo { + def foooooz = /**** + + + + + + ****/ { + + + + val a = 1 + + + a + } + } +} + +class B { def f = 1 } + +""" +} diff --git a/test/files/run/range.scala b/test/files/run/range.scala index f08b2105d3..b81e67921a 100644 --- a/test/files/run/range.scala +++ b/test/files/run/range.scala @@ -16,6 +16,17 @@ object Test { catch { case _: IllegalArgumentException => true } ) assert(caught) + // #7432 + val noElemAtMin = ( + try { (10 until 10).min ; false } + catch { case _: NoSuchElementException => true } + ) + assert(noElemAtMin) + val noElemAtMax = ( + try { (10 until 10).max ; false } + catch { case _: NoSuchElementException => true } + ) + assert(noElemAtMax) } case class GR[T](val x: T)(implicit val num: Integral[T]) { diff --git a/test/files/run/t2251b.check b/test/files/run/t2251b.check index 5fa5d5168c..4231fc6ea6 100644 --- a/test/files/run/t2251b.check +++ b/test/files/run/t2251b.check @@ -1,6 +1,6 @@ -TypeTag[List[scala.collection.immutable.LinearSeq[B[_ >: D with C <: B[_ >: D with C <: A]]] with scala.collection.AbstractSeq[B[_ >: D with C <: B[_ >: D with C <: A]]]{def companion: scala.collection.generic.GenericCompanion[scala.collection.immutable.LinearSeq with scala.collection.AbstractSeq]; def reverse: scala.collection.immutable.LinearSeq[B[_ >: D with C <: A]] with scala.collection.AbstractSeq[B[_ >: D with C <: A]]{def companion: scala.collection.generic.GenericCompanion[scala.collection.immutable.LinearSeq with scala.collection.AbstractSeq]; def reverse: scala.collection.immutable.LinearSeq[A] with scala.collection.AbstractSeq[A]; def dropRight(n: Int): scala.collection.immutable.LinearSeq[A] with scala.collection.AbstractSeq[A]; def takeRight(n: Int): scala.collection.immutable.LinearSeq[A] with scala.collection.AbstractSeq[A]; def drop(n: Int): scala.collection.immutable.LinearSeq[A] with scala.collection.AbstractSeq[A]; def take(n: Int): scala.collection.immutable.LinearSeq[A] with scala.collection.AbstractSeq[A]; def slice(from: Int,until: Int): scala.collection.immutable.LinearSeq[A] with scala.collection.AbstractSeq[A]}; def dropRight(n: Int): scala.collection.immutable.LinearSeq[B[_ >: D with C <: A]] with scala.collection.AbstractSeq[B[_ >: D with C <: A]]{def companion: scala.collection.generic.GenericCompanion[scala.collection.immutable.LinearSeq with scala.collection.AbstractSeq]; def reverse: scala.collection.immutable.LinearSeq[A] with scala.collection.AbstractSeq[A]; def dropRight(n: Int): scala.collection.immutable.LinearSeq[A] with scala.collection.AbstractSeq[A]; def takeRight(n: Int): scala.collection.immutable.LinearSeq[A] with scala.collection.AbstractSeq[A]; def drop(n: Int): scala.collection.immutable.LinearSeq[A] with scala.collection.AbstractSeq[A]; def take(n: Int): scala.collection.immutable.LinearSeq[A] with scala.collection.AbstractSeq[A]; def slice(from: Int,until: Int): scala.collection.immutable.LinearSeq[A] with scala.collection.AbstractSeq[A]}; def takeRight(n: Int): scala.collection.immutable.LinearSeq[B[_ >: D with C <: A]] with scala.collection.AbstractSeq[B[_ >: D with C <: A]]{def companion: scala.collection.generic.GenericCompanion[scala.collection.immutable.LinearSeq with scala.collection.AbstractSeq]; def reverse: scala.collection.immutable.LinearSeq[A] with scala.collection.AbstractSeq[A]; def dropRight(n: Int): scala.collection.immutable.LinearSeq[A] with scala.collection.AbstractSeq[A]; def takeRight(n: Int): scala.collection.immutable.LinearSeq[A] with scala.collection.AbstractSeq[A]; def drop(n: Int): scala.collection.immutable.LinearSeq[A] with scala.collection.AbstractSeq[A]; def take(n: Int): scala.collection.immutable.LinearSeq[A] with scala.collection.AbstractSeq[A]; def slice(from: Int,until: Int): scala.collection.immutable.LinearSeq[A] with scala.collection.AbstractSeq[A]}; def drop(n: Int): scala.collection.immutable.LinearSeq[B[_ >: D with C <: A]] with scala.collection.AbstractSeq[B[_ >: D with C <: A]]{def companion: scala.collection.generic.GenericCompanion[scala.collection.immutable.LinearSeq with scala.collection.AbstractSeq]; def reverse: scala.collection.immutable.LinearSeq[A] with scala.collection.AbstractSeq[A]; def dropRight(n: Int): scala.collection.immutable.LinearSeq[A] with scala.collection.AbstractSeq[A]; def takeRight(n: Int): scala.collection.immutable.LinearSeq[A] with scala.collection.AbstractSeq[A]; def drop(n: Int): scala.collection.immutable.LinearSeq[A] with scala.collection.AbstractSeq[A]; def take(n: Int): scala.collection.immutable.LinearSeq[A] with scala.collection.AbstractSeq[A]; def slice(from: Int,until: Int): scala.collection.immutable.LinearSeq[A] with scala.collection.AbstractSeq[A]}; def take(n: Int): scala.collection.immutable.LinearSeq[B[_ >: D with C <: A]] with scala.collection.AbstractSeq[B[_ >: D with C <: A]]{def companion: scala.collection.generic.GenericCompanion[scala.collection.immutable.LinearSeq with scala.collection.AbstractSeq]; def reverse: scala.collection.immutable.LinearSeq[A] with scala.collection.AbstractSeq[A]; def dropRight(n: Int): scala.collection.immutable.LinearSeq[A] with scala.collection.AbstractSeq[A]; def takeRight(n: Int): scala.collection.immutable.LinearSeq[A] with scala.collection.AbstractSeq[A]; def drop(n: Int): scala.collection.immutable.LinearSeq[A] with scala.collection.AbstractSeq[A]; def take(n: Int): scala.collection.immutable.LinearSeq[A] with scala.collection.AbstractSeq[A]; def slice(from: Int,until: Int): scala.collection.immutable.LinearSeq[A] with scala.collection.AbstractSeq[A]}; def slice(from: Int,until: Int): scala.collection.immutable.LinearSeq[B[_ >: D with C <: A]] with scala.collection.AbstractSeq[B[_ >: D with C <: A]]{def companion: scala.collection.generic.GenericCompanion[scala.collection.immutable.LinearSeq with scala.collection.AbstractSeq]; def reverse: scala.collection.immutable.LinearSeq[A] with scala.collection.AbstractSeq[A]; def dropRight(n: Int): scala.collection.immutable.LinearSeq[A] with scala.collection.AbstractSeq[A]; def takeRight(n: Int): scala.collection.immutable.LinearSeq[A] with scala.collection.AbstractSeq[A]; def drop(n: Int): scala.collection.immutable.LinearSeq[A] with scala.collection.AbstractSeq[A]; def take(n: Int): scala.collection.immutable.LinearSeq[A] with scala.collection.AbstractSeq[A]; def slice(from: Int,until: Int): scala.collection.immutable.LinearSeq[A] with scala.collection.AbstractSeq[A]}; def splitAt(n: Int): (scala.collection.immutable.LinearSeq[A] with scala.collection.AbstractSeq[A], scala.collection.immutable.LinearSeq[A] with scala.collection.AbstractSeq[A])}]] +TypeTag[List[scala.collection.immutable.LinearSeq[B[_ >: D with C <: B[_ >: D with C <: A]]] with scala.collection.AbstractSeq[B[_ >: D with C <: B[_ >: D with C <: A]]] with java.io.Serializable]] TypeTag[List[scala.collection.immutable.Iterable[B[_ >: F with E with D with C <: B[_ >: F with E with D with C <: A]]] with F with Int => Any]] -TypeTag[List[scala.collection.immutable.Seq[B[_ >: D with C <: B[_ >: D with C <: A]]] with scala.collection.AbstractSeq[B[_ >: D with C <: B[_ >: D with C <: A]]]{def companion: scala.collection.generic.GenericCompanion[scala.collection.immutable.Seq with scala.collection.AbstractSeq]; def dropRight(n: Int): scala.collection.immutable.Seq[B[_ >: D with C <: A]] with scala.collection.AbstractSeq[B[_ >: D with C <: A]]{def companion: scala.collection.generic.GenericCompanion[scala.collection.immutable.Seq with scala.collection.AbstractSeq]; def dropRight(n: Int): scala.collection.immutable.Seq[A] with scala.collection.AbstractSeq[A]; def takeRight(n: Int): scala.collection.immutable.Seq[A] with scala.collection.AbstractSeq[A]; def drop(n: Int): scala.collection.immutable.Seq[A] with scala.collection.AbstractSeq[A]; def take(n: Int): scala.collection.immutable.Seq[A] with scala.collection.AbstractSeq[A]; def slice(from: Int,until: Int): scala.collection.immutable.Seq[A] with scala.collection.AbstractSeq[A]; def init: scala.collection.immutable.Seq[A] with scala.collection.AbstractSeq[A]}; def takeRight(n: Int): scala.collection.immutable.Seq[B[_ >: D with C <: A]] with scala.collection.AbstractSeq[B[_ >: D with C <: A]]{def companion: scala.collection.generic.GenericCompanion[scala.collection.immutable.Seq with scala.collection.AbstractSeq]; def dropRight(n: Int): scala.collection.immutable.Seq[A] with scala.collection.AbstractSeq[A]; def takeRight(n: Int): scala.collection.immutable.Seq[A] with scala.collection.AbstractSeq[A]; def drop(n: Int): scala.collection.immutable.Seq[A] with scala.collection.AbstractSeq[A]; def take(n: Int): scala.collection.immutable.Seq[A] with scala.collection.AbstractSeq[A]; def slice(from: Int,until: Int): scala.collection.immutable.Seq[A] with scala.collection.AbstractSeq[A]; def init: scala.collection.immutable.Seq[A] with scala.collection.AbstractSeq[A]}; def drop(n: Int): scala.collection.immutable.Seq[B[_ >: D with C <: A]] with scala.collection.AbstractSeq[B[_ >: D with C <: A]]{def companion: scala.collection.generic.GenericCompanion[scala.collection.immutable.Seq with scala.collection.AbstractSeq]; def dropRight(n: Int): scala.collection.immutable.Seq[A] with scala.collection.AbstractSeq[A]; def takeRight(n: Int): scala.collection.immutable.Seq[A] with scala.collection.AbstractSeq[A]; def drop(n: Int): scala.collection.immutable.Seq[A] with scala.collection.AbstractSeq[A]; def take(n: Int): scala.collection.immutable.Seq[A] with scala.collection.AbstractSeq[A]; def slice(from: Int,until: Int): scala.collection.immutable.Seq[A] with scala.collection.AbstractSeq[A]; def init: scala.collection.immutable.Seq[A] with scala.collection.AbstractSeq[A]}; def take(n: Int): scala.collection.immutable.Seq[B[_ >: D with C <: A]] with scala.collection.AbstractSeq[B[_ >: D with C <: A]]{def companion: scala.collection.generic.GenericCompanion[scala.collection.immutable.Seq with scala.collection.AbstractSeq]; def dropRight(n: Int): scala.collection.immutable.Seq[A] with scala.collection.AbstractSeq[A]; def takeRight(n: Int): scala.collection.immutable.Seq[A] with scala.collection.AbstractSeq[A]; def drop(n: Int): scala.collection.immutable.Seq[A] with scala.collection.AbstractSeq[A]; def take(n: Int): scala.collection.immutable.Seq[A] with scala.collection.AbstractSeq[A]; def slice(from: Int,until: Int): scala.collection.immutable.Seq[A] with scala.collection.AbstractSeq[A]; def init: scala.collection.immutable.Seq[A] with scala.collection.AbstractSeq[A]}; def slice(from: Int,until: Int): scala.collection.immutable.Seq[B[_ >: D with C <: A]] with scala.collection.AbstractSeq[B[_ >: D with C <: A]]{def companion: scala.collection.generic.GenericCompanion[scala.collection.immutable.Seq with scala.collection.AbstractSeq]; def dropRight(n: Int): scala.collection.immutable.Seq[A] with scala.collection.AbstractSeq[A]; def takeRight(n: Int): scala.collection.immutable.Seq[A] with scala.collection.AbstractSeq[A]; def drop(n: Int): scala.collection.immutable.Seq[A] with scala.collection.AbstractSeq[A]; def take(n: Int): scala.collection.immutable.Seq[A] with scala.collection.AbstractSeq[A]; def slice(from: Int,until: Int): scala.collection.immutable.Seq[A] with scala.collection.AbstractSeq[A]; def init: scala.collection.immutable.Seq[A] with scala.collection.AbstractSeq[A]}; def splitAt(n: Int): (scala.collection.immutable.Seq[A] with scala.collection.AbstractSeq[A], scala.collection.immutable.Seq[A] with scala.collection.AbstractSeq[A]); def init: scala.collection.immutable.Seq[B[_ >: D with C <: A]] with scala.collection.AbstractSeq[B[_ >: D with C <: A]]{def companion: scala.collection.generic.GenericCompanion[scala.collection.immutable.Seq with scala.collection.AbstractSeq]; def dropRight(n: Int): scala.collection.immutable.Seq[A] with scala.collection.AbstractSeq[A]; def takeRight(n: Int): scala.collection.immutable.Seq[A] with scala.collection.AbstractSeq[A]; def drop(n: Int): scala.collection.immutable.Seq[A] with scala.collection.AbstractSeq[A]; def take(n: Int): scala.collection.immutable.Seq[A] with scala.collection.AbstractSeq[A]; def slice(from: Int,until: Int): scala.collection.immutable.Seq[A] with scala.collection.AbstractSeq[A]; def init: scala.collection.immutable.Seq[A] with scala.collection.AbstractSeq[A]}}]] +TypeTag[List[scala.collection.immutable.Seq[B[_ >: D with C <: B[_ >: D with C <: A]]] with scala.collection.AbstractSeq[B[_ >: D with C <: B[_ >: D with C <: A]]] with Serializable]] TypeTag[List[scala.collection.Set[_ >: G with F <: B[_ >: G with F <: B[_ >: G with F <: A]]]]] TypeTag[List[scala.collection.Set[_ >: G with F <: B[_ >: G with F <: B[_ >: G with F <: A]]]]] TypeTag[List[scala.collection.Set[_ >: G with F <: B[_ >: G with F <: B[_ >: G with F <: A]]]]] diff --git a/test/files/run/t5923a.check b/test/files/run/t5923a.check new file mode 100644 index 0000000000..7165b734ac --- /dev/null +++ b/test/files/run/t5923a.check @@ -0,0 +1,3 @@ +C(Int) +C(String) +C(Nothing) diff --git a/test/files/run/t5923a/Macros_1.scala b/test/files/run/t5923a/Macros_1.scala new file mode 100644 index 0000000000..6d21362c4d --- /dev/null +++ b/test/files/run/t5923a/Macros_1.scala @@ -0,0 +1,14 @@ +import scala.reflect.macros.Context +import language.experimental.macros + +case class C[T](t: String) +object C { + implicit def foo[T]: C[T] = macro Macros.impl[T] +} + +object Macros { + def impl[T: c.WeakTypeTag](c: Context) = { + import c.universe._ + reify(C[T](c.literal(weakTypeOf[T].toString).splice)) + } +}
\ No newline at end of file diff --git a/test/files/run/t5923a/Test_2.scala b/test/files/run/t5923a/Test_2.scala new file mode 100644 index 0000000000..001ff9aea8 --- /dev/null +++ b/test/files/run/t5923a/Test_2.scala @@ -0,0 +1,5 @@ +object Test extends App { + println(implicitly[C[Int]]) + println(implicitly[C[String]]) + println(implicitly[C[Nothing]]) +}
\ No newline at end of file diff --git a/test/files/run/t5923b.check b/test/files/run/t5923b.check new file mode 100644 index 0000000000..d56076f84e --- /dev/null +++ b/test/files/run/t5923b.check @@ -0,0 +1,3 @@ +class [Ljava.lang.Object; +class [Ljava.lang.Object; +class [Ljava.lang.Object; diff --git a/test/files/run/t5923b/Test.scala b/test/files/run/t5923b/Test.scala new file mode 100644 index 0000000000..7c2627462a --- /dev/null +++ b/test/files/run/t5923b/Test.scala @@ -0,0 +1,7 @@ +object Test extends App { + import scala.collection.generic.CanBuildFrom + val cbf = implicitly[CanBuildFrom[Nothing, Nothing, Array[Nothing]]] + println(cbf().result.getClass) + println(new Array[Nothing](0).getClass) + println(Array[Nothing]().getClass) +}
\ No newline at end of file diff --git a/test/files/run/t6028.check b/test/files/run/t6028.check index 2ec639fce2..57fd58f7d3 100644 --- a/test/files/run/t6028.check +++ b/test/files/run/t6028.check @@ -15,11 +15,11 @@ package <empty> { } }; def bar(barParam: Int): Object = { - @volatile var MethodLocalObject$module: runtime.VolatileObjectRef = new runtime.VolatileObjectRef(null); + @volatile var MethodLocalObject$module: runtime.VolatileObjectRef = scala.runtime.VolatileObjectRef.zero(); T.this.MethodLocalObject$1(barParam, MethodLocalObject$module) }; def tryy(tryyParam: Int): Function0 = { - var tryyLocal: runtime.IntRef = new runtime.IntRef(0); + var tryyLocal: runtime.IntRef = scala.runtime.IntRef.create(0); { (new anonymous class $anonfun$tryy$1(T.this, tryyParam, tryyLocal): Function0) } diff --git a/test/files/run/t6039.scala b/test/files/run/t6039.scala new file mode 100644 index 0000000000..9d811b0634 --- /dev/null +++ b/test/files/run/t6039.scala @@ -0,0 +1,18 @@ +import scala.tools.partest._ + +object Test extends StoreReporterDirectTest { + private def compileCode(): Boolean = { + new java.io.File("util") mkdirs + val classpath = List(sys.props("partest.lib"), ".") mkString sys.props("path.separator") + log(s"classpath = $classpath") + compileString(newCompiler("-cp", classpath, "-d", testOutput.path))(packageCode) + } + def code = ??? + def packageCode = """ +package scala.bippy +class A { new util.Random() } +""" + def show(): Unit = { + assert(compileCode(), filteredInfos take 1 mkString "") + } +} diff --git a/test/files/run/t7047.check b/test/files/run/t7047.check new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/test/files/run/t7047.check diff --git a/test/files/run/t7047/Impls_Macros_1.scala b/test/files/run/t7047/Impls_Macros_1.scala new file mode 100644 index 0000000000..2992e3efe4 --- /dev/null +++ b/test/files/run/t7047/Impls_Macros_1.scala @@ -0,0 +1,19 @@ +import scala.reflect.macros.Context +import language.experimental.macros + +class Foo + +object Macros { + def impl(c: Context) = { + import c.universe._ + try { + c.inferImplicitValue(typeOf[Foo], silent = false) + c.abort(c.enclosingPosition, "silent=false is not working") + } catch { + case _: Exception => + } + c.literalNull + } + + def foo = macro impl +}
\ No newline at end of file diff --git a/test/files/run/t7047/Test_2.scala b/test/files/run/t7047/Test_2.scala new file mode 100644 index 0000000000..acfddae942 --- /dev/null +++ b/test/files/run/t7047/Test_2.scala @@ -0,0 +1,3 @@ +object Test extends App { + Macros.foo +}
\ No newline at end of file diff --git a/test/files/run/t7200.scala b/test/files/run/t7200.scala new file mode 100644 index 0000000000..ba342df14d --- /dev/null +++ b/test/files/run/t7200.scala @@ -0,0 +1,34 @@ +import language.higherKinds + +object Test extends App { + + // Slice of comonad is where this came up + trait Foo[F[_]] { + def coflatMap[A, B](f: F[A] => B): F[A] => F[B] + } + + // A non-empty list + case class Nel[A](head: A, tail: List[A]) + + object NelFoo extends Foo[Nel] { + + // It appears that the return type for recursive calls is not inferred + // properly, yet no warning is issued. Providing a return type or + // type arguments for the recursive call fixes the problem. + + def coflatMap[A, B](f: Nel[A] => B) = // ok w/ return type + l => Nel(f(l), l.tail match { + case Nil => Nil + case h :: t => { + val r = coflatMap(f)(Nel(h, t)) // ok w/ type args + r.head :: r.tail + } + }) + } + + // Without a recursive call all is well, but with recursion we get a + // ClassCastException from Integer to Nothing + NelFoo.coflatMap[Int, Int](_.head + 1)(Nel(1, Nil)) // Ok + NelFoo.coflatMap[Int, Int](_.head + 1)(Nel(1, List(2))) // CCE + +} diff --git a/test/files/run/t7291.check b/test/files/run/t7291.check new file mode 100644 index 0000000000..c07ba986a3 --- /dev/null +++ b/test/files/run/t7291.check @@ -0,0 +1,2 @@ +conjure +traversable diff --git a/test/files/run/t7291.scala b/test/files/run/t7291.scala new file mode 100644 index 0000000000..30c4261a81 --- /dev/null +++ b/test/files/run/t7291.scala @@ -0,0 +1,19 @@ +trait Fooable[T] +object Fooable { + implicit def conjure[T]: Fooable[T] = { + println("conjure") + new Fooable[T]{} + } + +} + +object Test { + implicit def traversable[T, Coll[_] <: Traversable[_]](implicit +elem: Fooable[T]): Fooable[Coll[T]] = { + println("traversable") + new Fooable[Coll[T]]{} + } + def main(args: Array[String]) { + implicitly[Fooable[List[Any]]] + } +} diff --git a/test/files/scalacheck/HashTrieSplit.scala b/test/files/scalacheck/HashTrieSplit.scala deleted file mode 100644 index 908c878f54..0000000000 --- a/test/files/scalacheck/HashTrieSplit.scala +++ /dev/null @@ -1,47 +0,0 @@ - - - - - -import collection._ - - - - -// checks whether hash tries split their iterators correctly -// even after some elements have been traversed -object Test { - def main(args: Array[String]) { - doesSplitOk - } - - def doesSplitOk = { - val sz = 2000 - var ht = new parallel.immutable.ParHashMap[Int, Int] - // println("creating trie") - for (i <- 0 until sz) ht += ((i + sz, i)) - // println("created trie") - for (n <- 0 until (sz - 1)) { - // println("---------> n = " + n) - val pit = ht.splitter - val pit2 = ht.splitter - var i = 0 - while (i < n) { - pit.next - pit2.next - i += 1 - } - // println("splitting") - val pits = pit.split - val fst = pits(0).toSet - val snd = pits(1).toSet - val orig = pit2.toSet - if (orig.size != (fst.size + snd.size) || orig != (fst ++ snd)) { - println("Original: " + orig) - println("First: " + fst) - println("Second: " + snd) - assert(false) - } - } - } -} diff --git a/test/files/scalacheck/avl.scala b/test/files/scalacheck/avl.scala index af79ad49e3..02003bd271 100644 --- a/test/files/scalacheck/avl.scala +++ b/test/files/scalacheck/avl.scala @@ -2,14 +2,12 @@ import org.scalacheck.Gen import org.scalacheck.Prop.forAll import org.scalacheck.Properties -import util.logging.ConsoleLogger - package scala.collection.mutable { /** * Property of an AVL Tree : Any node of the tree has a balance value beetween in [-1; 1] */ - abstract class AVLTreeTest(name: String) extends Properties(name) with ConsoleLogger { + abstract class AVLTreeTest(name: String) extends Properties(name) { def `2^`(n: Int) = (1 to n).fold(1)((a, b) => b*2) diff --git a/test/files/scalacheck/parallel-collections/pc.scala b/test/files/scalacheck/parallel-collections/pc.scala index 0a91977da0..e6b6b4856d 100644 --- a/test/files/scalacheck/parallel-collections/pc.scala +++ b/test/files/scalacheck/parallel-collections/pc.scala @@ -1,12 +1,11 @@ - - - +/* + * scalac: -deprecation + * scalacheck: -workers 1 -minSize 0 -maxSize 4000 -minSuccessfulTests 5 + */ import org.scalacheck._ - import scala.collection.parallel._ - class ParCollProperties extends Properties("Parallel collections") { /* Collections */ @@ -35,8 +34,8 @@ class ParCollProperties extends Properties("Parallel collections") { include(immutable.IntParallelVectorCheck) } - -object Test { +object Test extends ParCollProperties { + /* def main(args: Array[String]) { val pc = new ParCollProperties org.scalacheck.Test.checkProperties( @@ -51,4 +50,5 @@ object Test { pc ) } + */ } diff --git a/test/partest b/test/partest index e3270f8eaa..99a731a49b 100755 --- a/test/partest +++ b/test/partest @@ -129,6 +129,7 @@ fi $JAVA_OPTS -cp "$EXT_CLASSPATH" \ ${partestDebugStr} \ "$color_opts" \ + -Dfile.encoding=UTF-8 \ -Dscala.home="${SCALA_HOME}" \ -Dpartest.javacmd="${JAVACMD}" \ -Dpartest.java_opts="${JAVA_OPTS}" \ diff --git a/test/scaladoc/run/SI-7367.check b/test/scaladoc/run/SI-7367.check new file mode 100755 index 0000000000..3925a0d464 --- /dev/null +++ b/test/scaladoc/run/SI-7367.check @@ -0,0 +1 @@ +Done.
\ No newline at end of file diff --git a/test/scaladoc/run/SI-7367.scala b/test/scaladoc/run/SI-7367.scala new file mode 100755 index 0000000000..6e5a317932 --- /dev/null +++ b/test/scaladoc/run/SI-7367.scala @@ -0,0 +1,25 @@ +import scala.tools.nsc.doc.model._ +import scala.tools.partest.ScaladocModelTest + +object Test extends ScaladocModelTest { + override def code = """ + class annot() extends annotation.StaticAnnotation { + def this(a: Any) = this() + } + + @annot(0) + class B + """ + + def scaladocSettings = "" + + def testModel(root: Package) = { + import access._ + val annotations = root._class("B").annotations + assert(annotations.size == 1) + assert(annotations(0).annotationClass == root._class("annot")) + val args = annotations(0).arguments + assert(args.size == 1) + assert(args(0).value.expression == "0") + } +} diff --git a/test/scaladoc/scalacheck/CommentFactoryTest.scala b/test/scaladoc/scalacheck/CommentFactoryTest.scala index dc64060716..ff64a25602 100644 --- a/test/scaladoc/scalacheck/CommentFactoryTest.scala +++ b/test/scaladoc/scalacheck/CommentFactoryTest.scala @@ -45,7 +45,7 @@ object Test extends Properties("CommentFactory") { with MemberLookup) } - def parse(src: String, dst: Inline) = { + def parse(src: String, dst: Inline): Boolean = { factory.parseComment(src) match { case Some(inline) => inline == dst diff --git a/test/scaladoc/scalacheck/HtmlFactoryTest.scala b/test/scaladoc/scalacheck/HtmlFactoryTest.scala index d7b5e48288..03348b81d2 100644 --- a/test/scaladoc/scalacheck/HtmlFactoryTest.scala +++ b/test/scaladoc/scalacheck/HtmlFactoryTest.scala @@ -2,6 +2,8 @@ import org.scalacheck._ import org.scalacheck.Prop._ import java.net.{URLClassLoader, URLDecoder} +import scala.collection.mutable +import scala.xml.NodeSeq object XMLUtil { import scala.xml._ @@ -34,21 +36,24 @@ object Test extends Properties("HtmlFactory") { // this test previously relied on the assumption that the current thread's classloader is an url classloader and contains all the classpaths // does partest actually guarantee this? to quote Leonard Nimoy: The answer, of course, is no. // this test _will_ fail again some time in the future. - val paths = Thread.currentThread.getContextClassLoader.asInstanceOf[URLClassLoader].getURLs.map(u => URLDecoder.decode(u.getPath)) - val morepaths = Thread.currentThread.getContextClassLoader.getParent.asInstanceOf[URLClassLoader].getURLs.map(u => URLDecoder.decode(u.getPath)) - (paths ++ morepaths).mkString(java.io.File.pathSeparator) + // Footnote: java.lang.ClassCastException: org.apache.tools.ant.loader.AntClassLoader5 cannot be cast to java.net.URLClassLoader + val loader = Thread.currentThread.getContextClassLoader.asInstanceOf[URLClassLoader] + val paths = loader.getURLs.map(u => URLDecoder.decode(u.getPath)) + paths mkString java.io.File.pathSeparator } def createFactory = { val settings = new Settings({Console.err.println(_)}) + settings.scaladocQuietRun = true + settings.nowarn.value = true settings.classpath.value = getClasspath val reporter = new scala.tools.nsc.reporters.ConsoleReporter(settings) new DocFactory(reporter, settings) } - def createTemplates(basename: String) = { - val result = scala.collection.mutable.Map[String, scala.xml.NodeSeq]() + def createTemplates(basename: String): collection.Map[String, NodeSeq] = { + val result = mutable.Map[String, NodeSeq]() createFactory.makeUniverse(Left(List(RESOURCES+basename))) match { case Some(universe) => { @@ -57,7 +62,7 @@ object Test extends Properties("HtmlFactory") { result += (page.absoluteLinkTo(page.path) -> page.body) }) } - case _ => ; + case _ => } result diff --git a/test/scaladoc/scalacheck/IndexScriptTest.scala b/test/scaladoc/scalacheck/IndexScriptTest.scala index 37f6947aaa..b8b9f92965 100644 --- a/test/scaladoc/scalacheck/IndexScriptTest.scala +++ b/test/scaladoc/scalacheck/IndexScriptTest.scala @@ -8,14 +8,20 @@ import java.net.{URLClassLoader, URLDecoder} object Test extends Properties("IndexScript") { def getClasspath = { - val loader = Thread.currentThread.getContextClassLoader - val paths = loader.asInstanceOf[URLClassLoader].getURLs - val morepaths = loader.getParent.asInstanceOf[URLClassLoader].getURLs - (paths ++ morepaths).map(u => URLDecoder.decode(u.getPath)).mkString(java.io.File.pathSeparator) + // these things can be tricky + // this test previously relied on the assumption that the current thread's classloader is an url classloader and contains all the classpaths + // does partest actually guarantee this? to quote Leonard Nimoy: The answer, of course, is no. + // this test _will_ fail again some time in the future. + // Footnote: java.lang.ClassCastException: org.apache.tools.ant.loader.AntClassLoader5 cannot be cast to java.net.URLClassLoader + val loader = Thread.currentThread.getContextClassLoader.asInstanceOf[URLClassLoader] + val paths = loader.getURLs.map(u => URLDecoder.decode(u.getPath)) + paths mkString java.io.File.pathSeparator } val docFactory = { val settings = new doc.Settings({Console.err.println(_)}) + settings.scaladocQuietRun = true + settings.nowarn.value = true settings.classpath.value = getClasspath val reporter = new scala.tools.nsc.reporters.ConsoleReporter(settings) new doc.DocFactory(reporter, settings) diff --git a/test/scaladoc/scalacheck/IndexTest.scala b/test/scaladoc/scalacheck/IndexTest.scala index dc4ab126d4..abc0e5da01 100644 --- a/test/scaladoc/scalacheck/IndexTest.scala +++ b/test/scaladoc/scalacheck/IndexTest.scala @@ -12,19 +12,19 @@ object Test extends Properties("Index") { // this test previously relied on the assumption that the current thread's classloader is an url classloader and contains all the classpaths // does partest actually guarantee this? to quote Leonard Nimoy: The answer, of course, is no. // this test _will_ fail again some time in the future. - val paths = Thread.currentThread.getContextClassLoader.asInstanceOf[URLClassLoader].getURLs.map(u => URLDecoder.decode(u.getPath)) - val morepaths = Thread.currentThread.getContextClassLoader.getParent.asInstanceOf[URLClassLoader].getURLs.map(u => URLDecoder.decode(u.getPath)) - (paths ++ morepaths).mkString(java.io.File.pathSeparator) + // Footnote: java.lang.ClassCastException: org.apache.tools.ant.loader.AntClassLoader5 cannot be cast to java.net.URLClassLoader + val loader = Thread.currentThread.getContextClassLoader.asInstanceOf[URLClassLoader] + val paths = loader.getURLs.map(u => URLDecoder.decode(u.getPath)) + paths mkString java.io.File.pathSeparator } val docFactory = { val settings = new doc.Settings({Console.err.println(_)}) - + settings.scaladocQuietRun = true + settings.nowarn.value = true settings.classpath.value = getClasspath - println(settings.classpath.value) val reporter = new scala.tools.nsc.reporters.ConsoleReporter(settings) - new doc.DocFactory(reporter, settings) } |